oid.c 7.76 KB
Newer Older
1
#include "clar_libgit2.h"
2
#include "oid.h"
3

4 5 6 7 8 9 10 11
static git_oid id_sha1;
static git_oid idp_sha1;
static git_oid idm_sha1;

const char *str_oid_sha1 = "ae90f12eea699729ed24555e40b9fd669da12a12";
const char *str_oid_sha1_p = "ae90f12eea699729ed";
const char *str_oid_sha1_m = "ae90f12eea699729ed24555e40b9fd669da12a12THIS IS EXTRA TEXT THAT SHOULD GET IGNORED";

12
#ifdef GIT_EXPERIMENTAL_SHA256
13 14 15 16 17 18 19
static git_oid id_sha256;
static git_oid idp_sha256;
static git_oid idm_sha256;

const char *str_oid_sha256 = "d3e63d2f2e43d1fee23a74bf19a0ede156cba2d1bd602eba13de433cea1bb512";
const char *str_oid_sha256_p = "d3e63d2f2e43d1fee2";
const char *str_oid_sha256_m = "d3e63d2f2e43d1fee23a74bf19a0ede156cba2d1bd602eba13de433cea1bb512 GARBAGE EXTRA TEXT AT THE END";
20
#endif
21 22 23

void test_core_oid__initialize(void)
{
24 25 26
	cl_git_pass(git_oid__fromstr(&id_sha1, str_oid_sha1, GIT_OID_SHA1));
	cl_git_pass(git_oid__fromstrp(&idp_sha1, str_oid_sha1_p, GIT_OID_SHA1));
	cl_git_fail(git_oid__fromstrp(&idm_sha1, str_oid_sha1_m, GIT_OID_SHA1));
27

28
#ifdef GIT_EXPERIMENTAL_SHA256
29 30 31
	cl_git_pass(git_oid__fromstr(&id_sha256, str_oid_sha256, GIT_OID_SHA256));
	cl_git_pass(git_oid__fromstrp(&idp_sha256, str_oid_sha256_p, GIT_OID_SHA256));
	cl_git_fail(git_oid__fromstrp(&idm_sha256, str_oid_sha256_m, GIT_OID_SHA256));
32
#endif
33 34
}

35
void test_core_oid__streq_sha1(void)
36
{
37 38
	cl_assert_equal_i(0, git_oid_streq(&id_sha1, str_oid_sha1));
	cl_assert_equal_i(-1, git_oid_streq(&id_sha1, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"));
39

40 41
	cl_assert_equal_i(-1, git_oid_streq(&id_sha1, "deadbeef"));
	cl_assert_equal_i(-1, git_oid_streq(&id_sha1, "I'm not an oid.... :)"));
42

43 44 45 46 47
	cl_assert_equal_i(0, git_oid_streq(&idp_sha1, "ae90f12eea699729ed0000000000000000000000"));
	cl_assert_equal_i(0, git_oid_streq(&idp_sha1, "ae90f12eea699729ed"));
	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "ae90f12eea699729ed1"));
	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "ae90f12eea699729ec"));
	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"));
48

49 50
	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "deadbeef"));
	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "I'm not an oid.... :)"));
51 52
}

53
void test_core_oid__streq_sha256(void)
54
{
55
#ifdef GIT_EXPERIMENTAL_SHA256
56 57
	cl_assert_equal_i(0, git_oid_streq(&id_sha256, str_oid_sha256));
	cl_assert_equal_i(-1, git_oid_streq(&id_sha256, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"));
58

59 60
	cl_assert_equal_i(-1, git_oid_streq(&id_sha256, "deadbeef"));
	cl_assert_equal_i(-1, git_oid_streq(&id_sha256, "I'm not an oid.... :)"));
61

62 63 64 65 66
	cl_assert_equal_i(0, git_oid_streq(&idp_sha256, "d3e63d2f2e43d1fee20000000000000000000000000000000000000000000000"));
	cl_assert_equal_i(0, git_oid_streq(&idp_sha256, "d3e63d2f2e43d1fee2"));
	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "d3e63d2f2e43d1fee21"));
	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "d3e63d2f2e43d1fee1"));
	cl_assert_equal_i(-1, git_oid_streq(&idp_sha256, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"));
67

68 69
	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "deadbeef"));
	cl_assert_equal_i(-1, git_oid_streq(&idp_sha1, "I'm not an oid.... :)"));
