自学教程：C++ ASSERT_INT_EQ函数代码示例

static voidsig_fuzz(struct sshkey *k, const char *sig_alg){	struct fuzz *fuzz;	u_char *sig, c[] = "some junk to be signed";	size_t l;	u_int fuzzers = FUZZ_1_BIT_FLIP | FUZZ_1_BYTE_FLIP | FUZZ_2_BYTE_FLIP |	    FUZZ_TRUNCATE_START | FUZZ_TRUNCATE_END;	if (test_is_fast())		fuzzers &= ~FUZZ_2_BYTE_FLIP;	if (test_is_slow())		fuzzers |= FUZZ_2_BIT_FLIP;	ASSERT_INT_EQ(sshkey_sign(k, &sig, &l, c, sizeof(c), sig_alg, 0), 0);	ASSERT_SIZE_T_GT(l, 0);	fuzz = fuzz_begin(fuzzers, sig, l);	ASSERT_INT_EQ(sshkey_verify(k, sig, l, c, sizeof(c), NULL, 0), 0);	free(sig);	TEST_ONERROR(onerror, fuzz);	for(; !fuzz_done(fuzz); fuzz_next(fuzz)) {		/* Ensure 1-bit difference at least */		if (fuzz_matches_original(fuzz))			continue;		ASSERT_INT_NE(sshkey_verify(k, fuzz_ptr(fuzz), fuzz_len(fuzz),		    c, sizeof(c), NULL, 0), 0);	}	fuzz_cleanup(fuzz);}

static voidtest_ensure(void){    struct sol_buffer buf = SOL_BUFFER_INIT_EMPTY;    const int size = 1024;    char *buf_data;    int i;    sol_buffer_ensure(&buf, size);    memset(buf.data, 22, size);    sol_buffer_ensure(&buf, size * 2);    buf_data = buf.data;    for (i = 0; i < size; i++) {        ASSERT_INT_EQ(buf_data[i], 22);    }    sol_buffer_ensure(&buf, size / 2);    buf_data = buf.data;    for (i = 0; i < size / 2; i++) {        ASSERT_INT_EQ(buf_data[i], 22);    }    sol_buffer_fini(&buf);}

static voidmunch(int fd, enum ev_type ev, void *arg){	ssize_t nbytes;	char buf[32] = { 0 };	int err;	if ((nbytes = read(fd, buf, sizeof (buf))) < 0) {		FAIL_ERRNO("bad read");	}	VERBOSE(("read %ld bytes '%s'", nbytes, buf));	err = mevent_disable(read_event);	ASSERT_INT_EQ(("mevent_disable: ", strerror(err)), err, 0);	pthread_mutex_lock(&mtx);	ASSERT_INT_EQ(("wrong lastwake"), lastwake, CB_NONE);	lastwake = CB_READ;	pthread_cond_signal(&cv);	VERBOSE(("wakeup"));	pthread_mutex_unlock(&mtx);}

