Mercurial > code
comparison c/buf/buf-test.c @ 667:325be9bbc68f
buf: initial import
author | David Demelier <markand@malikania.fr> |
---|---|
date | Fri, 21 Feb 2020 15:09:53 +0100 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
666:66015e773085 | 667:325be9bbc68f |
---|---|
1 /* | |
2 * test.c -- test basic buffers | |
3 * | |
4 * Copyright (c) 2016-2019 David Demelier <markand@malikania.fr> | |
5 * | |
6 * Permission to use, copy, modify, and/or distribute this software for any | |
7 * purpose with or without fee is hereby granted, provided that the above | |
8 * copyright notice and this permission notice appear in all copies. | |
9 * | |
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
17 */ | |
18 | |
19 #define GREATEST_USE_ABBREVS 0 | |
20 #include <greatest.h> | |
21 | |
22 #include "buf.h" | |
23 | |
24 GREATEST_TEST | |
25 init(void) | |
26 { | |
27 struct buf b; | |
28 | |
29 /* No allocation with buf_init. */ | |
30 buf_init(&b); | |
31 GREATEST_ASSERT(!b.data); | |
32 GREATEST_ASSERT(!b.capacity); | |
33 GREATEST_ASSERT(!b.length); | |
34 | |
35 /* Must stay zero'ed. */ | |
36 buf_finish(&b); | |
37 GREATEST_ASSERT(!b.data); | |
38 GREATEST_ASSERT(!b.capacity); | |
39 GREATEST_ASSERT(!b.length); | |
40 | |
41 GREATEST_PASS(); | |
42 } | |
43 | |
44 GREATEST_SUITE(basics) | |
45 { | |
46 GREATEST_RUN_TEST(init); | |
47 } | |
48 | |
49 GREATEST_TEST | |
50 reserve(void) | |
51 { | |
52 struct buf b; | |
53 | |
54 /* Reserve allocates but does not change length. */ | |
55 buf_init(&b); | |
56 buf_reserve(&b, 100U); | |
57 GREATEST_ASSERT(b.data); | |
58 GREATEST_ASSERT_EQ(b.length, 0U); | |
59 GREATEST_ASSERT_EQ(b.capacity, 100U); | |
60 buf_finish(&b); | |
61 | |
62 GREATEST_PASS(); | |
63 } | |
64 | |
65 GREATEST_TEST | |
66 resize(void) | |
67 { | |
68 struct buf b; | |
69 | |
70 /* Resize actually change the length with the specified character. */ | |
71 buf_init(&b); | |
72 buf_resize(&b, 10, 'a'); | |
73 GREATEST_ASSERT_STR_EQ(b.data, "aaaaaaaaaa"); | |
74 GREATEST_ASSERT_EQ(b.length, 10U); | |
75 GREATEST_ASSERT_EQ(b.capacity, 10U); | |
76 buf_finish(&b); | |
77 | |
78 GREATEST_PASS(); | |
79 } | |
80 | |
81 GREATEST_TEST | |
82 shrink(void) | |
83 { | |
84 struct buf b; | |
85 | |
86 /* Reserve and then shrink, it should be 0. */ | |
87 buf_init(&b); | |
88 buf_reserve(&b, 10U); | |
89 buf_shrink(&b); | |
90 GREATEST_ASSERT(b.data); | |
91 GREATEST_ASSERT_EQ(b.length, 0U); | |
92 GREATEST_ASSERT_EQ(b.capacity, 0U); | |
93 buf_finish(&b); | |
94 | |
95 GREATEST_PASS(); | |
96 } | |
97 | |
98 GREATEST_SUITE(allocs) | |
99 { | |
100 GREATEST_RUN_TEST(reserve); | |
101 GREATEST_RUN_TEST(resize); | |
102 } | |
103 | |
104 GREATEST_TEST | |
105 output_char(void) | |
106 { | |
107 struct buf b; | |
108 | |
109 buf_init(&b); | |
110 | |
111 /* This will allocate one byte and then increase by power of two. */ | |
112 buf_putc(&b, 'a'); | |
113 GREATEST_ASSERT_STR_EQ(b.data, "a"); | |
114 GREATEST_ASSERT_EQ(b.length, 1U); | |
115 GREATEST_ASSERT_EQ(b.capacity, 1U); | |
116 | |
117 buf_putc(&b, 'b'); | |
118 GREATEST_ASSERT_STR_EQ(b.data, "ab"); | |
119 GREATEST_ASSERT_EQ(b.length, 2U); | |
120 GREATEST_ASSERT_EQ(b.capacity, 2U); | |
121 | |
122 buf_putc(&b, 'c'); | |
123 GREATEST_ASSERT_STR_EQ(b.data, "abc"); | |
124 GREATEST_ASSERT_EQ(b.length, 3U); | |
125 GREATEST_ASSERT_EQ(b.capacity, 4U); | |
126 | |
127 /* No reallocation since there is still one byte left. */ | |
128 buf_putc(&b, 'd'); | |
129 GREATEST_ASSERT_STR_EQ(b.data, "abcd"); | |
130 GREATEST_ASSERT_EQ(b.length, 4U); | |
131 GREATEST_ASSERT_EQ(b.capacity, 4U); | |
132 | |
133 /* New reallocation here. */ | |
134 buf_putc(&b, 'e'); | |
135 GREATEST_ASSERT_STR_EQ(b.data, "abcde"); | |
136 GREATEST_ASSERT_EQ(b.length, 5U); | |
137 GREATEST_ASSERT_EQ(b.capacity, 8U); | |
138 buf_finish(&b); | |
139 | |
140 GREATEST_PASS(); | |
141 } | |
142 | |
143 GREATEST_TEST | |
144 output_string(void) | |
145 { | |
146 struct buf b; | |
147 | |
148 buf_init(&b); | |
149 | |
150 /* This will allocate an initial buffer of 10. */ | |
151 buf_puts(&b, "abcdefghij"); | |
152 GREATEST_ASSERT_STR_EQ(b.data, "abcdefghij"); | |
153 GREATEST_ASSERT_EQ(b.length, 10U); | |
154 GREATEST_ASSERT_EQ(b.capacity, 10U); | |
155 | |
156 /* This will multiply the capacity to 20 and increase length to 14. */ | |
157 buf_puts(&b, "klmn"); | |
158 GREATEST_ASSERT_STR_EQ(b.data, "abcdefghijklmn"); | |
159 GREATEST_ASSERT_EQ(b.length, 14U); | |
160 GREATEST_ASSERT_EQ(b.capacity, 20U); | |
161 buf_finish(&b); | |
162 | |
163 GREATEST_PASS(); | |
164 } | |
165 | |
166 GREATEST_TEST | |
167 output_printf(void) | |
168 { | |
169 struct buf b; | |
170 | |
171 buf_init(&b); | |
172 | |
173 /* This will allocate string of 6 characters. */ | |
174 buf_printf(&b, "%d%d", 123, 456); | |
175 GREATEST_ASSERT_STR_EQ(b.data, "123456"); | |
176 GREATEST_ASSERT_EQ(b.length, 6U); | |
177 GREATEST_ASSERT_EQ(b.capacity, 6U); | |
178 | |
179 /* This will multiply the capacity to 12 and increase length to 10. */ | |
180 buf_printf(&b, "%s", "hoho"); | |
181 GREATEST_ASSERT_STR_EQ(b.data, "123456hoho"); | |
182 GREATEST_ASSERT_EQ(b.length, 10U); | |
183 GREATEST_ASSERT_EQ(b.capacity, 12U); | |
184 buf_finish(&b); | |
185 | |
186 GREATEST_PASS(); | |
187 } | |
188 | |
189 GREATEST_SUITE(output) | |
190 { | |
191 GREATEST_RUN_TEST(output_char); | |
192 GREATEST_RUN_TEST(output_string); | |
193 GREATEST_RUN_TEST(output_printf); | |
194 } | |
195 | |
196 GREATEST_TEST | |
197 clones_sub(void) | |
198 { | |
199 struct buf b = { 0 }; | |
200 struct buf s1, s2; | |
201 | |
202 buf_puts(&b, "0123456789"); | |
203 | |
204 /* Copy only the portion from 1 to 3. */ | |
205 buf_sub(&s1, &b, 1, 3); | |
206 GREATEST_ASSERT_STR_EQ(s1.data, "123"); | |
207 GREATEST_ASSERT_EQ(s1.length, 3U); | |
208 GREATEST_ASSERT_EQ(s1.capacity, 3U); | |
209 buf_finish(&s1); | |
210 | |
211 /* Copy whole string starting from 4. */ | |
212 buf_sub(&s2, &b, 4, -1); | |
213 GREATEST_ASSERT_STR_EQ(s2.data, "456789"); | |
214 GREATEST_ASSERT_EQ(s2.length, 6U); | |
215 GREATEST_ASSERT_EQ(s2.capacity, 6U); | |
216 buf_finish(&s2); | |
217 buf_finish(&b); | |
218 | |
219 GREATEST_PASS(); | |
220 } | |
221 | |
222 GREATEST_TEST | |
223 clones_dup(void) | |
224 { | |
225 struct buf b = { 0 }; | |
226 struct buf d; | |
227 | |
228 buf_puts(&b, "0123456789"); | |
229 buf_dup(&d, &b); | |
230 GREATEST_ASSERT(b.data != d.data); | |
231 GREATEST_ASSERT_STR_EQ(d.data, "0123456789"); | |
232 GREATEST_ASSERT_EQ(d.length, 10U); | |
233 GREATEST_ASSERT_EQ(d.capacity, 10U); | |
234 buf_finish(&d); | |
235 | |
236 GREATEST_PASS(); | |
237 } | |
238 | |
239 GREATEST_SUITE(clones) | |
240 { | |
241 GREATEST_RUN_TEST(clones_sub); | |
242 GREATEST_RUN_TEST(clones_dup); | |
243 } | |
244 | |
245 GREATEST_TEST | |
246 misc_erase(void) | |
247 { | |
248 struct buf b = { 0 }; | |
249 | |
250 buf_puts(&b, "0123456789"); | |
251 | |
252 /* Only remove portion from 1 to 3, capacity must not change. */ | |
253 buf_erase(&b, 1, 3); | |
254 GREATEST_ASSERT_STR_EQ(b.data, "0456789"); | |
255 GREATEST_ASSERT_EQ(b.length, 7U); | |
256 GREATEST_ASSERT_EQ(b.capacity, 10U); | |
257 | |
258 /* Remove from 4 to the end. */ | |
259 buf_erase(&b, 1, -1); | |
260 GREATEST_ASSERT_STR_EQ(b.data, "0"); | |
261 GREATEST_ASSERT_EQ(b.length, 1U); | |
262 GREATEST_ASSERT_EQ(b.capacity, 10U); | |
263 buf_finish(&b); | |
264 | |
265 GREATEST_PASS(); | |
266 } | |
267 | |
268 GREATEST_TEST | |
269 misc_clear(void) | |
270 { | |
271 struct buf b = { 0 }; | |
272 | |
273 /* Clear should only reduce the length capacity must not change. */ | |
274 buf_puts(&b, "hello world"); | |
275 buf_clear(&b); | |
276 GREATEST_ASSERT_STR_EQ(b.data, ""); | |
277 GREATEST_ASSERT_EQ(b.length, 0U); | |
278 GREATEST_ASSERT_EQ(b.capacity, 11U); | |
279 buf_finish(&b); | |
280 | |
281 GREATEST_PASS(); | |
282 } | |
283 | |
284 GREATEST_SUITE(misc) | |
285 { | |
286 GREATEST_RUN_TEST(misc_erase); | |
287 GREATEST_RUN_TEST(misc_clear); | |
288 } | |
289 | |
290 GREATEST_MAIN_DEFS(); | |
291 | |
292 int | |
293 main(int argc, char **argv) | |
294 { | |
295 GREATEST_MAIN_BEGIN(); | |
296 GREATEST_RUN_SUITE(basics); | |
297 GREATEST_RUN_SUITE(allocs); | |
298 GREATEST_RUN_SUITE(output); | |
299 GREATEST_RUN_SUITE(clones); | |
300 GREATEST_RUN_SUITE(misc); | |
301 GREATEST_MAIN_END(); | |
302 } |