Ejemplo n.º 1
0
int
run_main (int argc, ACE_TCHAR *argv[])
{
  ACE_START_TEST (ACE_TEXT ("Map_Manager_Test"));
  ACE_LOG_MSG->clr_flags (ACE_Log_Msg::VERBOSE_LITE);
  int result = 0;
  size_t table_size = ACE_MAX_ITERATIONS / 2;
  size_t iterations = ACE_MAX_ITERATIONS;
  int test_iterators = 1;

  if (argc > 1)
    table_size = ACE_OS::atoi (argv[1]);

  if (argc > 2)
    iterations = ACE_OS::atoi (argv[2]);

  if (argc > 3)
    test_iterators = ACE_OS::atoi (argv[3]);

  if (table_size == 0)
    {
      ACE_ERROR ((LM_ERROR, "LM_ERROR@Table size is 0\n"));
      ++result;
    }
  else
    {
      // Test the <ACE_Map_Manager>.
      result += run_test (&test_map_manager,
                          table_size,
                          iterations,
                          test_iterators,
                          ACE_TEXT ("Map_Manager"));

      // Test the <ACE_Hash_Map_Manager>.
      result += run_test (&test_hash_map_manager,
                          table_size,
                          iterations,
                          test_iterators,
                          ACE_TEXT ("Hash_Map_Manager"));

      // Test the <ACE_Hash_Map_Manager>.
      result += run_test (&test_active_map_manager,
                          table_size,
                          iterations,
                          test_iterators,
                          ACE_TEXT ("Active_Map_Manager"));

      // Test the <ACE_Cache_Map_Manager>.
      result += run_test (&test_cache_map_manager,
                          table_size,
                          iterations,
                          test_iterators,
                          ACE_TEXT ("Cache_Map_Manager"));

      // Test the <ACE_Hash_Cache_Map_Manager>.
      result += run_test (&test_hash_cache_map_manager,
                          table_size,
                          iterations,
                          test_iterators,
                          ACE_TEXT ("Hash_Cache_Map_Manager"));
    }
  ACE_LOG_MSG->set_flags (ACE_Log_Msg::VERBOSE_LITE);
  ACE_END_TEST;
  return result;
}
Ejemplo n.º 2
0
/*
 * Take one step along the current "run" path
 *
 * Called with a real direction to begin a new run, and with zero
 * to continue a run in progress.
 */