70
#endif
71
}
72

73
void test_core_oid__strcmp_sha1(void)
74
{
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
	cl_assert_equal_i(0, git_oid_strcmp(&id_sha1, str_oid_sha1));
	cl_assert(git_oid_strcmp(&id_sha1, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef") < 0);

	cl_assert(git_oid_strcmp(&id_sha1, "deadbeef") < 0);
	cl_assert_equal_i(-1, git_oid_strcmp(&id_sha1, "I'm not an oid.... :)"));

	cl_assert_equal_i(0, git_oid_strcmp(&idp_sha1, "ae90f12eea699729ed0000000000000000000000"));
	cl_assert_equal_i(0, git_oid_strcmp(&idp_sha1, "ae90f12eea699729ed"));
	cl_assert(git_oid_strcmp(&idp_sha1, "ae90f12eea699729ed1") < 0);
	cl_assert(git_oid_strcmp(&idp_sha1, "ae90f12eea699729ec") > 0);
	cl_assert(git_oid_strcmp(&idp_sha1, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef") < 0);

	cl_assert(git_oid_strcmp(&idp_sha1, "deadbeef") < 0);
	cl_assert_equal_i(-1, git_oid_strcmp(&idp_sha1, "I'm not an oid.... :)"));
}

void test_core_oid__strcmp_sha256(void)
{
93
#ifdef GIT_EXPERIMENTAL_SHA256
94 95 96 97 98 99 100 101 102 103 104 105 106 107
	cl_assert_equal_i(0, git_oid_strcmp(&id_sha256, str_oid_sha256));
	cl_assert(git_oid_strcmp(&id_sha256, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef") < 0);

	cl_assert(git_oid_strcmp(&id_sha256, "deadbeef") < 0);
	cl_assert_equal_i(-1, git_oid_strcmp(&id_sha256, "I'm not an oid.... :)"));

	cl_assert_equal_i(0, git_oid_strcmp(&idp_sha256, "d3e63d2f2e43d1fee20000000000000000000000"));
	cl_assert_equal_i(0, git_oid_strcmp(&idp_sha256, "d3e63d2f2e43d1fee2"));
	cl_assert(git_oid_strcmp(&idp_sha256, "d3e63d2f2e43d1fee21") < 0);
	cl_assert(git_oid_strcmp(&idp_sha256, "d3e63d2f2e43d1fee1") > 0);
	cl_assert(git_oid_strcmp(&idp_sha256, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef") < 0);

	cl_assert(git_oid_strcmp(&idp_sha256, "deadbeef") < 0);
	cl_assert_equal_i(-1, git_oid_strcmp(&idp_sha256, "I'm not an oid.... :)"));
108
#endif
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
}

void test_core_oid__ncmp_sha1(void)
{
	cl_assert(!git_oid_ncmp(&id_sha1, &idp_sha1, 0));
	cl_assert(!git_oid_ncmp(&id_sha1, &idp_sha1, 1));
	cl_assert(!git_oid_ncmp(&id_sha1, &idp_sha1, 2));
	cl_assert(!git_oid_ncmp(&id_sha1, &idp_sha1, 17));
	cl_assert(!git_oid_ncmp(&id_sha1, &idp_sha1, 18));
	cl_assert(git_oid_ncmp(&id_sha1, &idp_sha1, 19));
	cl_assert(git_oid_ncmp(&id_sha1, &idp_sha1, 40));
	cl_assert(git_oid_ncmp(&id_sha1, &idp_sha1, 41));
	cl_assert(git_oid_ncmp(&id_sha1, &idp_sha1, 42));

	cl_assert(!git_oid_ncmp(&id_sha1, &id_sha1, 0));
	cl_assert(!git_oid_ncmp(&id_sha1, &id_sha1, 1));
	cl_assert(!git_oid_ncmp(&id_sha1, &id_sha1, 39));
	cl_assert(!git_oid_ncmp(&id_sha1, &id_sha1, 40));
	cl_assert(!git_oid_ncmp(&id_sha1, &id_sha1, 41));
}

void test_core_oid__ncmp_sha256(void)
{
132
#ifdef GIT_EXPERIMENTAL_SHA256
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
	cl_assert(!git_oid_ncmp(&id_sha256, &idp_sha256, 0));
	cl_assert(!git_oid_ncmp(&id_sha256, &idp_sha256, 1));
	cl_assert(!git_oid_ncmp(&id_sha256, &idp_sha256, 2));
	cl_assert(!git_oid_ncmp(&id_sha256, &idp_sha256, 17));
	cl_assert(!git_oid_ncmp(&id_sha256, &idp_sha256, 18));
	cl_assert(git_oid_ncmp(&id_sha256, &idp_sha256, 19));
	cl_assert(git_oid_ncmp(&id_sha256, &idp_sha256, 40));
	cl_assert(git_oid_ncmp(&id_sha256, &idp_sha256, 41));
	cl_assert(git_oid_ncmp(&id_sha256, &idp_sha256, 42));
	cl_assert(git_oid_ncmp(&id_sha256, &idp_sha256, 63));
	cl_assert(git_oid_ncmp(&id_sha256, &idp_sha256, 64));
	cl_assert(git_oid_ncmp(&id_sha256, &idp_sha256, 65));

	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 0));
	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 1));
	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 39));
	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 40));
	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 41));
	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 63));
	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 64));
	cl_assert(!git_oid_ncmp(&id_sha256, &id_sha256, 65));
