void test_plparse()
{
WITH_COLOR(GREEN, printf("test_plparse()\n"));
test_parse("sum.pl");
test_parse("ackermann.pl");
test_parse("facts.pl");
test_parse("parse_test.pl");
}
int test1(){
char *test_string[]={"(A B C)",
"((A) B C)",
"((A B) C D)",
"(A (B) C)",
"(A B (C))",
"((A) (B) (C))",
"(((A B)))",
"(abc efg)",
"(a . b)"
};
char *test_result[]={"(A . (B . (C . nil)))",
"((A . nil) . (B . (C . nil)))",
"((A . (B . nil)) . (C . (D . nil)))",
"(A . ((B . nil) . (C . nil)))",
"(A . (B . ((C . nil) . nil)))",
"((A . nil) . ((B . nil) . ((C . nil) . nil)))",
"(((A . (B . nil)) . nil) . nil)",
"(abc . (efg . nil))",
"(a . b)"
};
int count=0;
for(int i=0;i<sizeof(test_string)/sizeof(char*);i++){
count=test_parse(i,test_string[i],test_result[i]);
}
return 0;
}
int main(int argc, const char *argv[])
{
(void)argc;
(void)argv;
fprintf(stderr, "JSON parse test\n");
return test_parse();
}
int main( void ) {
test_input();
test_parse();
test_getPath();
test_forkAndRun();
test_execute();
return 0;
}
int main() {
#ifdef _WINDOWS
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
test_parse();
test_access();
printf("%d/%d (%3.2f%%) passed\n", test_pass, test_count, test_pass * 100.0 / test_count);
return main_ret;
}
int test_main()
{
test_output();
test_parse();
test_all();
return 0;
}
int main(int nargs, char** args) {
//char* s = "{ - 23.43 't est' {'hello': 5 'world'}, [] 'test' 3 ''";
char* s = "[1, 2, { 'hello':'world', 'test':[33, 4]}, [5, 6], 7, [[]]] 8";
if (nargs == 2) {
FILE* f = fopen(args[1], "r");
//READ FILE HERE
//s = blah();
}
//int result = test_lex(s);
test_parse(s);
return 0;
}
void
test_case2()
{
ni_stringbuf_t buf = NI_STRINGBUF_INIT_DYNAMIC;
ni_json_t *json;
json = init2();
ni_json_format_string(&buf, json, NULL);
printf("#--> j2:\n%s\n", buf.string);
printf("#<-- j2:\n");
test_parse(buf.string);
printf("\n");
ni_stringbuf_destroy(&buf);
ni_json_free(json);
}
int
main(int argc, char **argv)
{
int n;
if (argc == 1) {
test_case1();
test_case2();
}
for (n = 1; n < argc; ++n) {
printf("argv[%d]: ", n);
test_parse(argv[n]);
printf("\n");
}
return 0;
}
int
main(int argc, char **argv)
{
int ret = 0, optind = 0;
setprogname(argv[0]);
if(getarg(args, sizeof(args) / sizeof(args[0]), argc, argv, &optind))
usage(1);
if (help_flag)
usage (0);
if(version_flag){
print_version(NULL);
exit(0);
}
argc -= optind;
argv += optind;
if (verbose_flag)
printf("test_parse\n");
ret += test_parse();
if (verbose_flag)
printf("test_keys\n");
ret += test_keys();
if (verbose_flag)
printf("test_ntlm2_session_resp\n");
ret += test_ntlm2_session_resp();
if (verbose_flag)
printf("test_targetinfo\n");
ret += test_targetinfo();
return ret;
}
void VectorTest::run_test_case(void)
{
message += "Running vector test case...\n";
// Constructor and destructor methods
test_constructor();
test_destructor();
// Arithmetic operators
test_sum_operator();
test_rest_operator();
test_multiplication_operator();
test_division_operator();
// Operation and assignment operators
test_sum_assignment_operator();
test_rest_assignment_operator();
test_multiplication_assignment_operator();
test_division_assignment_operator();
// Equality and relational operators
test_equal_to_operator();
test_not_equal_to_operator();
test_greater_than_operator();
test_greater_than_or_equal_to_operator();
test_less_than_operator();
test_less_than_or_equal_to_operator();
// Output operator
test_output_operator();
// Get methods
test_get_display();
// Set methods
test_set();
test_set_display();
// Resize methods
test_resize();
test_tuck_in();
test_take_out();
test_remove_element();
test_get_assembly();
// Initialization methods
test_initialize();
test_initialize_sequential();
test_randomize_uniform();
test_randomize_normal();
// Checking methods
test_contains();
test_is_in();
test_is_constant();
test_is_crescent();
test_is_decrescent();
// Mathematical methods
test_dot_vector();
test_dot_matrix();
test_calculate_sum();
test_calculate_partial_sum();
test_calculate_product();
test_calculate_mean();
test_calculate_standard_deviation();
test_calculate_covariance();
test_calculate_mean_standard_deviation();
test_calculate_minimum();
test_calculate_maximum();
test_calculate_minimum_maximum();
test_calculate_minimum_missing_values();
test_calculate_maximum_missing_values();
test_calculate_minimum_maximum_missing_values();
test_calculate_explained_variance();
test_calculate_histogram();
test_calculate_bin();
test_calculate_frequency();
test_calculate_total_frequencies();
test_calculate_minimal_index();
test_calculate_maximal_index();
test_calculate_minimal_indices();
test_calculate_maximal_indices();
test_calculate_minimal_maximal_index();
test_calculate_cumulative_index();
test_calculate_closest_index();
test_calculate_norm();
test_calculate_normalized();
test_calculate_sum_squared_error();
test_calculate_mean_squared_error();
test_calculate_root_mean_squared_error();
test_apply_absolute_value();
test_calculate_lower_bounded();
test_calculate_upper_bounded();
test_calculate_lower_upper_bounded();
test_apply_lower_bound();
test_apply_upper_bound();
test_apply_lower_upper_bounds();
test_calculate_less_rank();
test_calculate_greater_rank();
test_calculate_linear_correlation();
test_calculate_linear_correlation_missing_values();
test_calculate_linear_regression_parameters();
// Scaling and unscaling
test_scale_minimum_maximum();
test_scale_mean_standard_deviation();
// Parsing methods
test_parse();
// Serialization methods
test_save();
test_load();
message += "End vector test case\n";
}
int
c_test(char **wp)
{
int argc;
int res;
Test_env te;
te.flags = 0;
te.isa = ptest_isa;
te.getopnd = ptest_getopnd;
te.eval = ptest_eval;
te.error = ptest_error;
for (argc = 0; wp[argc]; argc++)
;
if (strcmp(wp[0], "[") == 0) {
if (strcmp(wp[--argc], "]") != 0) {
bi_errorf("missing ]");
return T_ERR_EXIT;
}
}
te.pos.wp = wp + 1;
te.wp_end = wp + argc;
/*
* Handle the special cases from POSIX.2, section 4.62.4.
* Implementation of all the rules isn't necessary since
* our parser does the right thing for the omitted steps.
*/
if (argc <= 5) {
char **owp = wp;
int invert = 0;
Test_op op;
const char *opnd1, *opnd2;
while (--argc >= 0) {
if ((*te.isa)(&te, TM_END))
return !0;
if (argc == 3) {
opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
if ((op = (Test_op) (*te.isa)(&te, TM_BINOP))) {
opnd2 = (*te.getopnd)(&te, op, 1);
res = (*te.eval)(&te, op, opnd1,
opnd2, 1);
if (te.flags & TEF_ERROR)
return T_ERR_EXIT;
if (invert & 1)
res = !res;
return !res;
}
/* back up to opnd1 */
te.pos.wp--;
}
if (argc == 1) {
opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
/* Historically, -t by itself test if fd 1
* is a file descriptor, but POSIX says its
* a string test...
*/
if (!Flag(FPOSIX) && strcmp(opnd1, "-t") == 0)
break;
res = (*te.eval)(&te, TO_STNZE, opnd1,
(char *) 0, 1);
if (invert & 1)
res = !res;
return !res;
}
if ((*te.isa)(&te, TM_NOT)) {
invert++;
} else
break;
}
te.pos.wp = owp + 1;
}
return test_parse(&te);
}
int main() {
test_parse();
printf("%d/%d (%3.2f%%) passed\n", test_pass, test_count, test_pass * 100.0 / test_count);
return main_ret;
}
int main()
{
test_parse("never");
test_parse("today 23:59");
test_parse("tomorrow 23:59");
test_parse("on the day after tomorrow at 23:59");
test_parse("next Saturday at 23:59");
test_parse_ctx("next Saturday at 23:59", time(NULL) - 7 * 24 * 60 * 60);
test_parse("(2009-Jan-30 13:13)");
test_parse("(2009-January-30 13:13)");
test_parse("2008-11-30 13 and 2008-11-30 12 and 2008-11-30 14 and 2008-01-01 11");
test_parse("(2008-11-30 13:13) and on 2008-11-30 at 13:14");
test_parse("on 2008-11-30 at 13:13");
test_parse("at 13:13 on 2008-11-30");
test_parse("at 0:3 on 2008-11-30 and every day at 15:15");
test_parse("never at 13:12"); // wrong
test_parse("every Wednesday at 10");
test_parse("5 minutes past every hour and every Thursday at 3:30");
test_parse("every hour");
test_parse_ctx("every hour", ts("2008-08-30 23:59:59"));
test_parse("every day at 14:17");
test_parse("6 minutes past every hour");
test_parse("0 minutes past every hour and 10 minutes past every hour and 20 minutes past every hour and 30 minutes past every hour and 40 minutes past every hour and 50 minutes past every hour");
return 0;
}
int main(int argc, char* argv[])
{
// Parse test command line arguments, perform early
// initializations.
const char *name, *mode;
int n, nt, sx, sy, ss, rank, szcomm;
#ifdef CUDA
struct cudaDeviceProp props;
#endif
test_parse(argc, argv, &name, &mode,
&n, &nt, &sx, &sy, &ss, &rank, &szcomm
#ifdef CUDA
, &props
#endif
);
#ifdef CUDA
int cpu = !strcmp(mode, "CPU");
int gpu = !strcmp(mode, "GPU");
#else
int cpu = 1;
int gpu = 0;
#endif
// Create test configuration.
struct test_config_t* t = test_init(
name, mode, n, nt, sx, sy, ss, rank, szcomm,
xmin, ymin, zmin, xmax, ymax, zmax,
bx, by, bs, ex, ey, es
#ifdef CUDA
, &props
#endif
);
// Create another test configuration to check correctness.
struct test_config_t* t_check = NULL;
#ifdef MPI
if (t->rank == MPI_ROOT_NODE)
#endif
{
t_check = test_init(
name, mode, n, nt, 1, 1, 1, 0, 1,
xmin, ymin, zmin, xmax, ymax, zmax,
bx, by, bs, ex, ey, es
#ifdef CUDA
, &props
#endif
);
}
// Generate the initial data disrtibution and load it
// onto compute nodes.
integer* array = (integer*)malloc(t->cpu.parent->grid->extsize * sizeof(integer));
genirand(t->cpu.parent->grid->extsize, array);
test_load(t, n, sx, sy, ss, sizeof(integer), (char*)array);
#ifdef MPI
if (t->rank == MPI_ROOT_NODE)
#endif
{
size_t nxysb = n * n * n * sizeof(integer);
// Copy the data array.
memcpy(t_check->cpu.arrays[0], array, nxysb);
// Duplicate initial distribution to the second level array.
memcpy(t_check->cpu.arrays[1], t_check->cpu.arrays[0], nxysb);
}
free(array);
#ifdef VERBOSE
printf("step 0\n");
printf("step 1\n");
#endif
// The time iterations loop, CPU and GPU versions.
for (int it = 2; it < t->nt; it++)
{
// Run one iteration of the stencil, measuring its time.
// In case of MPI, the time of iteration is measured together
// with the time of data sync.
struct timespec start, stop;
#ifdef MPI
if (t->rank == MPI_ROOT_NODE)
#endif
{
stenfw_get_time(&start);
}
#ifdef MPI
struct grid_domain_t* subdomains = t->cpu.subdomains;
int nsubdomains = t->cpu.nsubdomains;
// Copy the current iteration data into boundary slices
// and compute stencil in them.
// Boundary slices themselves are subdomains with respect
// to each MPI decomposition domains.
{
// Set subdomain data copying callbacks:
// use simple memcpy in this case.
for (int i = 0; i < nsubdomains; i++)
{
struct grid_domain_t* sub = subdomains + i;
sub->scatter_memcpy = &grid_subcpy;
sub->gather_memcpy = &grid_subcpy;
}
// Scatter domain edges for separate computation.
grid_scatter(subdomains, &t->cpu, 0, LAYOUT_MODE_CUSTOM);
// Process edges subdomains.
for (int i = 0; i < nsubdomains; i++)
{
struct grid_domain_t* sub = subdomains + i;
int nx = sub->grid[0].bx + sub->grid[0].nx + sub->grid[0].ex;
int ny = sub->grid[0].by + sub->grid[0].ny + sub->grid[0].ey;
int ns = sub->grid[0].bs + sub->grid[0].ns + sub->grid[0].es;
isum13pt_cpu(nx, ny, ns,
(integer(*)[ny][nx])sub->arrays[0],
(integer(*)[ny][nx])sub->arrays[1],
(integer(*)[ny][nx])sub->arrays[2]);
}
}
// Start sharing boundary slices between linked subdomains.
MPI_Request* reqs = (MPI_Request*)malloc(sizeof(MPI_Request) * 2 * nsubdomains);
for (int i = 0; i < nsubdomains; i++)
{
struct grid_domain_t* subdomain = subdomains + i;
struct grid_domain_t* neighbor = *(subdomain->links.dense[0]);
assert(neighbor->grid[1].extsize == subdomain->grid[0].extsize);
int szelem = sizeof(integer);
size_t dnx = neighbor->grid[1].nx * szelem;
size_t dny = neighbor->grid[1].ny;
size_t dns = neighbor->grid[1].ns;
size_t snx = subdomain->grid[0].nx * szelem;
size_t sbx = subdomain->grid[0].bx * szelem;
size_t sex = subdomain->grid[0].ex * szelem;
size_t sny = subdomain->grid[0].ny, sns = subdomain->grid[0].ns;
size_t sby = subdomain->grid[0].by, sbs = subdomain->grid[0].bs;
size_t sey = subdomain->grid[0].ey, ses = subdomain->grid[0].es;
size_t soffset = sbx + (sbx + snx + sex) *
(sby + sbs * (sby + sny + sey));
struct grid_domain_t obuf;
memset(&obuf, 0, sizeof(struct grid_domain_t));
obuf.arrays = subdomain->arrays + 1;
obuf.narrays = 1;
obuf.offset = 0;
obuf.grid[0].nx = dnx;
obuf.grid[0].ny = dny;
obuf.grid[0].ns = dns;
obuf.grid->size = dnx * dny * dns;
struct grid_domain_t scpy = *subdomain;
scpy.arrays = subdomain->arrays + 2;
scpy.narrays = 1;
scpy.offset = soffset;
scpy.grid[0].nx = sbx + snx + sex;
scpy.grid[0].ny = sby + sny + sey;
scpy.grid[0].ns = sbs + sns + ses;
// Copy data to the temporary buffer.
grid_subcpy(dnx, dny, dns, &obuf, &scpy);
// Exchange temporary buffers with the subdomain neighbour.
int subdomain_rank = grid_rank1d(subdomain->parent->parent, subdomain->parent->grid);
int neighbor_rank = grid_rank1d(neighbor->parent->parent, neighbor->parent->grid);
MPI_SAFE_CALL(MPI_Isend(subdomain->arrays[1], obuf.grid->size,
MPI_BYTE, neighbor_rank, 0, MPI_COMM_WORLD, &reqs[2 * i]));
MPI_SAFE_CALL(MPI_Irecv(subdomain->arrays[0], obuf.grid->size,
MPI_BYTE, neighbor_rank, 0, MPI_COMM_WORLD, &reqs[2 * i + 1]));
#ifdef VERBOSE
printf("sharing: send %d->%d\n", subdomain_rank, neighbor_rank);
printf("sharing: recv %d->%d\n", neighbor_rank, subdomain_rank);
#endif
}
#endif // MPI
// Compute inner grid points of the subdomain.
int nx = t->cpu.grid->bx + t->cpu.grid->nx + t->cpu.grid->ex;
int ny = t->cpu.grid->by + t->cpu.grid->ny + t->cpu.grid->ey;
int ns = t->cpu.grid->bs + t->cpu.grid->ns + t->cpu.grid->es;
if (cpu)
{
isum13pt_cpu(nx, ny, ns,
(integer(*)[ny][nx])t->cpu.arrays[0],
(integer(*)[ny][nx])t->cpu.arrays[1],
(integer(*)[ny][nx])t->cpu.arrays[2]);
}
#ifdef CUDA
if (gpu)
{
isum13pt_gpu(nx, ny, ns,
(integer*)t->gpu.arrays[0],
(integer*)t->gpu.arrays[1],
(integer*)t->gpu.arrays[2]);
#ifdef VISUALIZE
#ifndef CUDA_MAPPED
// If GPU is not using mapped host memory, then need to fetch
// the current iteration solution explicitly.
// TODO: in case of MPI/CUDA/!MAPPED this copy must go AFTER
// boundaries gathering.
CUDA_SAFE_CALL(cudaMemcpy(t->cpu.arrays[2], t->gpu.arrays[2],
t->gpu.grid->extsize * sizeof(real), cudaMemcpyDeviceToHost));
#endif // CUDA_MAPPED
#endif
}
#endif // CUDA
#ifdef MPI
// Wait for boundaries sharing completion.
MPI_Status* statuses = (MPI_Status*)malloc(2 * nsubdomains * sizeof(MPI_Status));
MPI_SAFE_CALL(MPI_Waitall(2 * nsubdomains, reqs, statuses));
for (int i = 0; i < 2 * nsubdomains; i++)
MPI_SAFE_CALL(statuses[i].MPI_ERROR);
free(statuses);
free(reqs);
for (int i = 0; i < nsubdomains; i++)
{
struct grid_domain_t* subdomain = subdomains + i;
int szelem = sizeof(integer);
size_t dnx = subdomain->grid[1].nx * szelem;
size_t dbx = subdomain->grid[1].bx * szelem;
size_t dex = subdomain->grid[1].ex * szelem;
size_t dny = subdomain->grid[1].ny, dns = subdomain->grid[1].ns;
size_t dby = subdomain->grid[1].by, dbs = subdomain->grid[1].bs;
size_t dey = subdomain->grid[1].ey, des = subdomain->grid[1].es;
size_t doffset = dbx + (dbx + dnx + dex) *
(dby + dbs * (dby + dny + dey));
struct grid_domain_t dcpy = *subdomain;
dcpy.arrays = subdomain->arrays + 2;
dcpy.narrays = 1;
dcpy.offset = doffset;
dcpy.grid[0].nx = dbx + dnx + dex;
dcpy.grid[0].ny = dby + dny + dey;
dcpy.grid[0].ns = dbs + dns + des;
struct grid_domain_t ibuf;
memset(&ibuf, 0, sizeof(struct grid_domain_t));
ibuf.arrays = subdomain->arrays;
ibuf.narrays = 1;
ibuf.offset = 0;
ibuf.grid[0].nx = dnx;
ibuf.grid[0].ny = dny;
ibuf.grid[0].ns = dns;
// Copy data to temporary buffer.
grid_subcpy(dnx, dny, dns, &dcpy, &ibuf);
// Swap pointers to make the last iteration in the bottom.
char* w = subdomain->arrays[0];
subdomain->arrays[0] = subdomain->arrays[2];
subdomain->arrays[2] = w;
}
// Gather bounradies on for the next time step. Insert the
// separately computed boundaries back into the sudomains
// for the next time step.
struct grid_domain_t target = t->cpu;
target.narrays = 1;
target.arrays = t->cpu.arrays + 2;
grid_gather(&target, subdomains, 1, LAYOUT_MODE_CUSTOM);
if (t->rank != MPI_ROOT_NODE)
{
#ifdef VERBOSE
printf("step %d\n", it);
#endif
}
else
#endif // MPI
{
stenfw_get_time(&stop);
printf("step %d time = ", it);
stenfw_print_time_diff(start, stop);
printf(" sec\n");
}
#ifdef MPI
if (t->rank == MPI_ROOT_NODE)
#endif
{
// Compute inner grid points of the control solution subdomain.
int nx = t_check->cpu.grid->bx + t_check->cpu.grid->nx + t_check->cpu.grid->ex;
int ny = t_check->cpu.grid->by + t_check->cpu.grid->ny + t_check->cpu.grid->ey;
int ns = t_check->cpu.grid->bs + t_check->cpu.grid->ns + t_check->cpu.grid->es;
isum13pt_cpu(nx, ny, ns,
(integer(*)[ny][nx])t_check->cpu.arrays[0],
(integer(*)[ny][nx])t_check->cpu.arrays[1],
(integer(*)[ny][nx])t_check->cpu.arrays[2]);
}
// Print the stats of difference between the solution and
// the control solution.
test_write_imaxabsdiff(t, t_check, 2, it);
// Swap pointers to rewrite the oldest iteration with
// the next one.
char* w = t->cpu.arrays[0];
t->cpu.arrays[0] = t->cpu.arrays[1];
t->cpu.arrays[1] = t->cpu.arrays[2];
t->cpu.arrays[2] = w;
#ifdef CUDA
if (gpu)
{
// Also swap the corresponding GPU arrays pointers.
w = t->gpu.arrays[0];
t->gpu.arrays[0] = t->gpu.arrays[1];
t->gpu.arrays[1] = t->gpu.arrays[2];
t->gpu.arrays[2] = w;
}
#endif
#ifdef MPI
if (t->rank == MPI_ROOT_NODE)
#endif
{
// Swap pointers to rewrite the oldest control solution
// iteration with the next one.
char* w = t_check->cpu.arrays[0];
t_check->cpu.arrays[0] = t_check->cpu.arrays[1];
t_check->cpu.arrays[1] = t_check->cpu.arrays[2];
t_check->cpu.arrays[2] = w;
}
}
// Dispose the test configurations.
#ifdef MPI
if (t->rank == MPI_ROOT_NODE)
#endif
{
test_dispose(t_check);
}
test_dispose(t);
return 0;
}
int main(int argc,char **argv){
test_parse("*2\r");
test_parse("\n$53\r\nfasdfasdffasdfasdfasdfasdfasdfasfasdffasfsdffasdfadfs\r\n$36\r\nfasfsadfasdfsdafasdfasdfasdfsdafsadf\r\n");
test_parse("$5\r");
test_parse("\nhello\r");
test_parse("\n");
test_parse(":");
test_parse("10\r");
test_parse("\n");
test_parse("");
test_parse("+ok haha\r");
test_parse("\n");
char input[65535];
char *ptr;
signal(SIGPIPE,SIG_IGN);
engine *e = engine_new();
sockaddr_ server;
easy_sockaddr_ip4(&server,"127.0.0.1",6379);
redis_client = redis_connect(e,&server,on_disconnect);
if(!redis_client){
printf("connect to redis server %s:%u error\n",argv[1],atoi(argv[2]));
return 0;
}
redis_execute(redis_client,"set kenny h\r\nha",cmd_callback,NULL);
do{
ptr = input;
while((*ptr = getchar()) != '\n')
++ptr;
*ptr = 0;
flag = 1;
redis_execute(redis_client,input,cmd_callback,NULL);
while(flag && redis_client){
engine_runonce(e,10);
};
if(!redis_client)
return 0;
}while(1);
return 0;
}
int main()
{
test_null(NULL);
test_null("1");
test_fail("1a");
test_fail("b1");
test_fail("a");
test_parse("1", true);
test_parse("0", false);
test_parse("Y", true);
test_parse("y", true);
test_parse("N", false);
test_parse("n", false);
test_parse("yes", true);
test_parse("Yes", true);
test_parse("true", true);
test_parse("True", true);
test_parse("on", true);
test_parse("ON", true);
test_parse("On", true);
test_parse("oN", true);
test_parse("no", false);
test_parse("No", false);
test_parse("false", false);
test_parse("False", false);
test_parse("off", false);
test_parse("OFF", false);
test_parse("Off", false);
return EXIT_SUCCESS;
}
int main(void) {
test_parse();
return EXIT_SUCCESS;
}
/*
* execute command tree
*/
int
execute(struct op * volatile t,
/* if XEXEC don't fork */
volatile int flags,
volatile int * volatile xerrok)
{
int i;
volatile int rv = 0, dummy = 0;
int pv[2];
const char ** volatile ap = NULL;
char ** volatile up;
const char *s, *ccp;
struct ioword **iowp;
struct tbl *tp = NULL;
char *cp;
if (t == NULL)
return (0);
/* Caller doesn't care if XERROK should propagate. */
if (xerrok == NULL)
xerrok = &dummy;
if ((flags&XFORK) && !(flags&XEXEC) && t->type != TPIPE)
/* run in sub-process */
return (exchild(t, flags & ~XTIME, xerrok, -1));
newenv(E_EXEC);
if (trap)
runtraps(0);
/* we want to run an executable, do some variance checks */
if (t->type == TCOM) {
/* check if this is 'var=<<EOF' */
if (
/* we have zero arguments, i.e. no programme to run */
t->args[0] == NULL &&
/* we have exactly one variable assignment */
t->vars[0] != NULL && t->vars[1] == NULL &&
/* we have exactly one I/O redirection */
t->ioact != NULL && t->ioact[0] != NULL &&
t->ioact[1] == NULL &&
/* of type "here document" (or "here string") */
(t->ioact[0]->flag & IOTYPE) == IOHERE &&
/* the variable assignment begins with a valid varname */
(ccp = skip_wdvarname(t->vars[0], true)) != t->vars[0] &&
/* and has no right-hand side (i.e. "varname=") */
ccp[0] == CHAR && ccp[1] == '=' && ccp[2] == EOS &&
/* plus we can have a here document content */
herein(t->ioact[0], &cp) == 0 && cp && *cp) {
char *sp = cp, *dp;
size_t n = ccp - t->vars[0] + 2, z;
/* drop redirection (will be garbage collected) */
t->ioact = NULL;
/* set variable to its expanded value */
z = strlen(cp) + 1;
if (notoktomul(z, 2) || notoktoadd(z * 2, n))
internal_errorf(Toomem, (unsigned long)-1);
dp = alloc(z * 2 + n, ATEMP);
memcpy(dp, t->vars[0], n);
t->vars[0] = dp;
dp += n;
while (*sp) {
*dp++ = QCHAR;
*dp++ = *sp++;
}
*dp = EOS;
/* free the expanded value */
afree(cp, APERM);
}
/*
* Clear subst_exstat before argument expansion. Used by
* null commands (see comexec() and c_eval()) and by c_set().
*/
subst_exstat = 0;
/* for $LINENO */
current_lineno = t->lineno;
/*
* POSIX says expand command words first, then redirections,
* and assignments last..
*/
up = eval(t->args, t->u.evalflags | DOBLANK | DOGLOB | DOTILDE);
if (flags & XTIME)
/* Allow option parsing (bizarre, but POSIX) */
timex_hook(t, &up);
ap = (const char **)up;
if (Flag(FXTRACE) && ap[0]) {
shf_puts(substitute(str_val(global("PS4")), 0),
shl_out);
for (i = 0; ap[i]; i++)
shf_fprintf(shl_out, "%s%c", ap[i],
ap[i + 1] ? ' ' : '\n');
shf_flush(shl_out);
}
if (ap[0])
tp = findcom(ap[0], FC_BI|FC_FUNC);
}
flags &= ~XTIME;
if (t->ioact != NULL || t->type == TPIPE || t->type == TCOPROC) {
e->savefd = alloc2(NUFILE, sizeof(short), ATEMP);
/* initialise to not redirected */
memset(e->savefd, 0, NUFILE * sizeof(short));
}
/* mark for replacement later (unless TPIPE) */
vp_pipest->flag |= INT_L;
/* do redirection, to be restored in quitenv() */
if (t->ioact != NULL)
for (iowp = t->ioact; *iowp != NULL; iowp++) {
if (iosetup(*iowp, tp) < 0) {
exstat = rv = 1;
/*
* Redirection failures for special commands
* cause (non-interactive) shell to exit.
*/
if (tp && tp->type == CSHELL &&
(tp->flag & SPEC_BI))
errorfz();
/* Deal with FERREXIT, quitenv(), etc. */
goto Break;
}
}
switch (t->type) {
case TCOM:
rv = comexec(t, tp, (const char **)ap, flags, xerrok);
break;
case TPAREN:
rv = execute(t->left, flags | XFORK, xerrok);
break;
case TPIPE:
flags |= XFORK;
flags &= ~XEXEC;
e->savefd[0] = savefd(0);
e->savefd[1] = savefd(1);
while (t->type == TPIPE) {
openpipe(pv);
/* stdout of curr */
ksh_dup2(pv[1], 1, false);
/**
* Let exchild() close pv[0] in child
* (if this isn't done, commands like
* (: ; cat /etc/termcap) | sleep 1
* will hang forever).
*/
exchild(t->left, flags | XPIPEO | XCCLOSE,
NULL, pv[0]);
/* stdin of next */
ksh_dup2(pv[0], 0, false);
closepipe(pv);
flags |= XPIPEI;
t = t->right;
}
/* stdout of last */
restfd(1, e->savefd[1]);
/* no need to re-restore this */
e->savefd[1] = 0;
/* Let exchild() close 0 in parent, after fork, before wait */
i = exchild(t, flags | XPCLOSE | XPIPEST, xerrok, 0);
if (!(flags&XBGND) && !(flags&XXCOM))
rv = i;
break;
case TLIST:
while (t->type == TLIST) {
execute(t->left, flags & XERROK, NULL);
t = t->right;
}
rv = execute(t, flags & XERROK, xerrok);
break;
case TCOPROC: {
#ifndef MKSH_NOPROSPECTOFWORK
sigset_t omask;
/*
* Block sigchild as we are using things changed in the
* signal handler
*/
sigprocmask(SIG_BLOCK, &sm_sigchld, &omask);
e->type = E_ERRH;
if ((i = kshsetjmp(e->jbuf))) {
sigprocmask(SIG_SETMASK, &omask, NULL);
quitenv(NULL);
unwind(i);
/* NOTREACHED */
}
#endif
/* Already have a (live) co-process? */
if (coproc.job && coproc.write >= 0)
errorf("coprocess already exists");
/* Can we re-use the existing co-process pipe? */
coproc_cleanup(true);
/* do this before opening pipes, in case these fail */
e->savefd[0] = savefd(0);
e->savefd[1] = savefd(1);
openpipe(pv);
if (pv[0] != 0) {
ksh_dup2(pv[0], 0, false);
close(pv[0]);
}
coproc.write = pv[1];
coproc.job = NULL;
if (coproc.readw >= 0)
ksh_dup2(coproc.readw, 1, false);
else {
openpipe(pv);
coproc.read = pv[0];
ksh_dup2(pv[1], 1, false);
/* closed before first read */
coproc.readw = pv[1];
coproc.njobs = 0;
/* create new coprocess id */
++coproc.id;
}
#ifndef MKSH_NOPROSPECTOFWORK
sigprocmask(SIG_SETMASK, &omask, NULL);
/* no more need for error handler */
e->type = E_EXEC;
#endif
/*
* exchild() closes coproc.* in child after fork,
* will also increment coproc.njobs when the
* job is actually created.
*/
flags &= ~XEXEC;
exchild(t->left, flags | XBGND | XFORK | XCOPROC | XCCLOSE,
NULL, coproc.readw);
break;
}
case TASYNC:
/*
* XXX non-optimal, I think - "(foo &)", forks for (),
* forks again for async... parent should optimise
* this to "foo &"...
*/
rv = execute(t->left, (flags&~XEXEC)|XBGND|XFORK, xerrok);
break;
case TOR:
case TAND:
rv = execute(t->left, XERROK, xerrok);
if ((rv == 0) == (t->type == TAND))
rv = execute(t->right, XERROK, xerrok);
flags |= XERROK;
if (xerrok)
*xerrok = 1;
break;
case TBANG:
rv = !execute(t->right, XERROK, xerrok);
flags |= XERROK;
if (xerrok)
*xerrok = 1;
break;
case TDBRACKET: {
Test_env te;
te.flags = TEF_DBRACKET;
te.pos.wp = t->args;
te.isa = dbteste_isa;
te.getopnd = dbteste_getopnd;
te.eval = test_eval;
te.error = dbteste_error;
rv = test_parse(&te);
break;
}
case TFOR:
case TSELECT: {
volatile bool is_first = true;
ap = (t->vars == NULL) ? e->loc->argv + 1 :
(const char **)eval((const char **)t->vars,
DOBLANK | DOGLOB | DOTILDE);
e->type = E_LOOP;
while ((i = kshsetjmp(e->jbuf))) {
if ((e->flags&EF_BRKCONT_PASS) ||
(i != LBREAK && i != LCONTIN)) {
quitenv(NULL);
unwind(i);
} else if (i == LBREAK) {
rv = 0;
goto Break;
}
}
/* in case of a continue */
rv = 0;
if (t->type == TFOR) {
while (*ap != NULL) {
setstr(global(t->str), *ap++, KSH_UNWIND_ERROR);
rv = execute(t->left, flags & XERROK, xerrok);
}
} else {
/* TSELECT */
for (;;) {
if (!(ccp = do_selectargs(ap, is_first))) {
rv = 1;
break;
}
is_first = false;
setstr(global(t->str), ccp, KSH_UNWIND_ERROR);
execute(t->left, flags & XERROK, xerrok);
}
}
break;
}
case TWHILE:
case TUNTIL:
e->type = E_LOOP;
while ((i = kshsetjmp(e->jbuf))) {
if ((e->flags&EF_BRKCONT_PASS) ||
(i != LBREAK && i != LCONTIN)) {
quitenv(NULL);
unwind(i);
} else if (i == LBREAK) {
rv = 0;
goto Break;
}
}
/* in case of a continue */
rv = 0;
while ((execute(t->left, XERROK, NULL) == 0) ==
(t->type == TWHILE))
rv = execute(t->right, flags & XERROK, xerrok);
break;
case TIF:
case TELIF:
if (t->right == NULL)
/* should be error */
break;
rv = execute(t->left, XERROK, NULL) == 0 ?
execute(t->right->left, flags & XERROK, xerrok) :
execute(t->right->right, flags & XERROK, xerrok);
break;
case TCASE:
i = 0;
ccp = evalstr(t->str, DOTILDE);
for (t = t->left; t != NULL && t->type == TPAT; t = t->right) {
for (ap = (const char **)t->vars; *ap; ap++) {
if (i || ((s = evalstr(*ap, DOTILDE|DOPAT)) &&
gmatchx(ccp, s, false))) {
rv = execute(t->left, flags & XERROK,
xerrok);
i = 0;
switch (t->u.charflag) {
case '&':
i = 1;
/* FALLTHROUGH */
case '|':
goto TCASE_next;
}
goto TCASE_out;
}
}
i = 0;
TCASE_next:
/* empty */;
}
TCASE_out:
break;
case TBRACE:
rv = execute(t->left, flags & XERROK, xerrok);
break;
case TFUNCT:
rv = define(t->str, t);
break;
case TTIME:
/*
* Clear XEXEC so nested execute() call doesn't exit
* (allows "ls -l | time grep foo").
*/
rv = timex(t, flags & ~XEXEC, xerrok);
break;
case TEXEC:
/* an eval'd TCOM */
s = t->args[0];
up = makenv();
restoresigs();
cleanup_proc_env();
{
union mksh_ccphack cargs;
cargs.ro = t->args;
execve(t->str, cargs.rw, up);
rv = errno;
}
if (rv == ENOEXEC)
scriptexec(t, (const char **)up);
else
errorf("%s: %s", s, cstrerror(rv));
}
Break:
exstat = rv & 0xFF;
if (vp_pipest->flag & INT_L) {
unset(vp_pipest, 1);
vp_pipest->flag = DEFINED | ISSET | INTEGER | RDONLY |
ARRAY | INT_U;
vp_pipest->val.i = rv;
}
/* restores IO */
quitenv(NULL);
if ((flags&XEXEC))
/* exit child */
unwind(LEXIT);
if (rv != 0 && !(flags & XERROK) &&
(xerrok == NULL || !*xerrok)) {
if (Flag(FERREXIT) & 0x80) {
/* inside eval */
Flag(FERREXIT) = 0;
} else {
trapsig(ksh_SIGERR);
if (Flag(FERREXIT))
unwind(LERROR);
}
}
return (rv);
}
void MatrixTest::run_test_case(void)
{
message += "Running matrix test case...\n";
// Constructor and destructor methods
test_constructor();
test_destructor();
// Assignment operators methods
test_assignment_operator();
// Reference operator methods
test_reference_operator();
// Arithmetic operators
test_sum_operator();
test_rest_operator();
test_multiplication_operator();
test_division_operator();
// Arithmetic and assignment operators
test_sum_assignment_operator();
test_rest_assignment_operator();
test_multiplication_assignment_operator();
test_division_assignment_operator();
// Equality and relational operators
test_equal_to_operator();
test_not_equal_to_operator();
test_greater_than_operator();
test_less_than_operator();
test_greater_than_or_equal_to_operator();
test_less_than_or_equal_to_operator();
// Output operators
test_output_operator();
// Get methods
test_get_rows_number();
test_get_columns_number();
test_arrange_row();
test_arrange_column();
test_arrange_submatrix();
// Set methods
test_set();
test_set_rows_number();
test_set_columns_number();
test_set_row();
test_set_column();
// Diagonal methods
test_get_diagonal();
test_set_diagonal();
test_sum_diagonal();
// Resize methods
test_append_row();
test_append_column();
test_insert_row();
test_insert_column();
test_subtract_row();
test_subtract_column();
test_sort_less_rows();
test_sort_greater_rows();
// Initialization methods
test_initialize();
test_randomize_uniform();
test_randomize_normal();
test_set_to_identity();
// Mathematical methods
test_calculate_sum();
test_calculate_rows_sum();
test_dot_vector();
test_dot_matrix();
test_calculate_eigenvalues();
test_calculate_eigenvectors();
test_direct();
test_calculate_minimum_maximum();
test_calculate_mean_standard_deviation();
test_calculate_statistics();
test_calculate_histogram();
test_calculate_covariance_matrix();
test_calculate_minimal_indices();
test_calculate_maximal_indices();
test_calculate_minimal_maximal_indices();
test_calculate_sum_squared_error();
test_calculate_mean_squared_error();
test_calculate_root_mean_squared_error();
test_calculate_determinant();
test_calculate_transpose();
test_calculate_cofactor();
test_calculate_inverse();
test_is_symmetric();
test_is_antisymmetric();
// Scaling methods
test_scale_mean_standard_deviation();
test_scale_rows_mean_standard_deviation();
test_scale_columns_mean_standard_deviation();
test_scale_rows_columns_mean_standard_deviation();
test_scale_minimum_maximum();
test_scale_rows_minimum_maximum();
test_scale_columns_minimum_maximum();
test_scale_rows_columns_minimum_maximum();
// Unscaling methods
test_unscale_mean_standard_deviation();
test_unscale_rows_mean_standard_deviation();
test_unscale_columns_mean_standard_deviation();
test_unscale_rows_columns_mean_standard_deviation();
test_unscale_minimum_maximum();
test_unscale_rows_minimum_maximum();
test_unscale_columns_minimum_maximum();
test_unscale_rows_columns_minimum_maximum();
test_convert_angular_variables_degrees();
test_convert_angular_variables_radians();
// Serialization methods
test_print();
test_load();
test_save();
test_parse();
message += "End of matrix test case.\n";
}