void run_step(int dir)
{
	int x, y;

	/* Start run */
	if (dir)
	{
		/* Initialize */
		run_init(dir);

		/* Hack -- Set the run counter */
		p_ptr->running = (p_ptr->command_arg ? p_ptr->command_arg : 1000);

		/* Calculate torch radius */
		p_ptr->update |= (PU_TORCH);
	}

	/* Continue run */
	else
	{
		if (!p_ptr->running_withpathfind)
		{
			/* Update run */
			if (run_test())
			{
				/* Disturb */
				disturb(0, 0);
	
				/* Done */
				return;
			}
		}
		else
		{
			/* Abort if we have finished */
			if (pf_result_index < 0)
			{
				disturb(0, 0);
				p_ptr->running_withpathfind = FALSE;
				return;
			}

			/* Abort if we would hit a wall */
			else if (pf_result_index == 0)
			{
				/* Get next step */
				y = p_ptr->py + ddy[pf_result[pf_result_index] - '0'];
				x = p_ptr->px + ddx[pf_result[pf_result_index] - '0'];

				/* Known wall */
				if ((cave_info[y][x] & (CAVE_MARK)) && !cave_floor_bold(y, x))
				{
					disturb(0,0);
					p_ptr->running_withpathfind = FALSE;
					return;
				}
			}

			/*
			 * Hack -- walking stick lookahead.
			 *
			 * If the player has computed a path that is going to end up in a wall,
			 * we notice this and convert to a normal run. This allows us to click
			 * on unknown areas to explore the map.
			 *
			 * We have to look ahead two, otherwise we don't know which is the last
			 * direction moved and don't initialise the run properly.
			 */
			else if (pf_result_index > 0)
			{
				/* Get next step */
				y = p_ptr->py + ddy[pf_result[pf_result_index] - '0'];
				x = p_ptr->px + ddx[pf_result[pf_result_index] - '0'];

				/* Known wall */
				if ((cave_info[y][x] & (CAVE_MARK)) && !cave_floor_bold(y, x))
				{
					disturb(0,0);
					p_ptr->running_withpathfind = FALSE;
					return;
				}

				/* Get step after */
				y = y + ddy[pf_result[pf_result_index-1] - '0'];
				x = x + ddx[pf_result[pf_result_index-1] - '0'];

				/* Known wall */
				if ((cave_info[y][x] & (CAVE_MARK)) && !cave_floor_bold(y, x))
				{
					p_ptr->running_withpathfind = FALSE;

					run_init(pf_result[pf_result_index] - '0');
				}
			}

			p_ptr->run_cur_dir = pf_result[pf_result_index--] - '0';
		}
	}


	/* Decrease counter */
	p_ptr->running--;

	/* Take time */
	p_ptr->energy_use = 100;

	/* Move the player */
	move_player(p_ptr->run_cur_dir);
}
Ejemplo n.º 3
0
Archivo: 11.c Proyecto: Ravenbrook/mps
int main(void)
{
 run_test(test);
 return 0;
}
Ejemplo n.º 4
0
int main(int argc, char *argv[]) {
    MPI_Init(&argc, &argv);
    mpi = vex::mpi::comm_data(MPI_COMM_WORLD);

    if (mpi.rank == 0) std::cout << "World size: " << mpi.size << std::endl;

    try {
        vex::Context ctx( vex::Filter::Exclusive(
                    vex::Filter::Env && vex::Filter::Count(1) ) );

        mpi.precondition(!ctx.empty(), "No OpenCL devices found");

        for(int i = 0; i < mpi.size; ++i) {
            if (i == mpi.rank)
                std::cout << mpi.rank << ": " << ctx.device(0) << std::endl;

            MPI_Barrier(mpi.comm);
        }

        boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
        if (mpi.rank == 0) std::cout << std::endl;

        run_test("Allocate mpi::vector", [&]() -> bool {
                const size_t n = 1024;
                bool rc = true;

                vex::mpi::vector<double> x(mpi.comm, ctx, n);

                rc = rc && x.local_size() == n;
                rc = rc && x.global_size() == n * mpi.size;

                return rc;
                });

        run_test("Assign constant to mpi::vector", [&]() -> bool {
                const size_t n = 1024;
                bool rc = true;

                vex::mpi::vector<double> x(mpi.comm, ctx, n);

                x = 42;

                rc = rc && x[n/2] == 42;

                return rc;
                });

        run_test("Copy constructor for mpi::vector", [&]() -> bool {
                const size_t n = 1024;
                bool rc = true;

                vex::mpi::vector<double> x(mpi.comm, ctx, n);
                x = 42;

                vex::mpi::vector<double> y = x;

                rc = rc && y[n/2] == 42;

                return rc;
                });

        run_test("Assign arithmetic expression to mpi::vector", [&]() -> bool {
                const size_t n = 1024;
                bool rc = true;

                vex::mpi::vector<double> x(mpi.comm, ctx, n);
                vex::mpi::vector<double> y(mpi.comm, ctx, n);

                x = 42;
                y = vex::cos(x / 7);

                rc = rc && fabs(y[n/2] - cos(6.0)) < 1e-8;

                return rc;
                });

        run_test("Reduce mpi::vector", [&]() -> bool {
                const size_t n = 1024;
                bool rc = true;

                vex::mpi::vector<double> x(mpi.comm, ctx, n);
                vex::mpi::Reductor<double, vex::SUM> sum(mpi.comm, ctx);

                x = 1;

                rc = rc && fabs(sum(x) - x.global_size()) < 1e-8;

                return rc;
                });

        run_test("Allocate mpi::multivector", [&]() -> bool {
                const size_t n = 1024;
                const size_t m = 3;
                bool rc = true;

                vex::mpi::multivector<double,m> x(mpi.comm, ctx, n);

                rc = rc && x.local_size() == n;
                rc = rc && x.global_size() == n * mpi.size;

                return rc;
                });

        run_test("Assign constant to mpi::multivector", [&]() -> bool {
                const size_t n = 1024;
                const size_t m = 3;
                bool rc = true;

                vex::mpi::multivector<double,m> x(mpi.comm, ctx, n);

                x = 42;

                rc = rc && x(0)[n/2] == 42;
                rc = rc && x(1)[n/2] == 42;
                rc = rc && x(2)[n/2] == 42;

                x = std::make_tuple(6, 7, 42);

                rc = rc && x(0)[n/2] == 6;
                rc = rc && x(1)[n/2] == 7;
                rc = rc && x(2)[n/2] == 42;

                return rc;
                });

        run_test("Assign arithmetic expression to mpi::multivector", [&]() -> bool {
                const size_t n = 1024;
                const size_t m = 3;
                bool rc = true;

                vex::mpi::multivector<double,m> x(mpi.comm, ctx, n);
                vex::mpi::multivector<double,m> y(mpi.comm, ctx, n);

                x = std::make_tuple(6, 7, 42);
                y = vex::cos(x / 7);

                rc = rc && fabs(y(0)[n/2] - cos(6.0  / 7.0)) < 1e-8;
                rc = rc && fabs(y(1)[n/2] - cos(7.0  / 7.0)) < 1e-8;
                rc = rc && fabs(y(2)[n/2] - cos(42.0 / 7.0)) < 1e-8;

                return rc;
                });

        run_test("Reduce mpi::multivector", [&]() -> bool {
                const size_t n = 1024;
                const size_t m = 3;
                bool rc = true;

                vex::mpi::multivector<double, m> x(mpi.comm, ctx, n);
                vex::mpi::Reductor<double, vex::SUM> sum(mpi.comm, ctx);

                x = std::make_tuple(1, 2, 3);

                auto s = sum(x);

                rc = rc && fabs(s[0] - 1 * x.global_size()) < 1e-8;
                rc = rc && fabs(s[1] - 2 * x.global_size()) < 1e-8;
                rc = rc && fabs(s[2] - 3 * x.global_size()) < 1e-8;

                return rc;
                });

        run_test("Assign multiexpression to mpi::multivector", [&]() -> bool {
                const size_t n = 1024;
                const size_t m = 3;
                bool rc = true;

                vex::mpi::multivector<double, m> x(mpi.comm, ctx, n);
                vex::mpi::vector<double> y0(mpi.comm, ctx, n);
                vex::mpi::vector<double> y1(mpi.comm, ctx, n);

                y0 = 1;
                y1 = 2;

                int the_answer = 42;

                x = std::tie(y1 - y0, y1 + y0, the_answer);

                rc = rc && x(0)[42] == 1;
                rc = rc && x(1)[42] == 3;
                rc = rc && x(2)[42] == 42;

                return rc;
                });

        run_test("Assign multiexpression to tied mpi::vectors", [&]() -> bool {
                const size_t n = 1024;
                bool rc = true;

                vex::mpi::vector<double> x0(mpi.comm, ctx, n);
                vex::mpi::vector<double> x1(mpi.comm, ctx, n);
                vex::mpi::vector<double> x2(mpi.comm, ctx, n);

                vex::mpi::vector<double> y0(mpi.comm, ctx, n);
                vex::mpi::vector<double> y1(mpi.comm, ctx, n);

                y0 = 1;
                y1 = 2;

                int the_answer = 42;

                vex::tie(x0, x1, x2) = std::tie(y1 - y0, y1 + y0, the_answer);

                rc = rc && x0[42] == 1;
                rc = rc && x1[42] == 3;
                rc = rc && x2[42] == 42;

                return rc;
                });
        run_test("Matrix-vector product", [&]() -> bool {
                const size_t n  = 1024;
                const size_t m  = 3;
                const size_t n2 = n * n;
                bool rc = true;

                size_t chunk_size  = (n2 + mpi.size - 1) / mpi.size;
                size_t chunk_start = chunk_size * mpi.rank;
                size_t chunk_end   = std::min(n2, chunk_start + chunk_size);

                chunk_size = chunk_end - chunk_start;

                auto part = mpi.restore_partitioning(chunk_size);

                std::vector<int>    row;
                std::vector<int>    col;
                std::vector<double> val;

                row.reserve(chunk_size + 1);
                col.reserve(5 * chunk_size);
                val.reserve(5 * chunk_size);

                row.push_back(0);

                for(size_t idx = part[mpi.rank]; idx < part[mpi.rank + 1]; ++idx) {
                    size_t i = idx % n;
                    size_t j = idx / n;

                    if (i == 0 || i + 1 == n || j == 0 || j + 1 == n) {
                        col.push_back(idx);
                        val.push_back(0);
                    } else {
                        col.push_back(idx - n);
                        val.push_back(-1);

                        col.push_back(idx - 1);
                        val.push_back(-1);

                        col.push_back(idx);
                        val.push_back(4.5);

                        col.push_back(idx + 1);
                        val.push_back(-1);

                        col.push_back(idx + n);
                        val.push_back(-1);
                    }

                    row.push_back(col.size());
                }

                vex::mpi::SpMat<double, int, int> A(mpi.comm, ctx,
                        chunk_size, chunk_size,
                        row.data(), col.data(), val.data()
                        );

                vex::mpi::vector<double> x(mpi.comm, ctx, chunk_size);
                vex::mpi::vector<double> y(mpi.comm, ctx, chunk_size);

                vex::mpi::multivector<double, m> mx(mpi.comm, ctx, chunk_size);
                vex::mpi::multivector<double, m> my(mpi.comm, ctx, chunk_size);

                x = 1;
                y = A * x;

                mx = std::make_tuple(1, 2, 3);
                my = A * mx;

                vex::mpi::Reductor<double, vex::MIN> min(mpi.comm, ctx);
                vex::mpi::Reductor<double, vex::MAX> max(mpi.comm, ctx);
                vex::mpi::Reductor<double, vex::SUM> sum(mpi.comm, ctx);

                rc = rc && min(y) == 0;
                rc = rc && max(y) == 0.5;
                rc = rc && sum(y) == 0.5 * (n - 2) * (n - 2);

                auto vmin = min(my);
                auto vmax = max(my);
                auto vsum = sum(my);

                for(size_t i = 0; i < m; ++i) {
                    rc = rc && vmin[i] == 0;
                    rc = rc && vmax[i] == 0.5 * (i + 1);
                    rc = rc && vsum[i] == 0.5 * (i + 1) * (n - 2) * (n - 2);
                }

                return rc;
                });

        run_test("Use element_index in mpi::vector expression", [&]() -> bool {
                const size_t n = 1024;
                bool rc = true;

                vex::mpi::vector<double> x(mpi.comm, ctx, n);

                auto part = mpi.restore_partitioning(n);

                x = vex::element_index(part[mpi.rank]);

                for (int i = 0; i < 100; ++i) {
                    size_t idx = rand() % n;
                    rc = rc && x[idx] == part[mpi.rank] + idx;
                }

                return rc;
                });

    } catch (const cl::Error &err) {
        std::cerr << "OpenCL error (" << mpi.rank << "): " << err << std::endl;
    } catch (const std::exception &err) {
        std::cerr << "Error (" << mpi.rank << "): " << err.what() << std::endl;
    }

    MPI_Finalize();
    return !all_passed;
}
Ejemplo n.º 5
0
void node_testmess(xml_data_node *node)
{
	xml_data_node *child_node;
	xml_attribute_node *attr_node;
	int result;

	pile_init(&command_pile);
	command_pool = pool_alloc_lib(NULL);

	memset(&new_command, 0, sizeof(new_command));
	command_count = 0;

	/* 'driver' attribute */
	attr_node = xml_get_attribute(node, "driver");
	if (!attr_node)
	{
		error_missingattribute("driver");
		return;
	}
	current_testcase.driver = attr_node->value;

	/* 'name' attribute */
	attr_node = xml_get_attribute(node, "name");
	current_testcase.name = attr_node ? attr_node->value : current_testcase.driver;

	/* 'bios' attribute */
	attr_node = xml_get_attribute(node, "bios");
	current_testcase.bios = attr_node ? attr_node->value : NULL;

	/* 'ramsize' attribute */
	attr_node = xml_get_attribute(node, "ramsize");
	current_testcase.ram = attr_node ? ram_parse_string(attr_node->value) : 0;

	/* 'wavwrite' attribute */
	attr_node = xml_get_attribute(node, "wavwrite");
	current_testcase.wavwrite = attr_node && (atoi(attr_node->value) != 0);

	/* 'enabled' attribute */
	attr_node = xml_get_attribute(node, "enabled");
	current_testcase.enabled = (!attr_node || atoi(attr_node->value)) ? TRUE : FALSE;

	/* report the beginning of the test case */
	report_testcase_begin(current_testcase.name);

	if (current_testcase.enabled)
	{
		current_testcase.commands = NULL;

		for (child_node = node->child; child_node; child_node = child_node->next)
		{
			if (!strcmp(child_node->name, "wait"))
				node_wait(child_node);
			else if (!strcmp(child_node->name, "input"))
				node_input(child_node);
			else if (!strcmp(child_node->name, "rawinput"))
				node_rawinput(child_node);
			else if (!strcmp(child_node->name, "switch"))
				node_switch(child_node);
			else if (!strcmp(child_node->name, "screenshot"))
				node_screenshot(child_node);
			else if (!strcmp(child_node->name, "checkblank"))
				node_checkblank(child_node);
			else if (!strcmp(child_node->name, "imagecreate"))
				node_imagecreate(child_node);
			else if (!strcmp(child_node->name, "imageload"))
				node_imageload(child_node);
			else if (!strcmp(child_node->name, "memverify"))
				node_memverify(child_node);
			else if (!strcmp(child_node->name, "imageverify"))
				node_imageverify(child_node);
			else if (!strcmp(child_node->name, "trace"))
				node_trace(child_node);
			else if (!strcmp(child_node->name, "reset"))
				node_soft_reset(child_node);
			else if (!strcmp(child_node->name, "hardreset"))
				node_hard_reset(child_node);
		}

		memset(&new_command, 0, sizeof(new_command));
		new_command.command_type = MESSTEST_COMMAND_END;
		if (!append_command())
		{
			error_outofmemory();
			return;
		}

		result = run_test(0, NULL);
	}
	else
	{
		/* report that the test case was skipped */
		report_message(MSG_INFO, "Test case skipped");
		result = 0;
	}

	report_testcase_ran(result);
	pile_delete(&command_pile);
	pool_free_lib(command_pool);
}
Ejemplo n.º 6
0
int main(int argc, char *argv[])
{
	struct weston_config *config;
	struct weston_config_section *section;
	const char *name;
	char *s;
	int r, b, i;
	int32_t n;
	uint32_t u;

	config = run_test(t0);
	assert(config);
	weston_config_destroy(config);

	config = run_test(t1);
	assert(config);
	section = weston_config_get_section(config, "mollusc", NULL, NULL);
	assert(section == NULL);

	section = weston_config_get_section(config, "foo", NULL, NULL);
	r = weston_config_section_get_string(section, "a", &s, NULL);
	assert(r == 0 && strcmp(s, "b") == 0);
	free(s);

	section = weston_config_get_section(config, "foo", NULL, NULL);
	r = weston_config_section_get_string(section, "b", &s, NULL);
	assert(r == -1 && errno == ENOENT && s == NULL);

	section = weston_config_get_section(config, "foo", NULL, NULL);
	r = weston_config_section_get_string(section, "name", &s, NULL);
	assert(r == 0 && strcmp(s, "Roy Batty") == 0);
	free(s);

	section = weston_config_get_section(config, "bar", NULL, NULL);
	r = weston_config_section_get_string(section, "a", &s, "boo");
	assert(r == -1 && errno == ENOENT && strcmp(s, "boo") == 0);
	free(s);

	section = weston_config_get_section(config, "bar", NULL, NULL);
	r = weston_config_section_get_int(section, "number", &n, 600);
	assert(r == 0 && n == 5252);

	section = weston_config_get_section(config, "bar", NULL, NULL);
	r = weston_config_section_get_int(section, "+++", &n, 700);
	assert(r == -1 && errno == ENOENT && n == 700);

	section = weston_config_get_section(config, "bar", NULL, NULL);
	r = weston_config_section_get_uint(section, "number", &u, 600);
	assert(r == 0 && u == 5252);

	section = weston_config_get_section(config, "bar", NULL, NULL);
	r = weston_config_section_get_uint(section, "+++", &u, 600);
	assert(r == -1 && errno == ENOENT && u == 600);

	section = weston_config_get_section(config, "bar", NULL, NULL);
	r = weston_config_section_get_bool(section, "flag", &b, 600);
	assert(r == 0 && b == 0);

	section = weston_config_get_section(config, "stuff", NULL, NULL);
	r = weston_config_section_get_bool(section, "flag", &b, -1);
	assert(r == 0 && b == 1);

	section = weston_config_get_section(config, "stuff", NULL, NULL);
	r = weston_config_section_get_bool(section, "bonk", &b, -1);
	assert(r == -1 && errno == ENOENT && b == -1);

	section = weston_config_get_section(config, "bucket", "color", "blue");
	r = weston_config_section_get_string(section, "contents", &s, NULL);
	assert(r == 0 && strcmp(s, "live crabs") == 0);
	free(s);

	section = weston_config_get_section(config, "bucket", "color", "red");
	r = weston_config_section_get_string(section, "contents", &s, NULL);
	assert(r == 0 && strcmp(s, "sand") == 0);
	free(s);

	section = weston_config_get_section(config, "bucket", "color", "pink");
	assert(section == NULL);
	r = weston_config_section_get_string(section, "contents", &s, "eels");
	assert(r == -1 && errno == ENOENT && strcmp(s, "eels") == 0);
	free(s);

	section = NULL;
	i = 0;
	while (weston_config_next_section(config, &section, &name))
		assert(strcmp(section_names[i++], name) == 0);
	assert(i == 5);

	weston_config_destroy(config);

	config = run_test(t2);
	assert(config == NULL);

	config = run_test(t3);
	assert(config == NULL);

	config = run_test(t4);
	assert(config == NULL);

	weston_config_destroy(NULL);
	assert(weston_config_next_section(NULL, NULL, NULL) == 0);

	section = weston_config_get_section(NULL, "bucket", NULL, NULL);
	assert(section == NULL);

	return 0;
}
Ejemplo n.º 7
0
void
compares_tests(void)
{
	test_fixture_start();

	fixture_setup(&setup);

	run_test(test_eq_compare_true);
	run_test(test_eq_compare_false);
	run_test(test_ne_compare_true);
	run_test(test_ne_compare_false);
	run_test(test_lt_compare_true);
	run_test(test_lt_compare_false);
	run_test(test_le_compare_true);
	run_test(test_le_compare_false);
	run_test(test_ge_compare_true);
	run_test(test_ge_compare_false);
	run_test(test_gt_compare_true);
	run_test(test_gt_compare_false);
	run_test(test_compares_prefer_numbers);
	run_test(test_compares_convert_string_to_numbers);
	run_test(test_leading_spaces_ok);
	run_test(test_trailing_spaces_ok);
	run_test(test_spaces_before_op_ok);
	run_test(test_spaces_after_op_ok);
	run_test(test_spaces_in_op_fail);
	run_test(test_wrong_op_fail);

	test_fixture_end();
}
Ejemplo n.º 8
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_DEFAULT_only_malloc_large_allocations_1_thread)
{
    run_test(MEMKIND_DEFAULT, 2 * MB, 10 * MB, 1, 1.0, 100);
}
Ejemplo n.º 9
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_DEFAULT_random_malloc80_free20_random_small_allocations_10_thread)
{
    run_test(MEMKIND_DEFAULT, 128, 15 * KB, 10, 0.8);
}
Ejemplo n.º 10
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_DEFAULT_only_malloc_small_allocations_1_thread)
{
    run_test(MEMKIND_DEFAULT, 128, 15 * KB, 1);
}
Ejemplo n.º 11
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_DEFAULT_only_malloc_medium_allocations_1_thread)
{
    run_test(MEMKIND_DEFAULT, 16 * KB, 1 * MB, 1);
}
Ejemplo n.º 12
0
static bool run_test(const char *cmd, struct test *test)
{
	char *output;
	FILE *outf;
	int status;

	if (test->done)
		return test->answer;

	if (test->depends) {
		size_t len;
		const char *deps = test->depends;
		char *dep;

		/* Space-separated dependencies, could be ! for inverse. */
		while ((len = strcspn(deps, " "))) {
			bool positive = true;
			if (deps[len]) {
				dep = strdup(deps);
				dep[len] = '\0';
			} else {
				dep = (char *)deps;
			}

			if (dep[0] == '!') {
				dep++;
				positive = false;
			}
			if (run_test(cmd, find_test(dep)) != positive) {
				test->answer = false;
				test->done = true;
				return test->answer;
			}
			deps += len;
			deps += strspn(deps, " ");
		}
	}

	outf = fopen(INPUT_FILE, "w");
	if (!outf)
		err(1, "creating %s", INPUT_FILE);

	fprintf(outf, "%s", PRE_BOILERPLATE);
	switch (test->style & ~(EXECUTE|MAY_NOT_COMPILE)) {
	case INSIDE_MAIN:
		fprintf(outf, "%s", MAIN_START_BOILERPLATE);
		fprintf(outf, "%s", test->fragment);
		fprintf(outf, "%s", MAIN_END_BOILERPLATE);
		break;
	case OUTSIDE_MAIN:
		fprintf(outf, "%s", test->fragment);
		fprintf(outf, "%s", MAIN_START_BOILERPLATE);
		fprintf(outf, "%s", MAIN_BODY_BOILERPLATE);
		fprintf(outf, "%s", MAIN_END_BOILERPLATE);
		break;
	case DEFINES_FUNC:
		fprintf(outf, "%s", test->fragment);
		fprintf(outf, "%s", MAIN_START_BOILERPLATE);
		fprintf(outf, "%s", USE_FUNC_BOILERPLATE);
		fprintf(outf, "%s", MAIN_BODY_BOILERPLATE);
		fprintf(outf, "%s", MAIN_END_BOILERPLATE);
		break;
	case DEFINES_EVERYTHING:
		fprintf(outf, "%s", test->fragment);
		break;
	default:
		abort();

	}
	fclose(outf);

	if (verbose > 1)
		if (system("cat " INPUT_FILE) == -1);

	if (test->link) {
		char *newcmd;
		newcmd = malloc(strlen(cmd) + strlen(" ")
				+ strlen(test->link) + 1);
		sprintf(newcmd, "%s %s", cmd, test->link);
		if (verbose > 1)
			printf("Extra link line: %s", newcmd);
		cmd = newcmd;
	}

	output = run(cmd, &status);
	if (status != 0 || strstr(output, "warning")) {
		if (verbose)
			printf("Compile %s for %s, status %i: %s\n",
			       status ? "fail" : "warning",
			       test->name, status, output);
		if ((test->style & EXECUTE) && !(test->style & MAY_NOT_COMPILE))
			errx(1, "Test for %s did not compile:\n%s",
			     test->name, output);
		test->answer = false;
		free(output);
	} else {
		/* Compile succeeded. */
		free(output);
		/* We run INSIDE_MAIN tests for sanity checking. */
		if ((test->style & EXECUTE) || (test->style & INSIDE_MAIN)) {
			output = run("./" OUTPUT_FILE, &status);
			if (!(test->style & EXECUTE) && status != 0)
				errx(1, "Test for %s failed with %i:\n%s",
				     test->name, status, output);
			if (verbose && status)
				printf("%s exited %i\n", test->name, status);
			free(output);
		}
		test->answer = (status == 0);
	}
	test->done = true;

	if (test->answer && test->overrides) {
		struct test *override = find_test(test->overrides);
		override->done = true;
		override->answer = true;
Ejemplo n.º 13
0
THD_FUNCTION(Thread1, arg) {

  (void)arg;

  /*
   * Activate the serial driver 0 using the driver default configuration.
   */
  sdStart(&SD1, NULL);

  /* Activate the ADC driver 1 using its config */
  adcStart(&ADCD1, &config);

  while (chnGetTimeout(&SD1, TIME_INFINITE)) {
    print(start_msg);
    chThdSleepMilliseconds(2000);

    /* Test 1 - 1ch1d, no circular */
    run_test(test_1_msg, 1, 1, false);
    
    /* Test 2 - 1ch8d, no circular */
    run_test(test_2_msg, 1, 8, false);
    
    /* Test 3 - 4chd1, no circular */
    run_test(test_3_msg, 4, 1, false);
    
    /* Test 4 - 4ch8d, no circular */
    run_test(test_4_msg, 4, 8, false);
    
    /* Test 5 - 1ch1d, circular */
    run_test(test_5_msg, 1, 1, true);
    
    /* Test 6 - 1ch8d, circular */
    run_test(test_6_msg, 1, 8, true);
    
    /* Test 7 - 4ch1d, circular */
    run_test(test_7_msg, 4, 1, true);
    
    /* Test 8 - 4ch8d, circular */
    run_test(test_8_msg, 4, 8, true);
    
    /* Test 9 - 1ch1d, synchronous */
    print(test_9_msg);
    cb_arg = 0;
    
    group.num_channels = 1;
    group.circular = false;
    group.end_cb = adc_callback;
    
    cb_expect = 1;
    
    adcConvert(&ADCD1, &group, buffer, 1);
    
    while (ADCD1.state == ADC_ACTIVE) ;
    
    sniprintf(out_string, 128, chn_fmt_string, group.channels[0]);
    print(out_string);
    
    sniprintf(out_string, 128, raw_fmt_string, buffer[0]); 
    print(out_string);
    
    buffer[0] = adcMSP430XAdjustTemp(&group, buffer[0]);
    
    sniprintf(out_string, 128, cooked_fmt_string, buffer[0]); 
    print(out_string);
    
    if (cb_arg == cb_expect) {
      print(success_string);
    }
    else {
      print(fail_string);
    }
  }
}
Ejemplo n.º 14
0
void	test_fixture_part1(void)
{
	test_fixture_start();
	run_test(test_ft_memset);
	run_test(test_ft_bzero);
	run_test(test_ft_memcpy);
	run_test(test_ft_memccpy);
	run_test(test_ft_memmove);
	run_test(test_ft_memchr);
	run_test(test_ft_memcmp);
	run_test(test_ft_strlen);
	run_test(test_ft_strdup);
	run_test(test_ft_strcpy);
	run_test(test_ft_strncpy);
	run_test(test_ft_strcat);
	run_test(test_ft_strncat);
	run_test(test_ft_strlcat);
	run_test(test_ft_strchr);
	run_test(test_ft_strrchr);
	run_test(test_ft_strstr);
	run_test(test_ft_strnstr);
	run_test(test_ft_strcmp);
	run_test(test_ft_strncmp);
	run_test(test_ft_atoi);
	run_test(test_ft_isalpha);
	run_test(test_ft_isdigit);
	run_test(test_ft_isalnum);
	run_test(test_ft_isascii);
	run_test(test_ft_isprint);
	run_test(test_ft_toupper);
	run_test(test_ft_tolower);
	test_fixture_end();
}
Ejemplo n.º 15
0
END_TEST

START_TEST(test_proto2_interrupt)
{
	run_test(0, PROTO_2, 10, 100, setup_asfds_proto2_interrupt);
}
Ejemplo n.º 16
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_DEFAULT_random_malloc80_free20_random_medium_allocations_1_thread)
{
    run_test(MEMKIND_DEFAULT, 16 * KB, 1 * MB, 1, 0.8);
}
Ejemplo n.º 17
0
END_TEST

START_TEST(test_proto2_interrupt_no_match)
{
	run_test(0, PROTO_2, 10, 5, setup_asfds_proto2_interrupt_no_match);
}
Ejemplo n.º 18
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_HBW_only_malloc_small_allocations_10_thread)
{
    run_test(MEMKIND_HBW, 128, 15 * KB, 10);
}
Ejemplo n.º 19
0
// ---- testing ------
//To compile: gcc eigen_decomp.c -lm
//The lm links with the math library so we can use sqrt
int main()
{
    run_test();
	return 0;
}
Ejemplo n.º 20
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_HBW_only_malloc_medium_allocations_10_thread)
{
    run_test(MEMKIND_HBW, 16 * KB, 1 * MB, 10);
}
Ejemplo n.º 21
0
void menu() {
	small_uint_t cmd;
	int full_duplex;

	printf(&debug, "Free memory: %d bytes\n", mem_available(&pool));

	printf(&debug, "Ethernet: %s",
			eth_get_carrier(&eth) ? "Cable OK" : "No cable");
	if (eth_get_speed(&eth, &full_duplex)) {
		printf(&debug, ", %s", full_duplex ? "Full Duplex" : "Half Duplex");
	}
	printf(&debug, ", %u interrupts\n", eth.intr);

	printf(&debug, "Transmit: %ld packets, %ld collisions, %ld errors\n",
			eth.netif.out_packets, eth.netif.out_collisions,
			eth.netif.out_errors);

	printf(&debug, "Receive: %ld packets, %ld errors, %ld lost\n",
			eth.netif.in_packets, eth.netif.in_errors, eth.netif.in_discards);

	printf(&debug, "\n  1. Transmit 1 packet");
	printf(&debug, "\n  2. Transmit 2 packets");
	printf(&debug, "\n  3. Transmit 8 packets");
	printf(&debug, "\n  4. Run send/receive test");
	printf(&debug, "\n  5. Packet size: %d bytes", packet_size);
	printf(&debug, "\n  6. Local loopback: %s",
			local_loop ? "Enabled" : "Disabled");
	puts(&debug, "\n\n");
	for (;;) {
		/* Ввод команды. */
		puts(&debug, "Command: ");
		while (peekchar (&debug) < 0)
			timer_delay(&timer, 50);
		cmd = getchar(&debug);
		putchar(&debug, '\n');

		if (cmd == '\n' || cmd == '\r')
			break;

		if (cmd == '1') {
			send_packets(1);
			break;
		}
		if (cmd == '2') {
			send_packets(2);
			break;
		}
		if (cmd == '3') {
			send_packets(8);
			break;
		}
		if (cmd == '4') {
			run_test();
			break;
		}
		if (cmd == '5') {
			try_again: printf(&debug, "Enter packet size (1-1518): ");
			packet_size = get_short(packet_size);
			if (packet_size <= 0 || packet_size > 1518) {
				printf(&debug, "Invalid value, try again.");
				goto try_again;
			}
			putchar(&debug, '\n');
			data_pattern = mem_realloc(data_pattern, packet_size);
			if (!data_pattern) {
				printf(&debug, "No memory for data_pattern\n");
				uos_halt(1);
			}
			int i;
			for (i = 0; i < packet_size; i++)
				data_pattern[i] = i;
			if (packet_size >= 6)
				memset(data_pattern, 0xFF, 6);
			if (packet_size >= 12)
				memcpy(data_pattern + 6, eth.netif.ethaddr, 6);
			break;
		}
		if (cmd == '6') {
			local_loop = !local_loop;
			eth_set_loop(&eth, local_loop);
			break;
		}
		if (cmd == CTL('E')) {
			/* Регистры Ethernet. */
			putchar(&debug, '\n');
			eth_debug(&eth, &debug);
			putchar(&debug, '\n');
			continue;
		}
		if (cmd == CTL('T')) {
			/* Список задач uOS. */
			printf(&debug, "\nFree memory: %u bytes\n\n", mem_available(&pool));
			task_print(&debug, 0);
			task_print(&debug, (task_t*) stack_console);
			task_print(&debug, (task_t*) stack_test);
			task_print(&debug, (task_t*) eth.stack);
			putchar(&debug, '\n');
			continue;
		}
	}
}
Ejemplo n.º 22
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_HBW_only_malloc_large_allocations_10_thread)
{
    run_test(MEMKIND_HBW, 2 * MB, 10 * MB, 10, 100);
}
Ejemplo n.º 23
0
int
main(int argc, char *argv[])
{
    int c;
    int test_loops = 1;
    int test_normal = FALSE;
    int test_optimize = FALSE;

    setlocale(LC_ALL, "");

    while ((c = getopt(argc, argv, "cf:h:l:norsx")) != -1) {
	switch (c) {
	case 'c':
	    continuous = TRUE;
	    break;
	case 'f':
	    foot_lines = atoi(optarg);
	    break;
	case 'h':
	    head_lines = atoi(optarg);
	    break;
	case 'l':
	    test_loops = atoi(optarg);
	    assert(test_loops >= 0);
	    break;
	case 'n':
	    test_normal = TRUE;
	    break;
	case 'o':
	    test_optimize = TRUE;
	    break;
	case 'r':
	    reverse_loops = TRUE;
	    break;
	case 's':
	    single_step = TRUE;
	    break;
	case 'x':
	    extend_corner = TRUE;
	    break;
	default:
	    usage();
	}
    }
    if (!test_normal && !test_optimize) {
	test_normal = TRUE;
	test_optimize = TRUE;
    }
#if USE_TRACE
    trace(TRACE_TIMES);
#endif

    CATCHALL(finish);		/* arrange interrupts to terminate */

    (void) initscr();		/* initialize the curses library */
    keypad(stdscr, TRUE);	/* enable keyboard mapping */
    (void) nonl();		/* tell curses not to do NL->CR/NL on output */
    (void) cbreak();		/* take input chars one at a time, no wait for \n */
    (void) noecho();		/* don't echo input */
    scrollok(stdscr, TRUE);

    while (test_loops-- > 0) {
	if (test_normal)
	    run_test(FALSE);
	if (test_optimize)
	    run_test(TRUE);
    }

    cleanup();			/* we're done */
    ExitProgram(EXIT_SUCCESS);
}
Ejemplo n.º 24
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_HBW_random_malloc80_free20_random_small_allocations_1_thread)
{
    run_test(MEMKIND_HBW, 128, 15 * KB, 1, 0.8);
}
Ejemplo n.º 25
0
int main (int argc, char **argv)
{

	int retval,cid,rapl_cid=-1,numcmp;
	int EventSet = PAPI_NULL;
	long long *values;
	int num_events=0;
	int code;
	char event_names[MAX_RAPL_EVENTS][PAPI_MAX_STR_LEN];
	char units[MAX_RAPL_EVENTS][PAPI_MIN_STR_LEN];
	int data_type[MAX_RAPL_EVENTS];
	int r,i, do_wrap = 0;
	const PAPI_component_info_t *cmpinfo = NULL;
	PAPI_event_info_t evinfo;
	long long before_time,after_time;
	double elapsed_time;

	/* Set TESTS_QUIET variable */
	tests_quiet( argc, argv );
	if ( argc > 1 )
		if ( strstr( argv[1], "-w" ) )
			do_wrap = 1;

	/* PAPI Initialization */
	retval = PAPI_library_init( PAPI_VER_CURRENT );
	if ( retval != PAPI_VER_CURRENT ) {
		test_fail(__FILE__, __LINE__,"PAPI_library_init failed\n",retval);
	}

	if (!TESTS_QUIET) {
		printf("Trying all RAPL events\n");
	}

	numcmp = PAPI_num_components();

	for(cid=0; cid<numcmp; cid++) {

		if ( (cmpinfo = PAPI_get_component_info(cid)) == NULL) {
			test_fail(__FILE__, __LINE__,"PAPI_get_component_info failed\n", 0);
		}

		if (strstr(cmpinfo->name,"rapl")) {

			rapl_cid=cid;

			if (!TESTS_QUIET) {
				printf("Found rapl component at cid %d\n",rapl_cid);
			}

			if (cmpinfo->disabled) {
				if (!TESTS_QUIET) {
					printf("RAPL component disabled: %s\n",
							cmpinfo->disabled_reason);
				} 
				test_skip(__FILE__,__LINE__,"RAPL component disabled",0);
			}
			break;
		}
	}

	/* Component not found */
	if (cid==numcmp) {
		test_skip(__FILE__,__LINE__,"No rapl component found\n",0);
	}

	/* Create EventSet */
	retval = PAPI_create_eventset( &EventSet );
	if (retval != PAPI_OK) {
		test_fail(__FILE__, __LINE__, 
				"PAPI_create_eventset()",retval);
	}

	/* Add all events */

	code = PAPI_NATIVE_MASK;

	r = PAPI_enum_cmp_event( &code, PAPI_ENUM_FIRST, rapl_cid );

	while ( r == PAPI_OK ) {

		retval = PAPI_event_code_to_name( code, event_names[num_events] );
		if ( retval != PAPI_OK ) {
			printf("Error translating %#x\n",code);
			test_fail( __FILE__, __LINE__, 
					"PAPI_event_code_to_name", retval );
		}

		retval = PAPI_get_event_info(code,&evinfo);
		if (retval != PAPI_OK) {
			test_fail( __FILE__, __LINE__,
					"Error getting event info\n",retval);
		}

		strncpy(units[num_events],evinfo.units,sizeof(units[0])-1);
		// buffer must be null terminated to safely use strstr operation on it below
		units[num_events][sizeof(units[0])-1] = '\0';

		data_type[num_events] = evinfo.data_type;

		retval = PAPI_add_event( EventSet, code );
		if (retval != PAPI_OK) {
			break; /* We've hit an event limit */
		}
		num_events++;

		r = PAPI_enum_cmp_event( &code, PAPI_ENUM_EVENTS, rapl_cid );
	}

	values=calloc(num_events,sizeof(long long));
	if (values==NULL) {
		test_fail(__FILE__, __LINE__, 
				"No memory",retval);
	}

	if (!TESTS_QUIET) {
		printf("\nStarting measurements...\n\n");
	}

	/* Start Counting */
	before_time=PAPI_get_real_nsec();
	retval = PAPI_start( EventSet);
	if (retval != PAPI_OK) {
		test_fail(__FILE__, __LINE__, "PAPI_start()",retval);
	}

	/* Run test */
	run_test(TESTS_QUIET);

	/* Stop Counting */
	after_time=PAPI_get_real_nsec();
	retval = PAPI_stop( EventSet, values);
	if (retval != PAPI_OK) {
		test_fail(__FILE__, __LINE__, "PAPI_stop()",retval);
	}

	elapsed_time=((double)(after_time-before_time))/1.0e9;

	if (!TESTS_QUIET) {
		printf("\nStopping measurements, took %.3fs, gathering results...\n\n",
				elapsed_time);

		printf("Scaled energy measurements:\n");

		for(i=0;i<num_events;i++) {
			if (strstr(units[i],"nJ")) {

				printf("%-40s%12.6f J\t(Average Power %.1fW)\n",
						event_names[i],
						(double)values[i]/1.0e9,
						((double)values[i]/1.0e9)/elapsed_time);
			}
		}

		printf("\n");
		printf("Energy measurement counts:\n");

		for(i=0;i<num_events;i++) {
			if (strstr(event_names[i],"ENERGY_CNT")) {
				printf("%-40s%12lld\t%#08llx\n", event_names[i], values[i], values[i]);
			}
		}

		printf("\n");
		printf("Scaled Fixed values:\n");

		for(i=0;i<num_events;i++) {
			if (!strstr(event_names[i],"ENERGY")) {
				if (data_type[i] == PAPI_DATATYPE_FP64) {

					union {
						long long ll;
						double fp;
					} result;

					result.ll=values[i];
					printf("%-40s%12.3f %s\n", event_names[i], result.fp, units[i]);
				}
			}
		}

		printf("\n");
		printf("Fixed value counts:\n");

		for(i=0;i<num_events;i++) {
			if (!strstr(event_names[i],"ENERGY")) {
				if (data_type[i] == PAPI_DATATYPE_UINT64) {
					printf("%-40s%12lld\t%#08llx\n", event_names[i], values[i], values[i]);
				}
			}
		}

	}

#ifdef WRAP_TEST
	double max_time;
	unsigned long long max_value = 0;
	int repeat;

	for(i=0;i<num_events;i++) {
		if (strstr(event_names[i],"ENERGY_CNT")) {
			if (max_value < (unsigned) values[i]) {
				max_value = values[i];
			}
		}
	}
	max_time = elapsed_time * (0xffffffff / max_value);
	printf("\n");
	printf ("Approximate time to energy measurement wraparound: %.3f sec or %.3f min.\n", 
			max_time, max_time/60);

	if (do_wrap) {
		printf ("Beginning wraparound execution.");
		/* Start Counting */
		before_time=PAPI_get_real_nsec();
		retval = PAPI_start( EventSet);
		if (retval != PAPI_OK) {
			test_fail(__FILE__, __LINE__, "PAPI_start()",retval);
		}

		/* Run test */
		repeat = (int)(max_time/elapsed_time);
		for (i=0;i< repeat;i++) {
			run_test(1);
			printf("."); fflush(stdout);
		}
		printf("\n");

		/* Stop Counting */
		after_time=PAPI_get_real_nsec();
		retval = PAPI_stop( EventSet, values);
		if (retval != PAPI_OK) {
			test_fail(__FILE__, __LINE__, "PAPI_stop()",retval);
		}

		elapsed_time=((double)(after_time-before_time))/1.0e9;
		printf("\nStopping measurements, took %.3fs\n\n", elapsed_time);

		printf("Scaled energy measurements:\n");

		for(i=0;i<num_events;i++) {
			if (strstr(units[i],"nJ")) {

				printf("%-40s%12.6f J\t(Average Power %.1fW)\n",
						event_names[i],
						(double)values[i]/1.0e9,
						((double)values[i]/1.0e9)/elapsed_time);
			}
		}
		printf("\n");
		printf("Energy measurement counts:\n");

		for(i=0;i<num_events;i++) {
			if (strstr(event_names[i],"ENERGY_CNT")) {
				printf("%-40s%12lld\t%#08llx\n", event_names[i], values[i], values[i]);
			}
		}
	}

#endif

	/* Done, clean up */
	retval = PAPI_cleanup_eventset( EventSet );
	if (retval != PAPI_OK) {
		test_fail(__FILE__, __LINE__, 
				"PAPI_cleanup_eventset()",retval);
	}

	retval = PAPI_destroy_eventset( &EventSet );
	if (retval != PAPI_OK) {
		test_fail(__FILE__, __LINE__, 
				"PAPI_destroy_eventset()",retval);
	}

	test_pass( __FILE__, NULL, 0 );

	return 0;
}
Ejemplo n.º 26
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_HBW_random_malloc80_free20_random_medium_allocations_10_thread)
{
    run_test(MEMKIND_HBW, 16 * KB, 1 * MB, 10, 0.8);
}
Ejemplo n.º 27
0
int main(int argc, char **argv)
{
   for (unsigned i = 0; i < NUM_RUNS; i++)
      run_test();
}
Ejemplo n.º 28
0
TEST_F(MemoryFootprintTest, test_TC_MEMKIND_HBW_random_malloc80_free20_random_large_allocations_10_thread)
{
    run_test(MEMKIND_HBW, 2 * MB, 10 * MB, 10, 0.8, 100);
}
Ejemplo n.º 29
0
static int run_one_test(int dropMode, int serverFinishedPermute, int serverHelloPermute, int clientFinishedPermute)
{
	int fnIdx = 0;
	int res, filterIdx;
	filter_fn* local_filters = full ? filters_full : filters;
	const char** local_filter_names = full ? filter_names_full : filter_names;
	const char** permutation_namesX = full ? permutation_names5 : permutation_names3;
	int filter_count = full ? 12 : 8;
	run_id = ((dropMode * 2 + serverFinishedPermute) * (full ? 120 : 6) + serverHelloPermute) * (full ? 120 : 6) + clientFinishedPermute;

	filter_clear_state();

	if (full) {
		filter_chain[fnIdx++] = filter_permute_ServerHelloFull;
		state_permute_ServerHelloFull.order = permutations5[serverHelloPermute];

		filter_chain[fnIdx++] = filter_permute_ClientFinishedFull;
		state_permute_ClientFinishedFull.order = permutations5[clientFinishedPermute];
	} else {
		filter_chain[fnIdx++] = filter_permute_ServerHello;
		state_permute_ServerHello.order = permutations3[serverHelloPermute];

		filter_chain[fnIdx++] = filter_permute_ClientFinished;
		state_permute_ClientFinished.order = permutations3[clientFinishedPermute];
	}

	filter_chain[fnIdx++] = filter_permute_ServerFinished;
	state_permute_ServerFinished.order = permutations2[serverFinishedPermute];

	if (dropMode) {
		for (filterIdx = 0; filterIdx < filter_count; filterIdx++) {
			if (dropMode & (1 << filterIdx)) {
				filter_chain[fnIdx++] = local_filters[filterIdx];
			}
		}
	}
	filter_chain[fnIdx++] = NULL;

	res = run_test();

	switch (res) {
		case 0:
			fprintf(stdout, "%i ++ ", run_id);
			break;
		case 1:
			fprintf(stdout, "%i -- ", run_id);
			break;
		case 2:
			fprintf(stdout, "%i !! ", run_id);
			break;
		case 3:
			fprintf(stdout, "%i TT ", run_id);
			break;
	}

	fprintf(stdout, "SHello(%s), ", permutation_namesX[serverHelloPermute]);
	fprintf(stdout, "SFinished(%s), ", permutation_names2[serverFinishedPermute]);
	fprintf(stdout, "CFinished(%s) :- ", permutation_namesX[clientFinishedPermute]);
	if (dropMode) {
		for (filterIdx = 0; filterIdx < filter_count; filterIdx++) {
			if (dropMode & (1 << filterIdx)) {
				if (dropMode & ((1 << filterIdx) - 1)) {
					fprintf(stdout, ", ");
				}
				fprintf(stdout, "%s", local_filter_names[filterIdx]);
			}
		}
	}
	fprintf(stdout, "\n");

	return res;
}
Ejemplo n.º 30
0
rc_t run_tests (void)
{
    VDBManager * mgr;
    rc_t rc;

    if (verbose)
        printf("%s call VDBManagerMakeUpdate\n", __func__);
    rc = VDBManagerMakeUpdate (&mgr, NULL);
    if (rc)
    {
        LOGERR (klogInt, rc, "Failed to open VDBManager");
        return rc;
    }
    else
    {
        VSchema  * schema;

        if (verbose)
            printf("%s call VDBManagerMakeSchema\n", __func__);
        rc = VDBManagerMakeSchema (mgr, &schema);
        printf("%s schema == %p\n", __func__, (void*)schema);
        if (rc)
            LOGERR (klogInt, rc, "Failed to make empty schema");
        else
        {
            if(verbose)
                printf("%s call VSchemaParseText\n", __func__);
            rc = VSchemaParseText (schema, "rowlen_schema", schema_text, string_size (schema_text));
            if (rc)
                LOGERR (klogInt, rc, "Failed to parse internal schema");
            else
            {
                int ix;

                for ( ix = 0; ix < 6; ++ix)
                {
                    VTable * table;
                    rc_t orc;

                    if (verbose)
                        printf("%s call open_table\n", __func__);
                    rc = open_table (mgr, schema, &table);
                    if (rc)
                    {
                        LOGERR (klogErr, rc, "Failed to open table");
                        break;
                    }

                    if (verbose)
                        printf("%s call run_test\n", __func__);
                    rc = run_test (table, &tests[ix]);
                    if (rc)
                    {
                        pLOGERR (klogErr, rc, "Failed $(D)", PLOG_S(D), tests[ix].test_name);
                    }

                    if (verbose)
                        printf("%s call VTableRelease\n", __func__);
                    orc = VTableRelease (table);
                    if (orc)
                    {
                        LOGERR (klogErr, rc, "failed to close table");
                    }
                    if (orc && (rc == 0))
                        rc = orc;
                    if (rc)
                        break;
                }
            }

            if (verbose)
                printf("%s call VSchemaRelease\n", __func__);
            VSchemaRelease (schema);
        }
        if (verbose)
            printf("%s call VDBManagerRelease\n", __func__);
        VDBManagerRelease (mgr);
    }
    return rc;
}