static void test_double()
{
	printf ("Test double insertion\n");

	Trie *trie = test_insert (0, "", "root");
	succeed_if (trie, "could not insert into trie");

	Trie *t1 = test_insert (trie, "user/tests/simple", "t1");
	succeed_if (t1, "could not insert into trie");
	succeed_if (t1 == trie, "should be the same");

	// output_trie (trie);

	Trie *t2 = test_insert (trie, "user/tests/simple", "t2");
	succeed_if (t2, "could not insert into trie");
	succeed_if (t2 == trie, "should be not the same");

	// output_trie (trie);

	/* ... gets lost

	Trie *t3 = test_insert (trie, "user/tests/simple", "t3");
	succeed_if (t3, "could not insert into trie");
	succeed_if (t3 == trie, "should be not the same");

	// output_trie (trie);

	*/

	elektraTrieClose(trie, 0);
}
static void test_umlauts()
{
	printf ("Test umlauts trie\n");

	Trie *trie = test_insert (0, "user/umlauts/test", "slash");
	trie = test_insert (trie, "user/umlauts#test", "hash");
	trie = test_insert (trie, "user/umlauts test", "space");
	trie = test_insert (trie, "user/umlauts\200test", "umlauts");

	exit_if_fail (trie, "trie was not build up successfully");

	Key *searchKey = keyNew("user", KEY_END);
	Backend *backend = elektraTrieLookup(trie, searchKey);
	succeed_if (!backend, "there should be no backend");


	Key *mp = keyNew("user/umlauts/test", KEY_VALUE, "slash", KEY_END);
	keySetName(searchKey, "user/umlauts/test");
	backend = elektraTrieLookup(trie, searchKey);
	succeed_if (backend, "there should be a backend");
	compare_key(backend->mountpoint, mp);


	keySetName(searchKey, "user/umlauts#test");
	keySetName(mp, "user/umlauts#test");
	keySetString(mp, "hash");
	Backend *b2 = elektraTrieLookup(trie, searchKey);
	succeed_if (b2, "there should be a backend");
	succeed_if (backend != b2, "should be other backend");
	compare_key(b2->mountpoint, mp);


	keySetName(searchKey, "user/umlauts test");
	keySetName(mp, "user/umlauts test");
	keySetString(mp, "space");
	b2 = elektraTrieLookup(trie, searchKey);
	succeed_if (b2, "there should be a backend");
	succeed_if (backend != b2, "should be other backend");
	compare_key(b2->mountpoint, mp);

	keySetName(searchKey, "user/umlauts\200test");
	keySetName(mp, "user/umlauts\200test");
	keySetString(mp, "umlauts");
	b2 = elektraTrieLookup(trie, searchKey);
	succeed_if (b2, "there should be a backend");
	succeed_if (backend != b2, "should be other backend");
	compare_key(b2->mountpoint, mp);

	// output_trie(trie);

	elektraTrieClose(trie, 0);
	keyDel (mp);
	keyDel (searchKey);
}
Exemple #3
0
int main(){

  test_init();
  test_insert();
  printf("Tests finished");
  return 0;
}
int main(int argc, char *argv[])
{
    const char * test_server = (argc > 1 ? argv[1] : TEST_SERVER);
    mongo conn[1];
    char version[10];

    INIT_SOCKETS_FOR_WINDOWS;

    test_write_concern_finish( );

    CONN_CLIENT_TEST;

    ASSERT( conn->write_concern != (void*)0 );

    test_insert( conn );
    if( mongo_get_server_version( version ) != -1 && version[0] != '1' ) {
        test_write_concern_input( conn );
        test_update_and_remove( conn );
        test_batch_insert_with_continue( conn );
    }

    mongo_destroy( conn );
    test_write_concern_api();
    return 0;
}
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_all ()
{
   typedef typename ValueTraits::value_type value_type;
   static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
   value_cont_type values (6);
   for (int i = 0; i < 6; ++i)
      (&values[i])->value_ = random_init[i];
   typedef ContainerDefiner
      < value_type
      , value_traits<ValueTraits>
      , constant_time_size<value_type::constant_time_size>
      > definer_function;
   typedef typename definer_function::type multiset_type;
   {
      multiset_type testset(values.begin(), values.end());
      test::test_container(testset);
      testset.clear();
      testset.insert(values.begin(), values.end());
      test::test_common_unordered_and_associative_container(testset, values);
      testset.clear();
      testset.insert(values.begin(), values.end());
      test::test_associative_container(testset, values);
      testset.clear();
      testset.insert(values.begin(), values.end());
      test::test_non_unique_container(testset, values);
   }
   test_sort(values);
   test_insert(values);
   test_swap(values);
   test_find(values);
   test_impl();
   test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(values);
}
static void test_minimaltrie()
{
	printf ("Test minimal trie\n");

	Trie *trie = test_insert (0, "", "");
	Key *s = keyNew ("", KEY_END);
	Key *mp = keyNew ("", KEY_VALUE, "", KEY_END);

	succeed_if (elektraTrieLookup (trie, s), "trie should not be null");
	compare_key(elektraTrieLookup (trie, s)->mountpoint, mp);

	keySetName (s, "user");
	compare_key(elektraTrieLookup (trie, s)->mountpoint, mp);

	keySetName (s, "system");
	compare_key(elektraTrieLookup (trie, s)->mountpoint, mp);

	keySetName (s, "user/below");
	compare_key(elektraTrieLookup (trie, s)->mountpoint, mp);

	keySetName (s, "system/below");
	compare_key(elektraTrieLookup (trie, s)->mountpoint, mp);

	elektraTrieClose(trie, 0);
	keyDel (s);
	keyDel (mp);
}
void test_generic_set<ValueTraits, ContainerDefiner>::test_all()
{
   typedef typename ValueTraits::value_type value_type;
   static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
   std::vector<value_type> values (6);
   for (int i = 0; i < 6; ++i)
      values[i].value_ = random_init[i];

   typedef typename ContainerDefiner
      < value_type
      , value_traits<ValueTraits>
      , constant_time_size<value_type::constant_time_size>
      >::type set_type;
   {
      set_type testset(values.begin(), values.end());
      test::test_container(testset);
      testset.clear();
      testset.insert(values.begin(), values.end());
      test::test_common_unordered_and_associative_container(testset, values);
      testset.clear();
      testset.insert(values.begin(), values.end());
      test::test_associative_container(testset, values);
      testset.clear();
      testset.insert(values.begin(), values.end());
      test::test_unique_container(testset, values);
   }
   test_sort(values);
   test_insert(values);
   test_insert_advanced(values);
   test_swap(values);
   test_find(values);
   test_impl();
   test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(values);
}
int main() {
    mongo conn[1];
    char version[10];

    INIT_SOCKETS_FOR_WINDOWS;

    test_write_concern_finish( );

    if( mongo_client( conn, TEST_SERVER, 27017 ) != MONGO_OK ) {
        printf( "failed to connect\n" );
        exit( 1 );
    }

    ASSERT( conn->write_concern != (void*)0 );

    test_insert( conn );
    if( mongo_get_server_version( version ) != -1 && version[0] != '1' ) {
        test_write_concern_input( conn );
        test_update_and_remove( conn );
        test_batch_insert_with_continue( conn );
    }

    mongo_destroy( conn );
    return 0;
}
int main() {
  BTree *tree;
  BTree *find;
  int depth;
  char *array[11];
  
  array[0] = "5";
  array[1] = "1";
  array[2] = "6";
  array[3] = "9";
  array[4] = "0";
  array[5] = "4";
  array[6] = "3";
  array[7] = "8";
  array[8] = "2";
  array[9] = "7";
  array[10] = "4";
  
  tree = array_to_btree(array);
  /*print_preorder(tree);*/
  printLevelOrder(tree,5);
  depth  = btree_depth(tree);
  printf("d_array:%d\n", depth);
  find = btree_find(tree, "A");
  /*print_preorder(find);*/
  if(find == NULL){
    printf("Not found.\n");
  }else{
    printLevelOrder(find,5);
  }
  btree_free(tree);
  test_insert();
  return 0;
}
Exemple #10
0
int main(){
  int i;

  int a[] = {8, 2, 7, 9, 11, 3, 2, 6};


  BST_PTR t = bst_create();

  for(i=0; i<8; i++)
    bst_insert(t, a[i]);

  assert(bst_size(t) == 7);

  test_insert(t);

  test_contains(t);

  bst_inorder(t);

  bst_preorder(t);

  bst_postorder(t);

  bst_ith_smallest(t, 1)

  bst_size(t);

  bst_free(t);
}
int main()
{
	test_insert();
	test_lookup();
	test_remove();
	return 0;
}
static void test_emptyvalues()
{
	printf ("Test empty values in trie\n");

	Trie *trie = 0;
	trie = test_insert (trie, "user/umlauts/b/", "b");
	trie = test_insert (trie, "user/umlauts/a/", "a");
	trie = test_insert (trie, "user/umlauts/", "/");
	trie = test_insert (trie, "user/umlauts/c/", "c");
	trie = test_insert (trie, "user/", "u");

	exit_if_fail (trie, "trie was not build up successfully");

	// output_trie(trie);

	elektraTrieClose(trie, 0);
}
void test_insert( uint32_t num_nodes , uint32_t num_inserts , uint32_t num_duplicates , bool near )
{
  typedef Kokkos::UnorderedMap<uint32_t,uint32_t, Device> map_type;
  typedef Kokkos::UnorderedMap<const uint32_t,const uint32_t, Device> const_map_type;

  const uint32_t expected_inserts = (num_inserts + num_duplicates -1u) / num_duplicates;

  map_type map;
  map.rehash(num_nodes,false);

  if (near) {
    Impl::TestInsert<map_type,true> test_insert(map, num_inserts, num_duplicates);
    test_insert.testit();
  } else
  {
    Impl::TestInsert<map_type,false> test_insert(map, num_inserts, num_duplicates);
    test_insert.testit();
  }

  const bool print_list = false;
  if (print_list) {
    Kokkos::Impl::UnorderedMapPrint<map_type> f(map);
    f.apply();
  }

  const uint32_t map_size = map.size();

  ASSERT_FALSE( map.failed_insert());
  {
    EXPECT_EQ(expected_inserts, map_size);

    {
      uint32_t find_errors = 0;
      Impl::TestFind<const_map_type> test_find(map, num_inserts, num_duplicates);
      test_find.testit(find_errors);
      EXPECT_EQ( 0u, find_errors);
    }

    map.begin_erase();
    Impl::TestErase<map_type,false> test_erase(map, num_inserts, num_duplicates);
    test_erase.testit();
    map.end_erase();
    EXPECT_EQ(0u, map.size());
  }
}
Exemple #14
0
static void run_tests()
{
    test_misc();
    test_insert();
    test_remove();
    test_clear();
    test_extend();
    test_circular();
}
Exemple #15
0
int main(void){

  test_insert();
  test_insert_list3();

  printf("Success, no errors\n");

  return 0;
}
static void test_root()
{
	printf ("Test trie with root\n");

	Trie *trie = 0;
	trie = test_insert (trie, "", "root");
	trie = test_insert (trie, "user/tests/simple", "simple");

	exit_if_fail (trie, "trie was not build up successfully");

	Key *searchKey = keyNew("user", KEY_END);
	Key *rmp = keyNew("", KEY_VALUE, "root", KEY_END);
	Backend *backend = elektraTrieLookup(trie, searchKey);
	succeed_if (backend, "there should be the root backend");
	compare_key(backend->mountpoint, rmp);


	Key *mp = keyNew("user/tests/simple", KEY_VALUE, "simple", KEY_END);
	keySetName(searchKey, "user/tests/simple");
	backend = elektraTrieLookup(trie, searchKey);
	succeed_if (backend, "there should be a backend");
	compare_key(backend->mountpoint, mp);


	keySetName(searchKey, "user/tests/simple/below");
	Backend *b2 = elektraTrieLookup(trie, searchKey);
	succeed_if (b2, "there should be a backend");
	succeed_if (backend == b2, "should be same backend");
	compare_key(b2->mountpoint, mp);


	keySetName(searchKey, "user/tests/simple/deep/below");
	b2 = elektraTrieLookup(trie, searchKey);
	succeed_if (b2, "there should be a backend");
	succeed_if (backend == b2, "should be same backend");
	compare_key(b2->mountpoint, mp);

	// output_trie(trie);

	elektraTrieClose(trie, 0);
	keyDel (mp);
	keyDel (rmp);
	keyDel (searchKey);
}
Exemple #17
0
int
main()
{
	test_empty_rope();
	test_append();
	test_prepend();
	test_insert();
	test_erase();
	return 0;
}
Exemple #18
0
/* Program entry point */
int main(int argc, char **argv)
{
	cb_tree_t tree = cb_tree_make();

	printf("%d ", ++tnum); fflush(stdout);
	test_insert(&tree);

	printf("%d ", ++tnum); fflush(stdout);
	test_complete(&tree, sizeof(dict) / sizeof(const char *));

	printf("%d ", ++tnum); fflush(stdout);
	test_insert_dup(&tree);

	printf("%d ", ++tnum); fflush(stdout);
	test_contains(&tree);

	printf("%d ", ++tnum); fflush(stdout);
	test_delete(&tree);

	printf("%d ", ++tnum); fflush(stdout);
	cb_tree_clear(&tree);
	test_insert(&tree);
	test_complete(&tree, sizeof(dict) / sizeof(const char *));

	printf("%d ", ++tnum); fflush(stdout);
	test_delete_all(&tree);

	printf("%d ", ++tnum); fflush(stdout);
	test_complete(&tree, 0);

	printf("%d ", ++tnum); fflush(stdout);
	cb_tree_clear(&tree);
	test_empty(&tree);

	printf("%d ", ++tnum); fflush(stdout);
	test_insert(&tree);
	test_prefixes(&tree);

	cb_tree_clear(&tree);
	printf("ok\n");
	return 0;
}
void test_failed_insert( uint32_t num_nodes)
{
  typedef Kokkos::UnorderedMap<uint32_t,uint32_t, Device> map_type;

  map_type map(num_nodes);
  Impl::TestInsert<map_type> test_insert(map, 2u*num_nodes, 1u);
  test_insert.testit(false /*don't rehash on fail*/);
  Device::execution_space::fence();

  EXPECT_TRUE( map.failed_insert() );
}
int main() {
  test_push_back();
  test_emplace_back();
  test_insert_range();
  test_insert();
  test_emplace();
  test_insert_range2();
  test_insert_n();
  test_insert_n2();
  test_resize();
  test_resize_param();
}
Exemple #21
0
void test_insert (charT*, Traits*, Allocator*,
                  const StringTestCaseData<charT> &tdata)
{
    typedef std::basic_string<charT, Traits, Allocator> String;

    if (tdata.func_.which_ == Insert (iter_range)) {

        switch (tdata.func_.iter_id_) {

        // exercise possible overloads of the member function template
        // on common RandomAccessIterator types
#undef TEST
#define TEST(Iterator) do {                                                 \
        typedef typename String::Iterator Iter;                             \
        static const                                                        \
        InsertRangeOverload<String, Iter> rng;                              \
        test_insert ((charT*)0, (Traits*)0, (Allocator*)0, rng, tdata);     \
    } while (0)

        case StringIds::Pointer: TEST (pointer); break;
        case StringIds::ConstPointer: TEST (const_pointer); break;
        case StringIds::Iterator: TEST (iterator); break;
        case StringIds::ConstIterator: TEST (const_iterator); break;

        case StringIds::ReverseIterator: TEST (reverse_iterator); break;
        case StringIds::ConstReverseIterator: TEST (const_reverse_iterator);
            break;

        // exercise specializations of the member function template
        // on the required iterator categories
#undef TEST
#define TEST(Iterator) do {                                                 \
        typedef Iterator<charT> Iter;                                       \
        static const                                                        \
        InsertRange<String, Iter> rng;                                      \
        test_insert ((charT*)0, (Traits*)0, (Allocator*)0, rng, tdata);     \
    } while (0)

        case StringIds::Input: TEST (InputIter); break;
        case StringIds::Forward: TEST (ConstFwdIter); break;
        case StringIds::Bidir: TEST (ConstBidirIter); break;
        case StringIds::Random: TEST (ConstRandomAccessIter); break;

        default:
            rw_error (0, 0, __LINE__, "bad iterator id");
        }
    }
    else {
        // exercise ordinary overloads of the member function
        static const RangeBase<String> rng;
        test_insert ((charT*)0, (Traits*)0, (Allocator*)0, rng, tdata);
    }
}
Exemple #22
0
int
main(int argc, char **argv)
{
    int i;
    SQLLEN bytes_returned;

    /* do not allocate so big memory in stack */
    buf = (unsigned char *) malloc(TEST_BUF_LEN);

    odbc_connect();

    odbc_command("create table " TEST_TABLE_NAME " (im IMAGE)");
    odbc_command("SET TEXTSIZE 1000000");

    /* populate test buffer with ramp */
    for (i = 0; i < TEST_BUF_LEN; i++) {
        buf[i] = BYTE_AT(i);
    }

    /* insert test pattern into database */
    if (test_insert(buf, TEST_BUF_LEN) == -1) {
        clean_up();
        return -1;
    }

    memset(buf, 0, TEST_BUF_LEN);

    /* read test pattern from database */
    if (test_select(buf, TEST_BUF_LEN, &bytes_returned) == -1) {
        clean_up();
        return -1;
    }

    /* compare inserted and read back test patterns */
    if (bytes_returned != TEST_BUF_LEN) {
        show_error("main(): comparing buffers", "Mismatch in input and output pattern sizes.");
        clean_up();
        return -1;
    }

    for (i = 0; i < TEST_BUF_LEN; ++i) {
        if (buf[i] != BYTE_AT(i)) {
            printf("mismatch at pos %d %d != %d\n", i, buf[i], BYTE_AT(i));
            show_error("main(): comparing buffers", "Mismatch in input and output patterns.");
            clean_up();
            return -1;
        }
    }

    printf("Input and output buffers of length %d match.\nTest passed.\n", TEST_BUF_LEN);
    clean_up();
    return 0;
}
void test_deep_copy( uint32_t num_nodes )
{
  typedef Kokkos::UnorderedMap<uint32_t,uint32_t, Device> map_type;
  typedef Kokkos::UnorderedMap<const uint32_t, const uint32_t, Device> const_map_type;

  typedef typename map_type::HostMirror host_map_type ;
  // typedef Kokkos::UnorderedMap<uint32_t, uint32_t, typename Device::host_mirror_execution_space > host_map_type;

  map_type map;
  map.rehash(num_nodes,false);

  {
    Impl::TestInsert<map_type> test_insert(map, num_nodes, 1);
    test_insert.testit();
    ASSERT_EQ( map.size(), num_nodes);
    ASSERT_FALSE( map.failed_insert() );
    {
      uint32_t find_errors = 0;
      Impl::TestFind<map_type> test_find(map, num_nodes, 1);
      test_find.testit(find_errors);
      EXPECT_EQ( find_errors, 0u);
    }

  }

  host_map_type hmap;
  Kokkos::deep_copy(hmap, map);

  ASSERT_EQ( map.size(), hmap.size());
  ASSERT_EQ( map.capacity(), hmap.capacity());
  {
    uint32_t find_errors = 0;
    Impl::TestFind<host_map_type> test_find(hmap, num_nodes, 1);
    test_find.testit(find_errors);
    EXPECT_EQ( find_errors, 0u);
  }

  map_type mmap;
  Kokkos::deep_copy(mmap, hmap);

  const_map_type cmap = mmap;

  EXPECT_EQ( cmap.size(), num_nodes);

  {
    uint32_t find_errors = 0;
    Impl::TestFind<const_map_type> test_find(cmap, num_nodes, 1);
    test_find.testit(find_errors);
    EXPECT_EQ( find_errors, 0u);
  }

}
Exemple #24
0
int
main()
{
    BOOST_STATIC_ASSERT((!phx::stl::has_mapped_type<std::list<int> >::value));
    BOOST_STATIC_ASSERT((!phx::stl::has_key_type<std::list<int> >::value));

    std::list<int> const data = build_list();
    test_empty(data);
    test_end(data);
    test_erase(data);
    test_front(data);
    test_get_allocator(data);
    test_insert(data);
    test_max_size(data);
    return boost::report_errors();
}
Exemple #25
0
	virtual void run(void)
	{
		try
		{
			std::cout << "before" << std::endl;
			std::auto_ptr<SqlConnection> connection =
					dataSource_->getConnection();
			std::cout << "after" << std::endl;
			test_insert(*connection);
			//		test_insert(*connection);
			//		transaction->commit();
		} catch (SqlException& e)
		{
			std::cout << e.getMessage() << std::endl;
		}
	}
