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);
}