static voidtest_append_from_base64(void){    struct sol_buffer buf;    struct sol_str_slice slice;    const char to_decode[] = "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz";    int err;#define B64_DECODED "This is a message that is multiple of 3 chars"    sol_buffer_init(&buf);    slice = sol_str_slice_from_str("XYZ");    err = sol_buffer_append_slice(&buf, slice);    ASSERT_INT_EQ(err, 0);    ASSERT_INT_EQ(buf.used, strlen("XYZ"));    ASSERT_STR_EQ(buf.data, "XYZ");    slice = sol_str_slice_from_str(to_decode);    err = sol_buffer_append_from_base64(&buf, slice, SOL_BASE64_MAP);    ASSERT_INT_EQ(err, 0);    ASSERT_INT_EQ(buf.used, strlen("XYZ" B64_DECODED));    ASSERT_STR_EQ(buf.data, "XYZ" B64_DECODED);    sol_buffer_fini(&buf);#undef B64_DECODED}

static voidtest_append_from_base16(void){    struct sol_buffer buf;    struct sol_str_slice slice;    const char to_decode[] = "546573742001090a0f2048656c6c6f";    int err;#define B16_DECODED "Test /x01/x09/x0a/x0f Hello"    sol_buffer_init(&buf);    slice = sol_str_slice_from_str("XYZ");    err = sol_buffer_append_slice(&buf, slice);    ASSERT_INT_EQ(err, 0);    ASSERT_INT_EQ(buf.used, strlen("XYZ"));    ASSERT_STR_EQ(buf.data, "XYZ");    slice = sol_str_slice_from_str(to_decode);    err = sol_buffer_append_from_base16(&buf, slice, SOL_DECODE_LOWERCASE);    ASSERT_INT_EQ(err, 0);    ASSERT_INT_EQ(buf.used, strlen("XYZ" B16_DECODED));    ASSERT_STR_EQ(buf.data, "XYZ" B16_DECODED);    sol_buffer_fini(&buf);#undef B16_DECODED}

static voidpublic_fuzz(struct sshkey *k){	struct sshkey *k1;	struct sshbuf *buf;	struct fuzz *fuzz;	ASSERT_PTR_NE(buf = sshbuf_new(), NULL);	ASSERT_INT_EQ(sshkey_to_blob_buf(k, buf), 0);	/* XXX need a way to run the tests in "slow, but complete" mode */	fuzz = fuzz_begin(FUZZ_1_BIT_FLIP | /* XXX too slow FUZZ_2_BIT_FLIP | */	    FUZZ_1_BYTE_FLIP | /* XXX too slow FUZZ_2_BYTE_FLIP | */	    FUZZ_TRUNCATE_START | FUZZ_TRUNCATE_END,	    sshbuf_mutable_ptr(buf), sshbuf_len(buf));	ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(buf), sshbuf_len(buf),	    &k1), 0);	sshkey_free(k1);	sshbuf_free(buf);	TEST_ONERROR(onerror, fuzz);	for(; !fuzz_done(fuzz); fuzz_next(fuzz)) {		if (sshkey_from_blob(fuzz_ptr(fuzz), fuzz_len(fuzz), &k1) == 0)			sshkey_free(k1);	}	fuzz_cleanup(fuzz);}

static voidtest_no_nul_byte(void){    struct sol_buffer buf;    int32_t backend;    int32_t value = 0xdeadbeef;    int err;    sol_buffer_init_flags(&buf, &backend, sizeof(backend),        SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED | SOL_BUFFER_FLAGS_NO_NUL_BYTE);    err = sol_buffer_ensure(&buf, sizeof(int32_t));    ASSERT_INT_EQ(err, 0);    err = sol_buffer_append_slice(&buf, SOL_STR_SLICE_STR((const char *)&value, sizeof(value)));    ASSERT_INT_EQ(err, 0);    err = sol_buffer_append_slice(&buf, SOL_STR_SLICE_STR((const char *)&value, sizeof(value)));    ASSERT_INT_NE(err, 0);    sol_buffer_fini(&buf);    sol_buffer_init_flags(&buf, NULL, 0, SOL_BUFFER_FLAGS_NO_NUL_BYTE);    err = sol_buffer_append_printf(&buf, "123");    ASSERT_INT_EQ(err, 0);    err = sol_buffer_append_printf(&buf, "4");    ASSERT_INT_EQ(err, 0);    ASSERT(sol_str_slice_eq(sol_buffer_get_slice(&buf),        SOL_STR_SLICE_STR("1234", 4)));    sol_buffer_fini(&buf);}

