1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
#include "word.h"
// clang-format off
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
// clang-format on
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
FILE *create_tmp_file(const char *data) {
FILE *fp = tmpfile();
assert_non_null(fp);
fprintf(fp, "%s", data);
rewind(fp);
return fp;
}
/**
* GIVEN the an input containing a single word
* WHEN we read a word from the file
* THEN we would expect to read in the single word
*/
void test_read_word_single_word(void **state) {
const char *input = "hello";
const char *expected = "hello";
FILE *fp = create_tmp_file(input);
char word[100];
int result = read_word(fp, word, sizeof(word));
assert_int_equal(result, READ_WORD_SUCCESS);
assert_string_equal(word, expected);
fclose(fp);
}
/**
* GIVEN an input string with leading spaces
* WHEN we read a word from the file
* THEN we would expect to have discarded the leading spaces and
* read in the following word
*/
void test_read_word_leading_spaces(void **state) {
const char *input = " leading";
const char *expected = "leading";
FILE *fp = create_tmp_file(input);
char word[100];
int result = read_word(fp, word, sizeof(word));
assert_int_equal(result, READ_WORD_SUCCESS);
assert_string_equal(word, expected);
fclose(fp);
}
/**
* GIVEN an input string with trailing spaces
* WHEN we read a word from the file
* THEN we would expect to read in the word without
* the trailing spaces
* WHEN we read in another word
* THEN we expect to see the remaining spaces simply get
* consumed and get back EOF
*/
void test_read_word_trailing_spaces(void **state) {
const char *input = "trailing ";
const char *expected = "trailing";
FILE *fp = create_tmp_file(input);
char word[100];
int result = read_word(fp, word, sizeof(word));
assert_int_equal(result, READ_WORD_SUCCESS);
assert_string_equal(word, expected);
result = read_word(fp, word, sizeof(word));
assert_int_equal(result, READ_WORD_ERR_EOF);
assert_string_equal(word, "");
fclose(fp);
}
/**
* GIVEN an input string with multiple spaces between words
* WHEN we read a word from the file
* THEN we expect to read in the first word
* WHEN we read in another word from the file
* THEN we expect to skip over the multiple spaces
* and read in the last word
*/
void test_read_word_multiple_spaces(void **state) {
const char *input = "multiple spaces";
FILE *fp = create_tmp_file(input);
char word[100];
char *expected = "multiple";
int result = read_word(fp, word, sizeof(word));
assert_int_equal(result, READ_WORD_SUCCESS);
assert_string_equal(word, expected);
expected = "spaces";
result = read_word(fp, word, sizeof(word));
assert_int_equal(result, READ_WORD_SUCCESS);
assert_string_equal(word, expected);
fclose(fp);
}
/**
* GIVEN an empty input string
* WHEN we read a word from the file
* THEN we expect to get EOF on read
*/
void test_read_word_empty_input(void **state) {
const char *input = "";
const char *expected = "";
FILE *fp = create_tmp_file(input);
char word[100];
int result = read_word(fp, word, sizeof(word));
assert_int_equal(result, READ_WORD_ERR_EOF);
assert_string_equal(word, expected);
fclose(fp);
}
/**
* GIVEN an input string that is only whitespace characters
* WHEN we read a word from the file
* THEN we expect to get EOF on read
*/
void test_read_word_input_with_only_spaces(void **state) {
const char *input = " \t\t\n\n";
const char *expected = "";
FILE *fp = create_tmp_file(input);
char word[100];
int result = read_word(fp, word, sizeof(word));
assert_int_equal(result, READ_WORD_ERR_EOF);
assert_string_equal(word, expected);
fclose(fp);
}
/**
* GIVEN a NULL input
* WHEN we read a word from the file
* THEN we expect to get a read error
*/
void test_read_word_null_fp(void **state) {
char word[100];
int result = read_word(NULL, word, sizeof(word));
assert_int_equal(result, READ_WORD_ERR_READ);
}
/**
* GIVEN a NULL word buffer
* WHEN we read a word from the file
* THEN we expect to get a read error
*/
void test_read_word_null_word(void **state) {
FILE *fp = tmpfile();
assert_non_null(fp);
int result = read_word(fp, NULL, 100);
assert_int_equal(result, READ_WORD_ERR_READ);
fclose(fp);
}
/**
* GIVEN a word buffer with a 0 length
* WHEN we read a word from the file
* THEN we expect to get EOF
*/
void test_read_word_zero_length(void **state) {
FILE *fp = tmpfile();
assert_non_null(fp);
char word[100];
int result = read_word(fp, word, 0);
assert_int_equal(result, READ_WORD_ERR_EOF);
fclose(fp);
}
/**
* GIVEN a word that is too long to fit into the word buffer
* WHEN we read a word from the file
* THEN we expect to get the partial word back
* WHEN we read in another word
* THEN we expect to get the remainder of the word
*/
void test_read_word_overflow(void **state) {
const char *input = "thisisaverylongword";
FILE *fp = create_tmp_file(input);
char word[11]; // Buffer size is 11 to include null terminator
char *expected = "thisisaver";
int result = read_word(fp, word, sizeof(word));
assert_int_equal(result, READ_WORD_SUCCESS);
assert_string_equal(word, expected);
expected = "ylongword";
result = read_word(fp, word, sizeof(word));
assert_int_equal(result, READ_WORD_SUCCESS);
assert_string_equal(word, expected);
fclose(fp);
}
int main(void) {
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_read_word_single_word),
cmocka_unit_test(test_read_word_leading_spaces),
cmocka_unit_test(test_read_word_trailing_spaces),
cmocka_unit_test(test_read_word_multiple_spaces),
cmocka_unit_test(test_read_word_empty_input),
cmocka_unit_test(test_read_word_input_with_only_spaces),
cmocka_unit_test(test_read_word_null_fp),
cmocka_unit_test(test_read_word_null_word),
cmocka_unit_test(test_read_word_zero_length),
cmocka_unit_test(test_read_word_overflow),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}
|