// compare performance with boost::mem_fn
int main()
{
test_vector v;
boost::timer t;
double time1, time2;
std::cout <<
"Test case: sorting " << N << " objects.\n\n"
"Criterion accessor called with | elasped seconds\n"
"-------------------------------|----------------" << std::endl;
setup_test(v);
t.restart();
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1400)
do_test(v, BOOST_EXAMPLE_FAST_MEM_FN(& test::id));
#else // MSVC<8 does not like the implementation of the deduction macro:
do_test(v, ::example::fast_mem_fn< int (test::*)() const, & test::id >());
#endif
time1 = t.elapsed();
std::cout << "fast_mem_fn | " << time1 << std::endl;
setup_test(v);
t.restart();
do_test(v, boost::mem_fn(& test::id));
time2 = t.elapsed();
std::cout << "mem_fn | " << time2 << std::endl;
std::cout << '\n' << (time2/time1-1)*100 << "% speedup" << std::endl;
return 0;
}
static void test_redirect( void )
{
static const WCHAR codeweavers[] = {'c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
HANDLE ses, con, req;
DWORD size, status;
BOOL ret;
struct info info, *context = &info;
info.test = redirect_test;
info.count = sizeof(redirect_test) / sizeof(redirect_test[0]);
info.index = 0;
info.wait = NULL;
ses = WinHttpOpen( user_agent, 0, NULL, NULL, 0 );
ok(ses != NULL, "failed to open session %u\n", GetLastError());
WinHttpSetStatusCallback( ses, check_notification, WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS, 0 );
ret = WinHttpSetOption( ses, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
ok(ret, "failed to set context value %u\n", GetLastError());
setup_test( &info, winhttp_connect, __LINE__ );
con = WinHttpConnect( ses, codeweavers, 0, 0 );
ok(con != NULL, "failed to open a connection %u\n", GetLastError());
setup_test( &info, winhttp_open_request, __LINE__ );
req = WinHttpOpenRequest( con, NULL, NULL, NULL, NULL, NULL, 0 );
ok(req != NULL, "failed to open a request %u\n", GetLastError());
setup_test( &info, winhttp_send_request, __LINE__ );
ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
ok(ret, "failed to send request %u\n", GetLastError());
setup_test( &info, winhttp_receive_response, __LINE__ );
ret = WinHttpReceiveResponse( req, NULL );
ok(ret, "failed to receive response %u\n", GetLastError());
size = sizeof(status);
ret = WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL );
ok(ret, "failed unexpectedly %u\n", GetLastError());
ok(status == 200, "request failed unexpectedly %u\n", status);
setup_test( &info, winhttp_close_handle, __LINE__ );
WinHttpCloseHandle( req );
WinHttpCloseHandle( con );
WinHttpCloseHandle( ses );
}
void test_performance(void) {
for (size_t write_size = 1; write_size < CENSUS_LOG_MAX_RECORD_SIZE;
write_size *= 2) {
setup_test(0);
gpr_timespec start_time = gpr_now(GPR_CLOCK_REALTIME);
int nrecords = 0;
while (1) {
void* record = census_log_start_write(write_size);
if (record == NULL) {
break;
}
census_log_end_write(record, write_size);
nrecords++;
}
gpr_timespec write_time =
gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), start_time);
double write_time_micro =
(double)write_time.tv_sec * 1000000 + (double)write_time.tv_nsec / 1000;
census_log_shutdown();
printf(
"Wrote %d %d byte records in %.3g microseconds: %g records/us "
"(%g ns/record), %g gigabytes/s\n",
nrecords, (int)write_size, write_time_micro,
nrecords / write_time_micro, 1000 * write_time_micro / nrecords,
(double)((int)write_size * nrecords) / write_time_micro / 1000);
}
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
const uint32_t net = 0x0a0a0a00;
char *password;
setup_test("tcpr-test", "test-spurious-fins");
password = get_password(htonl(net | 2), 8888, htonl(net | 3), 9999);
setup_connection(net | 2, net | 4, net | 3, 8888, 9999, 0xdeadbeef,
0xcafebabe, test_options_size, test_options,
peer_mss, peer_ws, password);
fprintf(stderr, "Application: FIN (failure)\n");
send_segment(internal_log, net | 4, net | 2, 9999, 8888,
TH_ACK | TH_FIN, 0xcafebabe + 1, 0xdeadbeef + 1, 0,
NULL, 0, NULL, password);
fprintf(stderr, " Filter: RST\n");
recv_segment(internal_log, net | 2, net | 4, 8888, 9999, TH_RST,
0xdeadbeef + 1, 0, 0, NULL, 0, NULL, password);
cleanup_connection(net | 2, net | 4, 8888, 9999, 0xcafebabe + 1,
0xdeadbeef + 1, 0);
cleanup_test();
return EXIT_SUCCESS;
}
// Fills circular log with records that may straddle end of a block.
void test_fill_circular_log_with_straddling_records(void) {
printf("Starting test: fill circular log with straddling records\n");
const int circular = 1;
setup_test(circular);
fill_log(LOG_SIZE_IN_BYTES, 0 /* block straddling records */, circular);
census_log_shutdown();
}
int main(int ac, char **av)
{
int lc, i;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
/* Set up individual test */
if (setup_test(i) == 0) {
TEST(ltp_syscall(__NR_timer_settime, timer,
flag, &new_set, old_temp));
tst_resm((TEST_RETURN == 0 ?
TPASS :
TFAIL | TTERRNO),
"%s",
(TEST_RETURN ==
0 ? "passed" : "failed")
);
}
}
}
cleanup();
tst_exit();
}
// Tests scenario where multiple writers and a single reader are using a log
// that is configured to discard old records.
void test_multiple_writers(void) {
printf("Starting test: multiple writers\n");
const int circular = 0;
setup_test(circular);
multiple_writers_single_reader(circular);
census_log_shutdown();
}
// Tests scenario where block being read is detached from a core and put on the
// dirty list.
void test_detached_while_reading(void) {
printf("Starting test: detached while reading\n");
setup_test(0);
// Start a write.
static const size_t DWR_RECORD_SIZE = 10;
void* record_written = census_log_start_write(DWR_RECORD_SIZE);
GPR_ASSERT(record_written != NULL);
census_log_end_write(record_written, DWR_RECORD_SIZE);
// Read this record.
census_log_init_reader();
size_t bytes_available;
const void* record_read = census_log_read_next(&bytes_available);
GPR_ASSERT(record_read != NULL);
GPR_ASSERT(DWR_RECORD_SIZE == bytes_available);
// Now fill the log. This will move the block being read from core-local
// array to the dirty list.
while ((record_written = census_log_start_write(DWR_RECORD_SIZE))) {
census_log_end_write(record_written, DWR_RECORD_SIZE);
}
// In this iteration, read_next() should only traverse blocks in the
// core-local array. Therefore, we expect at most gpr_cpu_num_cores() more
// blocks. As log is full, if read_next() is traversing the dirty list, we
// will get more than gpr_cpu_num_cores() blocks.
int block_read = 0;
while ((record_read = census_log_read_next(&bytes_available))) {
++block_read;
GPR_ASSERT(block_read <= (int)gpr_cpu_num_cores());
}
census_log_shutdown();
}
// Fills circular log with records sized such that size is a multiple of
// CENSUS_LOG_MAX_RECORD_SIZE (no per-block fragmentation).
void test_fill_circular_log_no_fragmentation(void) {
printf("Starting test: fill circular log no fragmentation\n");
const int circular = 1;
setup_test(circular);
fill_log(LOG_SIZE_IN_BYTES, 1 /* no fragmentation */, circular);
census_log_shutdown();
}
int run_test()
{
test_assert_ret(setup_test() == 0);
odp_packet_t pkt_valid_eth_no_ip =
pack_pkt(pool, valid_eth_src_beef, valid_eth_dst, 0, 0, 64, 0);
odp_packet_t pkt_valid_eth_valid_ip =
pack_pkt(pool, valid_eth_src, valid_eth_dst, valid_ip_src, valid_ip_dst, 64, 1);
odp_packet_t pkt_valid_eth_invalid_ip =
pack_pkt(pool, valid_eth_src, valid_eth_dst, invalid_ip_src, valid_ip_dst, 64, 1);
odp_packet_t pkt_invalid_eth_no_ip =
pack_pkt(pool, invalid_eth_src, valid_eth_dst, 0, 0, 64, 0);
odp_packet_t pkt_invalid_eth_valid_ip =
pack_pkt(pool, invalid_eth_src, valid_eth_dst, valid_ip_src, valid_ip_dst, 64, 1);
odp_packet_t pkt_invalid_eth_invalid_ip =
pack_pkt(pool, invalid_eth_src, valid_eth_dst, invalid_ip_src, valid_ip_dst, 64, 1);
send_recv(pkt_valid_eth_no_ip, 10, 10);
send_recv(pkt_valid_eth_valid_ip, 10, 10);
send_recv(pkt_valid_eth_invalid_ip, 10, 10);
send_recv(pkt_invalid_eth_no_ip, 10, 0);
send_recv(pkt_invalid_eth_valid_ip, 10, 10);
send_recv(pkt_invalid_eth_invalid_ip, 10, 0);
test_assert_ret(term_test() == 0);
return 0;
}
// Tries reading beyond pending write.
void test_read_beyond_pending_record(void) {
printf("Starting test: read beyond pending record\n");
setup_test(0);
// Start a write.
const size_t incomplete_record_size = 10;
void* incomplete_record = census_log_start_write(incomplete_record_size);
GPR_ASSERT(incomplete_record != NULL);
const size_t complete_record_size = 20;
void* complete_record = census_log_start_write(complete_record_size);
GPR_ASSERT(complete_record != NULL);
GPR_ASSERT(complete_record != incomplete_record);
census_log_end_write(complete_record, complete_record_size);
// Now iterate over blocks to read completed records.
census_log_init_reader();
size_t bytes_available;
const void* record_read = census_log_read_next(&bytes_available);
GPR_ASSERT(complete_record == record_read);
GPR_ASSERT(complete_record_size == bytes_available);
// Complete first record.
census_log_end_write(incomplete_record, incomplete_record_size);
// Have read past the incomplete record, so read_next() should return NULL.
// NB: this test also assumes our thread did not get switched to a different
// CPU between the two start_write calls
record_read = census_log_read_next(&bytes_available);
GPR_ASSERT(record_read == NULL);
// Reset reader to get the newly completed record.
census_log_init_reader();
record_read = census_log_read_next(&bytes_available);
GPR_ASSERT(incomplete_record == record_read);
GPR_ASSERT(incomplete_record_size == bytes_available);
assert_log_empty();
census_log_shutdown();
}
int main(int argc, char **argv)
{
int i=0;
setsignals();
#ifdef RCU_SIGNAL
rcu_init();
#endif
setup_test(argc, argv);
printf("nbthreads %lu nbupdaters %lu nbbuckets %lu perbucket-pbnodes %lu nbtest %d nbreaders %d nbcores %d"
#ifdef POPULATE
" POPULATE"
#endif
"\n",
nbthreads, nbupdaters, nbbuckets, pbnodes, NB_TEST, nbreaders, get_nbcores());
for(; i < ITERATION; i++)
test(i);
double rops = get_avg(&trd_ops[0],ITERATION);
double wops = get_avg(&twr_ops[0],ITERATION);
printf("read ops per micsec = %g\n", rops);
printf("write ops per micsec = %g\n", wops);
printf("write/read = %g\n", wops/rops);
printf("nbmallocs = %g\n", get_avg(&run_mallocs[0],ITERATION));
printf("nbretry = %g\n", get_avg(&run_retry[0],ITERATION));
printf("nbrelink = %g\n", get_avg(&run_relink[0],ITERATION));
printf("nbreprev = %g\n", get_avg(&run_reprev[0],ITERATION));
printf("nbblockeds = %g\n", get_avg(&run_blockeds[0],ITERATION));
printf("sucess_search = %g on %g\n", get_avg(&run_sea[0],ITERATION), get_avg(&thd_ops[nbupdaters], nbreaders) );
printf("sucess_insert = %g on %g\n", get_avg(&run_ins[0],ITERATION), get_avg(&thd_ops[0], nbupdaters)/2);
printf("sucess_delete = %g on %g\n", get_avg(&run_del[0],ITERATION), get_avg(&thd_ops[0], nbupdaters)/2);
printf("\n");
printf("avg_max_read = %gus\n", get_max(&run_avg_rd[0],ITERATION));
printf("avg_avg_read = %gus\n", get_avg(&run_avg_rd[0],ITERATION));
printf("avg_min_read = %gus\n", get_min(&run_avg_rd[0],ITERATION));
printf("\n");
printf("avg_max_write = %gus\n", get_max(&run_avg_wr[0],ITERATION));
printf("avg_avg_write = %gus\n", get_avg(&run_avg_wr[0],ITERATION));
printf("avg_min_write = %gus\n", get_min(&run_avg_wr[0],ITERATION));
printf("\n");
printf("max_read = %gus\n", get_max(&run_max_rd[0],ITERATION));
printf("min_read = %gus\n", get_min(&run_min_rd[0],ITERATION));
printf("\n");
printf("max_write = %gus\n", get_max(&run_max_wr[0],ITERATION));
printf("min_write = %gus\n", get_min(&run_min_wr[0],ITERATION));
//printf("cpu time = %gus\n", get_avg(&run_cput[0],ITERATION));//FIXME
return 0;
}
/* Tests scenario where multiple writers and a single reader are using a log
that is configured to discard old records. */
void test_multiple_writers_circular_log(void) {
const int circular = 1;
printf("Starting test: multiple writers circular log\n");
setup_test(circular);
multiple_writers_single_reader(circular);
census_log_shutdown();
}
int main(int ac, char **av)
{
int lc, i;
char *msg;
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
for (i = 0; i < TST_TOTAL; i++) {
tst_count = 0;
if (i == 0) {
TEST(reboot(INVALID_PARAMETER));
} else {
/*change the user to nobody */
if (setup_test() == 0) {
TEST(reboot(LINUX_REBOOT_CMD_CAD_ON));
/* Set effective user id back to root */
if (seteuid(0) == -1) {
tst_brkm(TBROK, cleanup,
"seteuid failed to "
"set the effective uid"
" to root");
perror("seteuid");
}
} else {
tst_resm(TWARN, "skipping the test");
continue;
}
}
/* check return code */
if ((TEST_RETURN == -1)
&& (TEST_ERRNO == testcase[i].exp_errno)) {
tst_resm(TPASS,
"reboot(2) expected failure;"
" Got errno - %s : %s",
testcase[i].exp_errval,
testcase[i].err_desc);
} else {
tst_resm(TFAIL, "reboot(2) failed to produce"
" expected error; %d, errno"
": %s and got %d",
testcase[i].exp_errno,
testcase[i].exp_errval, TEST_ERRNO);
}
TEST_ERROR_LOG(TEST_ERRNO);
} /*End of TEST LOOPS */
}
/*Clean up and exit */
cleanup();
tst_exit();
} /*End of main */
int main(int ac, char **av)
{
int lc, i;
char *msg;
if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
if (setup_test(i) < 0)
continue;
TEST(ltp_syscall(__NR_clock_settime, clocks[i], temp));
/* Change the UID back to root */
if (i == TST_TOTAL - 1) {
if (seteuid(0) == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"Failed to set the effective "
"uid to root");
}
}
/* check return code */
if (TEST_RETURN == -1 && TEST_ERRNO == testcases[i]) {
tst_resm(TPASS | TTERRNO,
"clock_settime(2) got expected "
"failure.");
} else {
tst_resm(TFAIL | TTERRNO,
"clock_settime(2) failed to produce "
"expected error (return code = %ld)",
TEST_RETURN);
/* Restore the clock to its previous state. */
if (TEST_RETURN == 0) {
if (ltp_syscall(__NR_clock_settime,
CLOCK_REALTIME,
&saved) < 0) {
tst_resm(TWARN | TERRNO,
"FATAL: could not set "
"the clock!");
}
}
}
}
}
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc, i;
tst_parse_opts(ac, av, NULL, NULL);
setup();
/* check looping state */
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
if (setup_test(i)) {
tst_resm(TFAIL, "mlockall() Failed while setup "
"for checking error %s", TC[i].edesc);
continue;
}
TEST(mlockall(TC[i].flag));
/* check return code */
if (TEST_RETURN == -1) {
if (TEST_ERRNO != TC[i].error)
tst_brkm(TFAIL, cleanup,
"mlock() Failed with wrong "
"errno, expected errno=%s, "
"got errno=%d : %s",
TC[i].edesc, TEST_ERRNO,
strerror(TEST_ERRNO));
else
tst_resm(TPASS,
"expected failure - errno "
"= %d : %s",
TEST_ERRNO,
strerror(TEST_ERRNO));
} else {
if (i <= 1)
tst_resm(TCONF,
"mlockall02 did not BEHAVE as expected.");
else
tst_brkm(TFAIL, cleanup,
"mlock() Failed, expected "
"return value=-1, got %ld",
TEST_RETURN);
}
cleanup_test(i);
}
}
/* cleanup and exit */
cleanup();
tst_exit();
}
int main(int argc, char *argv[])
{
int ret;
setup_test();
ret = test_main(argc, argv);
return finish_test(ret);
}
int main(void)
{
setup_test();
test_get_random_generator();
test_get_hasher();
return (0);
}
int main(int argc, char **argv)
{
int initialized = setup_test(argc, argv);
if (initialized)
{
test_blit_speed();
SDL_Quit();
}
return(!initialized);
}
bam_hdr_t * setup_test_4(merged_header_t *merged_hdr) {
const char* t4_init_text =
"@HD\tVN:1.4\tSO:unknown\n"
"@SQ\tSN:fish\tLN:133\tSP:frog\n"
"@RG\tID:fish\tPU:out\n";
return setup_test(t4_init_text, init_refs, NELE(init_refs),
test_4_trans_text, test_4_refs, NELE(test_4_refs),
merged_hdr);
}
int main(int argc, char ** argv)
{
if (setup_test())
return 1;
run_tests();
teardown_test();
return 0;
}
bam_hdr_t * setup_test_5(merged_header_t *merged_hdr) {
const char* t5_init_text =
"@HD\tVN:1.4\tSO:unknown\n"
"@SQ\tSN:fish\tLN:133\tSP:frog\n"
"@RG\tID:fish\tPU:out\n"
"@PG\tXX:dummyx\tID:fish\tDS:out\n"
"@PG\tPP:fish\tID:hook\tDS:out\n";
return setup_test(t5_init_text, init_refs, NELE(init_refs),
test_5_trans_text, test_5_refs, NELE(test_5_refs),
merged_hdr);
}
int
main(int ac, char **av)
{
int lc, i; /* loop counter */
char *msg; /* message returned from parse_opts */
if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL)) !=
(char *) NULL) {
tst_brkm(TBROK, tst_exit, "OPTION PARSING ERROR - %s", msg);
}
/* perform global setup for test */
setup();
/* check looping state if -i option given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset Tst_count in case we are looping. */
Tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
/* Set up individual test */
if (setup_test(i) < 0) {
continue; /* We are skipping this test */
}
TEST(timer_settime(timer, flag, &new_set, old_temp));
if (TEST_ERRNO == ENOSYS) {
/* system call is not implemented */
Tst_count = TST_TOTAL;
perror("timer_settime");
tst_brkm(TBROK, cleanup, "");
}
if (TEST_RETURN == -1) {
TEST_ERROR_LOG(TEST_ERRNO);
tst_resm(TFAIL, "timer_settime(2) Failed and"
" set errno to %d", TEST_ERRNO);
} else {
tst_resm(TPASS, "timer_settime(2) Passed");
}
} /* End of TEST CASE LOOPING */
} /* End for TEST_LOOPING */
/* Clean up and exit */
cleanup();
/* NOTREACHED */
return 0;
}
// Tests end_write() with a different size than what was specified in
// start_write().
void test_end_write_with_different_size(void) {
static const size_t START_WRITE_SIZE = 10;
static const size_t END_WRITE_SIZE = 7;
printf("Starting test: end write with different size\n");
setup_test(0);
void* record_written = census_log_start_write(START_WRITE_SIZE);
GPR_ASSERT(record_written != NULL);
census_log_end_write(record_written, END_WRITE_SIZE);
census_log_init_reader();
size_t bytes_available;
const void* record_read = census_log_read_next(&bytes_available);
GPR_ASSERT(record_written == record_read);
GPR_ASSERT(END_WRITE_SIZE == bytes_available);
assert_log_empty();
census_log_shutdown();
}
int
main(int ac, char **av)
{
int lc, i; /* loop counter */
char *msg; /* message returned from parse_opts */
timer_t created_timer_id; /* holds the returned timer_id */
char *message[] = {
"SIGEV_SIGNAL",
"NULL",
"SIGEV_NONE"
};
/* parse standard options */
if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL)) !=
(char *) NULL) {
tst_brkm(TBROK, tst_exit, "OPTION PARSING ERROR - %s", msg);
}
/* perform global setup for test */
setup();
/* check looping state if -i option given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset Tst_count in case we are looping. */
Tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
setup_test(i);
TEST(syscall(__NR_timer_create, CLOCK_MONOTONIC,
evp_ptr, &created_timer_id));
tst_resm((TEST_RETURN == 0 ? TPASS : TFAIL | TTERRNO),
"%s with notification type = %s",
(TEST_RETURN == 0 ? "passed" : "failed"),
message[i]);
} /* End of TEST CASE LOOPING */
} /* End for TEST_LOOPING */
/* Clean up and exit */
cleanup();
tst_exit();
}
void test_corelib_do(void) {
awlenv* e = setup_test();
TEST_ASSERT_TYPE(e, "(do x)", AWLVAL_ERR);
TEST_ASSERT_TYPE(e, "(do (/ 1 0))", AWLVAL_ERR);
TEST_ASSERT_EQ(e, "(do (let ((x 5) (y 6)) (+ x y)))", "11");
TEST_ASSERT_TYPE(e, "x", AWLVAL_ERR);
TEST_ASSERT_TYPE(e, "y", AWLVAL_ERR);
TEST_ASSERT_EQ(e, "(do 1 2 3 4 5)", "5");
TEST_ASSERT_EQ(e, "(do (define x 5) (define y 6) (+ x y))", "11");
TEST_ASSERT_EQ(e, "x", "5");
TEST_ASSERT_EQ(e, "y", "6");
teardown_test(e);
}
int main(int argc, char **argv)
{
(void)argc;
(void)argv;
const uint32_t net = 0x0a0a0a00;
char *password;
setup_test("tcpr-test", "test-recover-peer-send");
password = get_password(htonl(net | 2), 8888, htonl(net | 3), 9999);
setup_connection(net | 2, net | 4, net | 3, 8888, 9999, 0xdeadbeef,
0xcafebabe, test_options_size, test_options,
peer_mss, peer_ws, password);
recover_connection(net | 5, net | 2, net | 3, 9999, 8888, 0xfeedbead,
0xcafebabe, 0xdeadbeef, test_options_size, test_options,
peer_mss, peer_ws, TCPR_HAVE_ACK | TCPR_HAVE_PEER_MSS
| TCPR_HAVE_PEER_WS, password);
fprintf(stderr, " Peer: \"baz\" (retransmit)\n");
send_segment(external_log, net | 2, net | 3, 8888, 9999, TH_ACK,
0xdeadbeef + 1, 0xcafebabe + 1, 0, NULL, 4, "baz", password);
recv_segment(internal_log, net | 2, net | 5, 8888, 9999, TH_ACK,
0xdeadbeef + 1, 0xfeedbead + 1, 0, NULL, 4, "baz", password);
fprintf(stderr, "Application: ACK\n");
send_segment(internal_log, net | 5, net | 2, 9999, 8888, TH_ACK,
0xfeedbead + 1, 0xdeadbeef + 5, 0, NULL, 0, NULL, password);
fprintf(stderr, "Application: update\n");
send_update(net | 2, net | 5, 8888, 9999, 0xcafebabe + 1,
0xdeadbeef + 5, 0, 0,
(0xfeedbead + 1) - (0xcafebabe + 1), TCPR_HAVE_ACK);
fprintf(stderr, " Filter: ACK\n");
recv_segment(external_log, net | 3, net | 2, 9999, 8888, TH_ACK,
0xcafebabe + 1, 0xdeadbeef + 5, 0, NULL, 0, NULL, password);
cleanup_connection(net | 2, net | 4, 8888, 9999, 0xcafebabe + 1,
0xdeadbeef + 1,
(0xfeedbead + 1) - (0xcafebabe + 1));
cleanup_test();
return EXIT_SUCCESS;
}
// Attempts to create a record of invalid size (size >
// CENSUS_LOG_MAX_RECORD_SIZE).
void test_invalid_record_size(void) {
static const size_t INVALID_SIZE = CENSUS_LOG_MAX_RECORD_SIZE + 1;
static const size_t VALID_SIZE = 1;
printf("Starting test: invalid record size\n");
setup_test(0);
void* record = census_log_start_write(INVALID_SIZE);
GPR_ASSERT(record == NULL);
// Now try writing a valid record.
record = census_log_start_write(VALID_SIZE);
GPR_ASSERT(record != NULL);
census_log_end_write(record, VALID_SIZE);
// Verifies that available space went down by one block. In theory, this
// check can fail if the thread is context switched to a new CPU during the
// start_write execution (multiple blocks get allocated), but this has not
// been observed in practice.
// GPR_ASSERT(LOG_SIZE_IN_BYTES - CENSUS_LOG_MAX_RECORD_SIZE ==
// census_log_remaining_space());
census_log_shutdown();
}
int
main(int ac, char **av)
{
int lc, i; /* loop counter */
char *msg; /* message returned from parse_opts */
kernel_timer_t created_timer_id; /* holds the returned timer_id */
char *message[] = {
"SIGEV_SIGNAL",
"NULL",
"SIGEV_NONE"
};
/* parse standard options */
if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL)) !=
(char *) NULL) {
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
}
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
Tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
setup_test(i);
TEST(syscall(__NR_timer_create, CLOCK_MONOTONIC,
evp_ptr, &created_timer_id));
tst_resm((TEST_RETURN == 0 ? TPASS : TFAIL | TTERRNO),
"%s with notification type = %s",
(TEST_RETURN == 0 ? "passed" : "failed"),
message[i]);
}
}
cleanup();
tst_exit();
}
// Verifies that pending records are not available via read_next().
void test_read_pending_record(void) {
static const size_t PR_RECORD_SIZE = 1024;
printf("Starting test: read pending record\n");
setup_test(0);
// Start a write.
void* record_written = census_log_start_write(PR_RECORD_SIZE);
GPR_ASSERT(record_written != NULL);
// As write is pending, read should fail.
census_log_init_reader();
size_t bytes_available;
const void* record_read = census_log_read_next(&bytes_available);
GPR_ASSERT(record_read == NULL);
// A read followed by end_write() should succeed.
census_log_end_write(record_written, PR_RECORD_SIZE);
census_log_init_reader();
record_read = census_log_read_next(&bytes_available);
GPR_ASSERT(record_written == record_read);
GPR_ASSERT(PR_RECORD_SIZE == bytes_available);
assert_log_empty();
census_log_shutdown();
}