voidtest_s2k(void){    TEST_START("s2k");    static unsigned char salt[S2K_SALT_BYTES] = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };    const char * pphrase = "ImGumbyAndYouAreNot";    static unsigned char expected_key1[AES128_KEY_BYTES] = {        0x0e, 0xa5, 0x00, 0x1c, 0xce, 0xad, 0x7e, 0xa8, 0xa0, 0x81, 0x38, 0xae, 0xaf, 0x4e, 0x28, 0xd5    };    unsigned char s2k_key1[AES128_KEY_BYTES];    compute_gpg_s2k_key(pphrase, sizeof(s2k_key1), salt, S2K_ITER_BYTE_COUNT, s2k_key1);    ASSERT_INT_EQ(memcmp(s2k_key1, expected_key1, sizeof(s2k_key1)), 0);    //  Second test to handle the case where we need to run multiple hashes to generate enough bits    //  Note that the first 16 bytes are the same as the previous test - this is to be expected, since the    //  salt and passphrase are the same, so the first hash is executed identically.    static unsigned char expected_key2[48] = {        0x0e, 0xa5, 0x00, 0x1c, 0xce, 0xad, 0x7e, 0xa8, 0xa0, 0x81, 0x38, 0xae, 0xaf, 0x4e, 0x28, 0xd5,        0x21, 0xf1, 0xee, 0x4b, 0x02, 0xc0, 0x0f, 0x63, 0x6a, 0x17, 0xbf, 0x62, 0x34, 0x10, 0x26, 0x48,        0x7b, 0xc6, 0x3f, 0x08, 0x9d, 0xb5, 0x6b, 0x34, 0x70, 0x3b, 0x71, 0xdb, 0x67, 0x92, 0x6f, 0x5f    };    unsigned char s2k_key2[48];    compute_gpg_s2k_key(pphrase, sizeof(s2k_key2), salt, S2K_ITER_BYTE_COUNT, s2k_key2);    ASSERT_INT_EQ(memcmp(s2k_key2, expected_key2, sizeof(s2k_key2)), 0);    TEST_DONE();}

static voidtest_coap_parse_empty_pdu(void){    uint8_t pdu[] = { 0x40, 0x01, 0, 0 };    struct sol_coap_packet *pkt;    struct sol_buffer *buf;    size_t offset;    uint8_t ver, type, code;    uint16_t id;    pkt = sol_coap_packet_new(NULL);    ASSERT(pkt);    ASSERT(!sol_coap_packet_get_payload(pkt, &buf, &offset));    ASSERT(!sol_buffer_remove_data(buf, 0, offset));    ASSERT(!sol_buffer_insert_bytes(buf, 0, pdu, sizeof(pdu)));    ASSERT(!coap_packet_parse(pkt));    sol_coap_header_get_version(pkt, &ver);    sol_coap_header_get_type(pkt, &type);    sol_coap_header_get_code(pkt, &code);    sol_coap_header_get_id(pkt, &id);    ASSERT_INT_EQ(ver, 1);    ASSERT_INT_EQ(type, SOL_COAP_MESSAGE_TYPE_CON);    ASSERT_INT_EQ(code, SOL_COAP_METHOD_GET);    ASSERT_INT_EQ(id, 0);    sol_coap_packet_unref(pkt);}

static voidtest_coap_find_options(void){    uint8_t pdu[] = { 0x55, 0xA5, 0x12, 0x34, 't', 'o', 'k', 'e', 'n',                      0x00, 0xC1, 0x00, 0xff, 'p', 'a', 'y', 'l', 'o', 'a', 'd', 0x00 };    struct sol_str_slice options[16];    struct sol_coap_packet *pkt;    struct sol_buffer *buf;    int count = 16;    size_t offset;    pkt = sol_coap_packet_new(NULL);    ASSERT(pkt);    ASSERT(!sol_coap_packet_get_payload(pkt, &buf, &offset));    ASSERT(!sol_buffer_remove_data(buf, 0, offset));    ASSERT(!sol_buffer_insert_bytes(buf, 0, pdu, sizeof(pdu)));    ASSERT(!coap_packet_parse(pkt));    count = sol_coap_find_options(pkt, SOL_COAP_OPTION_CONTENT_FORMAT, options, count);    ASSERT_INT_EQ(count, 1);    ASSERT_INT_EQ(options[0].len, 1);    ASSERT_INT_EQ((uint8_t)options[0].data[0], 0);    count = sol_coap_find_options(pkt, SOL_COAP_OPTION_IF_MATCH, options, count);    ASSERT_INT_EQ(count, 0);    sol_coap_packet_unref(pkt);}

intTEST_MAINLOOP_MAIN_FN(int argc, char *argv[]){    int err, i;    struct sol_timeout *timeout_to_del;    struct sol_idle *idler_to_del;    err = sol_init();    ASSERT(!err);    timeout_to_del = sol_timeout_add(100, timeout_never_called, NULL);    sol_timeout_add(20, on_timeout_del_and_new, timeout_to_del);    sol_timeout_add(1, on_timeout_renew_twice, NULL);    sol_idle_add(on_idler_renew_twice, NULL);    for (i = 0; i < 5; i++)        sol_idle_add(on_idler, (void *)(intptr_t)i);    sol_idle_add(on_idler_del_another, &idler_to_del);    idler_to_del = sol_idle_add(on_idler_never_called, NULL);    sol_run();    ASSERT_INT_EQ(timeout_called, 3);    ASSERT_INT_EQ(timeout_renewed, 2);    ASSERT_INT_EQ(idler_renewed, 2);    for (i = 0; i < 10; i++)        ASSERT_INT_EQ(idler_sequence[i], i);    sol_shutdown();    return 0;}

