static int
test_seqof2(void)
{
struct test_case tests[] = {
{ NULL, 4,
"\x30\x02\x30\x00",
"seqof2 1" },
{ NULL, 9,
"\x30\x07\x30\x05\x1b\x03\x66\x6f\x6f",
"seqof2 2" },
{ NULL, 14,
"\x30\x0c\x30\x0a\x1b\x03\x66\x6f\x6f\x1b\x03\x62\x61\x72",
"seqof2 3" }
};
int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
TESTSeqOf2 c0, c1, c2;
heim_general_string i[2];
i[0] = "foo";
i[1] = "bar";
c0.strings.val = NULL;
c0.strings.len = 0;
tests[0].val = &c0;
c1.strings.len = 1;
c1.strings.val = i;
tests[1].val = &c1;
c2.strings.len = 2;
c2.strings.val = i;
tests[2].val = &c2;
ret += generic_test (tests, ntests, sizeof(TESTSeqOf2),
(generic_encode)encode_TESTSeqOf2,
(generic_length)length_TESTSeqOf2,
(generic_decode)decode_TESTSeqOf2,
(generic_free)free_TESTSeqOf2,
cmp_dummy,
NULL);
return ret;
}
static int
test_seqofseq(void)
{
struct test_case tests[] = {
{ NULL, 2,
"\x30\x00",
"seqofseq 0" },
{ NULL, 9,
"\x30\x07\x30\x05\xa0\x03\x02\x01\x00",
"seqofseq 1" },
{ NULL, 16,
"\x30\x0e\x30\x05\xa0\x03\x02\x01\x00\x30\x05\xa0\x03\x02\x01\x01",
"seqofseq 2" }
};
int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
TESTSeqOfSeq c0, c1, c2;
struct TESTSeqOfSeq_val i[2];
i[0].zero = 0;
i[1].zero = 1;
c0.len = 0;
c0.val = NULL;
tests[0].val = &c0;
c1.len = 1;
c1.val = i;
tests[1].val = &c1;
c2.len = 2;
c2.val = i;
tests[2].val = &c2;
ret += generic_test (tests, ntests, sizeof(TESTSeqOfSeq),
(generic_encode)encode_TESTSeqOfSeq,
(generic_length)length_TESTSeqOfSeq,
(generic_decode)decode_TESTSeqOfSeq,
(generic_free)free_TESTSeqOfSeq,
cmp_dummy,
NULL);
return ret;
}
static int
test_general_string (void)
{
unsigned char *s1 = "Test User 1";
struct test_case tests[] = {
{NULL, 13, "\x1b\x0b\x54\x65\x73\x74\x20\x55\x73\x65\x72\x20\x31"}
};
int ntests = sizeof(tests) / sizeof(*tests);
tests[0].val = &s1;
asprintf (&tests[0].name, "the string \"%s\"", s1);
return generic_test (tests, ntests, sizeof(unsigned char *),
(generic_encode)encode_general_string,
(generic_length)length_general_string,
(generic_decode)decode_general_string,
cmp_general_string);
}
static int
test_octet_string (void)
{
heim_octet_string s1 = {8, "\x01\x23\x45\x67\x89\xab\xcd\xef"};
struct test_case tests[] = {
{NULL, 10, "\x04\x08\x01\x23\x45\x67\x89\xab\xcd\xef"}
};
int ntests = sizeof(tests) / sizeof(*tests);
tests[0].val = &s1;
asprintf (&tests[0].name, "a octet string");
return generic_test (tests, ntests, sizeof(heim_octet_string),
(generic_encode)encode_octet_string,
(generic_length)length_octet_string,
(generic_decode)decode_octet_string,
cmp_octet_string);
}
static int
test_boolean (void)
{
struct test_case tests[] = {
{NULL, 1, "\xff"},
{NULL, 1, "\x00"}
};
int values[] = { 1, 0 };
int i, ret;
int ntests = sizeof(tests) / sizeof(tests[0]);
size_t size;
heim_integer i2;
for (i = 0; i < ntests; ++i) {
tests[i].val = &values[i];
asprintf (&tests[i].name, "heim_boolean %d", i);
if (tests[i].name == NULL)
errx(1, "malloc");
}
ret = generic_test (tests, ntests, sizeof(int),
(generic_encode)der_put_boolean,
(generic_length)der_length_boolean,
(generic_decode)der_get_boolean,
(generic_free)NULL,
test_cmp_boolean);
for (i = 0; i < ntests; ++i)
free (tests[i].name);
if (ret)
return ret;
/* test zero length integer (BER format) */
ret = der_get_heim_integer(NULL, 0, &i2, &size);
if (ret)
errx(1, "der_get_heim_integer");
if (i2.length != 0)
errx(1, "der_get_heim_integer wrong length");
der_free_heim_integer(&i2);
return 0;
}
static int
test_integer (void)
{
struct test_case tests[] = {
{NULL, 1, "\x00", NULL },
{NULL, 1, "\x7f", NULL },
{NULL, 2, "\x00\x80", NULL },
{NULL, 2, "\x01\x00", NULL },
{NULL, 1, "\x80", NULL },
{NULL, 2, "\xff\x7f", NULL },
{NULL, 1, "\xff", NULL },
{NULL, 2, "\xff\x01", NULL },
{NULL, 2, "\x00\xff", NULL },
{NULL, 4, "\x7f\xff\xff\xff", NULL }
};
int values[] = {0, 127, 128, 256, -128, -129, -1, -255, 255,
0x7fffffff};
int i, ret;
int ntests = sizeof(tests) / sizeof(*tests);
for (i = 0; i < ntests; ++i) {
tests[i].val = &values[i];
if (asprintf (&tests[i].name, "integer %d", values[i]) < 0)
errx(1, "malloc");
if (tests[i].name == NULL)
errx(1, "malloc");
}
ret = generic_test (tests, ntests, sizeof(int),
(generic_encode)der_put_integer,
(generic_length) der_length_integer,
(generic_decode)der_get_integer,
(generic_free)NULL,
cmp_integer,
NULL);
for (i = 0; i < ntests; ++i)
free (tests[i].name);
return ret;
}
static int
test_generalized_time (void)
{
struct test_case tests[] = {
{NULL, 17, "\x18\x0f""19700101000000Z"},
{NULL, 17, "\x18\x0f""19851106210627Z"}
};
time_t values[] = {0, 500159187};
int i;
int ntests = sizeof(tests) / sizeof(*tests);
for (i = 0; i < ntests; ++i) {
tests[i].val = &values[i];
asprintf (&tests[i].name, "time %d", (int)values[i]);
}
return generic_test (tests, ntests, sizeof(time_t),
(generic_encode)encode_generalized_time,
(generic_length)length_generalized_time,
(generic_decode)decode_generalized_time,
cmp_generalized_time);
}
static int
test_unsigned (void)
{
struct test_case tests[] = {
{NULL, 1, "\x00", NULL },
{NULL, 1, "\x7f", NULL },
{NULL, 2, "\x00\x80", NULL },
{NULL, 2, "\x01\x00", NULL },
{NULL, 2, "\x02\x00", NULL },
{NULL, 3, "\x00\x80\x00", NULL },
{NULL, 5, "\x00\x80\x00\x00\x00", NULL },
{NULL, 4, "\x7f\xff\xff\xff", NULL }
};
unsigned int values[] = {0, 127, 128, 256, 512, 32768,
0x80000000, 0x7fffffff};
int i, ret;
int ntests = sizeof(tests) / sizeof(*tests);
for (i = 0; i < ntests; ++i) {
tests[i].val = &values[i];
if (asprintf (&tests[i].name, "unsigned %u", values[i]) < 0)
errx(1, "malloc");
if (tests[i].name == NULL)
errx(1, "malloc");
}
ret = generic_test (tests, ntests, sizeof(int),
(generic_encode)der_put_unsigned,
(generic_length)der_length_unsigned,
(generic_decode)der_get_unsigned,
(generic_free)NULL,
cmp_unsigned,
NULL);
for (i = 0; i < ntests; ++i)
free (tests[i].name);
return ret;
}
static int
test_oid (void)
{
struct test_case tests[] = {
{NULL, 2, "\x29\x01", NULL },
{NULL, 1, "\x29", NULL },
{NULL, 2, "\xff\x01", NULL },
{NULL, 1, "\xff", NULL }
};
heim_oid values[] = {
{ 3, oid_comp1 },
{ 2, oid_comp2 },
{ 3, oid_comp3 },
{ 2, oid_comp4 }
};
int i, ret;
int ntests = sizeof(tests) / sizeof(*tests);
for (i = 0; i < ntests; ++i) {
tests[i].val = &values[i];
if (asprintf (&tests[i].name, "oid %d", i) < 0)
errx(1, "malloc");
if (tests[i].name == NULL)
errx(1, "malloc");
}
ret = generic_test (tests, ntests, sizeof(heim_oid),
(generic_encode)der_put_oid,
(generic_length)der_length_oid,
(generic_decode)der_get_oid,
(generic_free)der_free_oid,
test_cmp_oid,
NULL);
for (i = 0; i < ntests; ++i)
free(tests[i].name);
return ret;
}
static int
test_uint64(void)
{
struct test_case tests[] = {
{ NULL, 3, "\x02\x01\x00", "uint64 0" },
{ NULL, 7, "\x02\x05\x01\xff\xff\xff\xff", "uint64 1" },
{ NULL, 7, "\x02\x05\x02\x00\x00\x00\x00", "uint64 2" },
{ NULL, 9, "\x02\x07\x7f\xff\xff\xff\xff\xff\xff", "uint64 3" },
{ NULL, 10, "\x02\x08\x00\x80\x00\x00\x00\x00\x00\x00", "uint64 4" },
{ NULL, 10, "\x02\x08\x7f\xff\xff\xff\xff\xff\xff\xff", "uint64 5" },
{ NULL, 11, "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff", "uint64 6" }
};
size_t i;
int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
TESTuint64 values[] = { 0, 8589934591LL, 8589934592LL,
36028797018963967LL, 36028797018963968LL,
9223372036854775807LL, 18446744073709551615ULL };
for (i = 0; i < ntests; i++)
tests[i].val = &values[i];
if (sizeof(TESTuint64) != sizeof(uint64_t)) {
ret += 1;
printf("sizeof(TESTuint64) %d != sizeof(uint64_t) %d\n",
(int)sizeof(TESTuint64), (int)sizeof(uint64_t));
}
ret += generic_test (tests, ntests, sizeof(TESTuint64),
(generic_encode)encode_TESTuint64,
(generic_length)length_TESTuint64,
(generic_decode)decode_TESTuint64,
(generic_free)free_TESTuint64,
cmp_dummy,
NULL);
return ret;
}
static int
test_general_string (void)
{
char *s1 = "Test User 1";
struct test_case tests[] = {
{NULL, 11, "\x54\x65\x73\x74\x20\x55\x73\x65\x72\x20\x31"}
};
int ret, ntests = sizeof(tests) / sizeof(*tests);
tests[0].val = &s1;
asprintf (&tests[0].name, "the string \"%s\"", s1);
if (tests[0].name == NULL)
errx(1, "malloc");
ret = generic_test (tests, ntests, sizeof(unsigned char *),
(generic_encode)der_put_general_string,
(generic_length)der_length_general_string,
(generic_decode)der_get_general_string,
(generic_free)der_free_general_string,
cmp_general_string);
free(tests[0].name);
return ret;
}
static int
test_seqof4(void)
{
struct test_case tests[] = {
{ NULL, 2,
"\x30\x00",
"seq4 0" },
{ NULL, 4,
"\x30\x02" "\xa1\x00",
"seq4 1" },
{ NULL, 8,
"\x30\x06" "\xa0\x02\x30\x00" "\xa1\x00",
"seq4 2" },
{ NULL, 2 + (2 + 0x18) + (2 + 0x27) + (2 + 0x31),
"\x30\x76" /* 2 SEQ */
"\xa0\x18\x30\x16" /* 4 [0] SEQ */
"\x30\x14" /* 2 SEQ */
"\x04\x00" /* 2 OCTET-STRING */
"\x04\x02\x01\x02" /* 4 OCTET-STRING */
"\x02\x01\x01" /* 3 INT */
"\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
/* 11 INT */
"\xa1\x27" /* 2 [1] IMPL SEQ */
"\x30\x25" /* 2 SEQ */
"\x02\x01\x01" /* 3 INT */
"\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
/* 11 INT */
"\x02\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00"
/* 11 INT */
"\x04\x00" /* 2 OCTET-STRING */
"\x04\x02\x01\x02" /* 4 OCTET-STRING */
"\x04\x04\x00\x01\x02\x03" /* 6 OCTET-STRING */
"\xa2\x31" /* 2 [2] IMPL SEQ */
"\x30\x2f" /* 2 SEQ */
"\x04\x00" /* 2 OCTET-STRING */
"\x02\x01\x01" /* 3 INT */
"\x04\x02\x01\x02" /* 4 OCTET-STRING */
"\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
/* 11 INT */
"\x04\x04\x00\x01\x02\x03" /* 6 OCTET-STRING */
"\x02\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00"
/* 11 INT */
"\x04\x01\x00" /* 3 OCTET-STRING */
"\x02\x05\x01\x00\x00\x00\x00", /* 7 INT */
"seq4 3" },
};
int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
TESTSeqOf4 c[4];
struct TESTSeqOf4_b1 b1[4];
struct TESTSeqOf4_b2 b2[4];
struct TESTSeqOf4_b3 b3[4];
struct TESTSeqOf4_b1_val b1val[4];
struct TESTSeqOf4_b2_val b2val[4];
struct TESTSeqOf4_b3_val b3val[4];
c[0].b1 = NULL;
c[0].b2 = NULL;
c[0].b3 = NULL;
tests[0].val = &c[0];
b2[1].len = 0;
b2[1].val = NULL;
c[1].b1 = NULL;
c[1].b2 = &b2[1];
c[1].b3 = NULL;
tests[1].val = &c[1];
b1[2].len = 0;
b1[2].val = NULL;
b2[2].len = 0;
b2[2].val = NULL;
c[2].b1 = &b1[2];
c[2].b2 = &b2[2];
c[2].b3 = NULL;
tests[2].val = &c[2];
b1val[3].s1.data = "";
b1val[3].s1.length = 0;
b1val[3].u1 = 1LL;
b1val[3].s2.data = "\x01\x02";
b1val[3].s2.length = 2;
b1val[3].u2 = -1LL;
b2val[3].s1.data = "";
b2val[3].s1.length = 0;
b2val[3].u1 = 1LL;
b2val[3].s2.data = "\x01\x02";
b2val[3].s2.length = 2;
b2val[3].u2 = -1LL;
b2val[3].s3.data = "\x00\x01\x02\x03";
b2val[3].s3.length = 4;
b2val[3].u3 = 1LL<<63;
b3val[3].s1.data = "";
b3val[3].s1.length = 0;
b3val[3].u1 = 1LL;
b3val[3].s2.data = "\x01\x02";
b3val[3].s2.length = 2;
b3val[3].u2 = -1LL;
b3val[3].s3.data = "\x00\x01\x02\x03";
b3val[3].s3.length = 4;
b3val[3].u3 = 1LL<<63;
b3val[3].s4.data = "\x00";
b3val[3].s4.length = 1;
b3val[3].u4 = 1LL<<32;
b1[3].len = 1;
b1[3].val = &b1val[3];
b2[3].len = 1;
b2[3].val = &b2val[3];
b3[3].len = 1;
b3[3].val = &b3val[3];
c[3].b1 = &b1[3];
c[3].b2 = &b2[3];
c[3].b3 = &b3[3];
tests[3].val = &c[3];
ret += generic_test (tests, ntests, sizeof(TESTSeqOf4),
(generic_encode)encode_TESTSeqOf4,
(generic_length)length_TESTSeqOf4,
(generic_decode)decode_TESTSeqOf4,
(generic_free)free_TESTSeqOf4,
cmp_dummy,
NULL);
return ret;
}