154
#endif
155
}
156 157 158

void test_core_oid__is_hexstr(void)
{
Edward Thomson committed
159 160 161 162
	cl_assert(git_oid__is_hexstr("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", GIT_OID_SHA1));
	cl_assert(!git_oid__is_hexstr("deadbeefdeadbeef", GIT_OID_SHA1));
	cl_assert(!git_oid__is_hexstr("zeadbeefdeadbeefdeadbeefdeadbeefdeadbeef", GIT_OID_SHA1));
	cl_assert(!git_oid__is_hexstr("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef1", GIT_OID_SHA1));
163
}
164 165 166

void test_core_oid__fmt_substr_sha1(void)
{
167
	char buf[GIT_OID_MAX_HEXSIZE + 1];
168

169
	memset(buf, 0, GIT_OID_MAX_HEXSIZE + 1);
170 171 172
	git_oid_fmt_substr(buf, &id_sha1, 0, 40);
	cl_assert_equal_s(buf, str_oid_sha1);

173
	memset(buf, 0, GIT_OID_MAX_HEXSIZE + 1);
174 175 176
	git_oid_fmt_substr(buf, &id_sha1, 0, 18);
	cl_assert_equal_s(buf, str_oid_sha1_p);

177
	memset(buf, 0, GIT_OID_MAX_HEXSIZE + 1);
178 179 180
	git_oid_fmt_substr(buf, &id_sha1, 0, 5);
	cl_assert_equal_s(buf, "ae90f");

181
	memset(buf, 0, GIT_OID_MAX_HEXSIZE + 1);
182 183 184
	git_oid_fmt_substr(buf, &id_sha1, 5, 5);
	cl_assert_equal_s(buf, "12eea");

185
	memset(buf, 0, GIT_OID_MAX_HEXSIZE + 1);
186 187 188
	git_oid_fmt_substr(buf, &id_sha1, 5, 6);
	cl_assert_equal_s(buf, "12eea6");
}