static voidtest_base64_encode(void){    const char base64_map[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";    const char instr[] = "This is a message that is multiple of 3 chars";    const char *expectstrs[] = {        "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz",        "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXI=",        "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYQ==",        "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNo"    };    struct sol_str_slice slice;    char outstr[(sizeof(instr) / 3 + 1) * 4 + 1];    size_t r, i;    slice = sol_str_slice_from_str(instr);    for (i = 0; i < SOL_UTIL_ARRAY_SIZE(expectstrs); i++) {        struct sol_str_slice exp = sol_str_slice_from_str(expectstrs[i]);        memset(outstr, 0xff, sizeof(outstr));        r = sol_util_base64_encode(outstr, sizeof(outstr), slice, base64_map);        ASSERT_INT_EQ(r, exp.len);        ASSERT_INT_EQ(outstr[r], (char)0xff);        outstr[r] = '/0';        ASSERT_STR_EQ(outstr, exp.data);        slice.len--;    }}

static voidpublic_fuzz(struct sshkey *k){	struct sshkey *k1;	struct sshbuf *buf;	struct fuzz *fuzz;	u_int fuzzers = FUZZ_1_BIT_FLIP | FUZZ_1_BYTE_FLIP |	    FUZZ_TRUNCATE_START | FUZZ_TRUNCATE_END;	if (test_is_fast())		fuzzers &= ~FUZZ_1_BIT_FLIP;	if (test_is_slow())		fuzzers |= FUZZ_2_BIT_FLIP | FUZZ_2_BYTE_FLIP;	ASSERT_PTR_NE(buf = sshbuf_new(), NULL);	ASSERT_INT_EQ(sshkey_putb(k, buf), 0);	fuzz = fuzz_begin(fuzzers, sshbuf_mutable_ptr(buf), sshbuf_len(buf));	ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(buf), sshbuf_len(buf),	    &k1), 0);	sshkey_free(k1);	sshbuf_free(buf);	TEST_ONERROR(onerror, fuzz);	for(; !fuzz_done(fuzz); fuzz_next(fuzz)) {		if (sshkey_from_blob(fuzz_ptr(fuzz), fuzz_len(fuzz), &k1) == 0)			sshkey_free(k1);	}	fuzz_cleanup(fuzz);}

static voidtest_coap_find_options(void){    uint8_t pdu[] = { 0x55, 0xA5, 0x12, 0x34, 't', 'o', 'k', 'e', 'n',                      0x00, 0xC1, 0x00, 0xff, 'p', 'a', 'y', 'l', 'o', 'a', 'd', 0x00 };    struct sol_coap_packet *pkt;    struct sol_str_slice options[16];    int count = 16;    pkt = sol_coap_packet_new(NULL);    ASSERT(pkt);    memcpy(pkt->buf, pdu, sizeof(pdu));    pkt->payload.size = sizeof(pdu);    ASSERT(!coap_packet_parse(pkt));    count = sol_coap_find_options(pkt, SOL_COAP_OPTION_CONTENT_FORMAT, options, count);    ASSERT_INT_EQ(count, 1);    ASSERT_INT_EQ(options[0].len, 1);    ASSERT_INT_EQ((uint8_t)options[0].data[0], 0);    count = sol_coap_find_options(pkt, SOL_COAP_OPTION_IF_MATCH, options, count);    ASSERT_INT_EQ(count, 0);    sol_coap_packet_unref(pkt);}

