int main()
{
pigeonattach(1);
init();
setipaddr("pg0", 0xc0a80002); // 192.168.0.2
test_ping();
return 0;
}
/* Test that we can bind/unbind and the lists update correctly */
static int dm_test_ordering(struct unit_test_state *uts)
{
struct dm_test_state *dms = uts->priv;
struct udevice *dev, *dev_penultimate, *dev_last, *test_dev;
int pingret;
ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
&dev));
ut_assert(dev);
/* Bind two new devices (numbers 4 and 5) */
ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
&dev_penultimate));
ut_assert(dev_penultimate);
ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
&dev_last));
ut_assert(dev_last);
/* Now remove device 3 */
ut_assertok(device_remove(dev));
ut_assertok(device_unbind(dev));
/* The device numbering should have shifted down one */
ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
ut_assert(dev_penultimate == test_dev);
ut_assertok(uclass_find_device(UCLASS_TEST, 4, &test_dev));
ut_assert(dev_last == test_dev);
/* Add back the original device 3, now in position 5 */
ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
&dev));
ut_assert(dev);
/* Try ping */
ut_assertok(test_ping(dev, 100, &pingret));
ut_assert(pingret == 102);
/* Remove 3 and 4 */
ut_assertok(device_remove(dev_penultimate));
ut_assertok(device_unbind(dev_penultimate));
ut_assertok(device_remove(dev_last));
ut_assertok(device_unbind(dev_last));
/* Our device should now be in position 3 */
ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
ut_assert(dev == test_dev);
/* Now remove device 3 */
ut_assertok(device_remove(dev));
ut_assertok(device_unbind(dev));
return 0;
}
/* Test that we can bind, probe, remove, unbind a driver */
static int dm_test_lifecycle(struct unit_test_state *uts)
{
struct dm_test_state *dms = uts->priv;
int op_count[DM_TEST_OP_COUNT];
struct udevice *dev, *test_dev;
int pingret;
int ret;
memcpy(op_count, dm_testdrv_op_count, sizeof(op_count));
ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
&dev));
ut_assert(dev);
ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND]
== op_count[DM_TEST_OP_BIND] + 1);
ut_assert(!dev->priv);
/* Probe the device - it should fail allocating private data */
dms->force_fail_alloc = 1;
ret = device_probe(dev);
ut_assert(ret == -ENOMEM);
ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
== op_count[DM_TEST_OP_PROBE] + 1);
ut_assert(!dev->priv);
/* Try again without the alloc failure */
dms->force_fail_alloc = 0;
ut_assertok(device_probe(dev));
ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
== op_count[DM_TEST_OP_PROBE] + 2);
ut_assert(dev->priv);
/* This should be device 3 in the uclass */
ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
ut_assert(dev == test_dev);
/* Try ping */
ut_assertok(test_ping(dev, 100, &pingret));
ut_assert(pingret == 102);
/* Now remove device 3 */
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
ut_assertok(device_remove(dev));
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]);
ut_assertok(device_unbind(dev));
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]);
return 0;
}
void
serial_test( void )
{
cyg_io_handle_t ser_handle;
cyg_ser_cfg_t *cfg=&test_configs[0];
cyg_ser_cfg_t new_cfg;
int count = sizeof(test_configs) / sizeof(cyg_ser_cfg_t);
int i;
test_open_ser(&ser_handle);
// We need the filter for this test.
test_ping(ser_handle);
// Choose the configuration with the fastest baud rate, to be most
// provocative. Start at 1 coz cfg already points at 0
for (i=1; i<count; i++) {
if (cfg->baud_rate < test_configs[i].baud_rate)
cfg=&test_configs[i];
}
// Set flow control from configuration
// Choose software first
#ifdef CYGOPT_IO_SERIAL_FLOW_CONTROL_SOFTWARE
CYG_TEST_INFO("Setting software flow control");
new_cfg = *cfg;
new_cfg.flags |= CYGNUM_SERIAL_FLOW_XONXOFF_RX |
CYGNUM_SERIAL_FLOW_XONXOFF_TX;
if (ENOERR == change_config(ser_handle, &new_cfg))
run_tests( ser_handle );
#endif
// hardware flow control
#ifdef CYGOPT_IO_SERIAL_FLOW_CONTROL_HW
CYG_TEST_INFO("Setting RTS/CTS hardware flow control");
new_cfg = *cfg;
new_cfg.flags |= CYGNUM_SERIAL_FLOW_RTSCTS_RX|CYGNUM_SERIAL_FLOW_RTSCTS_TX;
if (ENOERR == change_config(ser_handle, &new_cfg))
run_tests( ser_handle );
CYG_TEST_INFO("Setting DSR/DTR hardware flow control");
new_cfg = *cfg;
new_cfg.flags |= CYGNUM_SERIAL_FLOW_DSRDTR_RX|CYGNUM_SERIAL_FLOW_DSRDTR_TX;
if (ENOERR == change_config(ser_handle, &new_cfg))
run_tests( ser_handle );
#endif
CYG_TEST_PASS_FINISH("flow2 test OK");
}
int main()
{
conn = tnt_connect("localhost", 33013);
if (conn == NULL)
return 1;
test_ping();
test_bug702397();
test_bug702399();
tnt_disconnect(conn);
return 0;
}
int main(int argc, char **argv)
{
/*
if( argc == 2 )
{
printf("The argument supplied is %s\n", argv[1]);
sscanf(argv[1],"%ld",&tt);
show_tt(tt);
}
else if( argc > 2 )
{
printf("Too many arguments supplied.\n");
}
//write_test();
//write_29_test();
//printf ("Porgram name is %s\n",argv[0]);
//time_test();
//test_lstat();
//system("/Users/laurenceschenk/mini-src/mySrc/coldipozzo/email_weather_data");
*/
test_ping();
}
int main(int argc, char **argv) {
test_spec *spec;
size_t i;
const size_t NUM_ITERS = 10;
const size_t NUM_SERVERS = 4;
grpc_test_init(argc, argv);
grpc_init();
grpc_lb_round_robin_trace = 1;
GPR_ASSERT(grpc_lb_policy_create("this-lb-policy-does-not-exist", NULL) ==
NULL);
GPR_ASSERT(grpc_lb_policy_create(NULL, NULL) == NULL);
spec = test_spec_create(NUM_ITERS, NUM_SERVERS);
/* everything is fine, all servers stay up the whole time and life's peachy */
spec->verifier = verify_vanilla_round_robin;
spec->description = "test_all_server_up";
run_spec(spec);
/* Kill all servers first thing in the morning */
test_spec_reset(spec);
spec->verifier = verify_total_carnage_round_robin;
spec->description = "test_kill_all_server";
for (i = 0; i < NUM_SERVERS; i++) {
spec->kill_at[0][i] = 1;
}
run_spec(spec);
/* at the start of the 2nd iteration, kill all but the first and last
* servers.
* This should knock down the server bound to be selected next */
test_spec_reset(spec);
spec->verifier = verify_vanishing_floor_round_robin;
spec->description = "test_kill_all_server_at_2nd_iteration";
for (i = 1; i < NUM_SERVERS - 1; i++) {
spec->kill_at[1][i] = 1;
}
run_spec(spec);
/* Midway, kill all servers. */
test_spec_reset(spec);
spec->verifier = verify_partial_carnage_round_robin;
spec->description = "test_kill_all_server_midway";
for (i = 0; i < NUM_SERVERS; i++) {
spec->kill_at[spec->num_iters / 2][i] = 1;
}
run_spec(spec);
/* After first iteration, kill all servers. On the third one, bring them all
* back up. */
test_spec_reset(spec);
spec->verifier = verify_rebirth_round_robin;
spec->description = "test_kill_all_server_after_1st_resurrect_at_3rd";
for (i = 0; i < NUM_SERVERS; i++) {
spec->kill_at[1][i] = 1;
spec->revive_at[3][i] = 1;
}
run_spec(spec);
test_spec_destroy(spec);
test_pending_calls(4);
test_ping();
grpc_shutdown();
return 0;
}
void ping(grpc_end2end_test_config config) {
GPR_ASSERT(config.feature_mask & FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION);
test_ping(config);
}
int main(int argc, char* argv[])
{
int ch, n = 1, conn_timeout = 10, rw_timeout = 10;
acl::string addr("127.0.0.1:6379"), cmd;
bool slice_req = false;
while ((ch = getopt(argc, argv, "hs:n:C:I:a:S")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 's':
addr = optarg;
break;
case 'n':
n = atoi(optarg);
break;
case 'C':
conn_timeout = atoi(optarg);
break;
case 'I':
rw_timeout = atoi(optarg);
break;
case 'a':
cmd = optarg;
break;
case 'S':
slice_req = true;
break;
default:
break;
}
}
acl::acl_cpp_init();
acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
client.set_slice_request(slice_req);
acl::redis_connection redis(&client);
bool ret;
if (cmd == "auth")
ret = test_auth(redis);
else if (cmd == "echo")
ret = test_echo(redis, n);
else if (cmd == "ping")
ret = test_ping(redis, n);
else if (cmd == "quit")
ret = test_quit(redis);
else if (cmd == "select")
ret = test_select(redis, n);
else if (cmd == "all")
{
ret = test_auth(redis)
&& test_echo(redis, n)
&& test_ping(redis, n)
&& test_select(redis, n)
&& test_quit(redis);
}
else
{
printf("unknown cmd: %s\r\n", cmd.c_str());
ret = false;
}
printf("cmd: %s %s\r\n", cmd.c_str(), ret ? "ok" : "failed");
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
int
main(int argc, char *argv[])
{
struct intf_entry ifent;
intf_t *intf;
int i, tests;
char *cmd;
if (argc < 3)
usage();
for (tests = 0, i = 1; i < argc - 1; i++) {
cmd = argv[i];
if (strcmp(cmd, "all") == 0)
tests = ~0;
else if (strcmp(cmd, "ping") == 0)
tests |= TEST_PING;
else if (strcmp(cmd, "ip-opt") == 0)
tests |= TEST_IP_OPT;
else if (strcmp(cmd, "ip-tracert") == 0)
tests |= TEST_IP_TRACERT;
else if (strcmp(cmd, "frag") == 0)
tests |= TEST_FRAG;
else if (strcmp(cmd, "frag-new") == 0)
tests |= TEST_FRAG_NEW;
else if (strcmp(cmd, "frag-old") == 0)
tests |= TEST_FRAG_OLD;
else if (strcmp(cmd, "frag-timeout") == 0)
tests |= TEST_FRAG_TIMEOUT;
else
usage();
}
if (addr_aton(argv[i], &ctx.dst) < 0)
err(1, "invalid host %s", argv[i]);
if ((intf = intf_open()) == NULL)
err(1, "couldn't open interface handle");
ifent.intf_len = sizeof(ifent);
if (intf_get_dst(intf, &ifent, &ctx.dst) < 0)
err(1, "couldn't find interface for %s", addr_ntoa(&ctx.dst));
memcpy(&ctx.src, &ifent.intf_addr, sizeof(ctx.src));
ctx.src.addr_bits = IP_ADDR_BITS;
intf_close(intf);
if ((ctx.ip = ip_open()) == NULL)
err(1, "couldn't open raw IP interface");
if ((ctx.pcap = pcap_open(ifent.intf_name)) == NULL)
err(1, "couldn't open %s for sniffing", ifent.intf_name);
if ((ctx.dloff = pcap_dloff(ctx.pcap)) < 0)
err(1, "couldn't determine link layer offset");
ctx.rnd = rand_open();
pkt_init(16);
TAILQ_INIT(&ctx.pktq);
ping = pkt_new();
ip_pack_hdr(ping->pkt_ip, 0, IP_HDR_LEN + 8 + 24, 666, 0,
IP_TTL_DEFAULT, IP_PROTO_ICMP, ctx.src.addr_ip, ctx.dst.addr_ip);
icmp_pack_hdr_echo(ping->pkt_icmp, ICMP_ECHO, ICMP_CODE_NONE,
666, 1, "AAAAAAAABBBBBBBBCCCCCCCC", 24);
ping->pkt_end = ping->pkt_eth_data + IP_HDR_LEN + 8 + 24;
pkt_decorate(ping);
if ((tests & TEST_PING) != 0)
test_ping();
if ((tests & TEST_IP_OPT) != 0)
test_ip_opt();
if ((tests & TEST_IP_TRACERT) != 0)
test_ip_tracert();
if ((tests & TEST_FRAG) != 0)
test_frag(NULL, 0);
if ((tests & TEST_FRAG_NEW) != 0)
test_frag("new", 0);
if ((tests & TEST_FRAG_OLD) != 0)
test_frag("old", 0);
if ((tests & TEST_FRAG_TIMEOUT) != 0)
test_frag(NULL, 1);
rand_close(ctx.rnd);
pcap_close(ctx.pcap);
ip_close(ctx.ip);
exit(0);
}
