int
main (int argc,
char *argv[])
{
const char *default_uristr = "mongodb://localhost/test";
char *uristr;
const char *database_name;
mongoc_uri_t *uri;
mongoc_client_t *client;
mongoc_database_t *db;
mongoc_collection_t *collection;
mongoc_init ();
uristr = getenv ("MONGODB_URI");
uristr = uristr ? uristr : (char*)default_uristr;
uri = mongoc_uri_new (uristr);
client = mongoc_client_new_from_uri (uri);
database_name = mongoc_uri_get_database (uri);
db = mongoc_client_get_database (client, database_name);
collection = mongoc_database_get_collection (db, "test");
test_suite (db, collection);
mongoc_collection_destroy (collection);
mongoc_database_destroy (db);
mongoc_client_destroy (client);
mongoc_uri_destroy (uri);
mongoc_cleanup ();
return 0;
}
int
main (int argc,
char *argv[])
{
double start_time, end_time, delta_time;
int64_t count;
if (argc < 3) {
fprintf(stderr, "usage: %s [options] schema_file mbdump_dir table_names", argv[0]);
DIE;
}
argc--, argv++;
strcpy(schema_file, argv[0]);
argc--, argv++;
strcpy(mbdump_dir, argv[0]);
argc--, argv++;
test_suite ();
mongoc_init ();
mongoc_log_set_handler (log_local_handler, NULL);
start_time = dtimeofday ();
count = execute (argc, &argv[0]);
end_time = dtimeofday ();
delta_time = end_time - start_time + 0.0000001;
fprintf (stderr, "total:\n");
fprintf (stderr, "info: real: %.2f, count: %"PRId64", %"PRId64" docs/sec\n", delta_time, count, (int64_t)round (count/delta_time));
mongoc_cleanup ();
return 0;
}
int main(int argc, char *argv[])
{
int failed;
sxc_client_t *sx = server_init(NULL, NULL, NULL, 0, argc, argv);
#ifdef ABS_BUILDDIR
/* chdir so that tests that use execve() can find
* the executables */
if (chdir(ABS_BUILDDIR) == -1) {
fprintf(stderr,"chdir failed on %s: %s",
ABS_BUILDDIR, strerror(errno));
return 2;
}
#endif
sr = srunner_create(NULL);
if (srunner_fork_status(sr))
skip_dietests = 1;
srunner_add_suite(sr, test_suite());
srunner_run_all(sr, CK_NORMAL);
failed = srunner_ntests_failed(sr);
srunner_free(sr);
server_done(&sx);
return !failed ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int ac, char **av)
{
Test_Data *result = test_suite();
printf("Number of tests run: %d\n", result->tests_run);
printf("Tests failed: %d\n", result->tests_failed);
return result->tests_failed;
}
main(void) {
int number_failed;
Suite *s = test_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_NORMAL);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char *argv[]) {
int nf;
Suite *s = test_suite();
SRunner *sr = srunner_create(s);
srunner_set_xml(sr, "test_unicode.xml");
srunner_run_all(sr, CK_VERBOSE);
nf = srunner_ntests_failed(sr);
srunner_free(sr);
return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
// run suite
int main()
{
int number_failed;
Suite *s = test_suite();
SRunner *sr = srunner_create(s);
srunner_run_all(sr, CK_VERBOSE);
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return number_failed;
}
/*
* === FUNCTION ======================================================================
* Name: main
* Description: The entrance of the world
* =====================================================================================
*/
int main ( int argc, char *argv[] ) {
char *result = test_suite();
if (result != 0) {
printf("%s\n", result);
}
else {
printf("ALL tests passed\n");
}
printf("Tests run: %d\n", tests_run);
return result != 0;
} /* ---------- end of function main ---------- */
int
main(int argc, const char **argv)
{
int number_failed;
Suite *suite = test_suite();
SRunner *runner = srunner_create(suite);
srunner_run_all(runner, CK_NORMAL);
number_failed = srunner_ntests_failed(runner);
srunner_free(runner);
return (number_failed == 0)? EXIT_SUCCESS: EXIT_FAILURE;
}
int main(void)
{
GR_Host_Init(&test_host);
Suite *const s = test_suite();
SRunner *const sr = srunner_create(s);
srunner_set_fork_status(sr, CK_NOFORK);
srunner_run_all(sr, CK_NORMAL);
const int number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int
main(int argc, char **argv)
{
Vector v;
char *delims;
int i, ch, argi, flags;
flags = 0;
delims = NULL;
while ((ch = getopt(argc, argv, "d:f:t")) != -1) {
switch (ch) {
case 'd':
delims = optarg;
break;
case 'f':
flags = (int) strtol(optarg, NULL, 0);
break;
case 't':
return test_suite();
default:
optind = argc;
}
}
if (argc <= optind) {
(void) fputs(usage, stderr);
return EXIT_FAILURE;
}
for (argi = optind; argi < argc; argi++) {
if ((v = TextSplit(argv[argi], delims, flags)) == NULL) {
(void) fprintf(stderr, "out of memory\n");
return EXIT_FAILURE;
}
for (i = 0; i < VectorLength(v); i++)
(void) printf("%s\n", (char *)VectorGet(v, i));
VectorDestroy(v);
}
return EXIT_SUCCESS;
}
int
main (int argc, char **argv)
{
const char *filename = NULL;
toyvm_function *fn = NULL;
/* If called with no args, assume we're being run by the test suite. */
if (argc < 3)
{
test_suite ();
return 0;
}
if (argc != 3)
{
fprintf (stdout,
"%s FILENAME INPUT: Parse and run a .toy file\n",
argv[0]);
exit (1);
}
filename = argv[1];
fn = toyvm_function_parse (filename, filename);
if (!fn)
exit (1);
if (0)
toyvm_function_disassemble (fn, stdout);
printf ("interpreter result: %d\n",
toyvm_function_interpret (fn, atoi (argv[2]), NULL));
/* JIT-compilation. */
toyvm_compiled_function *compiled_fn
= toyvm_function_compile (fn);
toyvm_compiled_code code = compiled_fn->cf_code;
printf ("compiler result: %d\n",
code (atoi (argv[2])));
gcc_jit_result_release (compiled_fn->cf_jit_result);
free (compiled_fn);
return 0;
}
int main(int argc, char **argv)
{
if (argc < 2)
goto error;
if (0 == strcmp(argv[1], "-b"))
bm_suite();
else if (0 == strcmp(argv[1], "-t"))
test_suite();
else if (0 == strcmp(argv[1], "-u"))
use_suite();
else
goto error;
return EXIT_SUCCESS;
error:
fprintf(stdout, "Usage: %s [-tbu]\n", argv[0]);
return EXIT_FAILURE;
}
int
main(int argc, const char **argv)
{
int number_failed;
Suite *suite = test_suite();
SRunner *runner = srunner_create(suite);
setup_allocator();
if (argc > 1) {
if (sscanf(argv[1], "%" PRId64, &GENERATE_COUNT) != 1) {
fprintf(stderr, "Invalid record count: \"%s\"\n", argv[1]);
return -1;
}
}
vrt_testing_mode();
clog_setup_logging();
srunner_run_all(runner, CK_NORMAL);
number_failed = srunner_ntests_failed(runner);
srunner_free(runner);
return (number_failed == 0)? EXIT_SUCCESS: EXIT_FAILURE;
}
int main (int argc, char ** argv)
{
double h = 0,
L = 0,
a = 0,
t = 0.1;
int N = 100,
p = 4,
tryrac = 1,
n = 0,
g = 3,
d = 0,
T = 100,
D = 8,
y = 0,
e = 0,
I = 0,
A = 0,
v = 0,
arg;
char * dat = NULL;
opterr = 1;
while ((arg = getopt (argc, argv, "h:L:a:t:N:F:D:p:n:T:I:o:g:v:lAdey")) != -1)
{
switch (arg)
{
case 'h':
h = atof (optarg);
break;
case 'L':
L = atof (optarg);
break;
case 'a':
a = atof (optarg);
break;
case 't':
t = atof (optarg);
break;
case 'N':
N = atoi (optarg);
break;
case 'F':
tryrac = atoi (optarg);
break;
case 'p':
p = atoi (optarg);
break;
case 'n':
n = atoi (optarg);
break;
case 'T':
T = atoi (optarg);
break;
case 'o':
dat = (char *) malloc (15 * sizeof (char));
strcpy (dat, optarg);
break;
case 'd':
d = 1;
break;
case 'y':
y = 1;
break;
case 'g':
g = atoi (optarg);
break;
case 'e':
e = 1;
break;
case 'I':
I = atoi (optarg);
break;
case 'A':
A = 1;
break;
case 'D':
D = atoi (optarg);
break;
case 'v':
v = atoi (optarg);
break;
case 'l':
printf ("List of valid commands:\n\n");
printf ("[-l] prints this list and exit\n");
printf ("[-t] (0.1) time step\n");
printf ("[-h] (0.01) space step\n");
printf ("[-L] (0.0) lambda\n");
printf ("[-a] (0.0) f(x - a)\n");
printf ("[-N] (100) matrix rank\n");
printf ("[-F] (1) precision test\n");
printf ("[-T] (100) time iterations\n");
printf ("[-p] (4) order of 2nd derivative prec.\n");
printf ("[-g] (0.001) threshold for good eigenvalue\n");
printf ("[-n] (0) phi_n (x)\n");
printf ("[-A] (no) get the best possible h for given N\n");
printf ("[-I] (no) for calibration -- h (N)\n");
printf ("[-v] (0) get the good eigenvalues with increment\n");
printf ("[-y] (no) save the output -- 'yes'\n");
printf ("[-D] (8) duration of the animation in s\n");
printf ("[-o] (format) output filename\n");
printf ("[-e] (no) output the Energies\n");
printf ("[-d] animation set to 'yes'\n");
exit (EXIT_SUCCESS);
default:
abort ();
}
}
if (v != 0)
{
if (dat == NULL)
{
dat = (char *) malloc (40*sizeof(char));
sprintf (dat, "ratio-L%d.txt", (int) (100 * L));
}
vozi (L, a, t, g, N, p, d, tryrac, n, T, dat, v);
printf ("Written in %s\n", dat);
char * command = (char *) malloc (55 * sizeof (char));
sprintf (command, "./plot2.sh %d %s %d", 1, dat, y);
system (command);
free (dat);
free (command);
exit (EXIT_SUCCESS);
}
// optimiziran h
if (h == 0)
h = 1.78850/(pow (N, 0.614827)) - N * 3.28275e-6;
// we initialize the program
hod * u = (hod *) malloc (sizeof (hod));
init (u, h, L, a, t, g, N, p, d, tryrac, n, T, dat);
if (I == 0)
{
// we now diagonalize the matrix
if (A == 0)
diag_MRRR (u);
else if (A == 1)
autoh (u);
if (e == 0)
{
rotate (u);
init_v (u);
if (u->d == 1)
{
char * animation = (char *) malloc (40 * sizeof (char));
sprintf (animation, "./anime.sh %s %d %d", u->dat, y, D);
create_frames (u);
system (animation);
}
else
{
char * savenplot = (char *) malloc (40 * sizeof (char));
sprintf (savenplot, "./plot.sh %s %d", u->dat, y);
one_big_txt (u);
system (savenplot);
}
}
else
{
eigen_output (u);
count_harmonic (u);
if (y == 1)
eigen_dump (u);
}
}
else if (I != 0)
{
test_suite (u, I);
printf ("Written in file h-of-N.txt\n");
char * command = (char *) malloc (40 * sizeof (char));
sprintf (command, "./plot2.sh 0 0 %d", y);
system (command);
free (command);
}
destroy (u);
return 0;
}
int main(int argc, char ** argv)
{
char log_file[256];
int log_file_set = 0;
char stat_file[256];
int stat_file_set = 0;
int nodeId = DEFAULT_NODE_ID, levels = DEFAULT_NUM_LEVELS;
unsigned int width = DEFAULT_GRID_WIDTH, height = DEFAULT_GRID_HEIGHT,
startX = DEFAULT_GRID_STARTX, startY = DEFAULT_GRID_STARTY;
int bloom_interval_ms = DEFAULT_BLOOM_INTERVAL_SEC * 1000;
int cluster_interval_ms = DEFAULT_CLUSTER_INTERVAL_SEC * 1000;
read_config(&nodeId, &levels, &width, &height, &startX, &startY);
pid_t pid, sid;
signal(SIGHUP, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGUSR1, signal_handler);
signal(SIGUSR2, signal_handler);
int logging_level = LOG_NORMAL;
int c;
while ((c = getopt(argc, argv, "-h?tn:l:g:s:c:b:j:qv")) != -1) {
switch (c) {
case 'h':
case '?':
print_usage(argv[0]);
exit(EXIT_SUCCESS);
case 'b':
bloom_interval_ms = atoi(optarg);
if (bloom_interval_ms <= 0) {
bloom_interval_ms = DEFAULT_BLOOM_INTERVAL_SEC * 1000;
printf("error parsing bloom sharing interval! defaulting to %d.\n", bloom_interval_ms);
} else {
printf("set bloom sharing interval to %d ms.\n", bloom_interval_ms);
}
break;
case 'c':
sscanf(optarg, "%d,%d", &startX, &startY);
printf("set start pos = (%d, %d).\n", startX, startY);
break;
case 'f':
strncpy(optarg, log_file, 256);
printf("set log file = %s.\n", log_file);
log_file_set = 1;
break;
case 'g':
sscanf(optarg, "%dx%d", &height, &width);
printf("set grid dim: %d X %d.\n", height, width);
break;
case 'j':
cluster_interval_ms = atoi(optarg);
if (cluster_interval_ms <= 0) {
cluster_interval_ms = DEFAULT_CLUSTER_INTERVAL_SEC * 1000;
printf("error parsing cluster join interval default to %d.\n", cluster_interval_ms);
} else {
printf("set cluster join interval to %d ms.\n", cluster_interval_ms);
}
break;
case 'l':
levels = atoi(optarg);
printf("set levels = %d.\n", levels);
break;
case 'n':
nodeId = atoi(optarg);
printf("set node ID = %u.\n", nodeId);
break;
case 's':
strncpy(optarg, stat_file, 256);
printf("set stat file = %s.\n", stat_file);
stat_file_set = 1;
break;
case 't':
if (test_suite())
exit(EXIT_SUCCESS);
else
exit(EXIT_FAILURE);
case 'q':
logging_level = LOG_ERROR | LOG_CRITICAL;
break;
case 'v':
logging_level = LOG_DEVEL;
break;
default:
break;
}
}
g_bfr.nodeId = nodeId;
char proc[256];
snprintf(proc, 256, "bfrd%u", g_bfr.nodeId);
prctl(PR_SET_NAME, proc, 0, 0, 0);
char * home_env = getenv("HOME");
char home[256];
if (!home_env) {
fprintf(stderr, "bfrd: could not parse HOME environment, exiting!");
exit(EXIT_FAILURE);
}
strncpy(home, home_env, 256);
g_log = (struct log * ) malloc(sizeof(struct log));
char log_name[256];
snprintf(log_name, 256, "bfr_%u", nodeId);
if (!log_file_set)
snprintf(log_file, 256, "%s/log/bfr_%u.log", home, nodeId);
log_name[255] = '\0';
log_file[255] = '\0';
if (log_init(log_name, log_file, g_log, LOG_OVERWRITE | logging_level) < 0) {
fprintf(stderr, "bfr log: %s failed to initalize, exiting!", log_file);
exit(EXIT_FAILURE);
}
if (!stat_file_set)
snprintf(stat_file, 256, "%s/stat/bfr_%u.stat", home, nodeId);
stat_file[255] = '\0';
if (bfrstat_init(stat_file) < 0) {
fprintf(stderr, "bfrd stat: %s failed to initalize!", stat_file);
exit(EXIT_FAILURE);
}
fprintf(stderr, "Starting daemon...");
pid = fork();
if (pid < 0) {
exit(EXIT_FAILURE);
}
if (pid > 0) {
/* parent exits */
fprintf(stderr, "Done. pid = %d\n", pid);
exit(EXIT_SUCCESS);
}
umask(0); /* os calls provide their own permissions */
sid = setsid();
if (sid < 0) {
fprintf(stderr, "setsid: %s.", strerror(errno));
exit(EXIT_FAILURE);
}
/* close out the std io file handles */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
/* change the current working directory (after log is inited) */
if ((chdir("/")) < 0) {
log_print(g_log, "chdir: %s.", strerror(errno));
exit(EXIT_FAILURE);
}
/* stuff needs to be initialized in this order */
if (bfr_init(nodeId, levels, width, height, startX, startY) < 0) {
log_print(g_log, "bfr_init: error initializing.");
exit(EXIT_FAILURE);
}
if (strategy_init(levels, bloom_interval_ms, cluster_interval_ms) < 0) {
log_print(g_log, "stategy_init: error initializing.");
exit(EXIT_FAILURE);
}
if (bfr_listener_init() < 0) {
log_print(g_log, "bfr_listener_init: error initializing.");
exit(EXIT_FAILURE);
}
if (bfr_net_listener_init() < 0) {
log_print(g_log, "bfr_net_listener_init: error initializing.");
exit(EXIT_FAILURE);
}
log_print(g_log, "Initialized successfully, pid = %d.", getpid());
pthread_mutex_t bfrd_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t bfrd_var = PTHREAD_COND_INITIALIZER;
/* initialize the ipc listener */
struct listener_args ipc_args;
ipc_args.lock = &bfrd_mutex;
ipc_args.cond = &bfrd_var;
ipc_args.queue = synch_queue_init();
pthread_create(&ipc_listener, NULL, bfr_listener_service, &ipc_args);
/* initialize the net listener */
struct listener_args net_args;
net_args.lock = &bfrd_mutex;
net_args.cond = &bfrd_var;
net_args.queue = synch_queue_init();
pthread_create(&net_listener, NULL, bfr_net_listener_service, &net_args);
/* initialize the strategy serivce */
pthread_create(&strategy_thread, NULL, strategy_service, NULL);
while (1) {
/* for efficiency we sleep until someone wakes us up */
pthread_mutex_lock(&bfrd_mutex);
pthread_cond_wait(&bfrd_var, &bfrd_mutex);
pthread_mutex_unlock(&bfrd_mutex);
/* we don't know who woke us up, it could be the ipc listener or net
* listener
*/
bfr_handle_net(&net_args);
bfr_handle_ipc(&ipc_args);
}
exit(EXIT_SUCCESS);
}
int main(void)
{
test_suite();
time_trial();
return 0;
}
