/** Main function */
int main(int argc, char *argv[])
{
msg_error_t res = MSG_OK;
MSG_init(&argc, argv);
res = test_all(argv[1]);
if (res == MSG_OK)
return 0;
else
return 1;
} /* end_of_main */
static void
cmp_test (void)
{
grub_uint64_t a = 404, b = 7;
grub_size_t i;
for (i = 0; i < ARRAY_SIZE (vectors); i++)
{
test_all (vectors[i][0], vectors[i][1]);
}
for (i = 0; i < 40000; i++)
{
a = 17 * a + 13 * b;
b = 23 * a + 29 * b;
if (b == 0)
b = 1;
if (a == 0)
a = 1;
test_all (a, b);
}
}
void all_of_tests(std::vector<hpx::id_type>& localities)
{
hpx::partitioned_vector<T> xvalues(
SIZE, T(0), hpx::container_layout(localities));
initialize(xvalues);
test_all(hpx::parallel::execution::seq, xvalues, op8(), false);
test_all(hpx::parallel::execution::par, xvalues, op8(), false);
test_all_async(
hpx::parallel::execution::seq(hpx::parallel::execution::task), xvalues,
op8(), false);
test_all_async(
hpx::parallel::execution::par(hpx::parallel::execution::task), xvalues,
op8(), false);
test_all(hpx::parallel::execution::seq, xvalues, op5(), false);
test_all(hpx::parallel::execution::par, xvalues, op5(), false);
test_all_async(
hpx::parallel::execution::seq(hpx::parallel::execution::task), xvalues,
op5(), false);
test_all_async(
hpx::parallel::execution::par(hpx::parallel::execution::task), xvalues,
op5(), false);
test_all(hpx::parallel::execution::seq, xvalues, op0(), true);
test_all(hpx::parallel::execution::par, xvalues, op0(), true);
test_all_async(
hpx::parallel::execution::seq(hpx::parallel::execution::task), xvalues,
op0(), true);
test_all_async(
hpx::parallel::execution::par(hpx::parallel::execution::task), xvalues,
op0(), true);
}
int main(int argc, char* argv[]) {
if (argc < 4)
{
std::cout << "请按以下方式运行: 可执行文件名 current_node_path zookeeper_server_ip_port log_config_file" << std::endl
<< "current_node_path 一般为/auth/ip, ip为当前通讯端服务器的IP地址, 如/auth/116.255.130.148" << std::endl
<< "zookeeper_server_ip_port 逗号分隔的 IP:端口 标识, 每个关联一个 zookeeper 服务端, 如:127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002"
<< "log_config_file 日志配置文件"
<< std::endl;
boost::this_thread::sleep_for(boost::chrono::seconds(5));
return -1;
}
try {
init_log(argv[3]);
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
boost::this_thread::sleep_for(boost::chrono::seconds(5));
return -1;
}
boost::shared_ptr<config_server> config_server_;
try {
config_server_ = boost::make_shared<config_server>(argv[1], argv[2]);
}
catch (std::runtime_error e)
{
BOOST_LOG_SEV(cia_g_logger, Critical) << "连接zookeeper服务器失败：" << e.what();
boost::this_thread::sleep_for(boost::chrono::seconds(5));
return -1;
}
// 等待zookeeper相关值初始化完毕
while (!config_server_->get_started())
{
boost::this_thread::sleep_for(boost::chrono::seconds(1));
}
boost::shared_ptr<boost::asio::io_service> p_io_service_ = boost::make_shared<boost::asio::io_service>();
boost::thread_group io_comppletions_thread_;
boost::asio::io_service::work dummy_worker_(*p_io_service_); // 为了维持io_service线程池持续运行, 而设置的虚拟任务
int io_comppletions_thread_count = config_server_->get_cti_total_channel_count() * 2 + config_server_->get_iocp_thread_number();
while (io_comppletions_thread_count--)
{
io_comppletions_thread_.create_thread([p_io_service_]() {
p_io_service_->run();
});
}
//testNetLogic(config_server_, p_io_service_);
//testCTI(config_server_, p_io_service_);
test_all(config_server_, p_io_service_);
//test_config_server(config_server_);
boost::this_thread::sleep_for(boost::chrono::seconds(3));
config_server_->set_idol_channel_number(0);
stop_log();
}
static void test_main()
{
book = qof_book_new ();
test_use();
test_some();
test_all();
qof_book_destroy (book);
}
/** Main function */
int main(int argc, char *argv[])
{
MSG_error_t res = MSG_OK;
MSG_global_init(&argc, argv);
res = test_all();
MSG_clean();
if (res == MSG_OK)
return 0;
else
return 1;
} /* end_of_main */
int main()
{
int Failed = 0;
Failed += test_static_assert();
Failed += test_lessThan_vec2();
Failed += test_lessThan_vec3();
Failed += test_lessThan_vec4();
Failed += test_greaterThanEqual_vec2();
Failed += test_greaterThanEqual_vec3();
Failed += test_greaterThanEqual_vec4();
Failed += test_all();
return Failed;
}
int main(int argc, char *argv[])
{
msg_error_t res = MSG_OK;
MSG_init(&argc, argv);
if (argc < 3) {
printf("Usage: %s platform_file deployment_file\n", argv[0]);
exit(1);
}
res = test_all(argv[1], argv[2]);
if (res == MSG_OK)
return 0;
else
return 1;
}
int main()
{
int Error = 0;
Error += test_lessThan();
Error += test_lessThanEqual();
Error += test_greaterThan();
Error += test_greaterThanEqual();
Error += test_equal();
Error += test_notEqual();
Error += test_any();
Error += test_all();
Error += test_not();
return Error;
}
int main(int argc, char* argv[]) {
void * mem = open_table_head("/var/run/30m2k.shm", 'i');
printf("--- --- --- INFO --- --- ---\n");
print_table_info(mem);
printf("--- --- --- TEST --- --- ---\n");
test_all(mem);
if (argc > 1) {
printf("--- --- --- DATA --- --- ---\n");
print_item(mem, atoi(argv[1]));
}
printf("--- --- --- ---- --- --- ---\n");
if (mem != (void *) -1) {
close_table(mem);
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
unsigned verbose = 0;
FILE *fp = NULL;
unsigned long n = 1000;
unsigned i;
boolean success;
boolean single = FALSE;
struct gallivm_state *gallivm;
for(i = 1; i < argc; ++i) {
if(strcmp(argv[i], "-v") == 0)
++verbose;
else if(strcmp(argv[i], "-s") == 0)
single = TRUE;
else if(strcmp(argv[i], "-o") == 0)
fp = fopen(argv[++i], "wt");
else
n = atoi(argv[i]);
}
lp_build_init();
gallivm = gallivm_create();
util_cpu_detect();
if(fp) {
/* Warm up the caches */
test_some(gallivm, 0, NULL, 100);
write_tsv_header(fp);
}
if (single)
success = test_single(gallivm, verbose, fp);
else if (n)
success = test_some(gallivm, verbose, fp, n);
else
success = test_all(gallivm, verbose, fp);
if(fp)
fclose(fp);
return success ? 0 : 1;
}
int main(int argc, char** argv) {
test_no_arg();
test_no_value();
test_value();
test_long_alias();
test_short_alias();
test_stop_after_arguments();
test_arguments();
test_arguments_first();
test_arguments_first_marker();
test_arguments_many_markers();
test_arguments_issue_2();
test_arguments_issue_3();
test_all();
return 0;
}
int main(int argc, char *argv[])
{
msg_error_t res = MSG_OK;
MSG_init(&argc, argv);
if (argc < 2) {
printf("Usage: %s platform_file\n", argv[0]);
printf("example: %s msg_platform.xml\n", argv[0]);
exit(1);
}
res = test_all(argv[1]);
if (res == MSG_OK)
return 0;
else
return 1;
}
/** Main function */
int main(int argc, char *argv[])
{
MSG_error_t res = MSG_OK;
MSG_global_init(&argc,argv);
if (argc < 3) {
printf ("Usage: %s platform_file deployment_file\n",argv[0]);
printf ("example: %s msg_platform.xml msg_deployment.xml\n",argv[0]);
exit(1);
}
res = test_all(argv[1],argv[2]);
MSG_clean();
if(res==MSG_OK)
return 0;
else
return 1;
} /* end_of_main */
/** Main function */
int main(int argc, char *argv[])
{
msg_error_t res = MSG_OK;
MSG_init(&argc, argv);
if (argc < 3) {
XBT_CRITICAL("Usage: %s platform_file deployment_file\n", argv[0]);
XBT_CRITICAL("example: %s msg_platform.xml msg_deployment_suspend.xml\n",
argv[0]);
exit(1);
}
test_all(argv[1], argv[2]);
if (res == MSG_OK)
return 0;
else
return 1;
} /* end_of_main */
int main(int argc, char** argv) {
setup_inverse();
test_all(2);
test_all(3);
test_all(5);
test_all(7);
test_all(11);
test_all(17);
test_all(257);
teardown_inverse();
if (g_fail) {
printf("FAIL: failed %u of %u tests.\n", g_fail, g_test);
} else {
printf("PASS: passed %u tests.\n", g_test);
}
return 0;
}
/** Main function */
int main(int argc, char *argv[])
{
msg_error_t res = MSG_OK;
#ifdef _MSC_VER
unsigned int prev_exponent_format =
_set_output_format(_TWO_DIGIT_EXPONENT);
#endif
MSG_init(&argc, argv);
if (argc != 3) {
XBT_CRITICAL("Usage: %s platform_file deployment_file <model>\n",
argv[0]);
XBT_CRITICAL
("example: %s msg_platform.xml msg_deployment.xml KCCFLN05_Vegas\n",
argv[0]);
exit(1);
}
/* Options for the workstation/model:
KCCFLN05 => for maxmin
KCCFLN05_proportional => for proportional (Vegas)
KCCFLN05_Vegas => for TCP Vegas
KCCFLN05_Reno => for TCP Reno
*/
//MSG_config("workstation/model", argv[3]);
res = test_all(argv[1], argv[2]);
XBT_INFO("Total simulation time: %le", MSG_get_clock());
#ifdef _MSC_VER
_set_output_format(prev_exponent_format);
#endif
if (res == MSG_OK)
return 0;
else
return 1;
} /* end_of_main */
int main(int argc, char **argv)
{
unsigned verbose = 0;
FILE *fp = NULL;
unsigned long n = 1000;
unsigned i;
boolean success;
for(i = 1; i < argc; ++i) {
if(strcmp(argv[i], "-v") == 0)
++verbose;
else if(strcmp(argv[i], "-o") == 0)
fp = fopen(argv[++i], "wt");
else
n = atoi(argv[i]);
}
LLVMLinkInJIT();
LLVMInitializeNativeTarget();
util_cpu_detect();
if(fp) {
/* Warm up the caches */
test_some(0, NULL, 100);
write_tsv_header(fp);
}
if(n)
success = test_some(verbose, fp, n);
else
success = test_all(verbose, fp);
if(fp)
fclose(fp);
return success ? 0 : 1;
}
int main(int argc, char *argv[]) {
/* inlined functions, test commented out */
//printf("\n*** Testing bootstrap sample ***\n");
//test_boostrap_sample();
//printf("\n*** Testing compare doubles and qsort\n");
//test_sort();
//printf("\n*** Testing swap ***\n");
//test_swap();
/* regular functions */
printf("\n*** Testing percentile ***\n");
test_percentile();
printf("\n*** Testing min idx ***\n");
test_min_idx();
printf("\n*** Testing mean ***\n");
test_mean();
printf("\n*** Testing std dev ***\n");
test_std();
printf("\n*** Testing binomial ***\n");
test_binomial();
printf("\n*** Testing fetcount ***\n");
test_fetcount();
printf("\n*** Testing shift table ***\n");
test_shift_table();
printf("\n*** Testing fet p0 ***\n");
test_fet_p();
printf("\n*** Testing fet ***\n");
test_fet();
test_all(argc, argv);
test_thread(argc, argv);
return 0;
}
boolean
test_some(unsigned verbose, FILE *fp,
unsigned long n)
{
return test_all(verbose, fp);
}
int main() {
plan();
test_all();
return exit_status();
}
void spin_callback(void)
{
static unsigned int count = 0;
count++;
if(count % 100 == 0)
{
// ROS_INFO("STD_MSGS:");
// printf("[STD_MSGS] time_stamp %d \n",recv_sdk_std_msgs.time_stamp);
// printf("[STD_MSGS] q %f %f %f %f \n",recv_sdk_std_msgs.q.q0,recv_sdk_std_msgs.q.q1,recv_sdk_std_msgs.q.q2,recv_sdk_std_msgs.q.q3);
// printf("[STD_MSGS] a %f %f %f\n",recv_sdk_std_msgs.a.x,recv_sdk_std_msgs.a.y,recv_sdk_std_msgs.a.z);
// printf("[STD_MSGS] v %f %f %f\n",recv_sdk_std_msgs.v.x,recv_sdk_std_msgs.v.y,recv_sdk_std_msgs.v.z);
// printf("[STD_MSGS] w %f %f %f\n",recv_sdk_std_msgs.w.x,recv_sdk_std_msgs.w.y,recv_sdk_std_msgs.w.z);
// printf("[STD_MSGS] pos %f %f %f %f \n",recv_sdk_std_msgs.pos.lati, recv_sdk_std_msgs.pos.longti, recv_sdk_std_msgs.pos.alti, recv_sdk_std_msgs.pos.height);
// printf("[STD_MSGS] mag %d %d %d \n",recv_sdk_std_msgs.mag.x,recv_sdk_std_msgs.mag.y,recv_sdk_std_msgs.mag.z);
// printf("[STD_MSGS] rc %d %d %d %d %d\n",recv_sdk_std_msgs.rc.roll, recv_sdk_std_msgs.rc.pitch, recv_sdk_std_msgs.rc.yaw, recv_sdk_std_msgs.rc.throttle,recv_sdk_std_msgs.rc.mode);
// printf("[STD_MSGS] gimbal %f %f %f\n",recv_sdk_std_msgs.gimbal.x, recv_sdk_std_msgs.gimbal.y,recv_sdk_std_msgs.gimbal.z);
// printf("[STD_MSGS] status %d\n",recv_sdk_std_msgs.status);
// printf("[STD_MSGS] battery %d\n",recv_sdk_std_msgs.battery_remaining_capacity);
// printf("[STD_MSGS] ctrl_device %d\n",recv_sdk_std_msgs.ctrl_device);
}
/* test session ack for force close */
if(nav_force_close_req_id.reserve == 1)
{
nav_force_close_req_id.reserve = 0;
unsigned short ack = 0x0001;
printf("Ack close send %d !!!!!!!!!!! \n", ack);
App_Send_Ack(nav_force_close_req_id, (unsigned char *)&ack, sizeof(ack));
}
if(simple_task_num > -1)
{
static bool init_flag;
static unsigned int time = Get_Time();
if(Get_Time() - time < 1000)
{
}
else
{
init_flag = false;
}
time = Get_Time();
switch(simple_task_num)
{
case 0:
basic_test_mode2(init_flag);
break;
case 1:
basic_test_mode4(init_flag);
break;
case 2:
basic_test_cmd(init_flag);
break;
case 3:
random_test_cmd(init_flag);
break;
case 4:
test_all(init_flag);
break;
case 5:
Pro_API_Activation();
simple_task_num = -1;
break;
case 6:
test_version_query();
simple_task_num = -1;
break;
}
}
}
int test_main( int , char* [] )
{
test_all ();
return 0;
}
DEF_TEST(FILEStreamWithOffset, r) {
if (GetResourcePath().isEmpty()) {
return;
}
SkString filename = GetResourcePath("images/baby_tux.png");
SkFILEStream stream1(filename.c_str());
if (!stream1.isValid()) {
ERRORF(r, "Could not create SkFILEStream from %s", filename.c_str());
return;
}
REPORTER_ASSERT(r, stream1.hasLength());
REPORTER_ASSERT(r, stream1.hasPosition());
// Seek halfway through the file. The second SkFILEStream will be created
// with the same filename and offset and therefore will treat that offset as
// the beginning.
const size_t size = stream1.getLength();
const size_t middle = size / 2;
if (!stream1.seek(middle)) {
ERRORF(r, "Could not seek SkFILEStream to %lu out of %lu", middle, size);
return;
}
REPORTER_ASSERT(r, stream1.getPosition() == middle);
FILE* file = sk_fopen(filename.c_str(), kRead_SkFILE_Flag);
if (!file) {
ERRORF(r, "Could not open %s as a FILE", filename.c_str());
return;
}
if (fseek(file, (long) middle, SEEK_SET) != 0) {
ERRORF(r, "Could not fseek FILE to %lu out of %lu", middle, size);
return;
}
SkFILEStream stream2(file);
const size_t remaining = size - middle;
SkAutoTMalloc<uint8_t> expected(remaining);
REPORTER_ASSERT(r, stream1.read(expected.get(), remaining) == remaining);
auto test_full_read = [&r, &expected, remaining](SkStream* stream) {
SkAutoTMalloc<uint8_t> actual(remaining);
REPORTER_ASSERT(r, stream->read(actual.get(), remaining) == remaining);
REPORTER_ASSERT(r, !memcmp(expected.get(), actual.get(), remaining));
REPORTER_ASSERT(r, stream->getPosition() == stream->getLength());
REPORTER_ASSERT(r, stream->isAtEnd());
};
auto test_rewind = [&r, &expected, remaining](SkStream* stream) {
// Rewind goes back to original offset.
REPORTER_ASSERT(r, stream->rewind());
REPORTER_ASSERT(r, stream->getPosition() == 0);
SkAutoTMalloc<uint8_t> actual(remaining);
REPORTER_ASSERT(r, stream->read(actual.get(), remaining) == remaining);
REPORTER_ASSERT(r, !memcmp(expected.get(), actual.get(), remaining));
};
auto test_move = [&r, &expected, size, remaining](SkStream* stream) {
// Cannot move to before the original offset.
REPORTER_ASSERT(r, stream->move(- (long) size));
REPORTER_ASSERT(r, stream->getPosition() == 0);
REPORTER_ASSERT(r, stream->move(std::numeric_limits<long>::min()));
REPORTER_ASSERT(r, stream->getPosition() == 0);
SkAutoTMalloc<uint8_t> actual(remaining);
REPORTER_ASSERT(r, stream->read(actual.get(), remaining) == remaining);
REPORTER_ASSERT(r, !memcmp(expected.get(), actual.get(), remaining));
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == remaining);
// Cannot move beyond the end.
REPORTER_ASSERT(r, stream->move(1));
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == remaining);
};
auto test_seek = [&r, &expected, middle, remaining](SkStream* stream) {
// Seek to an arbitrary position.
const size_t arbitrary = middle / 2;
REPORTER_ASSERT(r, stream->seek(arbitrary));
REPORTER_ASSERT(r, stream->getPosition() == arbitrary);
const size_t miniRemaining = remaining - arbitrary;
SkAutoTMalloc<uint8_t> actual(miniRemaining);
REPORTER_ASSERT(r, stream->read(actual.get(), miniRemaining) == miniRemaining);
REPORTER_ASSERT(r, !memcmp(expected.get() + arbitrary, actual.get(), miniRemaining));
};
auto test_seek_beginning = [&r, &expected, remaining](SkStream* stream) {
// Seek to the beginning.
REPORTER_ASSERT(r, stream->seek(0));
REPORTER_ASSERT(r, stream->getPosition() == 0);
SkAutoTMalloc<uint8_t> actual(remaining);
REPORTER_ASSERT(r, stream->read(actual.get(), remaining) == remaining);
REPORTER_ASSERT(r, !memcmp(expected.get(), actual.get(), remaining));
};
auto test_seek_end = [&r, remaining](SkStream* stream) {
// Cannot seek past the end.
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->seek(remaining + 1));
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == remaining);
const size_t middle = remaining / 2;
REPORTER_ASSERT(r, stream->seek(middle));
REPORTER_ASSERT(r, !stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == middle);
REPORTER_ASSERT(r, stream->seek(remaining * 2));
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == remaining);
REPORTER_ASSERT(r, stream->seek(std::numeric_limits<long>::max()));
REPORTER_ASSERT(r, stream->isAtEnd());
REPORTER_ASSERT(r, stream->getPosition() == remaining);
};
std::function<void (SkStream* stream, bool recurse)> test_all;
test_all = [&](SkStream* stream, bool recurse) {
REPORTER_ASSERT(r, stream->getLength() == remaining);
REPORTER_ASSERT(r, stream->getPosition() == 0);
test_full_read(stream);
test_rewind(stream);
test_move(stream);
test_seek(stream);
test_seek_beginning(stream);
test_seek_end(stream);
if (recurse) {
// Duplicate shares the original offset.
auto duplicate = stream->duplicate();
if (!duplicate) {
ERRORF(r, "Failed to duplicate the stream!");
} else {
test_all(duplicate.get(), false);
}
// Fork shares the original offset, too.
auto fork = stream->fork();
if (!fork) {
ERRORF(r, "Failed to fork the stream!");
} else {
REPORTER_ASSERT(r, fork->isAtEnd());
REPORTER_ASSERT(r, fork->getLength() == remaining);
REPORTER_ASSERT(r, fork->rewind());
test_all(fork.get(), false);
}
}
};
test_all(&stream2, true);
}
int main(void)
{
return(test_all());
}
/*----------------------------------------------------------------------------*/
int
testing(int mytesttype, char *module)
{
testtype = mytesttype;
char pid[32] = "";
if( testtype == 0 ) {
snprintf(pid, sizeof pid, "%d", getpid());
}
printf("Pid is %s\n",pid);
if (!module) {
test_all();
test_module(TOPIARY_NTP_DRIFT);
test_module(TOPIARY_PROC_BUDDYINFO);
test_module(TOPIARY_PROC_CGROUPS);
test_module(TOPIARY_PROC_CMDLINE);
test_module(TOPIARY_PROC_CPUINFO);
test_module(TOPIARY_PROC_DISKSTATS);
test_module(TOPIARY_PROC_DOMAINNAME);
test_module(TOPIARY_PROC_HOSTNAME);
test_module(TOPIARY_PROC_INTERRUPTS);
test_module(TOPIARY_PROC_LOADAVG);
test_module(TOPIARY_PROC_MEMINFO);
test_module(TOPIARY_PROC_MOUNTS);
test_module(TOPIARY_PROC_NET_DEV);
test_module(TOPIARY_PROC_NET_NETSTAT);
test_module(TOPIARY_PROC_NET_RPC_NFS);
test_module(TOPIARY_PROC_NET_RPC_NFSD);
test_module(TOPIARY_PROC_NET_SNMP);
test_module(TOPIARY_PROC_NET_SNMP6);
test_module(TOPIARY_PROC_NET_SOCKSTAT);
test_module(TOPIARY_PROC_OSRELEASE);
test_module(TOPIARY_PROC_PARTITIONS);
test_module(TOPIARY_PROC_PID_ENVIRON);
test_pid_module(TOPIARY_PROC_PID_ENVIRON,pid);
test_module(TOPIARY_PROC_PID_IO);
test_pid_module(TOPIARY_PROC_PID_IO,pid);
test_module(TOPIARY_PROC_PID_SMAPS);
test_pid_module(TOPIARY_PROC_PID_SMAPS,pid);
test_module(TOPIARY_PROC_PID_STAT);
test_pid_module(TOPIARY_PROC_PID_STAT,pid);
test_master_module(TOPIARY_PROC_PID_STAT, "chrome");
test_mod_module(TOPIARY_PROC_PID_STAT, "chrome",
TOPIARY_PROC_PID_STATM);
test_module(TOPIARY_PROC_PID_STATM);
test_pid_module(TOPIARY_PROC_PID_STATM,pid);
test_module(TOPIARY_PROC_PID_STATUS);
test_pid_module(TOPIARY_PROC_PID_STATUS,pid);
test_module(TOPIARY_PROC_SOFTIRQS);
test_module(TOPIARY_PROC_STAT);
test_module(TOPIARY_PROC_SYS_FS_FILE_NR);
test_module(TOPIARY_PROC_UPTIME);
test_module(TOPIARY_PROC_VMSTAT);
/* later kernels (3.8?) do not have this....
* test_module(TOPIARY_SYS_CPUFREQ);
*/
test_module(TOPIARY_SYS_DISKSECTORS);
test_glob_module(TOPIARY_SYS_DISKSECTORS, "sd*");
}
else if (!strcmp(module, "all")) {
test_all();
}
else if (!strcmp(module, "ntp_drift")) {
test_module(TOPIARY_NTP_DRIFT);
}
else if (!strcmp(module, "proc_buddyinfo")) {
test_module(TOPIARY_PROC_BUDDYINFO);
}
else if (!strcmp(module, "proc_cgroups")) {
test_module(TOPIARY_PROC_CGROUPS);
}
else if (!strcmp(module, "proc_cmdline")) {
test_module(TOPIARY_PROC_CMDLINE);
}
else if (!strcmp(module, "proc_cpuinfo")) {
test_module(TOPIARY_PROC_CPUINFO);
}
else if (!strcmp(module, "proc_diskstats")) {
test_module(TOPIARY_PROC_DISKSTATS);
}
else if (!strcmp(module, "proc_domainname")) {
test_module(TOPIARY_PROC_DOMAINNAME);
}
else if (!strcmp(module, "proc_hostname")) {
test_module(TOPIARY_PROC_HOSTNAME);
}
else if (!strcmp(module, "proc_interrupts")) {
test_module(TOPIARY_PROC_INTERRUPTS);
}
else if (!strcmp(module, "proc_loadavg")) {
test_module(TOPIARY_PROC_LOADAVG);
}
else if (!strcmp(module, "proc_meminfo")) {
test_module(TOPIARY_PROC_MEMINFO);
}
else if (!strcmp(module, "proc_mounts")) {
test_module(TOPIARY_PROC_MOUNTS);
}
else if (!strcmp(module, "proc_net_dev")) {
test_module(TOPIARY_PROC_NET_DEV);
}
else if (!strcmp(module, "proc_net_netstat")) {
test_module(TOPIARY_PROC_NET_NETSTAT);
}
else if (!strcmp(module, "proc_net_rpc_nfs")) {
test_module(TOPIARY_PROC_NET_RPC_NFS);
}
else if (!strcmp(module, "proc_net_rpc_nfsd")) {
test_module(TOPIARY_PROC_NET_RPC_NFSD);
}
else if (!strcmp(module, "proc_net_snmp")) {
test_module(TOPIARY_PROC_NET_SNMP);
}
else if (!strcmp(module, "proc_net_snmp6")) {
test_module(TOPIARY_PROC_NET_SNMP6);
}
else if (!strcmp(module, "proc_net_sockstat")) {
test_module(TOPIARY_PROC_NET_SOCKSTAT);
}
else if (!strcmp(module, "proc_osrelease")) {
test_module(TOPIARY_PROC_OSRELEASE);
}
else if (!strcmp(module, "proc_partitions")) {
test_module(TOPIARY_PROC_PARTITIONS);
}
else if (!strcmp(module, "proc_pid_environ")) {
test_module(TOPIARY_PROC_PID_ENVIRON);
test_pid_module(TOPIARY_PROC_PID_ENVIRON,pid);
}
else if (!strcmp(module, "proc_pid_io")) {
test_module(TOPIARY_PROC_PID_IO);
test_pid_module(TOPIARY_PROC_PID_IO,pid);
}
else if (!strcmp(module, "proc_pid_smaps")) {
test_module(TOPIARY_PROC_PID_SMAPS);
test_pid_module(TOPIARY_PROC_PID_SMAPS,pid);
}
else if (!strcmp(module, "proc_pid_stat")) {
test_module(TOPIARY_PROC_PID_STAT);
test_pid_module(TOPIARY_PROC_PID_STAT,pid);
test_master_module(TOPIARY_PROC_PID_STAT, "chrome");
test_mod_module(TOPIARY_PROC_PID_STAT, "chrome",
TOPIARY_PROC_PID_STATM);
}
else if (!strcmp(module, "proc_pid_statm")) {
test_module(TOPIARY_PROC_PID_STATM);
test_pid_module(TOPIARY_PROC_PID_STATM,pid);
}
else if (!strcmp(module, "proc_pid_status")) {
test_module(TOPIARY_PROC_PID_STATUS);
test_pid_module(TOPIARY_PROC_PID_STATUS,pid);
}
else if (!strcmp(module, "proc_softirqs")) {
test_module(TOPIARY_PROC_SOFTIRQS);
}
else if (!strcmp(module, "proc_stat")) {
test_module(TOPIARY_PROC_STAT);
}
else if (!strcmp(module, "proc_sys_fs_file_nr")) {
test_module(TOPIARY_PROC_SYS_FS_FILE_NR);
}
else if (!strcmp(module, "proc_uptime")) {
test_module(TOPIARY_PROC_UPTIME);
}
else if (!strcmp(module, "proc_vmstat")) {
test_module(TOPIARY_PROC_VMSTAT);
}
else if (!strcmp(module, "sys_cpufreq")) {
test_module(TOPIARY_SYS_CPUFREQ);
}
else if (!strcmp(module, "sys_disksectors")) {
test_module(TOPIARY_SYS_DISKSECTORS);
test_glob_module(TOPIARY_SYS_DISKSECTORS, "sd*");
}
return 0;
}
int main(int argc, char *argv[])
{
test_all();
return(0);
}
void run_all_tests() {
test_empty();
test_all();
}
void self_test()
{
test_all(TP_READ, read_driver);
test_all(TP_EVAL, eval_driver);
}
void
TestLFReg_Run_IMP(TestLockFreeRegistry *self, TestBatchRunner *runner) {
TestBatchRunner_Plan(runner, (TestBatch*)self, 6);
test_all(runner);
}