static voidtest_coap_parse_simple_pdu(void){    uint8_t pdu[] = { 0x55, 0xA5, 0x12, 0x34, 't', 'o', 'k', 'e',                      'n',  0x00, 0xc1, 0x00, 0xff, 'p', 'a', 'y',                      'l', 'o', 'a', 'd', 0x00 };    struct sol_str_slice options[16];    struct sol_coap_packet *pkt;    struct sol_buffer *buf;    uint8_t *token;    int count = 16;    size_t offset;    uint8_t tkl, code, ver, type;    uint16_t id;    pkt = sol_coap_packet_new(NULL);    ASSERT(pkt);    ASSERT(!sol_coap_packet_get_payload(pkt, &buf, &offset));    ASSERT(!sol_buffer_remove_data(buf, 0, offset));    ASSERT(!sol_buffer_insert_bytes(buf, 0, pdu, sizeof(pdu)));    ASSERT(!coap_packet_parse(pkt));    sol_coap_header_get_version(pkt, &ver);    sol_coap_header_get_type(pkt, &type);    ASSERT_INT_EQ(ver, 1);    ASSERT_INT_EQ(type, SOL_COAP_MESSAGE_TYPE_NON_CON);    token = sol_coap_header_get_token(pkt, &tkl);    ASSERT(token);    ASSERT_INT_EQ(tkl, 5);    ASSERT(!strcmp((char *)token, "token"));    sol_coap_header_get_code(pkt, &code);    sol_coap_header_get_id(pkt, &id);    ASSERT_INT_EQ(code, SOL_COAP_RESPONSE_CODE_PROXYING_NOT_SUPPORTED);    ASSERT_INT_EQ(id, 0x1234);    count = sol_coap_find_options(pkt, SOL_COAP_OPTION_CONTENT_FORMAT, options, count);    ASSERT_INT_EQ(count, 1);    ASSERT_INT_EQ(options[0].len, 1);    ASSERT_INT_EQ((uint8_t)options[0].data[0], 0);    /* Not existent. */    count = sol_coap_find_options(pkt, SOL_COAP_OPTION_ETAG, options, count);    ASSERT_INT_EQ(count, 0);    ASSERT(!sol_coap_packet_get_payload(pkt, &buf, &offset));    ASSERT_INT_EQ(offset + sizeof("payload"), buf->used);    ASSERT(!strcmp((char *)buf->data + offset, "payload"));    sol_coap_packet_unref(pkt);}

voidTestQPSyntax_run_tests(Folder *index){    u32_t i;    TestBatch   *batch = Test_new_batch("TestQueryParserSyntax", 48, NULL);    Searcher    *searcher     = Searcher_new((Obj*)index);    QueryParser *qparser      = QParser_new(Searcher_Get_Schema(searcher),         NULL, NULL, NULL);    QParser_Set_Heed_Colons(qparser, true);    PLAN(batch);    for (i = 0; leaf_test_funcs[i] != NULL; i++) {        kino_TestQPSyntax_test_t test_func = leaf_test_funcs[i];        TestQueryParser *test_case = test_func(i);        Query *tree     = QParser_Tree(qparser, test_case->query_string);        Query *expanded = QParser_Expand_Leaf(qparser, test_case->tree);        Query *parsed   = QParser_Parse(qparser, test_case->query_string);        Hits  *hits     = Searcher_Hits(searcher, (Obj*)parsed, 0, 10, NULL);        ASSERT_TRUE(batch, Query_Equals(tree, (Obj*)test_case->tree),            "tree()    %s", test_case->query_string->ptr);        ASSERT_TRUE(batch, Query_Equals(expanded, (Obj*)test_case->expanded),            "expand_leaf()    %s", test_case->query_string->ptr);        ASSERT_INT_EQ(batch, Hits_Total_Hits(hits), test_case->num_hits,            "hits:    %s", test_case->query_string->ptr);        DECREF(hits);        DECREF(parsed);        DECREF(expanded);        DECREF(tree);        DECREF(test_case);    }    for (i = 0; syntax_test_funcs[i] != NULL; i++) {        kino_TestQPSyntax_test_t test_func = syntax_test_funcs[i];        TestQueryParser *test_case = test_func(i);        Query *tree   = QParser_Tree(qparser, test_case->query_string);        Query *parsed = QParser_Parse(qparser, test_case->query_string);        Hits  *hits   = Searcher_Hits(searcher, (Obj*)parsed, 0, 10, NULL);        ASSERT_TRUE(batch, Query_Equals(tree, (Obj*)test_case->tree),            "tree()    %s", test_case->query_string->ptr);        ASSERT_INT_EQ(batch, Hits_Total_Hits(hits), test_case->num_hits,            "hits:    %s", test_case->query_string->ptr);        DECREF(hits);        DECREF(parsed);        DECREF(tree);        DECREF(test_case);    }    batch->destroy(batch);    DECREF(searcher);    DECREF(qparser);}