Exemple #26
0
} SDFV
# endif

main (int argc, char *argv[])
{
//   Func1();
   test_allocfree();
   test_member();
   test_nthchild();
// test_clone();
   test_fileio();
   test_assign();
//   test_error();
   test_insert();
// test_notify();
}
int
main()
{
    std::deque<int> const data = build_deque();
    test_insert(data);
    test_max_size(data);
    test_pop_back(data);
    test_pop_front(data);
    test_push_back(data);
    test_push_front(data);
    test_rbegin(data);
    test_rend(data);
    test_resize(data);
    test_size(data);
    return boost::report_errors();
}
Exemple #28
0
void test_slist(struct cag_test_series *tests)
{
	test_it(tests);
	test_new(tests);
	test_prepend(tests);
	test_insert(tests);
	test_insertp(tests);
	test_distance(tests);
	test_front(tests);
	test_erase(tests);
	test_copy(tests);
	test_reverse(tests);
	test_copy_over(tests);
	test_sort(tests);
	test_find(tests);
}
Exemple #29
0
int main(int args, char *arg[]) {

	list_t *list = NULL;
	list = test_create();
	test_insert(list);
	test_delete(list);
	test_examine(list);
	test_distroy(&list);
	list = test_create();	
	test_sorting(list);
	test_distroy(&list);
    test_concat_lists();
	test_merge_lists();
	test_reverse_lists();

	exit (EXIT_SUCCESS);
}
Exemple #30
0
/*
 * The main function just calls all unit tests and prints a summary
 * message (success or failure).
 *
 * \return zero on success.
 */
int main (int argc, char ** argv)
{
  int ok = 1;
  if (0 != test_append())
    ok = 0;
  if (0 != test_prepend())
    ok = 0;
  if (0 != test_insert())
    ok = 0;
  if (0 != test_remove())
    ok = 0;
  
  if (ok) {
    printf ("\nall tests PASSED\n");
    return 0;
  }
  printf ("\none or more tests FAILED\n");
  return 1;
}