mirror of https://gitee.com/bigwinds/arangodb
removed tests for deleted functionality
This commit is contained in:
Jan Steemann
parent
13980ef299
commit
2690a611a6
|
|
@ -1,520 +0,0 @@
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test suite for TRI_associative_pointer_t
|
||||
///
|
||||
/// @file
|
||||
///
|
||||
/// DISCLAIMER
|
||||
///
|
||||
/// Copyright 2012 triagens GmbH, Cologne, Germany
|
||||
///
|
||||
/// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
/// you may not use this file except in compliance with the License.
|
||||
/// You may obtain a copy of the License at
|
||||
///
|
||||
/// http://www.apache.org/licenses/LICENSE-2.0
|
||||
///
|
||||
/// Unless required by applicable law or agreed to in writing, software
|
||||
/// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
/// See the License for the specific language governing permissions and
|
||||
/// limitations under the License.
|
||||
///
|
||||
/// Copyright holder is triAGENS GmbH, Cologne, Germany
|
||||
///
|
||||
/// @author Jan Steemann
|
||||
/// @author Copyright 2012, triAGENS GmbH, Cologne, Germany
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include "Basics/associative.h"
|
||||
#include "Basics/hashes.h"
|
||||
#include "Basics/tri-strings.h"
|
||||
#include "Basics/conversions.h"
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// --SECTION-- private macros
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
#define INIT_ASSOC \
|
||||
TRI_associative_pointer_t a1; \
|
||||
TRI_InitAssociativePointer(&a1, TRI_CORE_MEM_ZONE, TRI_HashStringKeyAssociativePointer, HashElement, IsEqualKeyElement, IsEqualElementElement);
|
||||
|
||||
#define DESTROY_ASSOC \
|
||||
TRI_DestroyAssociativePointer(&a1);
|
||||
|
||||
#define ELEMENT(name, k, v1, v2, v3) \
|
||||
data_container_t name; \
|
||||
name.key = k; \
|
||||
name.a = v1; \
|
||||
name.b = v2; \
|
||||
name.c = v3;
|
||||
|
||||
typedef struct data_container_s {
|
||||
char* key;
|
||||
int a;
|
||||
int b;
|
||||
int c;
|
||||
}
|
||||
data_container_t;
|
||||
|
||||
uint64_t HashElement (TRI_associative_pointer_t* a, void const* e) {
|
||||
data_container_s* element = (data_container_s*) e;
|
||||
|
||||
return TRI_FnvHashString(element->key);
|
||||
}
|
||||
|
||||
bool IsEqualKeyElement (TRI_associative_pointer_t* a, void const* k, void const* r) {
|
||||
data_container_s* element = (data_container_s*) r;
|
||||
|
||||
return TRI_EqualString((char*) k, element->key);
|
||||
}
|
||||
|
||||
bool IsEqualElementElement (TRI_associative_pointer_t* a, void const* l, void const* r) {
|
||||
data_container_s* left = (data_container_s*) l;
|
||||
data_container_s* right = (data_container_s*) r;
|
||||
|
||||
return TRI_EqualString(left->key, right->key);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// --SECTION-- private constants
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// --SECTION-- setup / tear-down
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
struct CAssociativePointerSetup {
|
||||
CAssociativePointerSetup () {
|
||||
BOOST_TEST_MESSAGE("setup TRI_associative_pointer_t");
|
||||
}
|
||||
|
||||
~CAssociativePointerSetup () {
|
||||
BOOST_TEST_MESSAGE("tear-down TRI_associative_pointer_t");
|
||||
}
|
||||
};
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// --SECTION-- test suite
|
||||
// -----------------------------------------------------------------------------
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief setup
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(CAssociativePointerTest, CAssociativePointerSetup)
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test sizes
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_size) {
|
||||
BOOST_CHECK_EQUAL((size_t) 8 + 6 * sizeof(void*), sizeof(TRI_associative_pointer_t));
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test initialization
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_init) {
|
||||
INIT_ASSOC
|
||||
|
||||
BOOST_CHECK_EQUAL((size_t) 0, a1._nrUsed);
|
||||
|
||||
DESTROY_ASSOC
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test unique insertion
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_insert_key_unique) {
|
||||
INIT_ASSOC
|
||||
|
||||
void* r = 0;
|
||||
|
||||
ELEMENT(e1, (char*) "test1", 1, 2, 3)
|
||||
BOOST_CHECK_EQUAL(r, TRI_InsertKeyAssociativePointer(&a1, e1.key, &e1, false));
|
||||
BOOST_CHECK_EQUAL((size_t) 1, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e1, TRI_LookupByKeyAssociativePointer(&a1, "test1"));
|
||||
|
||||
ELEMENT(e2, (char*) "test2", 2, 3, 4)
|
||||
BOOST_CHECK_EQUAL(r, TRI_InsertKeyAssociativePointer(&a1, e2.key, &e2, false));
|
||||
BOOST_CHECK_EQUAL((size_t) 2, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e2, TRI_LookupByKeyAssociativePointer(&a1, "test2"));
|
||||
|
||||
ELEMENT(e3, (char*) "test3", 99, 3, 5)
|
||||
BOOST_CHECK_EQUAL(r, TRI_InsertKeyAssociativePointer(&a1, e3.key, &e3, false));
|
||||
BOOST_CHECK_EQUAL((size_t) 3, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e3, TRI_LookupByKeyAssociativePointer(&a1, "test3"));
|
||||
|
||||
DESTROY_ASSOC
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test non-unique insertion
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_insert_key_nonunique) {
|
||||
INIT_ASSOC
|
||||
|
||||
void* r = 0;
|
||||
|
||||
ELEMENT(e1, (char*) "test1", 1, 2, 3)
|
||||
BOOST_CHECK_EQUAL(r, TRI_InsertKeyAssociativePointer(&a1, e1.key, &e1, false));
|
||||
BOOST_CHECK_EQUAL((size_t) 1, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e1, TRI_LookupByKeyAssociativePointer(&a1, "test1"));
|
||||
|
||||
ELEMENT(e2, (char*) "test1", 2, 3, 4)
|
||||
BOOST_CHECK_EQUAL(&e1, TRI_InsertKeyAssociativePointer(&a1, e2.key, &e2, false));
|
||||
BOOST_CHECK_EQUAL((size_t) 1, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e1, TRI_LookupByKeyAssociativePointer(&a1, "test1"));
|
||||
|
||||
ELEMENT(e3, (char*) "test2", 99, 3, 5)
|
||||
BOOST_CHECK_EQUAL(r, TRI_InsertKeyAssociativePointer(&a1, e3.key, &e3, false));
|
||||
BOOST_CHECK_EQUAL((size_t) 2, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e3, TRI_LookupByKeyAssociativePointer(&a1, "test2"));
|
||||
|
||||
ELEMENT(e4, (char*) "test1", 99, 3, 5)
|
||||
BOOST_CHECK_EQUAL(&e1, TRI_InsertKeyAssociativePointer(&a1, e4.key, &e4, false));
|
||||
BOOST_CHECK_EQUAL((size_t) 2, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e1, TRI_LookupByKeyAssociativePointer(&a1, "test1"));
|
||||
|
||||
ELEMENT(e5, (char*) "test2", -99, 33, 15)
|
||||
BOOST_CHECK_EQUAL(&e3, TRI_InsertKeyAssociativePointer(&a1, e5.key, &e5, false));
|
||||
BOOST_CHECK_EQUAL((size_t) 2, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e3, TRI_LookupByKeyAssociativePointer(&a1, "test2"));
|
||||
|
||||
DESTROY_ASSOC
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test non-unique insertion w/ overwrite
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_insert_key_nonunique_overwrite) {
|
||||
INIT_ASSOC
|
||||
|
||||
void* r = 0;
|
||||
|
||||
ELEMENT(e1, (char*) "test1", 1, 2, 3)
|
||||
BOOST_CHECK_EQUAL(r, TRI_InsertKeyAssociativePointer(&a1, e1.key, &e1, true));
|
||||
BOOST_CHECK_EQUAL((size_t) 1, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e1, TRI_LookupByKeyAssociativePointer(&a1, "test1"));
|
||||
|
||||
ELEMENT(e2, (char*) "test1", 2, 3, 4)
|
||||
BOOST_CHECK_EQUAL(&e1, TRI_InsertKeyAssociativePointer(&a1, e2.key, &e2, true));
|
||||
BOOST_CHECK_EQUAL((size_t) 1, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e2, TRI_LookupByKeyAssociativePointer(&a1, "test1"));
|
||||
|
||||
ELEMENT(e3, (char*) "test2", 99, 3, 5)
|
||||
BOOST_CHECK_EQUAL(r, TRI_InsertKeyAssociativePointer(&a1, e3.key, &e3, true));
|
||||
BOOST_CHECK_EQUAL((size_t) 2, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e3, TRI_LookupByKeyAssociativePointer(&a1, "test2"));
|
||||
|
||||
ELEMENT(e4, (char*) "test1", 99, 3, 5)
|
||||
BOOST_CHECK_EQUAL(&e2, TRI_InsertKeyAssociativePointer(&a1, e4.key, &e4, true));
|
||||
BOOST_CHECK_EQUAL((size_t) 2, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e4, TRI_LookupByKeyAssociativePointer(&a1, "test1"));
|
||||
|
||||
ELEMENT(e5, (char*) "test2", -99, 33, 15)
|
||||
BOOST_CHECK_EQUAL(&e3, TRI_InsertKeyAssociativePointer(&a1, e5.key, &e5, true));
|
||||
BOOST_CHECK_EQUAL((size_t) 2, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(&e5, TRI_LookupByKeyAssociativePointer(&a1, "test2"));
|
||||
|
||||
DESTROY_ASSOC
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test key lookup
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_lookup_key) {
|
||||
INIT_ASSOC
|
||||
|
||||
void* r = 0;
|
||||
|
||||
ELEMENT(e1, (char*) "test1", 1, 2, 3)
|
||||
TRI_InsertKeyAssociativePointer(&a1, e1.key, &e1, false);
|
||||
|
||||
ELEMENT(e2, (char*) "test2", 2, 3, 4)
|
||||
TRI_InsertKeyAssociativePointer(&a1, e2.key, &e2, false);
|
||||
|
||||
ELEMENT(e3, (char*) "test3", 3, 4, 5)
|
||||
TRI_InsertKeyAssociativePointer(&a1, e3.key, &e3, false);
|
||||
|
||||
ELEMENT(e4, (char*) "test4", 4, 5, 6)
|
||||
TRI_InsertKeyAssociativePointer(&a1, e4.key, &e4, false);
|
||||
|
||||
data_container_t* r1 = (data_container_t*) TRI_LookupByKeyAssociativePointer(&a1, "test1");
|
||||
BOOST_CHECK_EQUAL(&e1, r1);
|
||||
BOOST_CHECK_EQUAL("test1", r1->key);
|
||||
BOOST_CHECK_EQUAL(1, r1->a);
|
||||
BOOST_CHECK_EQUAL(2, r1->b);
|
||||
BOOST_CHECK_EQUAL(3, r1->c);
|
||||
|
||||
data_container_t* r2 = (data_container_t*) TRI_LookupByKeyAssociativePointer(&a1, "test2");
|
||||
BOOST_CHECK_EQUAL(&e2, r2);
|
||||
BOOST_CHECK_EQUAL("test2", r2->key);
|
||||
BOOST_CHECK_EQUAL(2, r2->a);
|
||||
BOOST_CHECK_EQUAL(3, r2->b);
|
||||
BOOST_CHECK_EQUAL(4, r2->c);
|
||||
|
||||
data_container_t* r3 = (data_container_t*) TRI_LookupByKeyAssociativePointer(&a1, "test3");
|
||||
BOOST_CHECK_EQUAL(&e3, r3);
|
||||
BOOST_CHECK_EQUAL("test3", r3->key);
|
||||
BOOST_CHECK_EQUAL(3, r3->a);
|
||||
BOOST_CHECK_EQUAL(4, r3->b);
|
||||
BOOST_CHECK_EQUAL(5, r3->c);
|
||||
|
||||
data_container_t* r4 = (data_container_t*) TRI_LookupByKeyAssociativePointer(&a1, "test4");
|
||||
BOOST_CHECK_EQUAL(&e4, r4);
|
||||
BOOST_CHECK_EQUAL("test4", r4->key);
|
||||
BOOST_CHECK_EQUAL(4, r4->a);
|
||||
BOOST_CHECK_EQUAL(5, r4->b);
|
||||
BOOST_CHECK_EQUAL(6, r4->c);
|
||||
|
||||
BOOST_CHECK_EQUAL(r, TRI_LookupByKeyAssociativePointer(&a1, "test0"));
|
||||
BOOST_CHECK_EQUAL(r, TRI_LookupByKeyAssociativePointer(&a1, "test5"));
|
||||
BOOST_CHECK_EQUAL(r, TRI_LookupByKeyAssociativePointer(&a1, "TEST1"));
|
||||
BOOST_CHECK_EQUAL(r, TRI_LookupByKeyAssociativePointer(&a1, "peng!"));
|
||||
|
||||
DESTROY_ASSOC
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test removal
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_remove_key) {
|
||||
INIT_ASSOC
|
||||
|
||||
void* r = 0;
|
||||
|
||||
ELEMENT(e1, (char*) "test1", 1, 2, 3)
|
||||
TRI_InsertKeyAssociativePointer(&a1, e1.key, &e1, false);
|
||||
|
||||
ELEMENT(e2, (char*) "test2", 2, 3, 4)
|
||||
TRI_InsertKeyAssociativePointer(&a1, e2.key, &e2, false);
|
||||
|
||||
ELEMENT(e3, (char*) "test3", 3, 4, 5)
|
||||
TRI_InsertKeyAssociativePointer(&a1, e3.key, &e3, false);
|
||||
|
||||
ELEMENT(e4, (char*) "test4", 4, 5, 6)
|
||||
TRI_InsertKeyAssociativePointer(&a1, e4.key, &e4, false);
|
||||
|
||||
data_container_t* r1 = (data_container_t*) TRI_RemoveKeyAssociativePointer(&a1, "test1");
|
||||
BOOST_CHECK_EQUAL(&e1, r1);
|
||||
BOOST_CHECK_EQUAL("test1", r1->key);
|
||||
BOOST_CHECK_EQUAL(1, r1->a);
|
||||
BOOST_CHECK_EQUAL(2, r1->b);
|
||||
BOOST_CHECK_EQUAL(3, r1->c);
|
||||
BOOST_CHECK_EQUAL((size_t) 3, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(r, TRI_LookupByKeyAssociativePointer(&a1, "test1"));
|
||||
|
||||
data_container_t* r2 = (data_container_t*) TRI_RemoveKeyAssociativePointer(&a1, "test2");
|
||||
BOOST_CHECK_EQUAL(&e2, r2);
|
||||
BOOST_CHECK_EQUAL("test2", r2->key);
|
||||
BOOST_CHECK_EQUAL(2, r2->a);
|
||||
BOOST_CHECK_EQUAL(3, r2->b);
|
||||
BOOST_CHECK_EQUAL(4, r2->c);
|
||||
BOOST_CHECK_EQUAL((size_t) 2, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(r, TRI_LookupByKeyAssociativePointer(&a1, "test2"));
|
||||
|
||||
data_container_t* rx1 = (data_container_t*) TRI_RemoveKeyAssociativePointer(&a1, "test2");
|
||||
BOOST_CHECK_EQUAL(r, rx1);
|
||||
BOOST_CHECK_EQUAL((size_t) 2, a1._nrUsed);
|
||||
|
||||
data_container_t* rx2 = (data_container_t*) TRI_RemoveKeyAssociativePointer(&a1, "test0");
|
||||
BOOST_CHECK_EQUAL(r, rx2);
|
||||
BOOST_CHECK_EQUAL((size_t) 2, a1._nrUsed);
|
||||
|
||||
data_container_t* r3 = (data_container_t*) TRI_RemoveKeyAssociativePointer(&a1, "test3");
|
||||
BOOST_CHECK_EQUAL(&e3, r3);
|
||||
BOOST_CHECK_EQUAL("test3", r3->key);
|
||||
BOOST_CHECK_EQUAL(3, r3->a);
|
||||
BOOST_CHECK_EQUAL(4, r3->b);
|
||||
BOOST_CHECK_EQUAL(5, r3->c);
|
||||
BOOST_CHECK_EQUAL((size_t) 1, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(r, TRI_LookupByKeyAssociativePointer(&a1, "test3"));
|
||||
|
||||
data_container_t* r4 = (data_container_t*) TRI_RemoveKeyAssociativePointer(&a1, "test4");
|
||||
BOOST_CHECK_EQUAL(&e4, r4);
|
||||
BOOST_CHECK_EQUAL("test4", r4->key);
|
||||
BOOST_CHECK_EQUAL(4, r4->a);
|
||||
BOOST_CHECK_EQUAL(5, r4->b);
|
||||
BOOST_CHECK_EQUAL(6, r4->c);
|
||||
BOOST_CHECK_EQUAL((size_t) 0, a1._nrUsed);
|
||||
BOOST_CHECK_EQUAL(r, TRI_LookupByKeyAssociativePointer(&a1, "test4"));
|
||||
|
||||
DESTROY_ASSOC
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test removal when empty
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_remove_key_empty) {
|
||||
INIT_ASSOC
|
||||
|
||||
void* r = 0;
|
||||
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveKeyAssociativePointer(&a1, "test1"));
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveKeyAssociativePointer(&a1, "test2"));
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveKeyAssociativePointer(&a1, "test3"));
|
||||
|
||||
DESTROY_ASSOC
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test mass insertion
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_mass_insert) {
|
||||
INIT_ASSOC
|
||||
|
||||
char key[40];
|
||||
void* r = 0;
|
||||
|
||||
for (size_t i = 1; i <= 1000; ++i) {
|
||||
char* num = TRI_StringUInt32((uint32_t) i);
|
||||
|
||||
memset(&key, 0, sizeof(key));
|
||||
strcpy(key, "test");
|
||||
strcat(key, num);
|
||||
TRI_FreeString(TRI_CORE_MEM_ZONE, num);
|
||||
|
||||
data_container_t* e = (data_container_t*) TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(data_container_t), false);
|
||||
e->key = TRI_DuplicateString(key);
|
||||
e->a = i;
|
||||
e->b = i + 1;
|
||||
e->c = i + 2;
|
||||
|
||||
BOOST_CHECK_EQUAL(r, TRI_InsertKeyAssociativePointer(&a1, e->key, e, false));
|
||||
BOOST_CHECK_EQUAL(i, a1._nrUsed);
|
||||
|
||||
data_container_t* s = (data_container_t*) TRI_LookupByKeyAssociativePointer(&a1, key);
|
||||
BOOST_CHECK_EQUAL(e, s);
|
||||
BOOST_CHECK_EQUAL((size_t) i, (size_t) s->a);
|
||||
BOOST_CHECK_EQUAL((size_t) i + 1, (size_t) s->b);
|
||||
BOOST_CHECK_EQUAL((size_t) i + 2, (size_t) s->c);
|
||||
BOOST_CHECK_EQUAL(key, s->key);
|
||||
}
|
||||
|
||||
// clean up memory
|
||||
for (size_t i = 0; i < a1._nrAlloc; ++i) {
|
||||
data_container_t* s = (data_container_t*) a1._table[i];
|
||||
|
||||
if (s) {
|
||||
// free element memory
|
||||
TRI_FreeString(TRI_CORE_MEM_ZONE, s->key);
|
||||
TRI_Free(TRI_CORE_MEM_ZONE, s);
|
||||
}
|
||||
}
|
||||
|
||||
DESTROY_ASSOC
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test mass insertion & removal
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_mass_insert_remove) {
|
||||
INIT_ASSOC
|
||||
|
||||
char key[40];
|
||||
void* r = 0;
|
||||
|
||||
// fill with 1000 elements
|
||||
for (size_t i = 1; i <= 1000; ++i) {
|
||||
char* num = TRI_StringUInt32((uint32_t) i);
|
||||
|
||||
memset(&key, 0, sizeof(key));
|
||||
strcpy(key, "test");
|
||||
strcat(key, num);
|
||||
TRI_FreeString(TRI_CORE_MEM_ZONE, num);
|
||||
|
||||
data_container_t* e = (data_container_t*) TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(data_container_t), false);
|
||||
e->key = TRI_DuplicateString(key);
|
||||
e->a = i;
|
||||
e->b = i + 1;
|
||||
e->c = i + 2;
|
||||
|
||||
BOOST_CHECK_EQUAL(r, TRI_InsertKeyAssociativePointer(&a1, e->key, e, false));
|
||||
BOOST_CHECK_EQUAL(i, a1._nrUsed);
|
||||
|
||||
data_container_t* s = (data_container_t*) TRI_LookupByKeyAssociativePointer(&a1, key);
|
||||
BOOST_CHECK_EQUAL(e, s);
|
||||
BOOST_CHECK_EQUAL((size_t) i, (size_t) s->a);
|
||||
BOOST_CHECK_EQUAL((size_t) i + 1, (size_t) s->b);
|
||||
BOOST_CHECK_EQUAL((size_t) i + 2, (size_t) s->c);
|
||||
BOOST_CHECK_EQUAL(key, s->key);
|
||||
}
|
||||
|
||||
|
||||
// remove 500 elements
|
||||
for (size_t i = 1; i <= 1000; i += 2) {
|
||||
char* num = TRI_StringUInt32((uint32_t) i);
|
||||
|
||||
memset(&key, 0, sizeof(key));
|
||||
strcpy(key, "test");
|
||||
strcat(key, num);
|
||||
TRI_FreeString(TRI_CORE_MEM_ZONE, num);
|
||||
|
||||
data_container_t* s = (data_container_t*) TRI_RemoveKeyAssociativePointer(&a1, key);
|
||||
if (s) {
|
||||
// free element memory
|
||||
TRI_FreeString(TRI_CORE_MEM_ZONE, s->key);
|
||||
TRI_Free(TRI_CORE_MEM_ZONE, s);
|
||||
}
|
||||
}
|
||||
BOOST_CHECK_EQUAL((size_t) 500, a1._nrUsed);
|
||||
|
||||
|
||||
// check remaining elements
|
||||
for (size_t i = 1; i <= 1000; ++i) {
|
||||
char* num = TRI_StringUInt32((uint32_t) i);
|
||||
|
||||
memset(&key, 0, sizeof(key));
|
||||
strcpy(key, "test");
|
||||
strcat(key, num);
|
||||
TRI_FreeString(TRI_CORE_MEM_ZONE, num);
|
||||
|
||||
data_container_t* s = (data_container_t*) TRI_LookupByKeyAssociativePointer(&a1, key);
|
||||
if (i % 2) {
|
||||
BOOST_REQUIRE_EQUAL(r, s);
|
||||
}
|
||||
else {
|
||||
BOOST_REQUIRE(s);
|
||||
BOOST_CHECK_EQUAL((size_t) i, (size_t) s->a);
|
||||
BOOST_CHECK_EQUAL((size_t) i + 1, (size_t) s->b);
|
||||
BOOST_CHECK_EQUAL((size_t) i + 2, (size_t) s->c);
|
||||
BOOST_CHECK_EQUAL(key, s->key);
|
||||
}
|
||||
}
|
||||
|
||||
// clean up memory
|
||||
for (size_t i = 0; i < a1._nrAlloc; ++i) {
|
||||
data_container_t* s = (data_container_t*) a1._table[i];
|
||||
|
||||
if (s) {
|
||||
// free element memory
|
||||
TRI_FreeString(TRI_CORE_MEM_ZONE, s->key);
|
||||
TRI_Free(TRI_CORE_MEM_ZONE, s);
|
||||
}
|
||||
}
|
||||
|
||||
DESTROY_ASSOC
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief generate tests
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END ()
|
||||
|
||||
// Local Variables:
|
||||
// mode: outline-minor
|
||||
// outline-regexp: "^\\(/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|// --SECTION--\\|/// @\\}\\)"
|
||||
// End:
|
||||
|
|
@ -448,75 +448,6 @@ BOOST_AUTO_TEST_CASE (tst_json_list_empty) {
|
|||
FREE_BUFFER
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test remove from array
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_remove_from_array_empty) {
|
||||
TRI_json_t* json = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
|
||||
|
||||
BOOST_CHECK_EQUAL(0ULL, TRI_LengthArrayJson(json));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 0));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 10));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 5));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 2));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 1));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 0));
|
||||
|
||||
FREE_JSON
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test remove from array
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_remove_from_array_nonempty1) {
|
||||
TRI_json_t* json = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
|
||||
TRI_PushBack3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, TRI_CreateNullJson(TRI_UNKNOWN_MEM_ZONE));
|
||||
TRI_PushBack3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, 3.5));
|
||||
|
||||
BOOST_CHECK_EQUAL(2ULL, TRI_LengthArrayJson(json));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 10));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 5));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 2));
|
||||
|
||||
BOOST_CHECK_EQUAL(true, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 1));
|
||||
BOOST_CHECK_EQUAL(static_cast<TRI_json_t*>(0), TRI_LookupArrayJson(json, 1));
|
||||
BOOST_CHECK_EQUAL(1ULL, TRI_LengthArrayJson(json));
|
||||
BOOST_CHECK_EQUAL(true, TRI_IsNullJson(TRI_LookupArrayJson(json, 0)));
|
||||
|
||||
BOOST_CHECK_EQUAL(true, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 0));
|
||||
BOOST_CHECK_EQUAL(0ULL, TRI_LengthArrayJson(json));
|
||||
BOOST_CHECK_EQUAL(static_cast<TRI_json_t*>(0), TRI_LookupArrayJson(json, 0));
|
||||
|
||||
FREE_JSON
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test remove from array
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_remove_from_array_nonempty2) {
|
||||
TRI_json_t* json = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
|
||||
TRI_PushBack3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, TRI_CreateNullJson(TRI_UNKNOWN_MEM_ZONE));
|
||||
TRI_PushBack3ArrayJson(TRI_UNKNOWN_MEM_ZONE, json, TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, 3.5));
|
||||
|
||||
BOOST_CHECK_EQUAL(2ULL, TRI_LengthArrayJson(json));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 10));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 5));
|
||||
BOOST_CHECK_EQUAL(false, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 2));
|
||||
|
||||
BOOST_CHECK_EQUAL(true, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 0));
|
||||
BOOST_CHECK_EQUAL(1ULL, TRI_LengthArrayJson(json));
|
||||
BOOST_CHECK_EQUAL(static_cast<TRI_json_t*>(0), TRI_LookupArrayJson(json, 1));
|
||||
BOOST_CHECK_EQUAL(true, TRI_IsNumberJson(TRI_LookupArrayJson(json, 0)));
|
||||
|
||||
BOOST_CHECK_EQUAL(true, TRI_DeleteArrayJson(TRI_UNKNOWN_MEM_ZONE, json, 0));
|
||||
BOOST_CHECK_EQUAL(0ULL, TRI_LengthArrayJson(json));
|
||||
BOOST_CHECK_EQUAL(static_cast<TRI_json_t*>(0), TRI_LookupArrayJson(json, 0));
|
||||
|
||||
FREE_JSON
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test json list mixed
|
||||
|
|
|
|||
|
|
@ -182,208 +182,6 @@ BOOST_AUTO_TEST_CASE (tst_compare_values_unequal) {
|
|||
JSON_CHECK(-1, TRI_CompareValuesJson, "1", "{}");
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test duplicate keys
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_duplicate_keys) {
|
||||
INIT_BUFFER
|
||||
|
||||
TRI_json_t* json;
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "[\"a\",\"a\"]");
|
||||
BOOST_CHECK_EQUAL(false, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{}");
|
||||
BOOST_CHECK_EQUAL(false, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":1}");
|
||||
BOOST_CHECK_EQUAL(false, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":1,\"b\":1}");
|
||||
BOOST_CHECK_EQUAL(false, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":1,\"b\":1,\"A\":1}");
|
||||
BOOST_CHECK_EQUAL(false, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":1,\"b\":1,\"a\":1}");
|
||||
BOOST_CHECK_EQUAL(true, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":1,\"b\":1,\"c\":1,\"d\":{},\"c\":1}");
|
||||
BOOST_CHECK_EQUAL(true, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":{}}");
|
||||
BOOST_CHECK_EQUAL(false, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":{\"a\":1}}");
|
||||
BOOST_CHECK_EQUAL(false, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":{\"a\":1,\"b\":1},\"b\":1}");
|
||||
BOOST_CHECK_EQUAL(false, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":{\"a\":1,\"b\":1,\"a\":3},\"b\":1}");
|
||||
BOOST_CHECK_EQUAL(true, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":{\"a\":1,\"b\":1,\"a\":3}}");
|
||||
BOOST_CHECK_EQUAL(true, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":{\"a\":{\"a\":{}}}}");
|
||||
BOOST_CHECK_EQUAL(false, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{\"a\":{\"a\":{\"a\":{},\"a\":2}}}");
|
||||
BOOST_CHECK_EQUAL(true, TRI_HasDuplicateKeyJson(json));
|
||||
FREE_JSON
|
||||
|
||||
FREE_BUFFER
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test hashing
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_json_hash_utf8) {
|
||||
TRI_json_t* json;
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "\"äöüßÄÖÜ€µ\"");
|
||||
BOOST_CHECK_EQUAL(17926322495289827824ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "\"코리아닷컴 메일알리미 서비스 중단안내 [안내] 개인정보취급방침 변경 안내 회사소개 | 광고안내 | 제휴안내 | 개인정보취급방침 | 청소년보호정책 | 스팸방지정책 | 사이버고객센터 | 약관안내 | 이메일 무단수집거부 | 서비스 전체보기\"");
|
||||
BOOST_CHECK_EQUAL(11647939066062684691ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "\"بان يأسف لمقتل لاجئين سوريين بتركيا المرزوقي يندد بعنف الأمن التونسي تنديد بقتل الجيش السوري مصورا تلفزيونيا 14 قتيلا وعشرات الجرحى بانفجار بالصومال\"");
|
||||
BOOST_CHECK_EQUAL(9773937585298648628ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "\"中华网以中国的市场为核心，致力为当地用户提供流动增值服务、网上娱乐及互联网服务。本公司亦推出网上游戏，及透过其门户网站提供包罗万有的网上产品及服务。\"");
|
||||
BOOST_CHECK_EQUAL(5348732066920102360ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test hashing
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_json_hash) {
|
||||
TRI_json_t* json;
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "null");
|
||||
BOOST_CHECK_EQUAL(6601085983368743140ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "false");
|
||||
BOOST_CHECK_EQUAL(13113042584710199672ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "true");
|
||||
BOOST_CHECK_EQUAL(6583304908937478053ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "0");
|
||||
BOOST_CHECK_EQUAL(12161962213042174405ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "123");
|
||||
BOOST_CHECK_EQUAL(3423744850239007323ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "\"\"");
|
||||
BOOST_CHECK_EQUAL(12638153115695167455ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "\" \"");
|
||||
BOOST_CHECK_EQUAL(560073664097094349ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "\"foobar\"");
|
||||
BOOST_CHECK_EQUAL(3770388817002598200ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "\"Foobar\"");
|
||||
BOOST_CHECK_EQUAL(6228943802847363544ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "\"FOOBAR\"");
|
||||
BOOST_CHECK_EQUAL(7710850877466186488ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "[]");
|
||||
BOOST_CHECK_EQUAL(13796666053062066497ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "[ null ]");
|
||||
BOOST_CHECK_EQUAL(12579909069687325360ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "[ 0 ]");
|
||||
BOOST_CHECK_EQUAL(10101894954932532065ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "[ false ]");
|
||||
BOOST_CHECK_EQUAL(4554324570636443940ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "[ \"false\" ]");
|
||||
BOOST_CHECK_EQUAL(295270779373686828ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "[ [ ] ]");
|
||||
BOOST_CHECK_EQUAL(3935687115999630221ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "[ { } ]");
|
||||
BOOST_CHECK_EQUAL(13595004369025342186ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "[ [ false, 0 ] ]");
|
||||
BOOST_CHECK_EQUAL(8026218647638185280ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{}");
|
||||
BOOST_CHECK_EQUAL(5737045748118630438ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
// the following hashes should be identical
|
||||
const uint64_t a = 5721494255658103046ULL;
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{ \"a\": \"1\", \"b\": \"2\" }");
|
||||
BOOST_CHECK_EQUAL(a, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{ \"b\": \"2\", \"a\": \"1\" }");
|
||||
BOOST_CHECK_EQUAL(a, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{ \"a\": \"2\", \"b\": \"1\" }");
|
||||
BOOST_CHECK_EQUAL(a, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{ \"a\": null, \"b\": \"1\" }");
|
||||
BOOST_CHECK_EQUAL(2549570315580563109ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{ \"b\": \"1\" }");
|
||||
BOOST_CHECK_EQUAL(5635413490308263533ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
|
||||
json = TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, "{ \"a\": 123, \"b\": [ ] }");
|
||||
BOOST_CHECK_EQUAL(9398364376493393319ULL, TRI_HashJson(json));
|
||||
FREE_JSON
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test hashing by attribute names
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -121,33 +121,6 @@ BOOST_AUTO_TEST_CASE (tst_length_insert) {
|
|||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test vector length after insertions & deletions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_length_insert_remove) {
|
||||
VECTOR_INIT
|
||||
VECTOR_DATA
|
||||
|
||||
TRI_PushBackVectorPointer(&v1, &p);
|
||||
BOOST_CHECK_EQUAL((size_t) 1, v1._length);
|
||||
|
||||
TRI_RemoveVectorPointer(&v1, 0);
|
||||
BOOST_CHECK_EQUAL((size_t) 0, v1._length);
|
||||
|
||||
TRI_PushBackVectorPointer(&v1, s);
|
||||
TRI_PushBackVectorPointer(&v1, s);
|
||||
BOOST_CHECK_EQUAL((size_t) 2, v1._length);
|
||||
|
||||
TRI_RemoveVectorPointer(&v1, 0);
|
||||
BOOST_CHECK_EQUAL((size_t) 1, v1._length);
|
||||
|
||||
TRI_RemoveVectorPointer(&v1, 0);
|
||||
BOOST_CHECK_EQUAL((size_t) 0, v1._length);
|
||||
|
||||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test vector length after clearing
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -166,50 +139,6 @@ BOOST_AUTO_TEST_CASE (tst_length_clear) {
|
|||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test removal of elements at invalid positions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_remove_invalid1) {
|
||||
VECTOR_INIT
|
||||
|
||||
void* r = 0;
|
||||
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveVectorPointer(&v1, 0)); // invalid position
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveVectorPointer(&v1, 0)); // invalid position
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveVectorPointer(&v1, 1)); // invalid position
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveVectorPointer(&v1, -1)); // invalid position
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveVectorPointer(&v1, 99)); // invalid position
|
||||
|
||||
BOOST_CHECK_EQUAL((size_t) 0, v1._length);
|
||||
|
||||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test removal of elements at invalid positions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_remove_invalid2) {
|
||||
VECTOR_INIT
|
||||
VECTOR_DATA
|
||||
|
||||
void* r = 0;
|
||||
|
||||
TRI_PushBackVectorPointer(&v1, &p);
|
||||
TRI_PushBackVectorPointer(&v1, s);
|
||||
|
||||
BOOST_CHECK_EQUAL(&p, TRI_RemoveVectorPointer(&v1, 0)); // valid
|
||||
BOOST_CHECK_EQUAL(s, TRI_RemoveVectorPointer(&v1, 0)); // valid
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveVectorPointer(&v1, 0)); // now invalid
|
||||
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveVectorPointer(&v1, 1)); // invalid position
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveVectorPointer(&v1, -1)); // invalid position
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveVectorPointer(&v1, 99)); // invalid position
|
||||
|
||||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test at
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -256,46 +185,6 @@ BOOST_AUTO_TEST_CASE (tst_at_insert) {
|
|||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test at and insert and remove
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_at_insert_remove) {
|
||||
VECTOR_INIT
|
||||
VECTOR_DATA2
|
||||
|
||||
void* r = 0;
|
||||
|
||||
TRI_PushBackVectorPointer(&v1, &a);
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 0));
|
||||
|
||||
TRI_RemoveVectorPointer(&v1, 0);
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 0));
|
||||
|
||||
TRI_PushBackVectorPointer(&v1, &b);
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 0));
|
||||
|
||||
TRI_PushBackVectorPointer(&v1, &c);
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 1));
|
||||
|
||||
TRI_RemoveVectorPointer(&v1, 0);
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 0));
|
||||
|
||||
TRI_PushBackVectorPointer(&v1, &d);
|
||||
TRI_PushBackVectorPointer(&v1, &a);
|
||||
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 2));
|
||||
|
||||
TRI_RemoveVectorPointer(&v1, 1);
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 1));
|
||||
|
||||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test duplicate pointers
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -322,139 +211,6 @@ BOOST_AUTO_TEST_CASE (tst_push_back_duplicate) {
|
|||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test duplicate pointers
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_remove_duplicate) {
|
||||
VECTOR_INIT
|
||||
VECTOR_DATA2
|
||||
|
||||
TRI_PushBackVectorPointer(&v1, &a);
|
||||
TRI_PushBackVectorPointer(&v1, &a);
|
||||
TRI_PushBackVectorPointer(&v1, &a);
|
||||
TRI_PushBackVectorPointer(&v1, &b);
|
||||
TRI_PushBackVectorPointer(&v1, &b);
|
||||
|
||||
BOOST_CHECK_EQUAL((size_t) 5, v1._length);
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 3));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 4));
|
||||
|
||||
TRI_RemoveVectorPointer(&v1, 4);
|
||||
TRI_RemoveVectorPointer(&v1, 0);
|
||||
TRI_RemoveVectorPointer(&v1, 1);
|
||||
BOOST_CHECK_EQUAL((size_t) 2, v1._length);
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 1));
|
||||
|
||||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test push back and remove
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_push_back_remove) {
|
||||
VECTOR_INIT
|
||||
VECTOR_DATA
|
||||
VECTOR_DATA2
|
||||
|
||||
TRI_PushBackVectorPointer(&v1, &a);
|
||||
TRI_PushBackVectorPointer(&v1, &b);
|
||||
TRI_PushBackVectorPointer(&v1, &c);
|
||||
TRI_PushBackVectorPointer(&v1, &d);
|
||||
TRI_PushBackVectorPointer(&v1, &a);
|
||||
TRI_PushBackVectorPointer(&v1, &b);
|
||||
TRI_PushBackVectorPointer(&v1, &c);
|
||||
TRI_PushBackVectorPointer(&v1, &d);
|
||||
TRI_PushBackVectorPointer(&v1, &a);
|
||||
TRI_PushBackVectorPointer(&v1, &a);
|
||||
TRI_PushBackVectorPointer(&v1, s);
|
||||
|
||||
BOOST_CHECK_EQUAL((size_t) 11, v1._length);
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 3));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 4));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 5));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 6));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 7));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 8));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 9));
|
||||
BOOST_CHECK_EQUAL(s, TRI_AtVectorPointer(&v1, 10));
|
||||
|
||||
BOOST_CHECK_EQUAL(&a, TRI_RemoveVectorPointer(&v1, 4));
|
||||
BOOST_CHECK_EQUAL((size_t) 10, v1._length);
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 3));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 4));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 5));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 6));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 7));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 8));
|
||||
BOOST_CHECK_EQUAL(s, TRI_AtVectorPointer(&v1, 9));
|
||||
|
||||
BOOST_CHECK_EQUAL(&a, TRI_RemoveVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL((size_t) 9, v1._length);
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 3));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 4));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 5));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 6));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 7));
|
||||
BOOST_CHECK_EQUAL(s, TRI_AtVectorPointer(&v1, 8));
|
||||
|
||||
BOOST_CHECK_EQUAL(s, TRI_RemoveVectorPointer(&v1, 8));
|
||||
BOOST_CHECK_EQUAL((size_t) 8, v1._length);
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 3));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 4));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 5));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 6));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 7));
|
||||
|
||||
BOOST_CHECK_EQUAL(&b, TRI_RemoveVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_RemoveVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL((size_t) 6, v1._length);
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 3));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 4));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 5));
|
||||
|
||||
BOOST_CHECK_EQUAL(&b, TRI_RemoveVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_RemoveVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL((size_t) 4, v1._length);
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 3));
|
||||
|
||||
BOOST_CHECK_EQUAL(&d, TRI_RemoveVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL((size_t) 3, v1._length);
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 2));
|
||||
|
||||
BOOST_CHECK_EQUAL(&a, TRI_RemoveVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&a, TRI_RemoveVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL((size_t) 1, v1._length);
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 0));
|
||||
|
||||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test insert
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -531,146 +287,6 @@ BOOST_AUTO_TEST_CASE (tst_insert) {
|
|||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test insert and remove
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_insert_remove) {
|
||||
VECTOR_INIT
|
||||
VECTOR_DATA2
|
||||
|
||||
void* r = 0;
|
||||
|
||||
TRI_InsertVectorPointer(&v1, &a, 0);
|
||||
TRI_InsertVectorPointer(&v1, &b, 4);
|
||||
TRI_InsertVectorPointer(&v1, &c, 8);
|
||||
TRI_InsertVectorPointer(&v1, &d, 12);
|
||||
|
||||
BOOST_CHECK_EQUAL((size_t) 13, v1._length);
|
||||
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 3));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 4));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 5));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 7));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 8));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 9));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 11));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 12));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 13));
|
||||
|
||||
BOOST_CHECK_EQUAL(&a, TRI_RemoveVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL((size_t) 12, v1._length);
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 3));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 4));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 6));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 7));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 8));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 10));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 11));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 12));
|
||||
|
||||
BOOST_CHECK_EQUAL(r, TRI_RemoveVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL((size_t) 11, v1._length);
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 3));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 4));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(&v1, 6));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 7));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 8));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(&v1, 10));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 11));
|
||||
|
||||
BOOST_CHECK_EQUAL(&d, TRI_RemoveVectorPointer(&v1, 10));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 10));
|
||||
BOOST_CHECK_EQUAL((size_t) 10, v1._length);
|
||||
|
||||
BOOST_CHECK_EQUAL(&c, TRI_RemoveVectorPointer(&v1, 6));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(&v1, 6));
|
||||
BOOST_CHECK_EQUAL((size_t) 9, v1._length);
|
||||
|
||||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test copy
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_copy) {
|
||||
VECTOR_INIT
|
||||
VECTOR_DATA2
|
||||
|
||||
void* r = 0;
|
||||
TRI_vector_pointer_t* v2;
|
||||
|
||||
TRI_InsertVectorPointer(&v1, &a, 0);
|
||||
TRI_InsertVectorPointer(&v1, &b, 1);
|
||||
TRI_InsertVectorPointer(&v1, &c, 2);
|
||||
TRI_InsertVectorPointer(&v1, &d, 3);
|
||||
|
||||
v2 = TRI_CopyVectorPointer(TRI_CORE_MEM_ZONE, &v1);
|
||||
|
||||
VECTOR_DESTROY
|
||||
|
||||
BOOST_CHECK_EQUAL((size_t) 4, v2->_length);
|
||||
BOOST_CHECK_EQUAL(&a, TRI_AtVectorPointer(v2, 0));
|
||||
BOOST_CHECK_EQUAL(&b, TRI_AtVectorPointer(v2, 1));
|
||||
BOOST_CHECK_EQUAL(&c, TRI_AtVectorPointer(v2, 2));
|
||||
BOOST_CHECK_EQUAL(&d, TRI_AtVectorPointer(v2, 3));
|
||||
BOOST_CHECK_EQUAL(r, TRI_AtVectorPointer(v2, 4));
|
||||
|
||||
TRI_FreeVectorPointer(v2->_memoryZone, v2);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test modifications
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_value_modifications) {
|
||||
VECTOR_INIT
|
||||
VECTOR_DATA2
|
||||
|
||||
TRI_vector_pointer_t* v2;
|
||||
|
||||
TRI_InsertVectorPointer(&v1, &a, 0);
|
||||
TRI_InsertVectorPointer(&v1, &b, 1);
|
||||
TRI_InsertVectorPointer(&v1, &c, 2);
|
||||
TRI_InsertVectorPointer(&v1, &d, 3);
|
||||
|
||||
BOOST_CHECK_EQUAL(1, *(int*) TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(2, *(int*) TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(3, *(int*) TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(4, *(int*) TRI_AtVectorPointer(&v1, 3));
|
||||
|
||||
v2 = TRI_CopyVectorPointer(TRI_CORE_MEM_ZONE, &v1);
|
||||
a = 99;
|
||||
b = 42;
|
||||
c = -1;
|
||||
d = 0;
|
||||
|
||||
BOOST_CHECK_EQUAL(99, *(int*) TRI_AtVectorPointer(&v1, 0));
|
||||
BOOST_CHECK_EQUAL(42, *(int*) TRI_AtVectorPointer(&v1, 1));
|
||||
BOOST_CHECK_EQUAL(-1, *(int*) TRI_AtVectorPointer(&v1, 2));
|
||||
BOOST_CHECK_EQUAL(0, *(int*) TRI_AtVectorPointer(&v1, 3));
|
||||
|
||||
VECTOR_DESTROY
|
||||
|
||||
BOOST_CHECK_EQUAL(99, *(int*) TRI_AtVectorPointer(v2, 0));
|
||||
BOOST_CHECK_EQUAL(42, *(int*) TRI_AtVectorPointer(v2, 1));
|
||||
BOOST_CHECK_EQUAL(-1, *(int*) TRI_AtVectorPointer(v2, 2));
|
||||
BOOST_CHECK_EQUAL(0, *(int*) TRI_AtVectorPointer(v2, 3));
|
||||
|
||||
TRI_FreeVectorPointer(v2->_memoryZone, v2);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief generate tests
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -130,31 +130,6 @@ BOOST_AUTO_TEST_CASE (tst_length_insert_remove) {
|
|||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test vector length after clearing
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOST_AUTO_TEST_CASE (tst_length_clear) {
|
||||
VECTOR_INIT
|
||||
|
||||
int p1 = 1;
|
||||
int p2 = 2;
|
||||
int p3 = 3;
|
||||
|
||||
TRI_PushBackVector(&v1, &p1);
|
||||
TRI_PushBackVector(&v1, &p2);
|
||||
TRI_PushBackVector(&v1, &p3);
|
||||
BOOST_CHECK_EQUAL((size_t) 3, TRI_LengthVector(&v1));
|
||||
|
||||
TRI_ClearVector(&v1);
|
||||
BOOST_CHECK_EQUAL((size_t) 0, TRI_LengthVector(&v1));
|
||||
|
||||
TRI_PushBackVector(&v1, &p2);
|
||||
BOOST_CHECK_EQUAL((size_t) 1, TRI_LengthVector(&v1));
|
||||
|
||||
VECTOR_DESTROY
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief test removal of elements at invalid positions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -18,7 +18,6 @@ if (USE_BOOST_UNITTESTS)
|
|||
Basics/json-test.cpp
|
||||
Basics/json-utilities-test.cpp
|
||||
Basics/hashes-test.cpp
|
||||
Basics/associative-pointer-test.cpp
|
||||
Basics/associative-multi-pointer-test.cpp
|
||||
Basics/associative-multi-pointer-nohashcache-test.cpp
|
||||
Basics/skiplist-test.cpp
|
||||
|
|
|
|||
Loading…
Reference in New Issue