static voidtest_size_mul(void){    const size_t half_size = SIZE_MAX / 2;    const size_t half_double_size = (SIZE_MAX % 2) ? (SIZE_MAX - 1) : SIZE_MAX;    size_t out;    ASSERT(sol_util_size_mul(half_size, 2, &out) == 0);    ASSERT_INT_EQ(out, half_double_size);    ASSERT_INT_EQ(sol_util_size_mul(half_size, 4, &out), -EOVERFLOW);}

static voidput_opt(struct sshbuf *b, const char *name, const char *value){	struct sshbuf *sect;	sect = sshbuf_new();	ASSERT_PTR_NE(sect, NULL);	ASSERT_INT_EQ(sshbuf_put_cstring(b, name), 0);	if (value != NULL)		ASSERT_INT_EQ(sshbuf_put_cstring(sect, value), 0);	ASSERT_INT_EQ(sshbuf_put_stringb(b, sect), 0);	sshbuf_free(sect);}

voidbadarg(void){	char	 buf[16];	int	 len, width;	width = 1;	TEST_START("utf8_badarg");	len = snmprintf(buf, sizeof(buf), &width, "/377");	ASSERT_INT_EQ(len, -1);	ASSERT_STRING_EQ(buf, "");	ASSERT_INT_EQ(width, 0);	TEST_DONE();}

static voidtest_check_slices_after_adding_all(void){    static const char *gladiators[] = { "Spartacus", "C r i x u s", "Priscus and Verus", "Tetraites",                                        "Spiculus", "Marcus Attilius", "Carpophorus", "Flamma", "Commodus", "Mevia", "Hoplomachus",                                        "Laquearius", "Lorarius", "Paegniarius", "Sagittarius", "Pegasasu no Seiya", "Thraex", "Gladiatrix",                                        "Crupellarii", "Cestus", "Arbelas", "Retiarius", "Samnite", "Venator", "Dimachaerus", "Bustuarius",                                        "This is a loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong name for a gladiator"                                      };    struct sol_arena *arena;    struct sol_str_slice results[sol_util_array_size(gladiators)];    unsigned int i;    arena = sol_arena_new();    ASSERT(arena);    for (i = 0; i < sol_util_array_size(gladiators); i++)        ASSERT_INT_EQ(sol_arena_slice_dup_str(arena, &results[i], gladiators[i]), 0);    for (i = 0; i < sol_util_array_size(gladiators); i++)        ASSERT(sol_str_slice_eq(results[i], sol_str_slice_from_str(gladiators[i])));    sol_arena_del(arena);}

static voidtest_set_slice(void){    struct sol_buffer buf;    struct sol_str_slice slice;    const char *str = "Hello";    char *backend;    int err;    backend = strdup(str);    slice = sol_str_slice_from_str(backend);    sol_buffer_init(&buf);    err = sol_buffer_set_slice(&buf, slice);    ASSERT(err >= 0);    ASSERT_INT_EQ(buf.used, strlen(backend));    ASSERT_STR_EQ(buf.data, backend);    backend[1] = 'a';    ASSERT_STR_NE(buf.data, backend);    ASSERT_STR_EQ(buf.data, str);    sol_buffer_fini(&buf);    free(backend);}

static voidsignature_test(struct sshkey *k, struct sshkey *bad, const u_char *d, size_t l){	size_t len;	u_char *sig;	ASSERT_INT_EQ(sshkey_sign(k, &sig, &len, d, l, 0), 0);	ASSERT_SIZE_T_GT(len, 8);	ASSERT_PTR_NE(sig, NULL);	ASSERT_INT_EQ(sshkey_verify(k, sig, len, d, l, 0), 0);	ASSERT_INT_NE(sshkey_verify(bad, sig, len, d, l, 0), 0);	/* Fuzz test is more comprehensive, this is just a smoke test */	sig[len - 5] ^= 0x10;	ASSERT_INT_NE(sshkey_verify(k, sig, len, d, l, 0), 0);	free(sig);}

