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

int main() {    FILE *fp = fopen("t/data/01-chrome-github.txt", "r");    if (fp==NULL) {fputs ("File error",stderr); exit (1);}    fseek(fp, 0 , SEEK_END);    size_t fsize = ftell(fp);    rewind(fp);        char * buf = (char*) malloc(sizeof(char) * fsize);    size_t s;    s = fread(buf, sizeof(char), fsize, fp );    if (s != fsize) {fputs ("Reading error",stderr); exit (3);}    // printf("%zu/n%s", s, buf);    RequestHeader *header;    header = h3_request_header_new();    h3_request_header_parse(header, buf, s);    h3_request_header_free(header);    test_header(SS("GET /method HTTP/1.1/r/n") );    test_header(SS("GET /method/r/n"));    test_header(SS("GET /path"));    char *headerbody1 = "GET /method HTTP/1.1/r/n"        "Host: github.com/r/n"        "Connection: keep-alive/r/n"        "Content-Length: 12611/r/n"        "Cache-Control: no-cache/r/n"        "/r/n"        ;    header = h3_request_header_new();    h3_request_header_parse( header, SL(headerbody1));    h3_request_header_free(header);    /*    while (feof(fp) == 0) {        s = fread(buf, sizeof(char), flen, fp );        printf("/n%zu/n%s", s, buf);    }    */    /*    while( (s = fread(buf, sizeof(char), BUFSIZE, fp )) > 0 ) {        printf("%zu ==> %s/n", s, buf);    }    */    fclose(fp);    free (buf);}

void BinaryTreeTest::test_node_children_are_null_by_default() {  test_header( "node children are null by default" );  Node<int> node;  print_test( node.left == NULL && node.right == NULL );}

void test_double_float() {    test_header();    double d = 2.2354e-10;    float f = d;    uint32_t i = 7821334;    uchar_vec b;    unsigned char *buffer = NULL;    kv_init(b);    dump_double(d, &b);    buffer = b.a;    fprintf(stderr, "%g == %g - ", d, load_double(&buffer));    fprintf(stderr, "buffer used: %zu/n", buffer - b.a);    kv_clear(b);    dump_float(f, &b);    buffer = b.a;    fprintf(stderr, "%g == %g - ", d, load_float(&buffer));    fprintf(stderr, "buffer used: %zu/n", buffer - b.a);    kv_clear(b);    dump_uint32(i, &b);    buffer = b.a;    fprintf(stderr, "%d == %d - ", i, load_uint32(&buffer));    fprintf(stderr, "buffer used: %zu/n", buffer - b.a);    kv_destroy(b);}

voidassert_ptr(const char *file, int line, const char *a1, const char *a2,    const void *aa1, const void *aa2, enum test_predicate pred){	TEST_CHECK(aa1, aa2, pred);	test_header(file, line, a1, a2, "PTR", pred);	fprintf(stderr, "%12s = %p/n", a1, aa1);	fprintf(stderr, "%12s = %p/n", a2, aa2);	test_die();}

void QueueTest::clear_queue() {  test_header( "clearing the queue (isEmpty and dequeue)" );  while( ! queue->isEmpty() ) {    queue->dequeue();  }  // Makes the assumption that program would fail if loop fails  print_test( true );}

voidassert_u32(const char *file, int line, const char *a1, const char *a2,    u_int32_t aa1, u_int32_t aa2, enum test_predicate pred){	TEST_CHECK(aa1, aa2, pred);	test_header(file, line, a1, a2, "U32", pred);	fprintf(stderr, "%12s = 0x%08x %u/n", a1, aa1, aa1);	fprintf(stderr, "%12s = 0x%08x %u/n", a2, aa2, aa2);	test_die();}

voidassert_u_int(const char *file, int line, const char *a1, const char *a2,    u_int aa1, u_int aa2, enum test_predicate pred){	TEST_CHECK(aa1, aa2, pred);	test_header(file, line, a1, a2, "U_INT", pred);	fprintf(stderr, "%12s = %u / 0x%x/n", a1, aa1, aa1);	fprintf(stderr, "%12s = %u / 0x%x/n", a2, aa2, aa2);	test_die();}

voidassert_size_t(const char *file, int line, const char *a1, const char *a2,    size_t aa1, size_t aa2, enum test_predicate pred){	TEST_CHECK(aa1, aa2, pred);	test_header(file, line, a1, a2, "SIZE_T", pred);	fprintf(stderr, "%12s = %zu/n", a1, aa1);	fprintf(stderr, "%12s = %zu/n", a2, aa2);	test_die();}

voidassert_long_long(const char *file, int line, const char *a1, const char *a2,    long long aa1, long long aa2, enum test_predicate pred){	TEST_CHECK(aa1, aa2, pred);	test_header(file, line, a1, a2, "LONG LONG", pred);	fprintf(stderr, "%12s = %lld / 0x%llx/n", a1, aa1, aa1);	fprintf(stderr, "%12s = %lld / 0x%llx/n", a2, aa2, aa2);	test_die();}

voidassert_mem(const char *file, int line, const char *a1, const char *a2,    const void *aa1, const void *aa2, size_t l, enum test_predicate pred){	int r = memcmp(aa1, aa2, l);	TEST_CHECK_INT(r, pred);	test_header(file, line, a1, a2, "STRING", pred);	fprintf(stderr, "%12s = %s (len %zu)/n", a1, tohex(aa1, MIN(l, 256)), l);	fprintf(stderr, "%12s = %s (len %zu)/n", a2, tohex(aa2, MIN(l, 256)), l);	test_die();}

voidassert_string(const char *file, int line, const char *a1, const char *a2,    const char *aa1, const char *aa2, enum test_predicate pred){	int r = strcmp(aa1, aa2);	TEST_CHECK_INT(r, pred);	test_header(file, line, a1, a2, "STRING", pred);	fprintf(stderr, "%12s = %s (len %zu)/n", a1, aa1, strlen(aa1));	fprintf(stderr, "%12s = %s (len %zu)/n", a2, aa2, strlen(aa2));	test_die();}

voidassert_u64(const char *file, int line, const char *a1, const char *a2,    u_int64_t aa1, u_int64_t aa2, enum test_predicate pred){	TEST_CHECK(aa1, aa2, pred);	test_header(file, line, a1, a2, "U64", pred);	fprintf(stderr, "%12s = 0x%016llx %llu/n", a1,	    (unsigned long long)aa1, (unsigned long long)aa1);	fprintf(stderr, "%12s = 0x%016llx %llu/n", a2,	    (unsigned long long)aa2, (unsigned long long)aa2);	test_die();}

voidassert_bignum(const char *file, int line, const char *a1, const char *a2,    const BIGNUM *aa1, const BIGNUM *aa2, enum test_predicate pred){	int r = BN_cmp(aa1, aa2);	TEST_CHECK_INT(r, pred);	test_header(file, line, a1, a2, "BIGNUM", pred);	fprintf(stderr, "%12s = 0x%s/n", a1, BN_bn2hex(aa1));	fprintf(stderr, "%12s = 0x%s/n", a2, BN_bn2hex(aa2));	test_die();}

voidassert_char(const char *file, int line, const char *a1, const char *a2,    char aa1, char aa2, enum test_predicate pred){	char buf[8];	TEST_CHECK(aa1, aa2, pred);	test_header(file, line, a1, a2, "CHAR", pred);	fprintf(stderr, "%12s = '%s' / 0x02%x/n", a1,	    vis(buf, aa1, VIS_SAFE|VIS_NL|VIS_TAB|VIS_OCTAL, 0), aa1);	fprintf(stderr, "%12s = '%s' / 0x02%x/n", a1,	    vis(buf, aa2, VIS_SAFE|VIS_NL|VIS_TAB|VIS_OCTAL, 0), aa2);	test_die();}

intmain(void){	// Valid headers	known_flags.backward_size = 1024;	for (lzma_check check = LZMA_CHECK_NONE;			check <= LZMA_CHECK_ID_MAX; ++check) {		test_header();		test_footer();	}	// Invalid headers	test_encode_invalid();	test_decode_invalid();	return 0;}

voidassert_string(const char *file, int line, const char *a1, const char *a2,    const char *aa1, const char *aa2, enum test_predicate pred){	int r;	/* Verify pointers are not NULL */	assert_ptr(file, line, a1, "NULL", aa1, NULL, TEST_NE);	assert_ptr(file, line, a2, "NULL", aa2, NULL, TEST_NE);	r = strcmp(aa1, aa2);	TEST_CHECK_INT(r, pred);	test_header(file, line, a1, a2, "STRING", pred);	fprintf(stderr, "%12s = %s (len %zu)/n", a1, aa1, strlen(aa1));	fprintf(stderr, "%12s = %s (len %zu)/n", a2, aa2, strlen(aa2));	test_die();}

voidassert_mem_filled(const char *file, int line, const char *a1,    const void *aa1, u_char v, size_t l, enum test_predicate pred){	size_t where = -1;	int r = memvalcmp(aa1, v, l, &where);	char tmp[64];	if (l == 0)		return;	TEST_CHECK_INT(r, pred);	test_header(file, line, a1, NULL, "MEM_ZERO", pred);	fprintf(stderr, "%20s = %s%s (len %zu)/n", a1,	    tohex(aa1, MIN(l, 20)), l > 20 ? "..." : "", l);	snprintf(tmp, sizeof(tmp), "(%s)[%zu]", a1, where);	fprintf(stderr, "%20s = 0x%02x (expected 0x%02x)/n", tmp,	    ((u_char *)aa1)[where], v);	test_die();}

voidassert_mem(const char *file, int line, const char *a1, const char *a2,    const void *aa1, const void *aa2, size_t l, enum test_predicate pred){	int r;	if (l == 0)		return;	/* If length is >0, then verify pointers are not NULL */	assert_ptr(file, line, a1, "NULL", aa1, NULL, TEST_NE);	assert_ptr(file, line, a2, "NULL", aa2, NULL, TEST_NE);	r = memcmp(aa1, aa2, l);	TEST_CHECK_INT(r, pred);	test_header(file, line, a1, a2, "STRING", pred);	fprintf(stderr, "%12s = %s (len %zu)/n", a1, tohex(aa1, MIN(l, 256)), l);	fprintf(stderr, "%12s = %s (len %zu)/n", a2, tohex(aa2, MIN(l, 256)), l);	test_die();}

/* Open a new decompressing object on the top of IO. If TRANSPARENT is true,   even if IO does not contain data compressed by gzip, return a valid file   object. Note that this function won't close IO, even if an error occurs.  */static grub_file_tgrub_gzio_open (grub_file_t io){  grub_file_t file;  grub_gzio_t gzio = 0;  file = (grub_file_t) grub_malloc (sizeof (*file));  if (! file)    return 0;  gzio = grub_zalloc (sizeof (*gzio));  if (! gzio)    {      grub_free (file);      return 0;    }  gzio->file = io;  file->device = io->device;  file->offset = 0;  file->data = gzio;  file->read_hook = 0;  file->fs = &grub_gzio_fs;  file->not_easly_seekable = 1;  if (! test_header (file))    {      grub_free (gzio);      grub_free (file);      grub_file_seek (io, 0);      if (grub_errno == GRUB_ERR_BAD_FILE_TYPE)	{	  grub_errno = GRUB_ERR_NONE;	  return io;	}    }  return file;}

voidtest_end_of_header (void){    const gchar *packet;    gsize packet_size;    test_header();    channel_free();    reply_continue();    cut_assert_true(milter_server_context_end_of_header(context));    pump_all_events();    milter_test_assert_state(END_OF_HEADER);    milter_test_assert_status(NOT_CHANGE);    milter_command_encoder_encode_end_of_header(encoder, &packet, &packet_size);    milter_test_assert_packet(channel, packet, packet_size);    cut_assert_equal_uint(0, n_message_processed);}

void test_forest_serialization() {    test_header();    ET_problem prob;    ET_params params;    ET_forest *forest, *forest2;    uchar_vec buffer;    unsigned char *mobile_buffer;    float vector[] = {3, 1, 1, 6, 6, 2};    kv_init(buffer);    problem_init(&prob, big_vectors, big_labels);    EXTRA_TREE_DEFAULT_REGR_PARAMS(prob, params);    params.number_of_trees = 100;    params.number_of_features_tested = 1;    params.select_features_with_replacement = true;    forest = ET_forest_build(&prob, &params);    ET_forest_dump(forest, &buffer, true);    fprintf(stderr, "forest dump: %zu bytes/n", kv_size(buffer));    mobile_buffer = buffer.a;    forest2 = ET_forest_load(&mobile_buffer);    forest2->params = forest->params; // FIXME    fprintf(stderr, "orig   forest pred: %g/n",        ET_forest_predict(forest, vector));    fprintf(stderr, "cloned forest pred: %g/n",        ET_forest_predict(forest2, vector));    kv_destroy(buffer);    ET_forest_destroy(forest);    ET_forest_destroy(forest2);    free(forest);    free(forest2);}

static grub_file_tgrub_xzio_open (grub_file_t io){  grub_file_t file;  grub_xzio_t xzio;  file = (grub_file_t) grub_zalloc (sizeof (*file));  if (!file)    return 0;  xzio = grub_zalloc (sizeof (*xzio));  if (!xzio)    {      grub_free (file);      return 0;    }  xzio->file = io;  xzio->saved_offset = 0;  file->device = io->device;  file->offset = 0;  file->data = xzio;  file->read_hook = 0;  file->fs = &grub_xzio_fs;  file->size = GRUB_FILE_SIZE_UNKNOWN;  file->not_easly_seekable = 1;  if (grub_file_tell (xzio->file) != 0)    grub_file_seek (xzio->file, 0);  /* Allocated 64KiB for dictionary.   * Decoder will relocate if bigger is needed.  */  xzio->dec = xz_dec_init (1 << 16);  if (!xzio->dec)    {      grub_free (file);      grub_free (xzio);      return 0;    }  xzio->buf.in = xzio->inbuf;  xzio->buf.in_pos = 0;  xzio->buf.in_size = 0;  xzio->buf.out = xzio->outbuf;  xzio->buf.out_pos = 0;  xzio->buf.out_size = XZBUFSIZ;  /* FIXME: don't test footer on not easily seekable files.  */  if (!test_header (file) || !test_footer (file))    {      grub_errno = GRUB_ERR_NONE;      grub_file_seek (io, 0);      xz_dec_end (xzio->dec);      grub_free (xzio);      grub_free (file);      return io;    }  return file;}