int main(void) { plan(2); const char *downloaded = "__remote_readme__.md"; unlink(downloaded); const char *url = "https://raw.github.com/thlorenz/cre-downloader/master/README.md"; FILE *fp; char *remote = 0; int remote_len, status; // Download fp = fopen(downloaded, "wb"); status = download_url_file(url, fp); fclose(fp); cmp_ok(status, "==", 200, "returns status 200"); // Read downloaded README fp = fopen(downloaded, "r"); remote_len = fs_fsize(fp); remote = malloc(remote_len); fread(remote, 1, remote_len, fp); fclose(fp); unlink(downloaded); like(remote, "cre-downloader", "downloaded README has same content as local README"); return 0; }
int like(node *tree1,node *tree2){ int like1,like2; if(tree1 == NULL && tree2 == NULL){ return 1; }else if(tree1 == NULL || tree2 == NULL){ return 2; }else{ like1 = like(tree1->lchild,tree2->lchild); like2 = like(tree1->rchild,tree2->rchild); return(like1 && like2); } }
void check_no_worker_running(char* worker_logfile) { char cmd[150]; char *result, *error; int rrc; // ensure no worker are running anymore char *username=getenv("USER"); snprintf(cmd, 150, "ps -efl 2>/dev/null | grep -v grep | grep '%s' | grep mod_gearman_worker", username); rrc = real_exit_code(run_check(cmd, &result, &error)); ok(rrc == 1, "no worker running anymore"); like(result, "^\\s*$", "ps output should be empty"); like(error, "^\\s*$", "ps error output should be empty"); if(rrc != 1) { check_logfile(worker_logfile, 3); } return; }
int like (BiTree * t1, BiTree * t2) { int like1; int like2; if (t1 == NULL && t2 == NULL) { return 1; } else if (t1 == NULL || t2 == NULL) { return 0; } else { like1 = like(t1->Lchild, t2->Lchild); like2 = like(t1->Rchild, t2->Rchild); return (like1 && like2); } }
void *get_results( gearman_job_st *job, void *context, size_t *result_size, gearman_return_t *ret_ptr ) { int wsize; char workload[GM_BUFFERSIZE]; char *decrypted_data; /* contect is unused */ context = context; /* set size of result */ *result_size = 0; /* set result pointer to success */ *ret_ptr = GEARMAN_SUCCESS; /* get the data */ wsize = gearman_job_workload_size(job); strncpy(workload, (const char*)gearman_job_workload(job), wsize); workload[wsize] = '\x0'; /* decrypt data */ decrypted_data = malloc(GM_BUFFERSIZE); mod_gm_decrypt(&decrypted_data, workload, mod_gm_opt->transportmode); if(decrypted_data == NULL) { *ret_ptr = GEARMAN_WORK_FAIL; return NULL; } like(decrypted_data, "host_name=host1", "output contains host_name"); like(decrypted_data, "output=", "output contains output"); if(last_result != NULL) free(last_result); last_result = decrypted_data; return NULL; }
bool Radio::runCommand(std::string input){ std::string command = ""; unsigned int i = 0; for(i = 0; i < input.length() && input[i] != ' '; ++ i){ command = command + input[i]; } ++ i; std::string restStr = ""; if(i < input.length()){ restStr = input.substr(i); } if(command == "QUIT"){ return false; } if(command == "INIT"){ init(restStr); return true; } if(command == "ADD"){ addSong(restStr); return true; } if(command == "RUN"){ int result = 0; result = runFile(restStr); if(result == 0){ return false; }else{ return true; } } if(command == "REST"){ rest(restStr); return true; } if(command == "PLAY"){ play(restStr); return true; } if(command == "LIKE"){ like(restStr); return true; } if(command == "DISLIKE"){ dislike(restStr); return true; } return false; }
void test_helpers (void) { char *name, *path; const char *modpath = flux_conf_get ("module_path", CONF_FLAG_INTREE); path = xasprintf ("%s/kvs/.libs/kvs.so", modpath); ok (access (path, F_OK) == 0, "built kvs module is located"); name = flux_modname (path); ok ((name != NULL), "flux_modname on kvs should find a name"); skip (name == NULL, 1, "skip next test because kvs.so name is NULL"); like (name, "^kvs$", "flux_modname says kvs module is named kvs"); end_skip; if (name) free (name); free (path); ok (!flux_modfind ("nowhere", "foo"), "flux_modfind fails with nonexistent directory"); ok (!flux_modfind (".", "foo"), "flux_modfind fails in current directory"); ok (!flux_modfind (modpath, "foo"), "flux_modfind fails to find unknown module in moduledir"); path = xasprintf ("%s/kvs/.libs", modpath); name = flux_modfind (path, "kvs"); ok ((name != NULL), "flux_modfind finds kvs in flat directory"); if (name) free (name); free (path); name = flux_modfind (modpath, "kvs"); ok ((name != NULL), "flux_modfind also finds kvs in moduledir"); if (name) free (name); path = xasprintf ("foo:bar:xyz:%s:zzz", modpath); name = flux_modfind (path, "kvs"); ok ((name != NULL), "flux_modfind also finds kvs in search path"); if (name) free (name); free (path); }
int parseLine(std::string line, Time*& time, Hash*& hash, Heap*& heap, Song*& playing){ if (!line.length()) return 1; switch(line[0]){ case 'I': init(line, time, hash, heap); break; case 'R': rest(line, time); break; case 'A': add(line, time, hash, heap); break; case 'P': play(line, time, hash, heap, playing); break; case 'L': like(line, time, hash, heap, playing); break; case 'D': dislike(line, time, hash, heap, playing); break; default : return 1; } return 0; }
static bool like(const UCHAR* p1, SSHORT l1, const UCHAR* p2, SSHORT l2, const UCHAR escape_char) { /************************************** * * l i k e * ************************************** * * Functional description * Return true if a string (p1, l1) matches a given pattern (p2, l2). * The character '_' in the pattern may match any single character * in the the string, and the character '%' may match any sequence * of characters. * Japanese version operates on short-based buffer, * instead of char-based. * **************************************/ bool escape = false; while (--l2 >= 0) { const UCHAR c = *p2++; if (escape_char && !escape && c == escape_char) { escape = true; continue; } if (!escape && c == '%') { if (l2 == 0) return true; while (l1) { if (like(p1++, l1--, p2, l2, escape_char)) return true; } return false; } if (--l1 < 0) return false; if ((escape || c != '_') && c != *p1) return false; escape = false; p1++; } return l1 ? false : true; }
void MainWindow::on_all_table_customContextMenuRequested(const QPoint &pos) { QModelIndex index = ui->all_table->indexAt(pos); if(!index.isValid()) return; book_name = ui->all_table->selectedItems()[0]->text().toStdString(); selected_row = ui->all_table->selectedItems()[0]; QMenu* menu = new QMenu(this); QAction* action = 0; if(DB::db()->user()->get_library()->is_in_library(book_name)) { cerr << "1" << endl; if(!DB::db()->user()->get_library()->is_in_starred(book_name)) { action = new QAction("Like this", this); menu->addAction(action); connect(action,SIGNAL(triggered()),this,SLOT(like())); } vector<Shelf*> shelves = DB::db()->user()->get_library()->get_shelves(); int count = 0; for(int i = 0; i < shelves.size(); i++) { if(shelves[i]->get_name() == "default") continue; if(shelves[i]->has_book(book_name)) continue; count++; } if(count > 0) { action = new QAction("Add to Shelf", this); menu->addAction(action); connect(action,SIGNAL(triggered()),this,SLOT(add_to_shelf())); } } else { action = new QAction("Add To Library",this); menu->addAction(action); connect(action,SIGNAL(triggered()),this,SLOT(add_to_library())); } menu->popup(ui->all_table->viewport()->mapToGlobal(pos)); }
void TestWMAP9Like::runSubTest(unsigned int i, double& res, double& expected, std::string& subTestName) { check(i >= 0 && i < numberOfSubtests(), "invalid index " << i); const double h = 0.6704; const double omBH2 = 0.022032; const double omCH2 = 0.12038; const double tau = 0.0925; const double ns = 0.9619; const double as = 2.2154e-9; const double pivot = 0.05; const double r = 0.2; const double nt = 0; const double nEff = 3.046; const int nMassive = 1; const double sumMNu = 0.0; LambdaCDMParams paramsLCDM(omBH2, omCH2, h, tau, ns, as, pivot); LCDMWithTensorParams paramsLCDMTens(omBH2, omCH2, h, tau, ns, as, pivot, r, nt, pivot); const bool useLowlT = true, useHighlT = true, useLowlP = true, useHighlP = true, useGibbs = true, useTTBeam = true; WMAP9Likelihood like(useLowlT, useHighlT, useLowlP, useHighlP, useGibbs, useTTBeam); like.setCosmoParams(paramsLCDM); like.calculateCls(); subTestName = std::string("LCDM"); res = like.likelihood(); check(Math::areEqual(res, like.lowlTLike() + like.highlTLike() + like.TTBeamLike() + like.lowlPLike() + like.TELike() + like.TBLike(), 1e-5), ""); output_screen1("low-l TT chi2 = " << like.lowlTChi2() << ", det = " << like.lowlTDet() << ", total = " << like.lowlTLike() << std::endl); output_screen1("high-l TT like = " << like.highlTLike() << std::endl); output_screen1("TT beam like = " << like.TTBeamLike() << std::endl); output_screen1("low-l P chi2 = " << like.lowlPChi2() << ", det = " << like.lowlPDet() << ", total = " << like.lowlPLike() << std::endl); output_screen1("high-l TE chi2 = " << like.TEChi2() << ", det = " << like.TEDet() << ", total = " << like.TELike() << std::endl); output_screen1("high-l TB chi2 = " << like.TBChi2() << ", det = " << like.TBDet() << ", total = " << like.TBLike() << std::endl); expected = 7592.228; // calculated by running the WMAP9 likelihood code itself on the same cl values }
void test_get (void) { JSON o; bool dir = false; bool link = false; const char *key = NULL; JSON val = NULL; int i; o = kp_tget_enc ("foo", false, true); ok (o != NULL, "kp_tget_enc works"); ok (kp_tget_dec (o, &key, &dir, &link) == 0 && dir == false && link == true, "kp_tget_dec works"); like (key, "^foo$", "kp_tget_dec returned encoded key"); Jput (o); val = Jnew (); Jadd_int (val, "i", 42); o = kp_rget_enc ("foo", val); val = NULL; /* val now owned by o */ ok (o != NULL, "kp_rget_enc works"); ok (kp_rget_dec (o, &val) == 0, "kp_rget_dec works"); ok (val && Jget_int (val, "i", &i) && i == 42, "kp_rget_dec returned encoded object"); Jput (o); /* owns val */ o = kp_rget_enc ("foo", NULL); ok (o != NULL, "kp_rget_enc works with NULL value"); errno = 0; ok (kp_rget_dec (o, &val) < 0 && errno == ENOENT, "kp_rget_dec returns error with errno = ENOENT if val is NULL"); Jput (o); }
static int like(char *str, char *mask) { if (!str) str = ""; if (!mask) mask = ""; while (*mask) { if (*mask == '*') { while (*mask == '*') mask++; if (*mask == 0) return 1; while (*str) { if (like(str, mask)) return 1; str++; } return 0; } else if (*mask == *str || *mask == '?' && *str != 0) { str++; mask++; } else { return 0; } } return *str == 0; }
int main(void) { int rc, rrc; char *result, *error; char cmd[120]; char hostname[GM_BUFFERSIZE]; plan(54); /* set hostname */ gethostname(hostname, GM_BUFFERSIZE-1); /* create options structure and set debug level */ mod_gm_opt = malloc(sizeof(mod_gm_opt_t)); set_default_options(mod_gm_opt); mod_gm_opt->debug_level = 0; /***************************************** * arg parsing test 1 */ char *argv[MAX_CMD_ARGS]; strcpy(cmd, "/bin/true"); parse_command_line(cmd, argv); like(argv[0], cmd, "parsing args cmd 1"); /***************************************** * arg parsing test 2 */ strcpy(cmd, "/bin/cmd blah blub foo"); parse_command_line(cmd,argv); like(argv[0], "/bin/cmd", "parsing args cmd 2"); like(argv[1], "blah", "parsing args cmd 2"); like(argv[2], "blub", "parsing args cmd 2"); like(argv[3], "foo", "parsing args cmd 2"); /***************************************** * send_gearman */ strcpy(cmd, "./send_gearman --server=blah --key=testtest --host=test --service=test --message=test --returncode=0"); rrc = real_exit_code(run_check(cmd, &result, &error)); diag(result); cmp_ok(rrc, "==", 3, "cmd '%s' returned rc %d", cmd, rrc); free(result); free(error); /***************************************** * send_gearman */ //mod_gm_opt->debug_level = 4; strcpy(cmd, "./send_multi --server=blah --host=blah < t/data/send_multi.txt"); rrc = real_exit_code(run_check(cmd, &result, &error)); diag(result); cmp_ok(rrc, "==", 3, "cmd '%s' returned rc %d", cmd, rrc); free(result); free(error); /***************************************** * simple test command 1 */ strcpy(cmd, "/bin/true"); rc = run_check(cmd, &result, &error); cmp_ok(rc, "==", 0, "pclose for cmd '%s' returned rc %d", cmd, rc); rrc = real_exit_code(rc); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); free(result); free(error); /***************************************** * simple test command 2 */ strcpy(cmd, "/bin/true 2>&1"); rc = run_check(cmd, &result, &error); cmp_ok(rc, "==", 0, "pclose for cmd '%s' returned rc %d", cmd, rc); rrc = real_exit_code(rc); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); free(result); free(error); /***************************************** * simple test command 3 */ strcpy(cmd, "/usr/lib/nagios/plugins/check_icmp -H 127.0.0.1"); rc = run_check(cmd, &result, &error); cmp_ok(rc, "==", 0, "pclose for cmd '%s' returned rc %d", cmd, rc); rrc = real_exit_code(rc); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); free(result); free(error); /***************************************** * simple test command 4 */ strcpy(cmd, "echo -n 'test'; exit 2"); rc = run_check(cmd, &result, &error); rrc = real_exit_code(rc); cmp_ok(rrc, "==", 2, "cmd '%s' returned rc %d", cmd, rrc); like(result, "test", "returned result string"); free(result); free(error); gm_job_t * exec_job; exec_job = ( gm_job_t * )malloc( sizeof *exec_job ); set_default_job(exec_job, mod_gm_opt); /***************************************** * non existing command 1 */ exec_job->command_line = strdup("/bin/doesntexist"); exec_job->type = strdup("service"); exec_job->timeout = 10; int fork_on_exec = 0; execute_safe_command(exec_job, fork_on_exec, hostname); cmp_ok(exec_job->return_code, "==", 2, "cmd '%s' returns rc 2", exec_job->command_line); like(exec_job->output, "CRITICAL: Return code of 127 is out of bounds. Make sure the plugin you're trying to run actually exists. \\(worker:", "returned result string"); free(exec_job->output); free(exec_job->error); fork_on_exec = 1; lives_ok({execute_safe_command(exec_job, fork_on_exec, hostname);}, "executing command using fork on exec");
int main (int argc, char **argv, char **env) { argc = argc; argv = argv; env = env; #ifndef EMBEDDEDPERL plan(1); ok(1, "skipped epn tests"); return exit_status(); #endif #ifdef EMBEDDEDPERL int rc, rrc; char *result, *error; char cmd[120]; plan(21); /* create options structure and set debug level */ mod_gm_opt = malloc(sizeof(mod_gm_opt_t)); set_default_options(mod_gm_opt); char cmds[150]; strcpy(cmds, "--p1_file=worker/mod_gearman2_p1.pl"); parse_args_line(mod_gm_opt, cmds, 0); strcpy(cmds, "--enable_embedded_perl=on"); parse_args_line(mod_gm_opt, cmds, 0); strcpy(cmds, "--use_embedded_perl_implicitly=on"); parse_args_line(mod_gm_opt, cmds, 0); /* * mod_gm_opt->debug_level=4; * dumpconfig(mod_gm_opt, GM_WORKER_MODE); */ ok(p1_file != NULL, "p1_file: %s", p1_file); /***************************************** * send_gearman */ init_embedded_perl(env); rc=file_uses_embedded_perl("t/ok.pl"); cmp_ok(rc, "==", TRUE, "ok.pl: file_uses_embedded_perl returned rc %d", rc); rc=file_uses_embedded_perl("t/noepn.pl"); cmp_ok(rc, "==", FALSE, "noepn.pl: file_uses_embedded_perl returned rc %d", rc); strcpy(cmd, "./t/fail.pl"); rrc = real_exit_code(run_check(cmd, &result, &error)); cmp_ok(rrc, "==", 3, "cmd '%s' returned rc %d", cmd, rrc); like(result, "ePN failed to compile", "returned result string"); like(error, "^$", "returned error string"); free(result); free(error); strcpy(cmd, "./t/ok.pl"); rrc = real_exit_code(run_check(cmd, &result, &error)); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); like(result, "test plugin OK", "returned result string"); unlike(result, "plugin did not call exit", "returned result string"); like(error, "^$", "returned error string"); free(result); free(error); strcpy(cmd, "./t/crit.pl"); rrc = real_exit_code(run_check(cmd, &result, &error)); cmp_ok(rrc, "==", 2, "cmd '%s' returned rc %d", cmd, rrc); like(result, "test plugin CRITICAL", "returned result string"); like(error, "some errors on stderr", "returned error string"); free(result); free(error); strcpy(cmd, "./t/noexit.pl"); rrc = real_exit_code(run_check(cmd, &result, &error)); cmp_ok(rrc, "==", 3, "cmd '%s' returned rc %d", cmd, rrc); like(result, "sample output but no exit", "returned result string"); like(result, "plugin did not call exit", "returned result string"); like(error, "^$", "returned error string"); free(result); free(error); /* test mini epn */ strcpy(cmd, "./mod_gearman2_mini_epn ./t/ok.pl"); rrc = real_exit_code(run_check(cmd, &result, &error)); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); like(result, "plugin return code: 0", "contains return code"); like(result, "perl plugin output: 'test plugin OK", "contains plugin output"); like(error, "^$", "returned error string"); free(result); free(error); /***************************************** * clean up */ mod_gm_free_opt(mod_gm_opt); deinit_embedded_perl(0); return exit_status(); #endif }
int main (int argc, char *argv[]) { nodeset_t *n, *n2; nodeset_iterator_t *itr; int i; struct timespec ts; uint32_t bigset = 1E6; char *tmp; plan (NO_PLAN); n = nodeset_create (); ok (n != NULL); nodeset_config_brackets (n, false); /* obtain constants used in other tests */ uint32_t maxrank = nodeset_getattr (n, NODESET_ATTR_MAXRANK); uint32_t minsize = nodeset_getattr (n, NODESET_ATTR_MINSIZE); uint32_t maxsize = nodeset_getattr (n, NODESET_ATTR_MAXSIZE); nodeset_add_rank (n, 8); nodeset_add_rank (n, 7); nodeset_add_rank (n, 9); like (nodeset_string (n), "7-9", "consecutive adds become range"); ok (nodeset_count (n) == 3); nodeset_add_rank (n, 1); like (nodeset_string (n), "1,7-9", "singleton prepended to range"); ok (nodeset_count (n) == 4); nodeset_add_rank (n, 16); like (nodeset_string (n), "1,7-9,16", "singleton appended to range"); ok (nodeset_count (n) == 5); nodeset_add_rank (n, 14); like (nodeset_string (n), "1,7-9,14,16", "singleton embedded in range"); ok (nodeset_count (n) == 6); nodeset_add_rank (n, 3); like (nodeset_string (n), "1,3,7-9,14,16", "singleton embedded in range 2"); ok (nodeset_count (n) == 7); nodeset_add_range (n, 1, 3); like (nodeset_string (n), "1-3,7-9,14,16", "overlapping range"); ok (nodeset_count (n) == 8); nodeset_add_range (n, 5, 8); like (nodeset_string (n), "1-3,5-9,14,16", "overlapping range 2"); ok (nodeset_count (n) == 10); nodeset_add_range (n, 8, 11); like (nodeset_string (n), "1-3,5-11,14,16", "overlapping range 3"); ok (nodeset_count (n) == 12); nodeset_add_range (n, 1, 16); like (nodeset_string (n), "1-16", "add range that contains existing"); ok (nodeset_count (n) == 16); nodeset_add_range (n, 4, 8); like (nodeset_string (n), "1-16", "add range contained by existing"); ok (nodeset_count (n) == 16); nodeset_destroy (n); /********************************************/ n = nodeset_create (); ok (n != NULL); nodeset_add_rank (n, 0); nodeset_add_rank (n, 1); nodeset_add_rank (n, 2); like (nodeset_string (n), "\\[0-2\\]", "edge case 1 merges with 0"); ok (nodeset_count (n) == 3); nodeset_config_ranges (n, false); like (nodeset_string (n), "\\[0,1,2\\]"); nodeset_destroy (n); /********************************************/ n = nodeset_create (); ok (n != NULL); nodeset_add_rank (n, 2); nodeset_add_rank (n, 1); nodeset_add_rank (n, 0); like (nodeset_string (n), "\\[0-2\\]", "reverse merge works"); ok (nodeset_count (n) == 3); nodeset_destroy (n); /********************************************/ n = nodeset_create_string ("[1,3,5,6-100]"); ok (n != NULL); like (nodeset_string (n), "\\[1,3,5-100\\]", "mundane range string works"); ok (nodeset_count (n) == 98); nodeset_destroy (n); n = nodeset_create_string ("2-1"); ok (n != NULL); like (nodeset_string (n), "\\[1-2\\]", "numerically reversed range handled"); ok (nodeset_count (n) == 2); nodeset_destroy (n); n = nodeset_create_string (""); ok (n != NULL); ok (nodeset_count (n) == 0); like (nodeset_string (n), "", "empty string produces empty range"); nodeset_destroy (n); n = nodeset_create_string (","); ok (n == NULL, "comma by itself produces error"); n = nodeset_create_string ("-1"); ok (n == NULL, "range missing start produces error"); n = nodeset_create_string ("1-"); ok (n == NULL, "range missing end produces error"); n = nodeset_create_string ("foo1"); ok (n == NULL, "alpha with numerical suffix produces error"); n = nodeset_create_string ("[1-2]"); ok (n != NULL); like (nodeset_string (n), "\\[1-2\\]", "bracketed range works"); ok (nodeset_count (n) == 2); nodeset_destroy (n); n = nodeset_create_string ("xyz"); ok (n == NULL, "alpha by itself produces error"); /********************************************/ n = nodeset_create_string ("0-2"); ok (n != NULL); ok (nodeset_test_rank (n, 0)); ok (nodeset_test_rank (n, 1)); ok (nodeset_test_rank (n, 2)); ok (!nodeset_test_rank (n, 3)); ok (!nodeset_test_rank (n, nodeset_getattr (n, NODESET_ATTR_SIZE) - 1), "nodeset_test_rank (internal size - 1) fails"); ok (!nodeset_test_rank (n, nodeset_getattr (n, NODESET_ATTR_SIZE)), "nodeset_test_rank (internal size) fails"); ok (!nodeset_test_rank (n, nodeset_getattr (n, NODESET_ATTR_SIZE) + 1), "nodeset_test_rank (internal size + 1) fails"); ok (!nodeset_test_range (n, 2, nodeset_getattr (n, NODESET_ATTR_SIZE) - 1), "nodeset_test_range (2, internal size - 1) fails"); ok (!nodeset_test_range (n, 2, nodeset_getattr (n, NODESET_ATTR_SIZE)), "nodeset_test_range (2, internal size) fails"); ok (!nodeset_test_range (n, 2, nodeset_getattr (n, NODESET_ATTR_SIZE) + 1), "nodeset_test_range (2, internal size + 1) fails"); ok (!nodeset_test_range (n, nodeset_getattr (n, NODESET_ATTR_SIZE) - 1, 2), "nodeset_test_range (internal size - 1, 2) fails"); ok (!nodeset_test_range (n, nodeset_getattr (n, NODESET_ATTR_SIZE), 2), "nodeset_test_range (internal size, 2) fails"); ok (!nodeset_test_range (n, nodeset_getattr (n, NODESET_ATTR_SIZE) + 1, 2), "nodeset_test_range (internal size + 1, 2) fails"); nodeset_config_brackets (n, false); like (nodeset_string (n), "0-2"); ok (nodeset_test_range (n, 0, 2), "nodeset_test_range works"); nodeset_delete_rank (n, 0); like (nodeset_string (n), "1-2", "nodeset_delete_rank works"); ok (!nodeset_test_rank (n, 0), "nodeset_test_rank works"); ok (nodeset_test_range (n, 1, 2)); nodeset_delete_rank (n, 1); ok (!nodeset_test_rank (n, 0)); ok (!nodeset_test_rank (n, 1)); ok (nodeset_test_rank (n, 2)); ok (!strcmp (nodeset_string (n), "2")); nodeset_delete_rank (n, 2); ok (!nodeset_test_rank (n, 0)); ok (!nodeset_test_rank (n, 1)); ok (!nodeset_test_rank (n, 2)); like (nodeset_string (n), ""); nodeset_destroy (n); /********************************************/ /* Exercise iteration */ n = nodeset_create_string ("0-2"); ok (n != NULL); itr = nodeset_iterator_create (n); ok (nodeset_next (itr) == 0, "iterator_next works on first element"); ok (nodeset_next (itr) == 1, "iterator_next works on next element"); ok (nodeset_next (itr) == 2, "iterator_next works on last element"); ok (nodeset_next (itr) == NODESET_EOF, "iterator_next returns EOF"); nodeset_iterator_rewind (itr); ok (nodeset_next (itr) == 0, "iterator rewind works"); nodeset_iterator_destroy (itr); nodeset_destroy (n); /********************************************/ /* Exercise iteration with nodeset_next_rank */ n = nodeset_create_string ("0,2-3,7"); ok (n != NULL); int r = nodeset_min (n); ok (r == 0, "nodeset_min"); ok ((r = nodeset_next_rank (n, r)) == 2, "nodeset_next_rank (n, min) returns second element"); ok ((r = nodeset_next_rank (n, r)) == 3, "nodeset_next_rank works on third element"); ok ((r = nodeset_next_rank (n, r)) == 7, "nodeset_next_rank works on fourth element"); ok ((r = nodeset_next_rank (n, r)) == NODESET_EOF, "nodeset_next_rank detects end of nodeset"); ok ((r = nodeset_next_rank (n, 1)) == 2, "nodeset_next_rank returns next rank even if arg not in set"); /********************************************/ /* Exercise nodeset_dup */ n = nodeset_create_string ("0-2"); ok (n != NULL); nodeset_config_brackets (n, false); like (nodeset_string (n), "0-2"); n2 = nodeset_dup (n); ok (n2 != NULL, "nodeset_dup says it worked"); like (nodeset_string (n2), "0-2", "nodeset_dup returned identical nodeset"); nodeset_add_rank (n, 4); nodeset_add_rank (n2, 5); like (nodeset_string (n), "0-2,4", "orig unaffected by changes in dup"); like (nodeset_string (n2), "0-2,5", "dup unaffected by changes in orig"); nodeset_destroy (n); nodeset_destroy (n2); /********************************************/ /* Try zero padding. */ n = nodeset_create_string ("[1,3,5,6-100]"); ok (n != NULL); nodeset_config_brackets (n, false); like (nodeset_string (n), "1,3,5-100", "results not zero padded by default"); //nodeset_config_padding (n, log10 (nodeset_max (n)) + 1); nodeset_config_padding (n, 3); like (nodeset_string (n), "001,003,005-100", "padding 3 on all all works"); nodeset_config_padding (n, 2); like (nodeset_string (n), "01,03,05-100", "padding 2 on subset works"); nodeset_config_padding (n, 4); like (nodeset_string (n), "0001,0003,0005-0100", "padding 4 on all works"); nodeset_destroy (n); /********************************************/ /* Add 'bigset' consecutive singletons. */ n = nodeset_create (); ok (n != NULL); nodeset_config_brackets (n, false); ok (nodeset_resize (n, bigset), "explicitly resize to %u", bigset); monotime (&ts); for (i = 0; i < bigset; i++) if (!nodeset_add_rank (n, i)) break; ok (i == bigset, "added %u consecutive ranks [%.2fs %u Mbytes]", bigset, monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/1024); monotime (&ts); tmp = xasprintf ("0-%u", bigset - 1); like (nodeset_string (n), tmp, "string conversion %s [%.2fs %u Mbytes]", tmp, monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/1024); free (tmp); ok (nodeset_count (n) == bigset, "large nodeset count is sane"); nodeset_destroy (n); /********************************************/ /* Add 'bigset'/2 non-consecutive singletons. */ n = nodeset_create (); ok (n != NULL); nodeset_config_brackets (n, false); ok (nodeset_resize (n, bigset), "explicitly resize to %u", bigset); monotime (&ts); for (i = 0; i < bigset; i += 2) if (!nodeset_add_rank (n, i)) break; ok (i == bigset, "added %u non-consecutive ranks [%.2fs %u Mbytes]", bigset/2, monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/1024); monotime (&ts); ok (nodeset_string (n) != NULL, "string conversion [%.2fs %u Mbytes]", monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/1024); ok (nodeset_count (n) == bigset/2, "large nodeset count is sane"); nodeset_destroy (n); /********************************************/ /* Check edge cases with very big ranks and resize. */ bool skip_huge = true; n = nodeset_create (); nodeset_config_brackets (n, false); ok (nodeset_getattr (n, NODESET_ATTR_SIZE) == minsize, "veb size is the minimum %u", minsize); monotime (&ts); ok (!nodeset_add_rank (n, maxrank + 1), "adding max+1 %u rank fails [%.2fs %u Mbytes]", maxrank + 1, monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/(1024*1024)); ok (nodeset_getattr (n, NODESET_ATTR_SIZE) == minsize, "veb size is the minimum %u", minsize); skip (skip_huge, 16, "too slow"); monotime (&ts); ok (nodeset_add_rank (n, maxrank), "add max rank %u [%.2fs %u Mbytes]", maxrank, monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/(1024*1024)); ok (nodeset_getattr (n, NODESET_ATTR_SIZE) == maxsize, "veb size is the maximum %u", maxsize); /* 2 */ monotime (&ts); ok (nodeset_add_rank (n, maxrank - 1), "add max-1 %u [%.2fs %u Mbytes]", maxrank - 1, monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/(1024*1024)); ok (nodeset_test_rank (n, maxrank - 1), "test rank max - 1"); ok (nodeset_test_rank (n, maxrank), "test rank max"); ok (!nodeset_test_rank (n, maxrank + 1), "test rank max + 1"); ok (nodeset_count (n) == 2, "nodeset count is sane"); /* 7 */ tmp = xasprintf ("%u-%u", maxrank-1, maxrank); monotime (&ts); like (nodeset_string (n), tmp, "convert to string %s [%.2fs %u Mbytes]", tmp, monotime_since (ts)/1000, nodeset_getattr (n, NODESET_ATTR_BYTES)/(1024*1024)); free (tmp); /* 8 */ ok (nodeset_resize (n, 0), "resize to 0 returns success"); ok (nodeset_getattr (n, NODESET_ATTR_SIZE) == maxsize, "nodeset size remains max %u", maxsize); /* 10 */ nodeset_delete_rank (n, maxrank - 1); ok (!nodeset_test_rank (n, maxrank - 1), "nodeset_del max - 1 works"); ok (nodeset_test_rank (n, maxrank)); ok (!nodeset_test_rank (n, maxrank + 1)); /* 13 */ nodeset_delete_rank (n, maxrank + 1); ok (!nodeset_test_rank (n, maxrank - 1), "nodeset_del max + 1 has no effect"); ok (nodeset_test_rank (n, maxrank)); ok (!nodeset_test_rank (n, maxrank + 1)); /* 16 */ end_skip; nodeset_delete_rank (n, maxrank); ok (!nodeset_test_rank (n, maxrank - 1), "nodeset_del max works"); ok (!nodeset_test_rank (n, maxrank)); ok (!nodeset_test_rank (n, maxrank + 1)); /* 19 */ ok (nodeset_resize (n, 0), "resize to zero returns success"); ok (nodeset_getattr (n, NODESET_ATTR_SIZE) == minsize, "nodeset size is the minimum %u", minsize); nodeset_destroy (n); done_testing (); }
int main(void) { plan(60); /* lowercase */ char test[100]; ok(lc(NULL) == NULL, "lc(NULL)"); strcpy(test, "Yes"); like(lc(test), "yes", "lc(yes)"); strcpy(test, "YES"); like(lc(test), "yes", "lc(YES)"); strcpy(test, "yeS"); like(lc(test), "yes", "lc(yeS)"); /* trim */ strcpy(test, " text "); like(ltrim(test), "text ", "ltrim()"); strcpy(test, " text "); like(rtrim(test), " text", "rtrim()"); strcpy(test, " text "); like(trim(test), "text", "trim()"); char *test2; test2 = strdup(" text "); like(trim(test2), "text", "trim()"); free(test2); /* parse_yes_or_no */ ok(parse_yes_or_no(NULL, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 1"); ok(parse_yes_or_no(NULL, GM_DISABLED) == GM_DISABLED, "parse_yes_or_no 2"); strcpy(test, ""); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 3"); strcpy(test, ""); ok(parse_yes_or_no(test, GM_DISABLED) == GM_DISABLED, "parse_yes_or_no 4"); strcpy(test, "yes"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 5"); strcpy(test, "true"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 6"); strcpy(test, "Yes"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 7"); strcpy(test, "1"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 8"); strcpy(test, "On"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 9"); strcpy(test, "Off"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_DISABLED, "parse_yes_or_no 10"); strcpy(test, "false"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_DISABLED, "parse_yes_or_no 11"); strcpy(test, "no"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_DISABLED, "parse_yes_or_no 12"); strcpy(test, "0"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_DISABLED, "parse_yes_or_no 13"); /* trim */ ok(trim(NULL) == NULL, "trim(NULL)"); strcpy(test, " test "); like(trim(test), "^test$", "trim(' test ')"); strcpy(test, "\ntest\n"); like(trim(test), "^test$", "trim('\\ntest\\n')"); /* reading keys */ mod_gm_opt_t *mod_gm_opt; mod_gm_opt = malloc(sizeof(mod_gm_opt_t)); int rc = set_default_options(mod_gm_opt); ok(rc == 0, "setting default options"); mod_gm_opt->keyfile = strdup("t/data/test1.key"); read_keyfile(mod_gm_opt); //printf_hex(mod_gm_opt->crypt_key, 32); test[0]='\x0'; int i = 0; char hex[4]; for(i=0; i<32; i++) { hex[0] = '\x0'; snprintf(hex, 4, "%02x", mod_gm_opt->crypt_key[i]); strncat(test, hex, 4); } like(test, "3131313131313131313131313131313131313131313131313131313131310000", "read keyfile t/data/test1.key"); free(mod_gm_opt->keyfile); mod_gm_opt->keyfile = strdup("t/data/test2.key"); read_keyfile(mod_gm_opt); like(mod_gm_opt->crypt_key, "abcdef", "reading keyfile t/data/test2.key"); free(mod_gm_opt->keyfile); mod_gm_opt->keyfile = strdup("t/data/test3.key"); read_keyfile(mod_gm_opt); //printf_hex(mod_gm_opt->crypt_key, 32); like(mod_gm_opt->crypt_key, "11111111111111111111111111111111", "reading keyfile t/data/test3.key"); ok(strlen(mod_gm_opt->crypt_key) == 32, "key size for t/data/test3.key"); /* encrypt */ char * key = "test1234"; char * encrypted = malloc(GM_BUFFERSIZE); char * text = "test message"; char * base = "a7HqhQEE8TQBde9uknpPYQ=="; mod_gm_crypt_init(key); int len; len = mod_gm_encrypt(&encrypted, text, GM_ENCODE_AND_ENCRYPT); ok(len == 24, "length of encrypted only"); like(encrypted, base, "encrypted string"); /* decrypt */ char * decrypted = malloc(GM_BUFFERSIZE); mod_gm_decrypt(&decrypted, encrypted, GM_ENCODE_AND_ENCRYPT); like(decrypted, text, "decrypted text"); free(decrypted); free(encrypted); /* base 64 */ char * base64 = malloc(GM_BUFFERSIZE); len = mod_gm_encrypt(&base64, text, GM_ENCODE_ONLY); ok(len == 16, "length of encode only"); like(base64, "dGVzdCBtZXNzYWdl", "base64 only string"); /* debase 64 */ char * debase64 = malloc(GM_BUFFERSIZE); mod_gm_decrypt(&debase64, base64, GM_ENCODE_ONLY); like(debase64, text, "debase64 text"); free(debase64); free(base64); /* file_exists */ ok(file_exists("01_utils") == 1, "file_exists('01_utils')"); ok(file_exists("non-exist") == 0, "file_exists('non-exist')"); /* nr2signal */ char * signame1 = nr2signal(9); like(signame1, "SIGKILL", "get SIGKILL for 9"); free(signame1); char * signame2 = nr2signal(15); like(signame2, "SIGTERM", "get SIGTERM for 15"); free(signame2); /* string2timeval */ struct timeval t; string2timeval("100.50", &t); ok(t.tv_sec == 100, "string2timeval 1"); ok(t.tv_usec == 50, "string2timeval 2"); string2timeval("100", &t); ok(t.tv_sec == 100, "string2timeval 3"); ok(t.tv_usec == 0, "string2timeval 4"); string2timeval("", &t); ok(t.tv_sec == 0, "string2timeval 5"); ok(t.tv_usec == 0, "string2timeval 6"); string2timeval(NULL, &t); ok(t.tv_sec == 0, "string2timeval 7"); ok(t.tv_usec == 0, "string2timeval 8"); /* command line parsing */ mod_gm_free_opt(mod_gm_opt); mod_gm_opt = renew_opts(); strcpy(test, "server=host:4730"); parse_args_line(mod_gm_opt, test, 0); like(mod_gm_opt->server_list[0], "host:4730", "server=host:4730"); ok(mod_gm_opt->server_num == 1, "server_number = %d", mod_gm_opt->server_num); mod_gm_free_opt(mod_gm_opt); mod_gm_opt = renew_opts(); strcpy(test, "server=:4730"); parse_args_line(mod_gm_opt, test, 0); like(mod_gm_opt->server_list[0], "localhost:4730", "server=:4730"); ok(mod_gm_opt->server_num == 1, "server_number = %d", mod_gm_opt->server_num); mod_gm_free_opt(mod_gm_opt); mod_gm_opt = renew_opts(); strcpy(test, "server=localhost:4730"); parse_args_line(mod_gm_opt, test, 0); strcpy(test, "server=localhost:4730"); parse_args_line(mod_gm_opt, test, 0); like(mod_gm_opt->server_list[0], "localhost:4730", "duplicate server"); ok(mod_gm_opt->server_num == 1, "server_number = %d", mod_gm_opt->server_num); mod_gm_free_opt(mod_gm_opt); mod_gm_opt = renew_opts(); strcpy(test, "server=localhost:4730,localhost:4730,:4730,host:4730,"); parse_args_line(mod_gm_opt, test, 0); like(mod_gm_opt->server_list[0], "localhost:4730", "duplicate server"); like(mod_gm_opt->server_list[1], "host:4730", "duplicate server"); ok(mod_gm_opt->server_num == 2, "server_number = %d", mod_gm_opt->server_num); /* escape newlines */ char * escaped = gm_escape_newlines(" test\n", GM_DISABLED); is(escaped, " test\\n", "untrimmed escape string"); free(escaped); escaped = gm_escape_newlines(" test\n", GM_ENABLED); is(escaped, "test", "trimmed escape string"); free(escaped); /* md5 sum */ char * sum = NULL; strcpy(test, ""); sum = md5sum(test); like(sum, "d41d8cd98f00b204e9800998ecf8427e", "md5sum()"); free(sum); strcpy(test, "The quick brown fox jumps over the lazy dog."); sum = md5sum(test); like(sum, "e4d909c290d0fb1ca068ffaddf22cbd0", "md5sum()"); free(sum); mod_gm_free_opt(mod_gm_opt); return exit_status(); }
int readline(char *buf, int size) { int idx; int len; int key; int i; int done; int hist_idx; int dir; if (size <= 0) { errno = EINVAL; return -1; } idx = 0; len = 0; done = 0; hist_idx = history_len; while (!done) { fflush(stdout); key = getkey(); if (key < 0) return key; if (key == KEY_TAB) { int start; int end; int split; char mask[MAXPATH]; struct direntry dirent; start = idx; while (start > 0 && !delimchar(buf[start - 1])) start--; end = split = start; while (end < len && !delimchar(buf[end])) { if (buf[end] == PS1 || buf[end] == PS2) split = end + 1; end++; } dir = find_dir(buf, start, end, split, mask); if (dir >= 0) { while (_readdir(dir, &dirent, 1) > 0) { int newlen = len - (end - split) + dirent.namelen; if (like(dirent.name, mask) && newlen < size - 1) { memmove(buf + split + dirent.namelen, buf + end, len - end); memcpy(buf + split, dirent.name, dirent.namelen); while (idx < split) putchar(buf[idx++]); while (idx > split) { putchar('\b'); idx--; } for (i = split; i < newlen; i++) putchar(buf[i]); if (newlen < len) { for (i = newlen; i < len; i++) putchar(' '); for (i = newlen; i < len; i++) putchar('\b'); } end = split + dirent.namelen; len = newlen; idx = end; for (i = end; i < len; i++) putchar('\b'); fflush(stdout); key = getkey(); if (key < 0) break; if (key != KEY_TAB) break; } } close(dir); if (key < 0) return key; } } switch (key) { case KEY_LEFT: if (idx > 0) { putchar('\b'); idx--; } break; case KEY_RIGHT: if (idx < len) { putchar(buf[idx]); idx++; } break; case KEY_CTRL_LEFT: if (idx > 0) { putchar('\b'); idx--; } while (idx > 0 && buf[idx - 1] != ' ') { putchar('\b'); idx--; } break; case KEY_CTRL_RIGHT: while (idx < len && buf[idx] != ' ') { putchar(buf[idx]); idx++; } if (idx < len) { putchar(buf[idx]); idx++; } break; case KEY_HOME: while (idx > 0) { putchar('\b'); idx--; } break; case KEY_END: while (idx < len) { putchar(buf[idx]); idx++; } break; case KEY_DEL: if (idx < len) { len--; memmove(buf + idx, buf + idx + 1, len - idx); for (i = idx; i < len; i++) putchar(buf[i]); putchar(' '); putchar('\b'); for (i = idx; i < len; i++) putchar('\b'); } break; case KEY_INS: insmode = !insmode; break; case KEY_BACKSPACE: if (idx > 0) { putchar('\b'); idx--; len--; memmove(buf + idx, buf + idx + 1, len - idx); for (i = idx; i < len; i++) putchar(buf[i]); putchar(' '); putchar('\b'); for (i = idx; i < len; i++) putchar('\b'); } break; case KEY_ESC: if (_break_on_escape) { buf[len] = 0; errno = EINTR; return -1; } else { for (i = 0; i < idx; i++) putchar('\b'); for (i = 0; i < len; i++) putchar(' '); for (i = 0; i < len; i++) putchar('\b'); idx = len = 0; } break; case KEY_EOF: if (len == 0) return -1; break; case KEY_ENTER: putchar('\r'); putchar('\n'); done = 1; break; case KEY_UP: if (hist_idx > 0) { hist_idx--; for (i = 0; i < idx; i++) putchar('\b'); for (i = 0; i < len; i++) putchar(' '); for (i = 0; i < len; i++) putchar('\b'); len = strlen(history[hist_idx]); if (len > size - 1) len = size - 1; idx = len; memcpy(buf, history[hist_idx], len); for (i = 0; i < len; i++) putchar(buf[i]); } break; case KEY_DOWN: if (hist_idx < history_len - 1) { hist_idx++; for (i = 0; i < idx; i++) putchar('\b'); for (i = 0; i < len; i++) putchar(' '); for (i = 0; i < len; i++) putchar('\b'); len = strlen(history[hist_idx]); if (len > size - 1) len = size - 1; idx = len; memcpy(buf, history[hist_idx], len); for (i = 0; i < len; i++) putchar(buf[i]); } break; case KEY_UNKNOWN: break; default: if (key >= 0x20 && key <= 0xFF) { if (insmode) { if (len < size - 1) { if (idx < len) memmove(buf + idx + 1, buf + idx, len - idx); buf[idx] = key; len++; for (i = idx; i < len; i++) putchar(buf[i]); idx++; for (i = idx; i < len; i++) putchar('\b'); } } else { if (idx < size - 1) { buf[idx] = key; putchar(buf[idx]); if (idx == len) len++; idx++; } } } } } buf[len] = 0; add_to_history(buf); return len; }
/* main tests */ int main (int argc, char **argv, char **env) { argc = argc; argv = argv; env = env; int status, chld, rc; int tests = 125; int rrc; char cmd[150]; char *result, *error, *message, *output; plan(tests); mod_gm_opt = malloc(sizeof(mod_gm_opt_t)); set_default_options(mod_gm_opt); #ifdef EMBEDDEDPERL char p1[150]; snprintf(p1, 150, "--p1_file=worker/mod_gearman_p1.pl"); parse_args_line(mod_gm_opt, p1, 0); init_embedded_perl(env); #endif char options[150]; snprintf(options, 150, "--server=127.0.0.1:%d", GEARMAND_TEST_PORT); ok(parse_args_line(mod_gm_opt, options, 0) == 0, "parse_args_line()"); mod_gm_opt->debug_level = GM_LOG_ERROR; worker_logfile = my_tmpfile(); if(!ok(worker_logfile != NULL, "created temp logile: %s", worker_logfile)) { diag("could not create temp logfile"); exit( EXIT_FAILURE ); } /* first fire up a gearmand server and one worker */ start_gearmand((void*)NULL); sleep(2); start_worker((void*)NULL); sleep(2); /* wait one second and catch died procs */ while((chld = waitpid(-1, &status, WNOHANG)) != -1 && chld > 0) { diag( "waitpid() %d exited with %d\n", chld, status); status = 0; } if(!ok(gearmand_pid > 0, "'gearmand started with port %d and pid: %d", GEARMAND_TEST_PORT, gearmand_pid)) { diag("make sure gearmand is in your PATH. Common locations are /usr/sbin or /usr/local/sbin"); exit( EXIT_FAILURE ); } if(!ok(pid_alive(gearmand_pid) == TRUE, "gearmand alive")) { check_logfile("/tmp/gearmand.log", 3); kill(gearmand_pid, SIGTERM); kill(worker_pid, SIGTERM); exit( EXIT_FAILURE ); } if(!ok(worker_pid > 0, "worker started with pid: %d", worker_pid)) diag("could not start worker"); if(!ok(pid_alive(worker_pid) == TRUE, "worker alive")) { check_logfile(worker_logfile, 3); kill(gearmand_pid, SIGTERM); kill(worker_pid, SIGTERM); exit( EXIT_FAILURE ); } skip(gearmand_pid <= 0 || worker_pid <= 0, tests-3, /* Number of tests to skip */ "Skipping all tests, no need to go on without gearmand or worker"); /* create server / clients */ mod_gm_opt->transportmode = GM_ENCODE_ONLY; create_modules(); /* send big job */ send_big_jobs(GM_ENCODE_ONLY); //diag_queues(); wait_for_empty_queue("eventhandler", 20); wait_for_empty_queue("service", 20); //diag_queues(); do_result_work(1); //diag_queues(); wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5); /***************************************** * test check */ //diag_queues(); test_servicecheck(GM_ENCODE_ONLY, "./t/crit.pl"); //diag_queues(); wait_for_empty_queue("eventhandler", 20); wait_for_empty_queue("service", 5); //diag_queues(); do_result_work(1); //diag_queues(); wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5); //diag_queues(); like(last_result, "test plugin CRITICAL", "stdout output from ./t/crit.pl"); like(last_result, "some errors on stderr", "stderr output from ./t/crit.pl"); /***************************************** * test check2 */ //diag_queues(); test_servicecheck(GM_ENCODE_ONLY, "./t/both"); //diag_queues(); wait_for_empty_queue("eventhandler", 20); wait_for_empty_queue("service", 5); //diag_queues(); do_result_work(1); //diag_queues(); wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5); like(last_result, "stdout output", "stdout output from ./t/both"); like(last_result, "stderr output", "stderr output from ./t/both"); /* try to send some data with base64 only */ //diag_queues(); test_eventhandler(GM_ENCODE_ONLY); //diag_queues(); test_servicecheck(GM_ENCODE_ONLY, NULL); //diag_queues(); wait_for_empty_queue("eventhandler", 20); wait_for_empty_queue("service", 5); //diag_queues(); do_result_work(1); //diag_queues(); wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5); sleep(1); kill(worker_pid, SIGTERM); waitpid(worker_pid, &status, 0); ok(status == 0, "worker (%d) exited with exit code %d", worker_pid, real_exit_code(status)); status = 0; check_no_worker_running(worker_logfile); check_logfile(worker_logfile, 0); char * test_keys[] = { "12345", "test", "test key 123", "me make you loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong key" }; /* ignore some signals for now */ signal(SIGTERM, SIG_IGN); int i; for(i=0;i<4;i++) { mod_gm_opt->transportmode = GM_ENCODE_AND_ENCRYPT; start_worker((void *)test_keys[i]); mod_gm_crypt_init( test_keys[i] ); ok(1, "initialized with key: %s", test_keys[i]); test_eventhandler(GM_ENCODE_AND_ENCRYPT); test_servicecheck(GM_ENCODE_AND_ENCRYPT, NULL); wait_for_empty_queue("eventhandler", 20); wait_for_empty_queue("service", 5); do_result_work(1); wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5); sleep(1); kill(worker_pid, SIGTERM); waitpid(worker_pid, &status, 0); ok(status == 0, "worker (%d) exited with exit code %d", worker_pid, real_exit_code(status)); status = 0; check_no_worker_running(worker_logfile); check_logfile(worker_logfile, 0); } /***************************************** * send_gearman */ snprintf(cmd, 150, "./send_gearman --server=127.0.0.1:%d --key=testtest --host=test --service=test --message=test --returncode=0", GEARMAND_TEST_PORT); rrc = real_exit_code(run_check(cmd, &result, &error)); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); like(result, "^\\s*$", "output from ./send_gearman"); free(result); free(error); /***************************************** * send_multi */ snprintf(cmd, 150, "./send_multi --server=127.0.0.1:%d --host=blah < t/data/send_multi.txt", GEARMAND_TEST_PORT); rrc = real_exit_code(run_check(cmd, &result, &error)); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); like(result, "send_multi OK: 2 check_multi child checks submitted", "output from ./send_multi"); free(result); free(error); /***************************************** * check_gearman */ snprintf(cmd, 150, "./check_gearman -H 127.0.0.1:%d -s check -a -q worker_test", GEARMAND_TEST_PORT); rrc = real_exit_code(run_check(cmd, &result, &error)); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); like(result, "check_gearman OK - sending background job succeded", "output from ./check_gearman"); /* cleanup */ free(result); free(error); free_client(&client); free_worker(&worker); /* shutdown gearmand */ rc = send2gearmandadmin("shutdown\n", "127.0.0.1", GEARMAND_TEST_PORT, &output, &message); ok(rc == 0, "rc of send2gearmandadmin %d", rc); like(output, "OK", "output contains OK"); free(message); free(output); /* wait 5 seconds to shutdown */ for(i=0;i<=5;i++) { waitpid(gearmand_pid, &status, WNOHANG); if(pid_alive(gearmand_pid) == FALSE) { todo(); ok(status == 0, "gearmand (%d) exited with: %d", gearmand_pid, real_exit_code(status)); endtodo; break; } sleep(1); } if(pid_alive(gearmand_pid) == TRUE) { /* kill it the hard way */ kill(gearmand_pid, SIGTERM); waitpid(gearmand_pid, &status, 0); ok(status == 0, "gearmand (%d) exited with exit code %d", gearmand_pid, real_exit_code(status)); status = 0; ok(false, "gearmand had to be killed!"); } todo(); check_logfile("/tmp/gearmand.log", status != 0 ? 2 : 0); endtodo; status = 0; kill(worker_pid, SIGTERM); waitpid(worker_pid, &status, 0); ok(status == 0, "worker (%d) exited with exit code %d", worker_pid, real_exit_code(status)); check_no_worker_running(worker_logfile); status = 0; #ifdef EMBEDDEDPERL deinit_embedded_perl(0); #endif free(last_result); free(worker_logfile); endskip; mod_gm_free_opt(mod_gm_opt); return exit_status(); }
extern void spk_non_par( size_t level , SpkModel< CppAD::AD<double> > &admodel , SpkModel<double> &model , const DoubleMatrix &N , const DoubleMatrix &y , const DoubleMatrix &max_itr , const DoubleMatrix &epsilon , const DoubleMatrix &blow , const DoubleMatrix &bup , const DoubleMatrix &Bin , DoubleMatrix &Bout , DoubleMatrix &lamout , DoubleMatrix &Pout ) { // temporary indices size_t i, j, k; // temporary double pointer double *ptr; const double *ptr_c; // number of discrete measure points size_t J = Bin.nc(); // number of random effects size_t n = blow.nr(); // ------------ Arguments to non_par::opt_measure -------------------- assert( max_itr.nr() == 2 ); mat2cpp::matrix<size_t> maxitr(2, 1); maxitr(0, 0) = size_t( *(max_itr.data() + 0) ); maxitr(1, 0) = size_t( *(max_itr.data() + 1) ); assert( epsilon.nr() == 5 ); mat2cpp::matrix<double> eps(5, 1); eps(0, 0) = *(epsilon.data() + 0); eps(1, 0) = *(epsilon.data() + 1); eps(2, 0) = *(epsilon.data() + 2); eps(3, 0) = *(epsilon.data() + 3); eps(4, 0) = *(epsilon.data() + 4); // input likelihood function Like like(admodel, model, N, y, n); // input number of individuals in the population size_t M = N.nr(); // input lower limit for the random effects mat2cpp::matrix<double> xLow(1, n); ptr_c = blow.data(); for(k = 0; k < n; k++) xLow(0, k) = ptr_c[k]; // input upper limit for the random effects mat2cpp::matrix<double> xUp(1, n); ptr_c = bup.data(); for(k = 0; k < n; k++) xUp(0, k) = ptr_c[k]; // input and return discrete measure points mat2cpp::matrix<double> X(J, n); ptr_c = Bin.data(); for(j = 0; j < J; j++) { for(k = 0; k < n; k++) X(j, k) = ptr_c[k + j * n]; } // return weight corresponding to each measure oint mat2cpp::matrix<double> lambda(J, 1); // return convergence information mat2cpp::matrix<double> info; // return status message const char *msg; // ----------------------------------------------------------------- msg = non_par::opt_measure( level, maxitr, eps, &like, M, xLow, xUp, X, lambda, info ); // ----------------------------------------------------------------- if( strcmp(msg, "ok") != 0 ) { throw SpkException( SpkError::SPK_NON_PAR_ERR, msg, __LINE__, __FILE__ ); } // determine number of discrete measure points assert( n == X.size2() ); J = X.size1(); // dimension the return matrices Bout.resize(n, J); lamout.resize(J, 1); Pout.resize(M, J); // retrun elements of Bout ptr = Bout.data(); for(j = 0; j < J; j++) { for(k = 0; k < n; k++) ptr[k + j * n] = X(j, k); } // return elements of lamout ptr = lamout.data(); for(j = 0; j < J; j++) ptr[j] = lambda(j, 0); // return elements of Pout mat2cpp::matrix<double> beta(1, n); mat2cpp::matrix<double> psi(M, 1); ptr = Pout.data(); for(j = 0; j < J; j++) { for(k = 0; k < n; k++) beta(0, k) = X(j, k); psi = like(beta); for(i = 0; i < M; i++) ptr[ i + j * M ] = psi(i, 0); } // Check for measure points that are constrained checkMeasurePoints( eps(0, 0), xLow, xUp, X ); return; }
void infinite_taunt1(struct mtwist_state *mt, char *buffer, int buflen) { snprintf(buffer, buflen, "%s %s %s %s %s %s", you(mt), action(mt), like(mt), adjective(mt), nationality(mt), beast(mt)); }
int main (int argc, char **argv, char **env) { argc = argc; argv = argv; env = env; int rc, rrc; char *result, *error; char cmd[120]; char hostname[GM_BUFFERSIZE]; plan(56); /* set hostname */ gethostname(hostname, GM_BUFFERSIZE-1); /* create options structure and set debug level */ mod_gm_opt = malloc(sizeof(mod_gm_opt_t)); set_default_options(mod_gm_opt); mod_gm_opt->debug_level = 0; #ifdef EMBEDDEDPERL char p1[150]; snprintf(p1, 150, "--p1_file=worker/mod_gearman_p1.pl"); parse_args_line(mod_gm_opt, p1, 0); init_embedded_perl(env); #endif /***************************************** * arg parsing test 1 */ char *args[MAX_CMD_ARGS]; strcpy(cmd, "/bin/hostname"); parse_command_line(cmd, args); like(args[0], cmd, "parsing args cmd 1"); /***************************************** * arg parsing test 2 */ strcpy(cmd, "/bin/cmd blah blub foo"); parse_command_line(cmd,args); like(args[0], "/bin/cmd", "parsing args cmd 2"); like(args[1], "blah", "parsing args cmd 2"); like(args[2], "blub", "parsing args cmd 2"); like(args[3], "foo", "parsing args cmd 2"); /***************************************** * send_gearman */ strcpy(cmd, "./send_gearman --server=blah --key=testtest --host=test --service=test --message=test --returncode=0"); rrc = real_exit_code(run_check(cmd, &result, &error)); //diag(result); cmp_ok(rrc, "==", 3, "cmd '%s' returned rc %d", cmd, rrc); if(atof(gearman_version()) >= 0.31) { like(result, "send_gearman UNKNOWN:", "result"); } else { like(result, "sending job to gearmand failed:", "result"); } free(result); free(error); /***************************************** * send_gearman */ //mod_gm_opt->debug_level = 4; strcpy(cmd, "./send_multi --server=blah --host=blah < t/data/send_multi.txt"); rrc = real_exit_code(run_check(cmd, &result, &error)); //diag(result); cmp_ok(rrc, "==", 3, "cmd '%s' returned rc %d", cmd, rrc); if(atof(gearman_version()) >= 0.31) { like(result, "send_multi UNKNOWN:", "result"); } else { like(result, "sending job to gearmand failed:", "result"); } free(result); free(error); /***************************************** * simple test command 1 */ strcpy(cmd, "/bin/hostname"); rc = run_check(cmd, &result, &error); cmp_ok(rc, "==", 0, "pclose for cmd '%s' returned rc %d", cmd, rc); rrc = real_exit_code(rc); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); free(result); free(error); /***************************************** * simple test command 2 */ strcpy(cmd, "/bin/hostname 2>&1"); rc = run_check(cmd, &result, &error); cmp_ok(rc, "==", 0, "pclose for cmd '%s' returned rc %d", cmd, rc); rrc = real_exit_code(rc); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); free(result); free(error); /***************************************** * simple test command 3 */ strcpy(cmd, "/usr/lib/nagios/plugins/check_icmp -H 127.0.0.1"); rc = run_check(cmd, &result, &error); cmp_ok(rc, "==", 0, "pclose for cmd '%s' returned rc %d", cmd, rc); rrc = real_exit_code(rc); cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc); free(result); free(error); /***************************************** * simple test command 4 */ strcpy(cmd, "echo -n 'test'; exit 2"); rc = run_check(cmd, &result, &error); rrc = real_exit_code(rc); cmp_ok(rrc, "==", 2, "cmd '%s' returned rc %d", cmd, rrc); like(result, "test", "returned result string"); free(result); free(error); gm_job_t * exec_job; exec_job = ( gm_job_t * )malloc( sizeof *exec_job ); set_default_job(exec_job, mod_gm_opt); /***************************************** * non existing command 1 */ exec_job->command_line = strdup("/bin/doesntexist"); exec_job->type = strdup("service"); exec_job->timeout = 10; int fork_on_exec = 0; execute_safe_command(exec_job, fork_on_exec, hostname); cmp_ok(exec_job->return_code, "==", 2, "cmd '%s' returns rc 2", exec_job->command_line); like(exec_job->output, "CRITICAL: Return code of 127 is out of bounds. Make sure the plugin you're trying to run actually exists. \\(worker:", "returned result string"); free(exec_job->output); free(exec_job->error); fork_on_exec = 1; lives_ok({execute_safe_command(exec_job, fork_on_exec, hostname);}, "executing command using fork on exec");
static bool string_function(qli_nod* node, SSHORT l1, const TEXT* p1, SSHORT l2, const TEXT* p2) { /************************************** * * s t r i n g _ f u n c t i o n * ************************************** * * Functional description * Perform one of the complex string functions CONTAINING, MATCHES, * or STARTS WITH. * **************************************/ // Handle "STARTS WITH" if (node->nod_type == nod_starts) { if (l1 < l2) return false; if (l2) return memcmp(p1, p2, l2) == 0; return true; } // Handle CONTAINS if (node->nod_type == nod_containing) { while (l1 >= l2) { --l1; const TEXT* q1 = p1++; const TEXT* q2 = p2; SSHORT l = l2; TEXT c1, c2; do { if (--l < 0) return true; c1 = *q1++; c2 = *q2++; } while (UPPER(c1) == UPPER(c2)); } return false; } // Handle LIKE if (node->nod_type == nod_like) { TEXT c1 = 0; Firebird::VaryStr<16> temp; const TEXT* q1 = NULL; if (node->nod_count > 2 && MOVQ_get_string(EVAL_value(node->nod_arg[2]), &q1, &temp, sizeof(temp))) { c1 = *q1; } if (like((const UCHAR*) p1, l1, (const UCHAR*) p2, l2, c1)) return true; return false; } // Handle MATCHES return node->nod_type == nod_matches && matches(p1, l1, p2, l2); }