static voidtest_base16_decode(void){    const char expstr[] = "Test /x01/x09/x0a/x0f Hello";    const char *instrs[] = {        "546573742001090a0f2048656c6c6f",        "546573742001090A0F2048656C6C6F"    };    char outstr[sizeof(expstr)];    struct sol_str_slice slice;    ssize_t r, i;    enum sol_decode_case decode_case;    for (i = 0; i < 4; i++) {        slice = sol_str_slice_from_str(instrs[i % 2]);        if (i == 0)            decode_case = SOL_DECODE_LOWERCASE;        else if (i == 1)            decode_case = SOL_DECODE_UPERCASE;        else            decode_case = SOL_DECODE_BOTH;        memset(outstr, 0xff, sizeof(outstr));        r = sol_util_base16_decode(outstr, sizeof(outstr), slice, decode_case);        ASSERT_INT_EQ(r, strlen(expstr));        ASSERT_INT_EQ(outstr[r], (char)0xff);        outstr[r] = '/0';        ASSERT_STR_EQ(outstr, expstr);    }    /* negative test (case swap) */    for (i = 0; i < 2; i++) {        slice = sol_str_slice_from_str(instrs[i]);        memset(outstr, 0xff, sizeof(outstr));        r = sol_util_base16_decode(outstr, sizeof(outstr), slice, !i ?            SOL_DECODE_UPERCASE : SOL_DECODE_LOWERCASE);    }    /* short sequence (not multiple of 2) */    slice = sol_str_slice_from_str("1");    memset(outstr, 0xff, sizeof(outstr));    r = sol_util_base16_decode(outstr, sizeof(outstr), slice,        SOL_DECODE_UPERCASE);    ASSERT_INT_EQ(r, -EINVAL);}

static voidtest_coap_parse_simple_pdu(void){    uint8_t pdu[] = { 0x55, 0xA5, 0x12, 0x34, 't', 'o', 'k', 'e',                      'n',  0x00, 0xc1, 0x00, 0xff, 'p', 'a', 'y',                      'l', 'o', 'a', 'd', 0x00 };    struct sol_coap_packet *pkt;    struct sol_str_slice options[16];    uint8_t *payload, *token;    uint16_t len;    int count = 16;    uint8_t tkl;    pkt = sol_coap_packet_new(NULL);    ASSERT(pkt);    memcpy(pkt->buf, pdu, sizeof(pdu));    pkt->payload.size = sizeof(pdu);    ASSERT(!coap_packet_parse(pkt));    ASSERT_INT_EQ(sol_coap_header_get_ver(pkt), 1);    ASSERT_INT_EQ(sol_coap_header_get_type(pkt), SOL_COAP_TYPE_NONCON);    token = sol_coap_header_get_token(pkt, &tkl);    ASSERT(token);    ASSERT_INT_EQ(tkl, 5);    ASSERT(!strcmp((char *)token, "token"));    ASSERT_INT_EQ(sol_coap_header_get_code(pkt), SOL_COAP_RSPCODE_PROXYING_NOT_SUPPORTED);    ASSERT_INT_EQ(sol_coap_header_get_id(pkt), 0x1234);    count = sol_coap_find_options(pkt, SOL_COAP_OPTION_CONTENT_FORMAT, options, count);    ASSERT_INT_EQ(count, 1);    ASSERT_INT_EQ(options[0].len, 1);    ASSERT_INT_EQ((uint8_t)options[0].data[0], 0);    /* Not existent. */    count = sol_coap_find_options(pkt, SOL_COAP_OPTION_ETAG, options, count);    ASSERT_INT_EQ(count, 0);    ASSERT(!sol_coap_packet_get_payload(pkt, &payload, &len));    ASSERT_INT_EQ(len, sizeof("payload"));    ASSERT(!strcmp((char *)payload, "payload"));    sol_coap_packet_unref(pkt);}

