]>
Commit | Line | Data |
---|---|---|
2a1732b4 VM |
1 | /* |
2 | * This file is free software; you can redistribute it and/or modify | |
3 | * it under the terms of the GNU General Public License, version 2, | |
4 | * as published by the Free Software Foundation. | |
5 | * | |
6 | * In addition to the permissions in the GNU General Public License, | |
7 | * the authors give you unlimited permission to link the compiled | |
8 | * version of this file into combinations with other programs, | |
9 | * and to distribute those combinations without any restriction | |
10 | * coming from the use of this file. (The General Public License | |
11 | * restrictions do apply in other respects; for example, they cover | |
12 | * modification of the file, and distribution when not linked into | |
13 | * a combined executable.) | |
14 | * | |
15 | * This file is distributed in the hope that it will be useful, but | |
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
18 | * General Public License for more details. | |
19 | * | |
20 | * You should have received a copy of the GNU General Public License | |
21 | * along with this program; see the file COPYING. If not, write to | |
22 | * the Free Software Foundation, 51 Franklin Street, Fifth Floor, | |
23 | * Boston, MA 02110-1301, USA. | |
24 | */ | |
25 | #include "test_lib.h" | |
2a1732b4 | 26 | |
72a3fe42 | 27 | #include "odb.h" |
2a1732b4 VM |
28 | #include "hash.h" |
29 | ||
72a3fe42 VM |
30 | #include "t01-data.h" |
31 | ||
32 | static int hash_object(git_oid *oid, git_rawobj *obj) | |
33 | { | |
34 | return git_odb_hash(oid, obj->data, obj->len, obj->type); | |
35 | } | |
36 | ||
3dccfed1 | 37 | BEGIN_TEST(oid0, "validate size of oid objects") |
2a1732b4 VM |
38 | git_oid out; |
39 | must_be_true(20 == GIT_OID_RAWSZ); | |
40 | must_be_true(40 == GIT_OID_HEXSZ); | |
41 | must_be_true(sizeof(out) == GIT_OID_RAWSZ); | |
42 | must_be_true(sizeof(out.id) == GIT_OID_RAWSZ); | |
43 | END_TEST | |
44 | ||
3dccfed1 | 45 | BEGIN_TEST(oid1, "fail when parsing an empty string as oid") |
2a1732b4 VM |
46 | git_oid out; |
47 | must_fail(git_oid_mkstr(&out, "")); | |
48 | END_TEST | |
49 | ||
3dccfed1 | 50 | BEGIN_TEST(oid2, "fail when parsing an invalid string as oid") |
2a1732b4 VM |
51 | git_oid out; |
52 | must_fail(git_oid_mkstr(&out, "moo")); | |
53 | END_TEST | |
54 | ||
55 | static int from_hex(unsigned int i) | |
56 | { | |
57 | if (i >= '0' && i <= '9') | |
58 | return i - '0'; | |
59 | if (i >= 'a' && i <= 'f') | |
60 | return 10 + (i - 'a'); | |
61 | if (i >= 'A' && i <= 'F') | |
62 | return 10 + (i - 'A'); | |
63 | return -1; | |
64 | } | |
65 | ||
3dccfed1 | 66 | BEGIN_TEST(oid3, "find all invalid characters when parsing an oid") |
2a1732b4 VM |
67 | git_oid out; |
68 | unsigned char exp[] = { | |
69 | 0x16, 0xa6, 0x77, 0x70, 0xb7, | |
70 | 0xd8, 0xd7, 0x23, 0x17, 0xc4, | |
71 | 0xb7, 0x75, 0x21, 0x3c, 0x23, | |
72 | 0xa8, 0xbd, 0x74, 0xf5, 0xe0, | |
73 | }; | |
74 | char in[41] = "16a67770b7d8d72317c4b775213c23a8bd74f5e0"; | |
75 | unsigned int i; | |
76 | ||
77 | for (i = 0; i < 256; i++) { | |
78 | in[38] = (char)i; | |
79 | ||
80 | if (from_hex(i) >= 0) { | |
81 | exp[19] = (unsigned char)(from_hex(i) << 4); | |
82 | must_pass(git_oid_mkstr(&out, in)); | |
83 | must_be_true(memcmp(out.id, exp, sizeof(out.id)) == 0); | |
84 | } else { | |
85 | must_fail(git_oid_mkstr(&out, in)); | |
86 | } | |
87 | } | |
88 | END_TEST | |
89 | ||
3dccfed1 | 90 | BEGIN_TEST(oid4, "fail when parsing an invalid oid string") |
2a1732b4 VM |
91 | git_oid out; |
92 | must_fail(git_oid_mkstr(&out, "16a67770b7d8d72317c4b775213c23a8bd74f5ez")); | |
93 | END_TEST | |
94 | ||
3dccfed1 | 95 | BEGIN_TEST(oid5, "succeed when parsing a valid oid string") |
2a1732b4 VM |
96 | git_oid out; |
97 | unsigned char exp[] = { | |
98 | 0x16, 0xa6, 0x77, 0x70, 0xb7, | |
99 | 0xd8, 0xd7, 0x23, 0x17, 0xc4, | |
100 | 0xb7, 0x75, 0x21, 0x3c, 0x23, | |
101 | 0xa8, 0xbd, 0x74, 0xf5, 0xe0, | |
102 | }; | |
103 | ||
104 | must_pass(git_oid_mkstr(&out, "16a67770b7d8d72317c4b775213c23a8bd74f5e0")); | |
105 | must_pass(memcmp(out.id, exp, sizeof(out.id))); | |
106 | ||
107 | must_pass(git_oid_mkstr(&out, "16A67770B7D8D72317C4b775213C23A8BD74F5E0")); | |
108 | must_pass(memcmp(out.id, exp, sizeof(out.id))); | |
109 | END_TEST | |
110 | ||
3dccfed1 | 111 | BEGIN_TEST(oid6, "build a valid oid from raw bytes") |
2a1732b4 VM |
112 | git_oid out; |
113 | unsigned char exp[] = { | |
114 | 0x16, 0xa6, 0x77, 0x70, 0xb7, | |
115 | 0xd8, 0xd7, 0x23, 0x17, 0xc4, | |
116 | 0xb7, 0x75, 0x21, 0x3c, 0x23, | |
117 | 0xa8, 0xbd, 0x74, 0xf5, 0xe0, | |
118 | }; | |
119 | ||
120 | git_oid_mkraw(&out, exp); | |
121 | must_pass(memcmp(out.id, exp, sizeof(out.id))); | |
122 | END_TEST | |
123 | ||
3dccfed1 | 124 | BEGIN_TEST(oid7, "properly copy an oid to another") |
2a1732b4 VM |
125 | git_oid a, b; |
126 | unsigned char exp[] = { | |
127 | 0x16, 0xa6, 0x77, 0x70, 0xb7, | |
128 | 0xd8, 0xd7, 0x23, 0x17, 0xc4, | |
129 | 0xb7, 0x75, 0x21, 0x3c, 0x23, | |
130 | 0xa8, 0xbd, 0x74, 0xf5, 0xe0, | |
131 | }; | |
132 | ||
133 | memset(&b, 0, sizeof(b)); | |
134 | git_oid_mkraw(&a, exp); | |
135 | git_oid_cpy(&b, &a); | |
136 | must_pass(memcmp(a.id, exp, sizeof(a.id))); | |
137 | END_TEST | |
138 | ||
3dccfed1 | 139 | BEGIN_TEST(oid8, "compare two oids (lesser than)") |
2a1732b4 VM |
140 | git_oid a, b; |
141 | unsigned char a_in[] = { | |
142 | 0x16, 0xa6, 0x77, 0x70, 0xb7, | |
143 | 0xd8, 0xd7, 0x23, 0x17, 0xc4, | |
144 | 0xb7, 0x75, 0x21, 0x3c, 0x23, | |
145 | 0xa8, 0xbd, 0x74, 0xf5, 0xe0, | |
146 | }; | |
147 | unsigned char b_in[] = { | |
148 | 0x16, 0xa6, 0x77, 0x70, 0xb7, | |
149 | 0xd8, 0xd7, 0x23, 0x17, 0xc4, | |
150 | 0xb7, 0x75, 0x21, 0x3c, 0x23, | |
151 | 0xa8, 0xbd, 0x74, 0xf5, 0xf0, | |
152 | }; | |
153 | ||
154 | git_oid_mkraw(&a, a_in); | |
155 | git_oid_mkraw(&b, b_in); | |
156 | must_be_true(git_oid_cmp(&a, &b) < 0); | |
157 | END_TEST | |
158 | ||
3dccfed1 | 159 | BEGIN_TEST(oid9, "compare two oids (equal)") |
2a1732b4 VM |
160 | git_oid a, b; |
161 | unsigned char a_in[] = { | |
162 | 0x16, 0xa6, 0x77, 0x70, 0xb7, | |
163 | 0xd8, 0xd7, 0x23, 0x17, 0xc4, | |
164 | 0xb7, 0x75, 0x21, 0x3c, 0x23, | |
165 | 0xa8, 0xbd, 0x74, 0xf5, 0xe0, | |
166 | }; | |
167 | ||
168 | git_oid_mkraw(&a, a_in); | |
169 | git_oid_mkraw(&b, a_in); | |
170 | must_be_true(git_oid_cmp(&a, &b) == 0); | |
171 | END_TEST | |
172 | ||
3dccfed1 | 173 | BEGIN_TEST(oid10, "compare two oids (greater than)") |
2a1732b4 VM |
174 | git_oid a, b; |
175 | unsigned char a_in[] = { | |
176 | 0x16, 0xa6, 0x77, 0x70, 0xb7, | |
177 | 0xd8, 0xd7, 0x23, 0x17, 0xc4, | |
178 | 0xb7, 0x75, 0x21, 0x3c, 0x23, | |
179 | 0xa8, 0xbd, 0x74, 0xf5, 0xe0, | |
180 | }; | |
181 | unsigned char b_in[] = { | |
182 | 0x16, 0xa6, 0x77, 0x70, 0xb7, | |
183 | 0xd8, 0xd7, 0x23, 0x17, 0xc4, | |
184 | 0xb7, 0x75, 0x21, 0x3c, 0x23, | |
185 | 0xa8, 0xbd, 0x74, 0xf5, 0xd0, | |
186 | }; | |
187 | ||
188 | git_oid_mkraw(&a, a_in); | |
189 | git_oid_mkraw(&b, b_in); | |
190 | must_be_true(git_oid_cmp(&a, &b) > 0); | |
191 | END_TEST | |
192 | ||
3dccfed1 | 193 | BEGIN_TEST(oid11, "compare formated oids") |
2a1732b4 VM |
194 | const char *exp = "16a0123456789abcdef4b775213c23a8bd74f5e0"; |
195 | git_oid in; | |
196 | char out[GIT_OID_HEXSZ + 1]; | |
197 | ||
198 | must_pass(git_oid_mkstr(&in, exp)); | |
199 | ||
200 | /* Format doesn't touch the last byte */ | |
201 | out[GIT_OID_HEXSZ] = 'Z'; | |
202 | git_oid_fmt(out, &in); | |
203 | must_be_true(out[GIT_OID_HEXSZ] == 'Z'); | |
204 | ||
205 | /* Format produced the right result */ | |
206 | out[GIT_OID_HEXSZ] = '\0'; | |
207 | must_pass(strcmp(exp, out)); | |
208 | END_TEST | |
209 | ||
3dccfed1 | 210 | BEGIN_TEST(oid12, "compare oids (allocate + format)") |
2a1732b4 VM |
211 | const char *exp = "16a0123456789abcdef4b775213c23a8bd74f5e0"; |
212 | git_oid in; | |
213 | char *out; | |
214 | ||
215 | must_pass(git_oid_mkstr(&in, exp)); | |
216 | ||
217 | out = git_oid_allocfmt(&in); | |
218 | must_be_true(out); | |
219 | must_pass(strcmp(exp, out)); | |
220 | free(out); | |
221 | END_TEST | |
222 | ||
3dccfed1 | 223 | BEGIN_TEST(oid13, "compare oids (path format)") |
2a1732b4 VM |
224 | const char *exp1 = "16a0123456789abcdef4b775213c23a8bd74f5e0"; |
225 | const char *exp2 = "16/a0123456789abcdef4b775213c23a8bd74f5e0"; | |
226 | git_oid in; | |
227 | char out[GIT_OID_HEXSZ + 2]; | |
228 | ||
229 | must_pass(git_oid_mkstr(&in, exp1)); | |
230 | ||
231 | /* Format doesn't touch the last byte */ | |
232 | out[GIT_OID_HEXSZ + 1] = 'Z'; | |
233 | git_oid_pathfmt(out, &in); | |
234 | must_be_true(out[GIT_OID_HEXSZ + 1] == 'Z'); | |
235 | ||
236 | /* Format produced the right result */ | |
237 | out[GIT_OID_HEXSZ + 1] = '\0'; | |
238 | must_pass(strcmp(exp2, out)); | |
239 | END_TEST | |
240 | ||
3dccfed1 | 241 | BEGIN_TEST(oid14, "convert raw oid to string") |
2a1732b4 VM |
242 | const char *exp = "16a0123456789abcdef4b775213c23a8bd74f5e0"; |
243 | git_oid in; | |
244 | char out[GIT_OID_HEXSZ + 1]; | |
245 | char *str; | |
246 | int i; | |
247 | ||
248 | must_pass(git_oid_mkstr(&in, exp)); | |
249 | ||
250 | /* NULL buffer pointer, returns static empty string */ | |
251 | str = git_oid_to_string(NULL, sizeof(out), &in); | |
252 | must_be_true(str && *str == '\0' && str != out); | |
253 | ||
254 | /* zero buffer size, returns static empty string */ | |
255 | str = git_oid_to_string(out, 0, &in); | |
256 | must_be_true(str && *str == '\0' && str != out); | |
257 | ||
258 | /* NULL oid pointer, returns static empty string */ | |
259 | str = git_oid_to_string(out, sizeof(out), NULL); | |
260 | must_be_true(str && *str == '\0' && str != out); | |
261 | ||
262 | /* n == 1, returns out as an empty string */ | |
263 | str = git_oid_to_string(out, 1, &in); | |
264 | must_be_true(str && *str == '\0' && str == out); | |
265 | ||
266 | for (i = 1; i < GIT_OID_HEXSZ; i++) { | |
267 | out[i+1] = 'Z'; | |
268 | str = git_oid_to_string(out, i+1, &in); | |
269 | /* returns out containing c-string */ | |
270 | must_be_true(str && str == out); | |
271 | /* must be '\0' terminated */ | |
272 | must_be_true(*(str+i) == '\0'); | |
273 | /* must not touch bytes past end of string */ | |
274 | must_be_true(*(str+(i+1)) == 'Z'); | |
275 | /* i == n-1 charaters of string */ | |
276 | must_pass(strncmp(exp, out, i)); | |
277 | } | |
278 | ||
279 | /* returns out as hex formatted c-string */ | |
280 | str = git_oid_to_string(out, sizeof(out), &in); | |
281 | must_be_true(str && str == out && *(str+GIT_OID_HEXSZ) == '\0'); | |
282 | must_pass(strcmp(exp, out)); | |
283 | END_TEST | |
284 | ||
3dccfed1 | 285 | BEGIN_TEST(oid15, "convert raw oid to string (big)") |
2a1732b4 VM |
286 | const char *exp = "16a0123456789abcdef4b775213c23a8bd74f5e0"; |
287 | git_oid in; | |
288 | char big[GIT_OID_HEXSZ + 1 + 3]; /* note + 4 => big buffer */ | |
289 | char *str; | |
290 | ||
291 | must_pass(git_oid_mkstr(&in, exp)); | |
292 | ||
293 | /* place some tail material */ | |
294 | big[GIT_OID_HEXSZ+0] = 'W'; /* should be '\0' afterwards */ | |
295 | big[GIT_OID_HEXSZ+1] = 'X'; /* should remain untouched */ | |
296 | big[GIT_OID_HEXSZ+2] = 'Y'; /* ditto */ | |
297 | big[GIT_OID_HEXSZ+3] = 'Z'; /* ditto */ | |
298 | ||
299 | /* returns big as hex formatted c-string */ | |
300 | str = git_oid_to_string(big, sizeof(big), &in); | |
301 | must_be_true(str && str == big && *(str+GIT_OID_HEXSZ) == '\0'); | |
302 | must_pass(strcmp(exp, big)); | |
303 | ||
304 | /* check tail material is untouched */ | |
305 | must_be_true(str && str == big && *(str+GIT_OID_HEXSZ+1) == 'X'); | |
306 | must_be_true(str && str == big && *(str+GIT_OID_HEXSZ+2) == 'Y'); | |
307 | must_be_true(str && str == big && *(str+GIT_OID_HEXSZ+3) == 'Z'); | |
308 | END_TEST | |
309 | ||
26022f07 VM |
310 | |
311 | BEGIN_TEST(oid16, "make sure the OID shortener doesn't choke on duplicate sha1s") | |
312 | ||
313 | git_oid_shorten *os; | |
314 | int min_len; | |
315 | ||
316 | os = git_oid_shorten_new(0); | |
317 | must_be_true(os != NULL); | |
318 | ||
319 | git_oid_shorten_add(os, "22596363b3de40b06f981fb85d82312e8c0ed511"); | |
320 | git_oid_shorten_add(os, "ce08fe4884650f067bd5703b6a59a8b3b3c99a09"); | |
321 | git_oid_shorten_add(os, "16a0123456789abcdef4b775213c23a8bd74f5e0"); | |
322 | min_len = git_oid_shorten_add(os, "ce08fe4884650f067bd5703b6a59a8b3b3c99a09"); | |
323 | ||
324 | must_be_true(min_len == GIT_OID_HEXSZ + 1); | |
325 | ||
326 | git_oid_shorten_free(os); | |
327 | END_TEST | |
328 | ||
329 | BEGIN_TEST(oid17, "stress test for the git_oid_shorten object") | |
330 | ||
331 | #define MAX_OIDS 1000 | |
332 | ||
333 | git_oid_shorten *os; | |
334 | char *oids[MAX_OIDS]; | |
335 | char number_buffer[16]; | |
336 | git_oid oid; | |
337 | size_t i, j; | |
338 | ||
339 | int min_len = 0, found_collision; | |
340 | ||
341 | os = git_oid_shorten_new(0); | |
342 | must_be_true(os != NULL); | |
343 | ||
344 | /* | |
345 | * Insert in the shortener 1000 unique SHA1 ids | |
346 | */ | |
347 | for (i = 0; i < MAX_OIDS; ++i) { | |
348 | char *oid_text; | |
349 | ||
350 | sprintf(number_buffer, "%u", (unsigned int)i); | |
351 | git_hash_buf(&oid, number_buffer, strlen(number_buffer)); | |
352 | ||
353 | oid_text = git__malloc(GIT_OID_HEXSZ + 1); | |
354 | git_oid_fmt(oid_text, &oid); | |
355 | oid_text[GIT_OID_HEXSZ] = 0; | |
356 | ||
357 | min_len = git_oid_shorten_add(os, oid_text); | |
358 | must_be_true(min_len >= 0); | |
359 | ||
360 | oids[i] = oid_text; | |
361 | } | |
362 | ||
363 | /* | |
364 | * Compare the first `min_char - 1` characters of each | |
365 | * SHA1 OID. If the minimizer worked, we should find at | |
366 | * least one collision | |
367 | */ | |
368 | found_collision = 0; | |
369 | for (i = 0; i < MAX_OIDS; ++i) { | |
370 | for (j = 0; j < MAX_OIDS; ++j) { | |
371 | if (i != j && memcmp(oids[i], oids[j], min_len - 1) == 0) | |
372 | found_collision = 1; | |
373 | } | |
374 | } | |
375 | must_be_true(found_collision == 1); | |
376 | ||
377 | /* | |
378 | * Compare the first `min_char` characters of each | |
379 | * SHA1 OID. If the minimizer worked, every single preffix | |
380 | * should be unique. | |
381 | */ | |
382 | found_collision = 0; | |
383 | for (i = 0; i < MAX_OIDS; ++i) { | |
384 | for (j = 0; j < MAX_OIDS; ++j) { | |
385 | if (i != j && memcmp(oids[i], oids[j], min_len) == 0) | |
386 | found_collision = 1; | |
387 | } | |
388 | } | |
389 | must_be_true(found_collision == 0); | |
390 | ||
391 | /* cleanup */ | |
392 | for (i = 0; i < MAX_OIDS; ++i) | |
393 | free(oids[i]); | |
394 | ||
395 | git_oid_shorten_free(os); | |
396 | ||
397 | #undef MAX_OIDS | |
398 | END_TEST | |
399 | ||
2a1732b4 VM |
400 | static char *hello_id = "22596363b3de40b06f981fb85d82312e8c0ed511"; |
401 | static char *hello_text = "hello world\n"; | |
402 | ||
403 | static char *bye_id = "ce08fe4884650f067bd5703b6a59a8b3b3c99a09"; | |
404 | static char *bye_text = "bye world\n"; | |
405 | ||
3dccfed1 | 406 | BEGIN_TEST(hash0, "normal hash by blocks") |
2a1732b4 VM |
407 | git_hash_ctx *ctx; |
408 | git_oid id1, id2; | |
409 | ||
410 | must_be_true((ctx = git_hash_new_ctx()) != NULL); | |
411 | ||
412 | /* should already be init'd */ | |
413 | git_hash_update(ctx, hello_text, strlen(hello_text)); | |
414 | git_hash_final(&id2, ctx); | |
415 | must_pass(git_oid_mkstr(&id1, hello_id)); | |
416 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
417 | ||
418 | /* reinit should permit reuse */ | |
419 | git_hash_init(ctx); | |
420 | git_hash_update(ctx, bye_text, strlen(bye_text)); | |
421 | git_hash_final(&id2, ctx); | |
422 | must_pass(git_oid_mkstr(&id1, bye_id)); | |
423 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
424 | ||
425 | git_hash_free_ctx(ctx); | |
426 | END_TEST | |
427 | ||
3dccfed1 | 428 | BEGIN_TEST(hash1, "hash whole buffer in a single call") |
2a1732b4 VM |
429 | git_oid id1, id2; |
430 | ||
431 | must_pass(git_oid_mkstr(&id1, hello_id)); | |
432 | ||
433 | git_hash_buf(&id2, hello_text, strlen(hello_text)); | |
434 | ||
435 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
436 | END_TEST | |
437 | ||
3dccfed1 | 438 | BEGIN_TEST(hash2, "hash a vector") |
2a1732b4 VM |
439 | git_oid id1, id2; |
440 | git_buf_vec vec[2]; | |
441 | ||
442 | must_pass(git_oid_mkstr(&id1, hello_id)); | |
443 | ||
444 | vec[0].data = hello_text; | |
445 | vec[0].len = 4; | |
446 | vec[1].data = hello_text+4; | |
447 | vec[1].len = strlen(hello_text)-4; | |
448 | ||
449 | git_hash_vec(&id2, vec, 2); | |
450 | ||
451 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
452 | END_TEST | |
453 | ||
3dccfed1 | 454 | BEGIN_TEST(objtype0, "convert type to string") |
2a1732b4 VM |
455 | must_be_true(!strcmp(git_object_type2string(GIT_OBJ_BAD), "")); |
456 | must_be_true(!strcmp(git_object_type2string(GIT_OBJ__EXT1), "")); | |
457 | must_be_true(!strcmp(git_object_type2string(GIT_OBJ_COMMIT), "commit")); | |
458 | must_be_true(!strcmp(git_object_type2string(GIT_OBJ_TREE), "tree")); | |
459 | must_be_true(!strcmp(git_object_type2string(GIT_OBJ_BLOB), "blob")); | |
460 | must_be_true(!strcmp(git_object_type2string(GIT_OBJ_TAG), "tag")); | |
461 | must_be_true(!strcmp(git_object_type2string(GIT_OBJ__EXT2), "")); | |
462 | must_be_true(!strcmp(git_object_type2string(GIT_OBJ_OFS_DELTA), "OFS_DELTA")); | |
463 | must_be_true(!strcmp(git_object_type2string(GIT_OBJ_REF_DELTA), "REF_DELTA")); | |
464 | ||
465 | must_be_true(!strcmp(git_object_type2string(-2), "")); | |
466 | must_be_true(!strcmp(git_object_type2string(8), "")); | |
467 | must_be_true(!strcmp(git_object_type2string(1234), "")); | |
468 | END_TEST | |
469 | ||
3dccfed1 | 470 | BEGIN_TEST(objtype1, "convert string to type") |
2a1732b4 VM |
471 | must_be_true(git_object_string2type(NULL) == GIT_OBJ_BAD); |
472 | must_be_true(git_object_string2type("") == GIT_OBJ_BAD); | |
473 | must_be_true(git_object_string2type("commit") == GIT_OBJ_COMMIT); | |
474 | must_be_true(git_object_string2type("tree") == GIT_OBJ_TREE); | |
475 | must_be_true(git_object_string2type("blob") == GIT_OBJ_BLOB); | |
476 | must_be_true(git_object_string2type("tag") == GIT_OBJ_TAG); | |
477 | must_be_true(git_object_string2type("OFS_DELTA") == GIT_OBJ_OFS_DELTA); | |
478 | must_be_true(git_object_string2type("REF_DELTA") == GIT_OBJ_REF_DELTA); | |
479 | ||
480 | must_be_true(git_object_string2type("CoMmIt") == GIT_OBJ_BAD); | |
481 | must_be_true(git_object_string2type("hohoho") == GIT_OBJ_BAD); | |
482 | END_TEST | |
483 | ||
3dccfed1 | 484 | BEGIN_TEST(objtype2, "check if an object type is loose") |
2a1732b4 VM |
485 | must_be_true(git_object_typeisloose(GIT_OBJ_BAD) == 0); |
486 | must_be_true(git_object_typeisloose(GIT_OBJ__EXT1) == 0); | |
487 | must_be_true(git_object_typeisloose(GIT_OBJ_COMMIT) == 1); | |
488 | must_be_true(git_object_typeisloose(GIT_OBJ_TREE) == 1); | |
489 | must_be_true(git_object_typeisloose(GIT_OBJ_BLOB) == 1); | |
490 | must_be_true(git_object_typeisloose(GIT_OBJ_TAG) == 1); | |
491 | must_be_true(git_object_typeisloose(GIT_OBJ__EXT2) == 0); | |
492 | must_be_true(git_object_typeisloose(GIT_OBJ_OFS_DELTA) == 0); | |
493 | must_be_true(git_object_typeisloose(GIT_OBJ_REF_DELTA) == 0); | |
494 | ||
495 | must_be_true(git_object_typeisloose(-2) == 0); | |
496 | must_be_true(git_object_typeisloose(8) == 0); | |
497 | must_be_true(git_object_typeisloose(1234) == 0); | |
498 | END_TEST | |
499 | ||
3dccfed1 | 500 | BEGIN_TEST(objhash0, "hash junk data") |
2a1732b4 VM |
501 | git_oid id, id_zero; |
502 | ||
503 | must_pass(git_oid_mkstr(&id_zero, zero_id)); | |
504 | ||
505 | /* invalid types: */ | |
506 | junk_obj.data = some_data; | |
72a3fe42 | 507 | must_fail(hash_object(&id, &junk_obj)); |
2a1732b4 VM |
508 | |
509 | junk_obj.type = GIT_OBJ__EXT1; | |
72a3fe42 | 510 | must_fail(hash_object(&id, &junk_obj)); |
2a1732b4 VM |
511 | |
512 | junk_obj.type = GIT_OBJ__EXT2; | |
72a3fe42 | 513 | must_fail(hash_object(&id, &junk_obj)); |
2a1732b4 VM |
514 | |
515 | junk_obj.type = GIT_OBJ_OFS_DELTA; | |
72a3fe42 | 516 | must_fail(hash_object(&id, &junk_obj)); |
2a1732b4 VM |
517 | |
518 | junk_obj.type = GIT_OBJ_REF_DELTA; | |
72a3fe42 | 519 | must_fail(hash_object(&id, &junk_obj)); |
2a1732b4 VM |
520 | |
521 | /* data can be NULL only if len is zero: */ | |
522 | junk_obj.type = GIT_OBJ_BLOB; | |
523 | junk_obj.data = NULL; | |
72a3fe42 | 524 | must_pass(hash_object(&id, &junk_obj)); |
2a1732b4 VM |
525 | must_be_true(git_oid_cmp(&id, &id_zero) == 0); |
526 | ||
527 | junk_obj.len = 1; | |
72a3fe42 | 528 | must_fail(hash_object(&id, &junk_obj)); |
2a1732b4 VM |
529 | END_TEST |
530 | ||
3dccfed1 | 531 | BEGIN_TEST(objhash1, "hash a commit object") |
2a1732b4 VM |
532 | git_oid id1, id2; |
533 | ||
534 | must_pass(git_oid_mkstr(&id1, commit_id)); | |
535 | ||
72a3fe42 | 536 | must_pass(hash_object(&id2, &commit_obj)); |
2a1732b4 VM |
537 | |
538 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
539 | END_TEST | |
540 | ||
3dccfed1 | 541 | BEGIN_TEST(objhash2, "hash a tree object") |
2a1732b4 VM |
542 | git_oid id1, id2; |
543 | ||
544 | must_pass(git_oid_mkstr(&id1, tree_id)); | |
545 | ||
72a3fe42 | 546 | must_pass(hash_object(&id2, &tree_obj)); |
2a1732b4 VM |
547 | |
548 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
549 | END_TEST | |
550 | ||
3dccfed1 | 551 | BEGIN_TEST(objhash3, "hash a tag object") |
2a1732b4 VM |
552 | git_oid id1, id2; |
553 | ||
554 | must_pass(git_oid_mkstr(&id1, tag_id)); | |
555 | ||
72a3fe42 | 556 | must_pass(hash_object(&id2, &tag_obj)); |
2a1732b4 VM |
557 | |
558 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
559 | END_TEST | |
560 | ||
3dccfed1 | 561 | BEGIN_TEST(objhash4, "hash a zero-length object") |
2a1732b4 VM |
562 | git_oid id1, id2; |
563 | ||
564 | must_pass(git_oid_mkstr(&id1, zero_id)); | |
565 | ||
72a3fe42 | 566 | must_pass(hash_object(&id2, &zero_obj)); |
2a1732b4 VM |
567 | |
568 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
569 | END_TEST | |
570 | ||
3dccfed1 | 571 | BEGIN_TEST(objhash5, "hash an one-byte long object") |
2a1732b4 VM |
572 | git_oid id1, id2; |
573 | ||
574 | must_pass(git_oid_mkstr(&id1, one_id)); | |
575 | ||
72a3fe42 | 576 | must_pass(hash_object(&id2, &one_obj)); |
2a1732b4 VM |
577 | |
578 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
579 | END_TEST | |
580 | ||
3dccfed1 | 581 | BEGIN_TEST(objhash6, "hash a two-byte long object") |
2a1732b4 VM |
582 | git_oid id1, id2; |
583 | ||
584 | must_pass(git_oid_mkstr(&id1, two_id)); | |
585 | ||
72a3fe42 | 586 | must_pass(hash_object(&id2, &two_obj)); |
2a1732b4 VM |
587 | |
588 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
589 | END_TEST | |
590 | ||
3dccfed1 | 591 | BEGIN_TEST(objhash7, "hash an object several bytes long") |
2a1732b4 VM |
592 | git_oid id1, id2; |
593 | ||
594 | must_pass(git_oid_mkstr(&id1, some_id)); | |
595 | ||
72a3fe42 | 596 | must_pass(hash_object(&id2, &some_obj)); |
2a1732b4 VM |
597 | |
598 | must_be_true(git_oid_cmp(&id1, &id2) == 0); | |
599 | END_TEST | |
600 | ||
3dccfed1 VM |
601 | BEGIN_SUITE(rawobjects) |
602 | ADD_TEST(oid0); | |
603 | ADD_TEST(oid1); | |
604 | ADD_TEST(oid2); | |
605 | ADD_TEST(oid3); | |
606 | ADD_TEST(oid4); | |
607 | ADD_TEST(oid5); | |
608 | ADD_TEST(oid6); | |
609 | ADD_TEST(oid7); | |
610 | ADD_TEST(oid8); | |
611 | ADD_TEST(oid9); | |
612 | ADD_TEST(oid10); | |
613 | ADD_TEST(oid11); | |
614 | ADD_TEST(oid12); | |
615 | ADD_TEST(oid13); | |
616 | ADD_TEST(oid14); | |
617 | ADD_TEST(oid15); | |
26022f07 VM |
618 | ADD_TEST(oid16); |
619 | ADD_TEST(oid17); | |
3dccfed1 VM |
620 | |
621 | ADD_TEST(hash0); | |
622 | ADD_TEST(hash1); | |
623 | ADD_TEST(hash2); | |
624 | ||
625 | ADD_TEST(objtype0); | |
626 | ADD_TEST(objtype1); | |
627 | ADD_TEST(objtype2); | |
628 | ||
629 | ADD_TEST(objhash0); | |
630 | ADD_TEST(objhash1); | |
631 | ADD_TEST(objhash2); | |
632 | ADD_TEST(objhash3); | |
633 | ADD_TEST(objhash4); | |
634 | ADD_TEST(objhash5); | |
635 | ADD_TEST(objhash6); | |
636 | ADD_TEST(objhash7); | |
637 | END_SUITE | |
2a1732b4 | 638 |