static voidtest_base64_decode(void){    const char base64_map[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";    char expstr[] = "This is a message that is multiple of 3 chars";    const char *instrs[] = {        "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz",        "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXI=",        "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYQ==",        "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNo"    };    struct sol_str_slice exp, slice;    char outstr[sizeof(expstr)];    size_t r, i;    exp = sol_str_slice_from_str(expstr);    for (i = 0; i < SOL_UTIL_ARRAY_SIZE(instrs); i++) {        slice = sol_str_slice_from_str(instrs[i]);        memset(outstr, 0xff, sizeof(outstr));        r = sol_util_base64_decode(outstr, sizeof(outstr), slice, base64_map);        ASSERT_INT_EQ(r, exp.len);        ASSERT_INT_EQ(outstr[r], (char)0xff);        outstr[r] = '/0';        ASSERT_STR_EQ(outstr, exp.data);        exp.len--;        expstr[exp.len] = '/0';    }    /* negative test (invalid char) */    slice = sol_str_slice_from_str("****");    memset(outstr, 0xff, sizeof(outstr));    r = sol_util_base64_decode(outstr, sizeof(outstr), slice, base64_map);    ASSERT_INT_EQ(r, -EINVAL);    /* short sequence (not multiple of 4) */    slice = sol_str_slice_from_str("123");    memset(outstr, 0xff, sizeof(outstr));    r = sol_util_base64_decode(outstr, sizeof(outstr), slice, base64_map);    ASSERT_INT_EQ(r, -EINVAL);}

struct sshbuf *load_text_file(const char *name){	struct sshbuf *ret = load_file(name);	const u_char *p;	/* Trim whitespace at EOL */	for (p = sshbuf_ptr(ret); sshbuf_len(ret) > 0;) {		if (p[sshbuf_len(ret) - 1] == '/r' ||		    p[sshbuf_len(ret) - 1] == '/t' ||		    p[sshbuf_len(ret) - 1] == ' ' ||		    p[sshbuf_len(ret) - 1] == '/n')			ASSERT_INT_EQ(sshbuf_consume_end(ret, 1), 0);		else			break;	}	/* /0 terminate */	ASSERT_INT_EQ(sshbuf_put_u8(ret, 0), 0);	return ret;}

static voidtest_ssize_mul(void){    ssize_t half_ssize = SSIZE_MAX / 2;    ssize_t half_double_ssize = (SSIZE_MAX % 2) ?        (SSIZE_MAX - 1) : SSIZE_MAX;    ssize_t out;    ASSERT(sol_util_ssize_mul(half_ssize, 2, &out) == 0);    ASSERT(out == half_double_ssize);    ASSERT_INT_EQ(sol_util_ssize_mul(half_ssize, 4, &out), -EOVERFLOW);    half_ssize *= -1;    half_double_ssize *= -1;    ASSERT(sol_util_ssize_mul(half_ssize, 2, &out) == 0);    ASSERT(out == half_double_ssize);    ASSERT_INT_EQ(sol_util_ssize_mul(half_ssize, 4, &out), -EOVERFLOW);}

static boolon_timeout_del_and_new(void *data){    struct sol_timeout *timeout_to_del = data;    timeout_called++;    ASSERT_INT_EQ(sol_timeout_del(timeout_to_del), 1);    sol_timeout_add(250, on_timeout_quit, NULL);    sol_timeout_add(200, on_timeout_chained, NULL);    return false;}

voidone(const char *name, const char *mbs, int width,    int wantwidth, int wantlen, const char *wants){	char	 buf[16];	int	*wp;	int	 len;	if (wantlen == -2)		wantlen = strlen(wants);	(void)strlcpy(buf, "utf8_", sizeof(buf));	(void)strlcat(buf, name, sizeof(buf));	TEST_START(buf);	wp = wantwidth == -2 ? NULL : &width;	len = snmprintf(buf, sizeof(buf), wp, "%s", mbs);	ASSERT_INT_EQ(len, wantlen);	ASSERT_STRING_EQ(buf, wants);	ASSERT_INT_EQ(width, wantwidth);	TEST_DONE();}

static struct sshkey *get_private(const char *n){	struct sshbuf *b;	struct sshkey *ret;	b = load_file(n);	ASSERT_INT_EQ(sshkey_parse_private_fileblob(b, "", n, &ret, NULL), 0);	sshbuf_free(b);	return ret;}