i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor Kernel Util tests

Browse Source 
Change-Id: I4f5dbc664a621cdba3d928f2f358a73a07b71aa1
Reviewed-on: https://review.haiku-os.org/c/haiku/+/10671
Tested-by: Commit checker robot <[email protected]>
Reviewed-by: waddlesplash <[email protected]>
This commit is contained in:
Kacper Kasper
2026-04-06 20:03:08 +00:00
parent e05fd7f5a4
commit e4f18e3cf4
20 changed files with 2225 additions and 3273 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/tests/system/kernel/util/AVLTreeMapTest.cpp
+16 -25
View File
@@ -1,32 +1,23 @@
#include <AVLTreeMapTest.h> /*
#include <cppunit/Test.h> * Copyright 2003-2026, Haiku, Inc. All rights reserved.
#include <cppunit/TestCaller.h> * Distributed under the terms of the MIT License.
#include <cppunit/TestSuite.h> */
#include <stdio.h>
#include <TestUtils.h>
#include <TestSuiteAddon.h>
#include <cppunit/extensions/HelperMacros.h>
#include <AVLTreeMap.h> #include <AVLTreeMap.h>
AVLTreeMapTest::AVLTreeMapTest(std::string name)
: BTestCase(name)
{
}
CppUnit::Test* class AVLTreeMapTest : public CppUnit::TestFixture {
AVLTreeMapTest::Suite() CPPUNIT_TEST_SUITE(AVLTreeMapTest);
{ CPPUNIT_TEST(Test1);
CppUnit::TestSuite *suite = new CppUnit::TestSuite("AVLTreeMap"); CPPUNIT_TEST_SUITE_END();
suite->addTest(new CppUnit::TestCaller<AVLTreeMapTest>( public:
"SinglyLinkedList::User Strategy Test (default next parameter)", void Test1() {}
&AVLTreeMapTest::Test1)); };
return suite;
}
//! Test1
void
AVLTreeMapTest::Test1()
{
}
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(AVLTreeMapTest, getTestSuiteName());
src/tests/system/kernel/util/AVLTreeMapTest.h
-19
View File
@@ -1,19 +0,0 @@
#ifndef _avl_tree_map_test_h_
#define _avl_tree_map_test_h_
#include <TestCase.h>
class AVLTreeMapTest : public BTestCase {
public:
AVLTreeMapTest(std::string name = "");
static CppUnit::Test* Suite();
void Test1();
private:
template <class List>
void TestList(List &list, typename List::ValueType *values, int valueCount);
};
#endif // _avl_tree_map_test_h_
src/tests/system/kernel/util/BOpenHashTableTest.cpp
-399
View File
@@ -1,399 +0,0 @@
#include <cppunit/TestAssert.h>
#include <cppunit/TestCaller.h>
#include <cppunit/TestSuite.h>
#include <TestShell.h>
#include <os/support/ObjectList.h>
#include <shared/AutoDeleter.h>
#include <util/OpenHashTable.h>
#include "BOpenHashTableTest.h"
namespace {
class Entry {
public:
Entry(uint32_t value)
:
fValue(value),
fNext(NULL)
{
}
const uint32_t Value() const
{
return fValue;
}
Entry* Next() const
{
return fNext;
}
private:
uint32_t fValue;
Entry *fNext;
friend class EntryDefinition;
};
class EntryDefinition {
public:
typedef uint32_t KeyType;
typedef Entry ValueType;
size_t HashKey(const KeyType& key) const
{
return key;
}
size_t Hash(Entry* entry) const
{
return entry->fValue;
}
bool Compare(const KeyType& key, Entry* entry) const
{
return key == entry->fValue;
}
Entry*& GetLink(Entry* entry) const
{
return entry->fNext;
}
};
}
CppUnit::Test* BOpenHashTableTest::Suite()
{
CppUnit::TestSuite* suite = new CppUnit::TestSuite("BOpenHashTable");
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Insert test",
&BOpenHashTableTest::InsertTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Insert unchecked test",
&BOpenHashTableTest::InsertUncheckedTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Insert unchecked uninitialized test",
&BOpenHashTableTest::InsertUncheckedUninitializedTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Iterate and count test",
&BOpenHashTableTest::IterateAndCountTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Lookup test",
&BOpenHashTableTest::LookupTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Resize test",
&BOpenHashTableTest::ResizeTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Remove test",
&BOpenHashTableTest::RemoveTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Remove unchecked test",
&BOpenHashTableTest::RemoveUncheckedTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Remove when not present test",
&BOpenHashTableTest::RemoveWhenNotPresentTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Duplicate insert test",
&BOpenHashTableTest::DuplicateInsertTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Disable auto expand",
&BOpenHashTableTest::DisableAutoExpandTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Init with zero size",
&BOpenHashTableTest::InitWithZeroSizeTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Clear test",
&BOpenHashTableTest::ClearTest));
suite->addTest(new CppUnit::TestCaller<BOpenHashTableTest>(
"BOpenHashTable::Clear and return test",
&BOpenHashTableTest::ClearAndReturnTest));
return suite;
}
BOpenHashTableTest::BOpenHashTableTest(std::string name)
: BTestCase(name)
{
}
void BOpenHashTableTest::InsertTest()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
}
void BOpenHashTableTest::InsertUncheckedTest()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
table.InsertUnchecked(&entry);
}
void BOpenHashTableTest::InsertUncheckedUninitializedTest()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
table.InsertUnchecked(&entry);
}
void BOpenHashTableTest::IterateAndCountTest() {
const size_t kEntryCount = 20;
BObjectList<Entry, true> entries(20);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(kEntryCount * 2), B_OK);
for (uint32_t i = 0; i < kEntryCount; ++i) {
Entry* entry = new Entry(i);
entries.AddItem(entry);
CPPUNIT_ASSERT_EQUAL(table.Insert(entry), B_OK);
}
// Verify that the table contains the expected values.
uint64_t map = 0;
BOpenHashTable<EntryDefinition>::Iterator iterator = table.GetIterator();
while (iterator.HasNext()) {
Entry* entry = iterator.Next();
CPPUNIT_ASSERT_EQUAL(0, map & (1 << entry->Value()));
map |= (1 << entry->Value());
}
CPPUNIT_ASSERT_EQUAL(map, (1 << kEntryCount) - 1);
CPPUNIT_ASSERT_EQUAL(kEntryCount, table.CountElements());
}
void BOpenHashTableTest::ResizeTest()
{
// This is the same as IterateAndCountTest, except that the table will
// be resized mid insertion.
const size_t kEntryCount = 20;
BObjectList<Entry, true> entries(20);
BOpenHashTable<EntryDefinition> table;
// Start off with capacity for 8 elements. This will mean that the table
// will be resized in the loop below since we are inserting 20 elements.
CPPUNIT_ASSERT_EQUAL(table.Init(8), B_OK);
for (uint32_t i = 0; i < kEntryCount; ++i) {
Entry* entry = new Entry(i);
entries.AddItem(entry);
CPPUNIT_ASSERT_EQUAL(table.Insert(entry), B_OK);
}
// Verify that after resize the expected elements are present within
// the table.
uint64_t map = 0;
BOpenHashTable<EntryDefinition>::Iterator iterator = table.GetIterator();
while (iterator.HasNext()) {
Entry* entry = iterator.Next();
CPPUNIT_ASSERT_EQUAL(0, map & (1 << entry->Value()));
map |= (1 << entry->Value());
}
CPPUNIT_ASSERT_EQUAL(map, (1 << kEntryCount) - 1);
CPPUNIT_ASSERT_EQUAL(kEntryCount, table.CountElements());
}
void BOpenHashTableTest::LookupTest() {
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(0), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
}
void BOpenHashTableTest::RemoveTest() {
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(0), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
table.Remove(&entry);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), NULL);
}
void BOpenHashTableTest::RemoveUncheckedTest()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(0), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
table.RemoveUnchecked(&entry);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), NULL);
}
void BOpenHashTableTest::RemoveWhenNotPresentTest()
{
Entry entry1(123);
Entry entry2(456);
Entry entry3(789);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
// Only add the first two entries.
table.Insert(&entry1);
table.Insert(&entry2);
// entry3 is not in the table, but we'll remove it anyway.
table.Remove(&entry3);
table.RemoveUnchecked(&entry3);
// The original two entries should still be there.
CPPUNIT_ASSERT_EQUAL(table.CountElements(), 2);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry1);
CPPUNIT_ASSERT_EQUAL(table.Lookup(456), &entry2);
CPPUNIT_ASSERT_EQUAL(table.Lookup(789), NULL);
}
void BOpenHashTableTest::DuplicateInsertTest()
{
Entry entry(123);
BOpenHashTable<EntryDefinition, true, true> table;
CPPUNIT_ASSERT_EQUAL(table.Init(0), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
CPPUNIT_ASSERT_DEBUGGER(table.Insert(&entry));
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
// The item can basically never be removed now since there is a cycle,
// but we'll break into the debugger on remove when that happens as well.
CPPUNIT_ASSERT_DEBUGGER(table.Remove(&entry));
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
CPPUNIT_ASSERT_DEBUGGER(table.Remove(&entry));
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
}
void BOpenHashTableTest::DisableAutoExpandTest()
{
// Insert multiple items into a table with a fixed size of 1. This
// essentially turns this BOpenHashTable into a linked list, since resize
// will never occur.
Entry entry1(123);
Entry entry2(456);
BOpenHashTable<EntryDefinition, false> table;
CPPUNIT_ASSERT_EQUAL(table.Init(1), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry1), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry2), B_OK);
CPPUNIT_ASSERT_EQUAL(table.CountElements(), 2);
}
void BOpenHashTableTest::InitWithZeroSizeTest()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(0), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
}
void BOpenHashTableTest::ClearTest()
{
const size_t kEntryCount = 3;
BObjectList<Entry, true> entries(20);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
for (uint32_t i = 0; i < kEntryCount; ++i) {
Entry* entry = new Entry(i);
entries.AddItem(entry);
CPPUNIT_ASSERT_EQUAL(table.Insert(entry), B_OK);
}
CPPUNIT_ASSERT_EQUAL(table.CountElements(), kEntryCount);
CPPUNIT_ASSERT(table.Lookup(2) != NULL);
CPPUNIT_ASSERT_EQUAL(table.Clear(false), NULL);
CPPUNIT_ASSERT_EQUAL(table.CountElements(), 0);
CPPUNIT_ASSERT_EQUAL(table.Lookup(2), NULL);
CPPUNIT_ASSERT_EQUAL(table.GetIterator().HasNext(), false);
}
void BOpenHashTableTest::ClearAndReturnTest()
{
// Same as ClearTest(), except that Clear(true) is called, which tells
// the BOpenHashTable<T> to return a linked list of entries before clearing
// the table.
const size_t kEntryCount = 3;
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
for (uint32_t i = 0; i < kEntryCount; ++i) {
Entry* entry = new Entry(i);
CPPUNIT_ASSERT_EQUAL(table.Insert(entry), B_OK);
}
CPPUNIT_ASSERT_EQUAL(table.CountElements(), kEntryCount);
CPPUNIT_ASSERT(table.Lookup(2) != NULL);
Entry* head = table.Clear(true);
CPPUNIT_ASSERT(head != NULL);
CPPUNIT_ASSERT_EQUAL(table.CountElements(), 0);
CPPUNIT_ASSERT_EQUAL(table.Lookup(2), NULL);
CPPUNIT_ASSERT_EQUAL(table.GetIterator().HasNext(), false);
size_t items_returned = 0;
while (head != NULL) {
Entry* next = head->Next();
delete head;
head = next;
++items_returned;
}
CPPUNIT_ASSERT_EQUAL(items_returned, kEntryCount);
}
src/tests/system/kernel/util/BOpenHashTableTest.h
-28
View File
@@ -1,28 +0,0 @@
#ifndef BOPENHASHTABLE_TEST_H
#define BOPENHASHTABLE_TEST_H
#include <TestCase.h>
class BOpenHashTableTest : public BTestCase {
public:
BOpenHashTableTest(std::string name = "");
void InsertTest();
void InsertUncheckedTest();
void InsertUncheckedUninitializedTest();
void IterateAndCountTest();
void ResizeTest();
void LookupTest();
void RemoveTest();
void RemoveUncheckedTest();
void RemoveWhenNotPresentTest();
void DuplicateInsertTest();
void DisableAutoExpandTest();
void InitWithZeroSizeTest();
void ClearTest();
void ClearAndReturnTest();
static CppUnit::Test* Suite();
};
#endif // BOPENHASHTABLE_TEST_H
src/tests/system/kernel/util/BitmapTest.cpp
+59 -60
View File
@@ -1,32 +1,70 @@
#include <cppunit/Test.h> /*
#include <cppunit/TestCaller.h> * Copyright 2022-2026, Haiku, Inc. All rights reserved.
#include <cppunit/TestSuite.h> * Distributed under the terms of the MIT License.
#include <stdio.h> */
#include <TestUtils.h>
#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include <TestSuiteAddon.h>
#include "BitmapTest.h"
#include "Bitmap.h" #include "Bitmap.h"
BitmapTest::BitmapTest(std::string name)
: BTestCase(name) class BitmapTest : public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(BitmapTest);
CPPUNIT_TEST(Shift_CorrectBitSet);
CPPUNIT_TEST(Multielement_Shift_CorrectBitSet);
CPPUNIT_TEST(Resize_CorrectBitSet);
CPPUNIT_TEST_SUITE_END();
public:
void Shift_CorrectBitSet()
{ {
BKernel::Bitmap bitmap(20);
bitmap.Set(6);
CPPUNIT_ASSERT(bitmap.Get(6));
CPPUNIT_ASSERT(!bitmap.Get(5));
CPPUNIT_ASSERT(!bitmap.Get(7));
bitmap.Shift(10);
CPPUNIT_ASSERT(bitmap.Get(16));
CPPUNIT_ASSERT(!bitmap.Get(15));
CPPUNIT_ASSERT(!bitmap.Get(17));
CPPUNIT_ASSERT(!bitmap.Get(6));
bitmap.Shift(-9);
CPPUNIT_ASSERT(bitmap.Get(7));
CPPUNIT_ASSERT(!bitmap.Get(6));
CPPUNIT_ASSERT(!bitmap.Get(8));
CPPUNIT_ASSERT(!bitmap.Get(16));
} }
CppUnit::Test* void Multielement_Shift_CorrectBitSet() {
BitmapTest::Suite() BKernel::Bitmap bitmap(200);
{ bitmap.Set(7);
CppUnit::TestSuite *suite = new CppUnit::TestSuite("Bitmap");
suite->addTest(new CppUnit::TestCaller<BitmapTest>("Bitmap::Resize test", CPPUNIT_ASSERT(bitmap.Get(7));
&BitmapTest::ResizeTest)); CPPUNIT_ASSERT(!bitmap.Get(6));
suite->addTest(new CppUnit::TestCaller<BitmapTest>("Bitmap::Shift test",
&BitmapTest::ShiftTest));
return suite; bitmap.Shift(100);
CPPUNIT_ASSERT(!bitmap.Get(7));
CPPUNIT_ASSERT(bitmap.Get(107));
CPPUNIT_ASSERT(!bitmap.Get(106));
bitmap.Shift(-100);
CPPUNIT_ASSERT(bitmap.Get(7));
CPPUNIT_ASSERT(!bitmap.Get(107));
CPPUNIT_ASSERT(!bitmap.Get(6));
} }
void void Resize_CorrectBitSet()
BitmapTest::ResizeTest()
{ {
BKernel::Bitmap bitmap(10); BKernel::Bitmap bitmap(10);
bitmap.Set(6); bitmap.Set(6);
@@ -50,46 +88,7 @@ BitmapTest::ResizeTest()
CPPUNIT_ASSERT(bitmap.Get(199)); CPPUNIT_ASSERT(bitmap.Get(199));
CPPUNIT_ASSERT(!bitmap.Get(198)); CPPUNIT_ASSERT(!bitmap.Get(198));
} }
};
void
BitmapTest::ShiftTest()
{
BKernel::Bitmap bitmap(20);
bitmap.Set(6);
CPPUNIT_ASSERT(bitmap.Get(6)); CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(BitmapTest, getTestSuiteName());
CPPUNIT_ASSERT(!bitmap.Get(5));
CPPUNIT_ASSERT(!bitmap.Get(7));
bitmap.Shift(10);
CPPUNIT_ASSERT(bitmap.Get(16));
CPPUNIT_ASSERT(!bitmap.Get(15));
CPPUNIT_ASSERT(!bitmap.Get(17));
CPPUNIT_ASSERT(!bitmap.Get(6));
bitmap.Shift(-9);
CPPUNIT_ASSERT(bitmap.Get(7));
CPPUNIT_ASSERT(!bitmap.Get(6));
CPPUNIT_ASSERT(!bitmap.Get(8));
CPPUNIT_ASSERT(!bitmap.Get(16));
// Now test cross-element shifting.
bitmap.Resize(200);
CPPUNIT_ASSERT(bitmap.Get(7));
CPPUNIT_ASSERT(!bitmap.Get(6));
bitmap.Shift(100);
CPPUNIT_ASSERT(!bitmap.Get(7));
CPPUNIT_ASSERT(bitmap.Get(107));
CPPUNIT_ASSERT(!bitmap.Get(106));
bitmap.Shift(-100);
CPPUNIT_ASSERT(bitmap.Get(7));
CPPUNIT_ASSERT(!bitmap.Get(107));
CPPUNIT_ASSERT(!bitmap.Get(6));
}
src/tests/system/kernel/util/BitmapTest.h
-16
View File
@@ -1,16 +0,0 @@
#ifndef _bitmap_test_h_
#define _bitmap_test_h_
#include <TestCase.h>
class BitmapTest : public BTestCase {
public:
BitmapTest(std::string name = "");
static CppUnit::Test* Suite();
void ResizeTest();
void ShiftTest();
};
#endif // _bitmap_test_h_
src/tests/system/kernel/util/DoublyLinkedListTest.cpp
+78 -126
View File
@@ -1,14 +1,13 @@
/* /*
** Copyright 2003-2004, Axel Dörfler, [email protected]. All rights reserved. * Copyright 2003-2004, Axel Dörfler, [email protected]. All rights reserved.
** Distributed under the terms of the MIT License. * Copyright 2026, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/ */
#include "DoublyLinkedListTest.h" #include <TestSuiteAddon.h>
#include <cppunit/TestCaller.h>
#include <cppunit/TestSuite.h>
#include <TestUtils.h> #include <TestUtils.h>
#include <cppunit/extensions/HelperMacros.h>
#include <util/DoublyLinkedList.h> #include <util/DoublyLinkedList.h>
@@ -20,6 +19,7 @@ class ItemWithout {
int32 value; int32 value;
}; };
// Class used for testing with offset // Class used for testing with offset
class ItemWith { class ItemWith {
public: public:
@@ -27,166 +27,118 @@ class ItemWith {
DoublyLinkedListLink<ItemWith> fLink; DoublyLinkedListLink<ItemWith> fLink;
}; };
// Class used for testing without offset // Class used for testing without offset
class ItemVirtualWithout { class ItemVirtualWithout {
public: public:
virtual int32 Value();
DoublyLinkedListLink<ItemVirtualWithout> fLink; DoublyLinkedListLink<ItemVirtualWithout> fLink;
int32 value; int32 value;
int32 Value() { return value; }
}; };
// Class used for testing with offset // Class used for testing with offset
class ItemVirtualWith { class ItemVirtualWith {
public: public:
virtual int32 Value();
int32 value; int32 value;
DoublyLinkedListLink<ItemVirtualWith> fLink; DoublyLinkedListLink<ItemVirtualWith> fLink;
int32 Value() { return value; }
}; };
int32
ItemVirtualWithout::Value()
{
return value;
}
int32
ItemVirtualWith::Value()
{
return value;
}
// #pragma mark -
DoublyLinkedListTest::DoublyLinkedListTest(std::string name)
: BTestCase(name)
{
}
CppUnit::Test*
DoublyLinkedListTest::Suite() {
CppUnit::TestSuite *suite = new CppUnit::TestSuite("DLL");
suite->addTest(new CppUnit::TestCaller<DoublyLinkedListTest>("DoublyLinkedList::no offset", &DoublyLinkedListTest::WithoutOffsetTest));
suite->addTest(new CppUnit::TestCaller<DoublyLinkedListTest>("DoublyLinkedList::with offset", &DoublyLinkedListTest::WithOffsetTest));
suite->addTest(new CppUnit::TestCaller<DoublyLinkedListTest>("DoublyLinkedList::virtual no offset", &DoublyLinkedListTest::VirtualWithoutOffsetTest));
suite->addTest(new CppUnit::TestCaller<DoublyLinkedListTest>("DoublyLinkedList::virtual with offset", &DoublyLinkedListTest::VirtualWithOffsetTest));
return suite;
}
//! Tests the given list
template<typename Item> template<typename Item>
void class DoublyLinkedListTest : public CppUnit::TestFixture {
DoublyLinkedListTest::TestList() CPPUNIT_TEST_SUITE(DoublyLinkedListTest);
CPPUNIT_TEST(IsEmpty_ReturnsFalse);
CPPUNIT_TEST(Count_ReturnsItemCount);
CPPUNIT_TEST(Iterating_ItemsEqualAddedItems);
CPPUNIT_TEST(RemoveHead_ReturnsFirstItem);
CPPUNIT_TEST(HeadAndEverySecondItemRemoved_AddingFirstItem_ItemsAndCountAreCorrect);
CPPUNIT_TEST_SUITE_END();
typedef DoublyLinkedList<Item, DoublyLinkedListMemberGetLink<Item> > List;
List* fList;
static const int fValueCount = 10;
Item fItems[fValueCount];
public:
void setUp()
{ {
DoublyLinkedList<Item, DoublyLinkedListMemberGetLink<Item> > list; fList = new List;
int valueCount = 10; for (int i = 0; i < fValueCount; i++) {
Item items[valueCount]; fItems[i].value = i;
fList->Add(&fItems[i]);
// initialize }
for (int i = 0; i < valueCount; i++) {
items[i].value = i;
list.Add(&items[i]);
} }
// list must not be empty void tearDown()
{
delete fList;
}
CHK(!list.IsEmpty()); void IsEmpty_ReturnsFalse()
{
// count items in list CPPUNIT_ASSERT(!fList->IsEmpty());
}
void Count_ReturnsItemCount()
{
int count = 0; int count = 0;
typename DoublyLinkedList<Item, typename List::Iterator iterator = fList->GetIterator();
DoublyLinkedListMemberGetLink<Item> >::Iterator
iterator = list.GetIterator();
while (iterator.Next() != NULL) while (iterator.Next() != NULL)
count++; count++;
CHK(count == valueCount); CPPUNIT_ASSERT(count == fValueCount);
}
// test for equality void Iterating_ItemsEqualAddedItems()
{
int i = 0;
typename List::Iterator iterator = fList->GetIterator();
Item* item;
while ((item = iterator.Next()) != NULL) {
CPPUNIT_ASSERT(item->value == i);
CPPUNIT_ASSERT(item == &fItems[i]);
i++;
}
}
iterator = list.GetIterator(); void RemoveHead_ReturnsFirstItem()
{
Item* first = fList->RemoveHead();
CPPUNIT_ASSERT(first->value == 0);
CPPUNIT_ASSERT(first == &fItems[0]);
}
void HeadAndEverySecondItemRemoved_AddingFirstItem_ItemsAndCountAreCorrect()
{
fList->RemoveHead();
typename List::Iterator iterator = fList->GetIterator();
int i = 0; int i = 0;
Item* item; Item* item;
while ((item = iterator.Next()) != NULL) { while ((item = iterator.Next()) != NULL) {
CHK(item->value == i); CPPUNIT_ASSERT(item->value == i + 1);
CHK(item == &items[i]);
i++;
}
// remove first
Item *first = list.RemoveHead();
CHK(first->value == 0);
CHK(first == &items[0]);
// remove every second
iterator = list.GetIterator();
i = 0;
while ((item = iterator.Next()) != NULL) {
CHK(item->value == i + 1);
if (i % 2) if (i % 2)
list.Remove(item); fList->Remove(item);
i++; i++;
} }
// re-add first fList->Add(&fItems[0]);
list.Add(first); int count = 0;
iterator = fList->GetIterator();
// count again
count = 0;
iterator = list.GetIterator();
while (iterator.Next() != NULL) while (iterator.Next() != NULL)
count++; count++;
CHK(count == (valueCount / 2) + 1); CPPUNIT_ASSERT(count == (fValueCount / 2) + 1);
} }
};
//! Test using no offset, no virtual CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(DoublyLinkedListTest<ItemWith>, getTestSuiteName());
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(DoublyLinkedListTest<ItemWithout>, getTestSuiteName());
void CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(DoublyLinkedListTest<ItemVirtualWith>, getTestSuiteName());
DoublyLinkedListTest::WithoutOffsetTest() { CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(DoublyLinkedListTest<ItemVirtualWithout>, getTestSuiteName());
TestList<ItemWithout>();
}
//! Test using offset, no virtual
void
DoublyLinkedListTest::WithOffsetTest() {
TestList<ItemWith>();
}
//! Test using no offset, virtual
void
DoublyLinkedListTest::VirtualWithoutOffsetTest() {
TestList<ItemVirtualWithout>();
}
//! Test using offset, virtual
void
DoublyLinkedListTest::VirtualWithOffsetTest() {
TestList<ItemVirtualWith>();
}
src/tests/system/kernel/util/DoublyLinkedListTest.h
-21
View File
@@ -1,21 +0,0 @@
#ifndef _DOUBLY_LINKED_LIST_TEST_H_
#define _DOUBLY_LINKED_LIST_TEST_H_
#include <TestCase.h>
class DoublyLinkedListTest : public BTestCase {
public:
DoublyLinkedListTest(std::string name = "");
static CppUnit::Test *Suite();
void WithoutOffsetTest();
void WithOffsetTest();
void VirtualWithoutOffsetTest();
void VirtualWithOffsetTest();
private:
template <typename Item> void TestList();
};
#endif /* _DOUBLY_LINKED_LIST_TEST_H_ */
src/tests/system/kernel/util/Jamfile
+1 -1
View File
@@ -12,7 +12,7 @@ SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src system kernel util ] ;
UnitTestLib libkernelutilstest.so UnitTestLib libkernelutilstest.so
: KernelUtilsTestAddon.cpp : KernelUtilsTestAddon.cpp
# AVLTreeMapTest.cpp # AVLTreeMapTest.cpp
BOpenHashTableTest.cpp OpenHashTableTest.cpp
BitmapTest.cpp BitmapTest.cpp
SinglyLinkedListTest.cpp SinglyLinkedListTest.cpp
DoublyLinkedListTest.cpp DoublyLinkedListTest.cpp
src/tests/system/kernel/util/KernelUtilsTestAddon.cpp
+8 -20
View File
@@ -1,25 +1,13 @@
/*
* Copyright 2003-2026, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#include <TestSuite.h> #include <TestSuite.h>
#include <TestSuiteAddon.h> #include <TestSuiteAddon.h>
//#include "AVLTreeMapTest.h"
#include "BOpenHashTableTest.h"
#include "BitmapTest.h"
#include "DoublyLinkedListTest.h"
#include "SinglyLinkedListTest.h"
#include "VectorMapTest.h"
#include "VectorSetTest.h"
#include "VectorTest.h"
const char* getTestSuiteName() {
BTestSuite* getTestSuite() { return "KernelUtils";
BTestSuite *suite = new BTestSuite("KernelUtils");
// suite->addTest("AVLTreeMap", AVLTreeMapTest::Suite());
suite->addTest("BOpenHashTable", BOpenHashTableTest::Suite());
suite->addTest("Bitmap", BitmapTest::Suite());
suite->addTest("SinglyLinkedList", SinglyLinkedListTest::Suite());
suite->addTest("DoublyLinkedList", DoublyLinkedListTest::Suite());
suite->addTest("VectorMap", VectorMapTest::Suite());
suite->addTest("VectorSet", VectorSetTest::Suite());
suite->addTest("Vector", VectorTest::Suite());
return suite;
} }
src/tests/system/kernel/util/OpenHashTableTest.cpp
+326
View File
@@ -0,0 +1,326 @@
/*
* Copyright 2020-2026, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#include <TestShell.h>
#include <TestSuiteAddon.h>
#include <cppunit/extensions/HelperMacros.h>
#include <os/support/ObjectList.h>
#include <shared/AutoDeleter.h>
#include <util/OpenHashTable.h>
namespace {
class Entry {
public:
Entry(uint32_t value)
:
fValue(value),
fNext(NULL)
{
}
const uint32_t Value() const { return fValue; }
Entry* Next() const { return fNext; }
private:
uint32_t fValue;
Entry* fNext;
friend class EntryDefinition;
};
class EntryDefinition {
public:
typedef uint32_t KeyType;
typedef Entry ValueType;
size_t HashKey(const KeyType& key) const { return key; }
size_t Hash(Entry* entry) const { return entry->fValue; }
bool Compare(const KeyType& key, Entry* entry) const { return key == entry->fValue; }
Entry*& GetLink(Entry* entry) const { return entry->fNext; }
};
} // namespace
class OpenHashTableTest : public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(OpenHashTableTest);
CPPUNIT_TEST(Init_ZeroSize_ReturnsOk);
CPPUNIT_TEST(Clear_EmptiesTable);
CPPUNIT_TEST(Clear_ReturnElementsSet_ClearsAndReturnsEntries);
CPPUNIT_TEST(Insert_AutoExpandDisabled_InsertsEntriesWithoutResize);
CPPUNIT_TEST(Insert_DuplicateEntry_ReturnsError);
CPPUNIT_TEST(Insert_InsertsEntry_ReturnsOk);
CPPUNIT_TEST(InsertUnchecked_InsertsEntry_ReturnsOk);
CPPUNIT_TEST(IterateAndCount_IteratesEntries_ReturnsCorrectCount);
CPPUNIT_TEST(Lookup_ExistingKey_ReturnsEntry);
CPPUNIT_TEST(Remove_ExistingEntry_ReturnsOk);
CPPUNIT_TEST(Remove_NotPresent_ReturnsNull);
CPPUNIT_TEST(RemoveUnchecked_RemovesEntry_ReturnsOk);
CPPUNIT_TEST(Resize_InsertsManyEntries_ResizesSuccessfully);
CPPUNIT_TEST_SUITE_END();
public:
void Init_ZeroSize_ReturnsOk()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(0), B_OK);
}
void Clear_EmptiesTable()
{
const size_t kEntryCount = 3;
BObjectList<Entry, true> entries(20);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
for (uint32_t i = 0; i < kEntryCount; ++i) {
Entry* entry = new Entry(i);
entries.AddItem(entry);
CPPUNIT_ASSERT_EQUAL(table.Insert(entry), B_OK);
}
CPPUNIT_ASSERT_EQUAL(table.CountElements(), kEntryCount);
CPPUNIT_ASSERT(table.Lookup(2) != NULL);
CPPUNIT_ASSERT_EQUAL(table.Clear(false), NULL);
CPPUNIT_ASSERT_EQUAL(table.CountElements(), 0);
CPPUNIT_ASSERT_EQUAL(table.Lookup(2), NULL);
CPPUNIT_ASSERT_EQUAL(table.GetIterator().HasNext(), false);
}
void Clear_ReturnElementsSet_ClearsAndReturnsEntries()
{
// Same as ClearTest(), except that Clear(true) is called, which tells
// the BOpenHashTable<T> to return a linked list of entries before clearing
// the table.
const size_t kEntryCount = 3;
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
for (uint32_t i = 0; i < kEntryCount; ++i) {
Entry* entry = new Entry(i);
CPPUNIT_ASSERT_EQUAL(table.Insert(entry), B_OK);
}
CPPUNIT_ASSERT_EQUAL(table.CountElements(), kEntryCount);
CPPUNIT_ASSERT(table.Lookup(2) != NULL);
Entry* head = table.Clear(true);
CPPUNIT_ASSERT(head != NULL);
CPPUNIT_ASSERT_EQUAL(table.CountElements(), 0);
CPPUNIT_ASSERT_EQUAL(table.Lookup(2), NULL);
CPPUNIT_ASSERT_EQUAL(table.GetIterator().HasNext(), false);
size_t items_returned = 0;
while (head != NULL) {
Entry* next = head->Next();
delete head;
head = next;
++items_returned;
}
CPPUNIT_ASSERT_EQUAL(items_returned, kEntryCount);
}
void Insert_AutoExpandDisabled_InsertsEntriesWithoutResize()
{
// Insert multiple items into a table with a fixed size of 1. This
// essentially turns this BOpenHashTable into a linked list, since resize
// will never occur.
Entry entry1(123);
Entry entry2(456);
BOpenHashTable<EntryDefinition, false> table;
CPPUNIT_ASSERT_EQUAL(table.Init(1), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry1), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry2), B_OK);
CPPUNIT_ASSERT_EQUAL(table.CountElements(), 2);
}
void Insert_DuplicateEntry_ReturnsError()
{
Entry entry(123);
BOpenHashTable<EntryDefinition, true, true> table;
CPPUNIT_ASSERT_EQUAL(table.Init(0), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
CPPUNIT_ASSERT_DEBUGGER(table.Insert(&entry));
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
// The item can basically never be removed now since there is a cycle,
// but we'll break into the debugger on remove when that happens as well.
CPPUNIT_ASSERT_DEBUGGER(table.Remove(&entry));
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
CPPUNIT_ASSERT_DEBUGGER(table.Remove(&entry));
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
}
void Insert_InsertsEntry_ReturnsOk()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
}
void InsertUnchecked_InsertsEntry_ReturnsOk()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
table.InsertUnchecked(&entry);
}
void IterateAndCount_IteratesEntries_ReturnsCorrectCount()
{
const size_t kEntryCount = 20;
BObjectList<Entry, true> entries(20);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(kEntryCount * 2), B_OK);
for (uint32_t i = 0; i < kEntryCount; ++i) {
Entry* entry = new Entry(i);
entries.AddItem(entry);
CPPUNIT_ASSERT_EQUAL(table.Insert(entry), B_OK);
}
// Verify that the table contains the expected values.
uint64_t map = 0;
BOpenHashTable<EntryDefinition>::Iterator iterator = table.GetIterator();
while (iterator.HasNext()) {
Entry* entry = iterator.Next();
CPPUNIT_ASSERT_EQUAL(0, map & (1 << entry->Value()));
map |= (1 << entry->Value());
}
CPPUNIT_ASSERT_EQUAL(map, (1 << kEntryCount) - 1);
CPPUNIT_ASSERT_EQUAL(kEntryCount, table.CountElements());
}
void Lookup_ExistingKey_ReturnsEntry()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(0), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
}
void Remove_ExistingEntry_ReturnsOk()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(0), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
table.Remove(&entry);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), NULL);
}
void Remove_NotPresent_ReturnsNull()
{
Entry entry1(123);
Entry entry2(456);
Entry entry3(789);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(), B_OK);
// Only add the first two entries.
table.Insert(&entry1);
table.Insert(&entry2);
// entry3 is not in the table, but we'll remove it anyway.
table.Remove(&entry3);
table.RemoveUnchecked(&entry3);
// The original two entries should still be there.
CPPUNIT_ASSERT_EQUAL(table.CountElements(), 2);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry1);
CPPUNIT_ASSERT_EQUAL(table.Lookup(456), &entry2);
CPPUNIT_ASSERT_EQUAL(table.Lookup(789), NULL);
}
void RemoveUnchecked_RemovesEntry_ReturnsOk()
{
Entry entry(123);
BOpenHashTable<EntryDefinition> table;
CPPUNIT_ASSERT_EQUAL(table.Init(0), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Insert(&entry), B_OK);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), &entry);
table.RemoveUnchecked(&entry);
CPPUNIT_ASSERT_EQUAL(table.Lookup(123), NULL);
}
void Resize_InsertsManyEntries_ResizesSuccessfully()
{
// This is the same as IterateAndCountTest, except that the table will
// be resized mid insertion.
const size_t kEntryCount = 20;
BObjectList<Entry, true> entries(20);
BOpenHashTable<EntryDefinition> table;
// Start off with capacity for 8 elements. This will mean that the table
// will be resized in the loop below since we are inserting 20 elements.
CPPUNIT_ASSERT_EQUAL(table.Init(8), B_OK);
for (uint32_t i = 0; i < kEntryCount; ++i) {
Entry* entry = new Entry(i);
entries.AddItem(entry);
CPPUNIT_ASSERT_EQUAL(table.Insert(entry), B_OK);
}
// Verify that after resize the expected elements are present within
// the table.
uint64_t map = 0;
BOpenHashTable<EntryDefinition>::Iterator iterator = table.GetIterator();
while (iterator.HasNext()) {
Entry* entry = iterator.Next();
CPPUNIT_ASSERT_EQUAL(0, map & (1 << entry->Value()));
map |= (1 << entry->Value());
}
CPPUNIT_ASSERT_EQUAL(map, (1 << kEntryCount) - 1);
CPPUNIT_ASSERT_EQUAL(kEntryCount, table.CountElements());
}
};
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(OpenHashTableTest, getTestSuiteName());
src/tests/system/kernel/util/OrderedMapTest.h
-1140
View File
File diff suppressed because it is too large Load Diff
src/tests/system/kernel/util/SinglyLinkedListTest.cpp
+81 -78
View File
@@ -1,26 +1,15 @@
#include <cppunit/Test.h> /*
#include <cppunit/TestCaller.h> * Copyright 2003-2026, Haiku, Inc. All rights reserved.
#include <cppunit/TestSuite.h> * Distributed under the terms of the MIT License.
#include <stdio.h> */
#include <TestUtils.h>
#include <TestSuiteAddon.h>
#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "SinglyLinkedListTest.h"
#include "SinglyLinkedList.h" #include "SinglyLinkedList.h"
SinglyLinkedListTest::SinglyLinkedListTest(std::string name)
: BTestCase(name)
{
}
CppUnit::Test*
SinglyLinkedListTest::Suite() {
CppUnit::TestSuite *suite = new CppUnit::TestSuite("SLL");
suite->addTest(new CppUnit::TestCaller<SinglyLinkedListTest>("SinglyLinkedList::User Strategy Test (default next parameter)", &SinglyLinkedListTest::UserDefaultTest));
suite->addTest(new CppUnit::TestCaller<SinglyLinkedListTest>("SinglyLinkedList::User Strategy Test (custom next parameter)", &SinglyLinkedListTest::UserCustomTest));
return suite;
}
// Class used for testing default User strategy // Class used for testing default User strategy
class Link { class Link {
@@ -28,80 +17,94 @@ public:
SinglyLinkedListLink<Link> next; SinglyLinkedListLink<Link> next;
long data; long data;
SinglyLinkedListLink<Link>* GetSinglyLinkedListLink() { SinglyLinkedListLink<Link>* GetSinglyLinkedListLink() { return &next; }
return &next;
}
bool operator==(const Link &ref) { bool operator==(const Link& ref) { return data == ref.data; }
return data == ref.data;
}
}; };
// Class used for testing custom User strategy // Class used for testing custom User strategy
class MyLink { class MyLink {
public: public:
SinglyLinkedListLink<MyLink> mynext; SinglyLinkedListLink<MyLink> next;
long data; long data;
bool operator==(const MyLink &ref) { bool operator==(const MyLink& ref) { return data == ref.data; }
return data == ref.data;
}
}; };
//! Tests the given list
template <class List, class Element>
void
SinglyLinkedListTest::TestList(List &list, Element *values, int valueCount)
{
list.MakeEmpty();
// PushFront template<typename Link, typename List>
for (int i = 0; i < valueCount; i++) { class SinglyLinkedListTest : public CppUnit::TestFixture {
NextSubTest(); CPPUNIT_TEST_SUITE(SinglyLinkedListTest);
CHK(list.Count() == i); CPPUNIT_TEST(TwoValues_MakeEmpty_ListIsEmpty);
list.Add(&values[i]); CPPUNIT_TEST(EmptyList_AddingValues_CountIncreases);
CHK(list.Count() == i+1); CPPUNIT_TEST(TenValues_AccessingWithIterator_IteratesThroughAllValues);
CPPUNIT_TEST_SUITE_END();
List* fList;
static const int fValueCount = 10;
Link fValues[fValueCount];
public:
void setUp()
{
fList = new List;
for (int i = 0; i < fValueCount; i++) {
fValues[i].data = i * 2;
if (!(i % 2))
fValues[i].next.next = NULL; // Leave some next pointers invalid just for fun
}
}
void tearDown()
{
delete fList;
}
void TwoValues_MakeEmpty_ListIsEmpty()
{
Link value1, value2;
value1.data = 2;
value2.data = 5;
fList->Add(&value1);
fList->Add(&value2);
CPPUNIT_ASSERT(fList->Count() == 2);
fList->MakeEmpty();
CPPUNIT_ASSERT(fList->Count() == 0);
}
void EmptyList_AddingValues_CountIncreases() {
for (int i = 0; i < fValueCount; i++) {
CPPUNIT_ASSERT(fList->Count() == i);
fList->Add(&fValues[i]);
CPPUNIT_ASSERT(fList->Count() == i + 1);
}
}
void TenValues_AccessingWithIterator_IteratesThroughAllValues()
{
for (int i = 0; i < fValueCount; i++) {
fList->Add(&fValues[i]);
} }
// Prefix increment // Prefix increment
int preIndex = valueCount-1; int preIndex = fValueCount - 1;
for (typename List::ConstIterator iterator = list.GetIterator(); for (typename List::ConstIterator iterator = fList->GetIterator(); iterator.HasNext();
iterator.HasNext(); --preIndex) { --preIndex) {
NextSubTest(); Link* element = iterator.Next();
CPPUNIT_ASSERT(*element == fValues[preIndex]);
Element* element = iterator.Next();
CHK(*element == values[preIndex]);
} }
CHK(preIndex == -1); CPPUNIT_ASSERT(preIndex == -1);
list.MakeEmpty();
} }
};
typedef SinglyLinkedListTest<Link, SinglyLinkedList<Link> > SinglyLinkedListDefaultTest;
typedef SinglyLinkedListTest<MyLink,
SinglyLinkedList<MyLink, SinglyLinkedListMemberGetLink<MyLink, &MyLink::next> > >
SinglyLinkedListCustomTest;
//! Test using the User strategy with the default NextMember. //! Test using the User strategy with the default NextMember.
void CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(SinglyLinkedListDefaultTest, getTestSuiteName());
SinglyLinkedListTest::UserDefaultTest() {
SinglyLinkedList<Link> list;
const int valueCount = 10;
Link values[valueCount];
for (int i = 0; i < valueCount; i++) {
values[i].data = i;
if (i % 2)
values[i].next.next = NULL; // Leave some next pointers invalid just for fun
}
TestList(list, values, valueCount);
}
//! Test using the User strategy with a custom NextMember. //! Test using the User strategy with a custom NextMember.
void CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(SinglyLinkedListCustomTest, getTestSuiteName());
SinglyLinkedListTest::UserCustomTest() {
SinglyLinkedList<MyLink, SinglyLinkedListMemberGetLink<MyLink, &MyLink::mynext> > list;
const int valueCount = 10;
MyLink values[valueCount];
for (int i = 0; i < valueCount; i++) {
values[i].data = i*2;
if (!(i % 2))
values[i].mynext.next = NULL; // Leave some next pointers invalid just for fun
}
TestList(list, values, valueCount);
}
src/tests/system/kernel/util/SinglyLinkedListTest.h
-19
View File
@@ -1,19 +0,0 @@
#ifndef _single_linked_list_test_h_
#define _single_linked_list_test_h_
#include <TestCase.h>
class SinglyLinkedListTest : public BTestCase {
public:
SinglyLinkedListTest(std::string name = "");
static CppUnit::Test* Suite();
void UserDefaultTest();
void UserCustomTest();
private:
template <class List, class Element>
void TestList(List &list, Element *values, int valueCount);
};
#endif // _single_linked_list_test_h_
src/tests/system/kernel/util/VectorMapTest.cpp
+854 -67
View File
@@ -1,19 +1,825 @@
/*
* Copyright 2003-2026, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <map> #include <map>
#include <TestUtils.h> #include <TestSuiteAddon.h>
#include <cppunit/Test.h> #include <cppunit/TestFixture.h>
#include <cppunit/TestCaller.h> #include <cppunit/extensions/HelperMacros.h>
#include <cppunit/TestSuite.h>
#include <VectorMap.h> #include <VectorMap.h>
#include "common.h" #include <KernelUtilsOrder.h>
#include "OrderedMapTest.h"
#include "VectorMapTest.h"
template<typename _Value> class SimpleValueStrategy {
public:
typedef _Value Value;
SimpleValueStrategy(int32 differentValues = 100000)
:
fDifferentValues(differentValues)
{
srand(0);
}
Value Generate();
private:
int32 fDifferentValues;
};
template<>
int
SimpleValueStrategy<int>::Generate()
{
return rand() % fDifferentValues;
}
template<>
string
SimpleValueStrategy<string>::Generate()
{
char buffer[10];
sprintf(buffer, "%ld", rand() % fDifferentValues);
return string(buffer);
}
template<typename _KeyStrategy, typename _ValueStrategy>
class PairEntryStrategy {
public:
typedef _KeyStrategy KeyStrategy;
typedef _ValueStrategy ValueStrategy;
typedef typename KeyStrategy::Value Key;
typedef typename ValueStrategy::Value Value;
inline Key GenerateKey() { return fKeyStrategy.Generate(); }
inline Value GenerateValue() { return fValueStrategy.Generate(); }
inline void Generate(Key& key, Value& value)
{
key = GenerateKey();
value = GenerateValue();
}
private:
KeyStrategy fKeyStrategy;
ValueStrategy fValueStrategy;
};
template<typename _KeyStrategy, typename _ValueStrategy, typename GetKey>
class ImplicitKeyStrategy {
public:
typedef _KeyStrategy KeyStrategy;
typedef _ValueStrategy ValueStrategy;
typedef typename KeyStrategy::Value Key;
typedef typename ValueStrategy::Value Value;
inline Key GenerateKey() { return fKeyStrategy.Generate(); }
inline Value GenerateValue() { return fValueStrategy.Generate(); }
inline void Generate(Key& key, Value& value)
{
value = GenerateValue();
key = fGetKey(value);
}
private:
KeyStrategy fKeyStrategy;
ValueStrategy fValueStrategy;
GetKey fGetKey;
};
// Non-template wrapper for the Ascending compare strategy.
// Work-around for our compiler not eating nested template template
// parameters.
struct Ascending {
template<typename Value>
class Strategy : public KernelUtilsOrder::Ascending<Value> {};
};
// Non-template wrapper for the Descending compare strategy.
// Work-around for our compiler not eating nested template template
// parameters.
struct Descending {
template<typename Value>
class Strategy : public KernelUtilsOrder::Descending<Value> {};
};
template<typename Value, typename Compare>
class CompareWrapper {
public:
inline bool operator()(const Value& a, const Value& b) const
{ return fCompare(a, b) < 0; }
private:
Compare fCompare;
};
template<typename Entry, typename TestMap, typename MyIterator, typename ReferenceIterator>
class TestIterator {
private:
typedef TestIterator<Entry, TestMap, MyIterator, ReferenceIterator> Iterator;
public:
inline TestIterator(TestMap* s, MyIterator myIt, ReferenceIterator refIt)
:
fMap(s),
fMyIterator(myIt),
fReferenceIterator(refIt)
{
}
inline TestIterator(const Iterator& other)
:
fMap(other.fMap),
fMyIterator(other.fMyIterator),
fReferenceIterator(other.fReferenceIterator)
{
CPPUNIT_ASSERT(fMyIterator == other.fMyIterator);
}
inline Iterator& operator++()
{
MyIterator& myResult = ++fMyIterator;
ReferenceIterator& refResult = ++fReferenceIterator;
if (refResult == fMap->fReferenceMap.end()) {
CPPUNIT_ASSERT(myResult == fMap->fMyMap.End());
} else {
CPPUNIT_ASSERT(myResult->Key() == refResult->first);
CPPUNIT_ASSERT(myResult->Value() == refResult->second);
}
return *this;
}
inline Iterator operator++(int)
{
MyIterator oldMyResult = fMyIterator;
MyIterator myResult = fMyIterator++;
ReferenceIterator refResult = fReferenceIterator++;
CPPUNIT_ASSERT(oldMyResult == myResult);
if (refResult == fMap->fReferenceMap.end()) {
CPPUNIT_ASSERT(myResult == fMap->fMyMap.End());
} else {
CPPUNIT_ASSERT(myResult->Key() == refResult->first);
CPPUNIT_ASSERT(myResult->Value() == refResult->second);
}
return Iterator(fMap, myResult, refResult);
}
inline Iterator& operator--()
{
MyIterator& myResult = --fMyIterator;
ReferenceIterator& refResult = --fReferenceIterator;
CPPUNIT_ASSERT(myResult->Key() == refResult->first);
CPPUNIT_ASSERT(myResult->Value() == refResult->second);
return *this;
}
inline Iterator operator--(int)
{
MyIterator oldMyResult = fMyIterator;
MyIterator myResult = fMyIterator--;
ReferenceIterator refResult = fReferenceIterator--;
CPPUNIT_ASSERT(oldMyResult == myResult);
CPPUNIT_ASSERT(myResult->Key() == refResult->first);
CPPUNIT_ASSERT(myResult->Value() == refResult->second);
return Iterator(fMap, myResult, refResult);
}
inline Iterator& operator=(const Iterator& other)
{
fMap = other.fMap;
fMyIterator = other.fMyIterator;
fReferenceIterator = other.fReferenceIterator;
CPPUNIT_ASSERT(fMyIterator == other.fMyIterator);
return *this;
}
inline bool operator==(const Iterator& other) const
{
bool result = (fMyIterator == other.fMyIterator);
CPPUNIT_ASSERT((fReferenceIterator == other.fReferenceIterator) == result);
return result;
}
inline bool operator!=(const Iterator& other) const
{
bool result = (fMyIterator != other.fMyIterator);
CPPUNIT_ASSERT((fReferenceIterator != other.fReferenceIterator) == result);
return result;
}
inline Entry operator*() const
{
Entry entry = *fMyIterator;
CPPUNIT_ASSERT(entry.Key() == fReferenceIterator->first);
CPPUNIT_ASSERT(entry.Value() == fReferenceIterator->second);
return entry;
}
inline Entry operator->() const
{
Entry entry = fMyIterator.operator->();
CPPUNIT_ASSERT(entry.Key() == fReferenceIterator->first);
CPPUNIT_ASSERT(entry.Value() == fReferenceIterator->second);
return entry;
}
inline operator bool() const
{
bool result = fMyIterator;
CPPUNIT_ASSERT((fMyIterator == fMap->fMyMap.Null()) != result);
return result;
}
public:
TestMap* fMap;
MyIterator fMyIterator;
ReferenceIterator fReferenceIterator;
};
template<typename Key, typename Value, typename MyMap, typename ReferenceMap, typename Compare>
class TestMap {
public:
typedef TestMap<Key, Value, MyMap, ReferenceMap, Compare> Class;
typedef typename MyMap::Iterator MyIterator;
typedef typename ReferenceMap::iterator ReferenceIterator;
typedef typename MyMap::ConstIterator MyConstIterator;
typedef typename ReferenceMap::const_iterator ReferenceConstIterator;
typedef typename MyMap::Entry Entry;
typedef typename MyMap::ConstEntry ConstEntry;
typedef TestIterator<Entry, Class, MyIterator, ReferenceIterator> Iterator;
typedef TestIterator<ConstEntry, const Class, MyConstIterator, ReferenceConstIterator>
ConstIterator;
TestMap()
:
fMyMap(),
fReferenceMap(),
fChecking(true)
{
}
void Insert(const Key& key, const Value& value)
{
CPPUNIT_ASSERT(fMyMap.Insert(key, value) == B_OK);
fReferenceMap[key] = value;
Check();
}
void Put(const Key& key, const Value& value)
{
CPPUNIT_ASSERT(fMyMap.Put(key, value) == B_OK);
fReferenceMap[key] = value;
Check();
}
Value& Get(const Key& key)
{
Value& value = fMyMap.Get(key);
CPPUNIT_ASSERT(value == fReferenceMap[key]);
return value;
}
const Value& Get(const Key& key) const
{
const Value& value = fMyMap.Get(key);
CPPUNIT_ASSERT(value == fReferenceMap.find(key)->second);
return value;
}
void Remove(const Key& key)
{
int32 oldCount = Count();
ReferenceIterator it = fReferenceMap.find(key);
if (it != fReferenceMap.end())
fReferenceMap.erase(it);
int32 newCount = fReferenceMap.size();
CPPUNIT_ASSERT(fMyMap.Remove(key) == oldCount - newCount);
Check();
}
Iterator Erase(const Iterator& iterator)
{
bool outOfRange = (iterator.fReferenceIterator == fReferenceMap.end());
MyIterator myIt = fMyMap.Erase(iterator.fMyIterator);
if (outOfRange) {
CPPUNIT_ASSERT(myIt == fMyMap.Null());
return Iterator(this, myIt, fReferenceMap.end());
}
Key nextKey;
ReferenceIterator refIt = iterator.fReferenceIterator;
++refIt;
bool noNextEntry = (refIt == fReferenceMap.end());
if (!noNextEntry)
nextKey = refIt->first;
fReferenceMap.erase(iterator.fReferenceIterator);
if (noNextEntry)
refIt = fReferenceMap.end();
else
refIt = fReferenceMap.find(nextKey);
Check();
if (refIt == fReferenceMap.end()) {
CPPUNIT_ASSERT(myIt == fMyMap.End());
} else {
CPPUNIT_ASSERT(myIt->Key() == refIt->first);
CPPUNIT_ASSERT(myIt->Value() == refIt->second);
}
return Iterator(this, myIt, refIt);
}
inline int32 Count() const
{
int32 count = fReferenceMap.size();
CPPUNIT_ASSERT(fMyMap.Count() == count);
return count;
}
inline bool IsEmpty() const
{
bool result = fReferenceMap.empty();
CPPUNIT_ASSERT(fMyMap.IsEmpty() == result);
return result;
}
void MakeEmpty()
{
fMyMap.MakeEmpty();
fReferenceMap.clear();
Check();
}
inline Iterator Begin() { return Iterator(this, fMyMap.Begin(), fReferenceMap.begin()); }
inline ConstIterator Begin() const
{
return ConstIterator(this, fMyMap.Begin(), fReferenceMap.begin());
}
inline Iterator End() { return Iterator(this, fMyMap.End(), fReferenceMap.end()); }
inline ConstIterator End() const
{
return ConstIterator(this, fMyMap.End(), fReferenceMap.end());
}
inline Iterator Null() { return Iterator(this, fMyMap.Null(), fReferenceMap.end()); }
inline ConstIterator Null() const
{
return ConstIterator(this, fMyMap.Null(), fReferenceMap.end());
}
// for testing only
inline Iterator IteratorForIndex(int32 index)
{
if (index < 0 || index > Count())
return End();
MyIterator myIt = fMyMap.Begin();
ReferenceIterator refIt = fReferenceMap.begin();
for (int32 i = 0; i < index; i++) {
++myIt;
++refIt;
}
return Iterator(this, myIt, refIt);
}
// for testing only
inline ConstIterator IteratorForIndex(int32 index) const
{
if (index < 0 || index > Count())
return End();
MyConstIterator myIt = fMyMap.Begin();
ReferenceConstIterator refIt = fReferenceMap.begin();
for (int32 i = 0; i < index; i++) {
++myIt;
++refIt;
}
return ConstIterator(this, myIt, refIt);
}
Iterator Find(const Key& key)
{
MyIterator myIt = fMyMap.Find(key);
ReferenceIterator refIt = fReferenceMap.find(key);
if (refIt == fReferenceMap.end()) {
CPPUNIT_ASSERT(myIt = fMyMap.End());
} else {
CPPUNIT_ASSERT(myIt->Key() == refIt->first);
CPPUNIT_ASSERT(myIt->Value() == refIt->second);
}
return Iterator(this, myIt, refIt);
}
ConstIterator Find(const Key& key) const
{
MyConstIterator myIt = fMyMap.Find(key);
ReferenceConstIterator refIt = fReferenceMap.find(key);
if (refIt == fReferenceMap.end()) {
CPPUNIT_ASSERT(myIt = fMyMap.End());
} else {
CPPUNIT_ASSERT(myIt->Key() == refIt->first);
CPPUNIT_ASSERT(myIt->Value() == refIt->second);
}
return ConstIterator(this, myIt, refIt);
}
Iterator FindClose(const Key& key, bool less)
{
MyIterator myIt = fMyMap.FindClose(key, less);
if (myIt == fMyMap.End()) {
if (fMyMap.Count() > 0) {
if (less)
CPPUNIT_ASSERT(fCompare(fMyMap.Begin()->Key(), key) > 0);
else
CPPUNIT_ASSERT(fCompare((--MyIterator(myIt))->Key(), key) < 0);
}
return End();
}
if (less) {
CPPUNIT_ASSERT(fCompare(myIt->Key(), key) <= 0);
MyIterator nextMyIt(myIt);
++nextMyIt;
if (nextMyIt != fMyMap.End())
CPPUNIT_ASSERT(fCompare(nextMyIt->Key(), key) > 0);
} else {
CPPUNIT_ASSERT(fCompare(myIt->Key(), key) >= 0);
if (myIt != fMyMap.Begin()) {
MyIterator prevMyIt(myIt);
--prevMyIt;
CPPUNIT_ASSERT(fCompare(prevMyIt->Key(), key) < 0);
}
}
return Iterator(this, myIt, fReferenceMap.find(myIt->Key()));
}
ConstIterator FindClose(const Key& key, bool less) const
{
MyConstIterator myIt = fMyMap.FindClose(key, less);
if (myIt == fMyMap.End()) {
if (fMyMap.Count() > 0) {
if (less)
CPPUNIT_ASSERT(fCompare(fMyMap.Begin()->Key(), key) > 0);
else
CPPUNIT_ASSERT(fCompare((--MyConstIterator(myIt))->Key(), key) < 0);
}
return End();
}
if (less) {
CPPUNIT_ASSERT(fCompare(myIt->Key(), key) <= 0);
MyConstIterator nextMyIt(myIt);
++nextMyIt;
if (nextMyIt != fMyMap.End())
CPPUNIT_ASSERT(fCompare(nextMyIt->Key(), key) > 0);
} else {
CPPUNIT_ASSERT(fCompare(myIt->Key(), key) >= 0);
if (myIt != fMyMap.Begin()) {
MyConstIterator prevMyIt(myIt);
--prevMyIt;
CPPUNIT_ASSERT(fCompare(prevMyIt->Key(), key) < 0);
}
}
return ConstIterator(this, myIt, fReferenceMap.find(myIt->Key()));
}
void SetChecking(bool enable) { fChecking = enable; }
void Check() const
{
if (fChecking) {
int32 count = fReferenceMap.size();
CPPUNIT_ASSERT(fMyMap.Count() == count);
CPPUNIT_ASSERT(fMyMap.IsEmpty() == fReferenceMap.empty());
MyConstIterator myIt = fMyMap.Begin();
ReferenceConstIterator refIt = fReferenceMap.begin();
for (int32 i = 0; i < count; i++, ++myIt, ++refIt) {
CPPUNIT_ASSERT(myIt->Key() == refIt->first);
CPPUNIT_ASSERT(myIt->Value() == refIt->second);
CPPUNIT_ASSERT((*myIt).Key() == refIt->first);
CPPUNIT_ASSERT((*myIt).Value() == refIt->second);
}
CPPUNIT_ASSERT(myIt == fMyMap.End());
}
}
public:
MyMap fMyMap;
ReferenceMap fReferenceMap;
bool fChecking;
Compare fCompare;
};
template<template<typename> class _MyMap, typename _EntryStrategy,
// template<typename> class _CompareStrategy>
class CompareStrategyWrapper>
class TestStrategy {
public:
typedef _EntryStrategy EntryStrategy;
typedef typename EntryStrategy::KeyStrategy KeyStrategy;
typedef typename EntryStrategy::ValueStrategy ValueStrategy;
typedef typename KeyStrategy::Value Key;
typedef typename ValueStrategy::Value Value;
// typedef _CompareStrategy<Key> Compare;
typedef typename CompareStrategyWrapper::template Strategy<Key> Compare;
typedef CompareWrapper<Key, Compare> BoolCompare;
typedef _MyMap<Compare> MyMap;
typedef std::map<Key, Value, BoolCompare> ReferenceMap;
typedef TestMap<Key, Value, MyMap, ReferenceMap, Compare> TestClass;
};
template<class TestStrategy>
class VectorMapTest : public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(VectorMapTest);
CPPUNIT_TEST(ConstructorTest);
CPPUNIT_TEST(Insert30ElementsTest);
CPPUNIT_TEST(Insert200ElementsTest);
CPPUNIT_TEST(Put30ElementsTest);
CPPUNIT_TEST(Put200ElementsTest);
CPPUNIT_TEST(Get30ElementsTest);
CPPUNIT_TEST(Get200ElementsTest);
CPPUNIT_TEST(Remove30ElementsTest);
CPPUNIT_TEST(Remove200ElementsTest);
CPPUNIT_TEST(Erase30ElementsTest);
CPPUNIT_TEST(Erase200ElementsTest);
CPPUNIT_TEST(MakeEmpty30ElementsTest);
CPPUNIT_TEST(MakeEmpty200ElementsTest);
CPPUNIT_TEST(Find30ElementsTest);
CPPUNIT_TEST(Find200ElementsTest);
CPPUNIT_TEST(FindClose30ElementsTest);
CPPUNIT_TEST(FindClose200ElementsTest);
CPPUNIT_TEST(Iterator30ElementsTest);
CPPUNIT_TEST(Iterator200ElementsTest);
CPPUNIT_TEST_SUITE_END();
typedef typename TestStrategy::EntryStrategy EntryStrategy;
typedef typename TestStrategy::Key Key;
typedef typename TestStrategy::Value Value;
typedef typename TestStrategy::TestClass TestClass;
typedef typename TestStrategy::MyMap MyMap;
typedef typename TestClass::Iterator Iterator;
typedef typename TestClass::ConstIterator ConstIterator;
void InsertTest(int32 maxNumber)
{
EntryStrategy entryStrategy;
TestClass v;
for (int32 i = 0; i < maxNumber; i++) {
Key key;
Value value;
entryStrategy.Generate(key, value);
v.Insert(key, value);
}
}
void PutTest(int32 maxNumber)
{
EntryStrategy entryStrategy;
TestClass v;
for (int32 i = 0; i < maxNumber; i++) {
Key key;
Value value;
entryStrategy.Generate(key, value);
v.Put(key, value);
}
}
void GetTest(int32 maxNumber)
{
EntryStrategy entryStrategy;
TestClass v;
Fill(v, entryStrategy, maxNumber);
const TestClass& cv = v;
// find the keys in the map
for (int32 i = 0; i < maxNumber; i++) {
Iterator it = v.IteratorForIndex(i);
Key key = it->Key();
const Value& value = it->Value();
CPPUNIT_ASSERT(&v.Get(key) == &value);
CPPUNIT_ASSERT(&cv.Get(key) == &value);
}
}
void Fill(TestClass& v, EntryStrategy strategy, int32 maxNumber)
{
typedef typename EntryStrategy::Key Key;
typedef typename EntryStrategy::Value Value;
v.SetChecking(false);
for (int32 i = 0; v.Count() < maxNumber; i++) {
Key key;
Value value;
strategy.Generate(key, value);
v.Put(key, value);
}
v.SetChecking(true);
v.Check();
}
void RemoveTest(int32 maxNumber)
{
EntryStrategy entryStrategy;
TestClass v;
Fill(v, entryStrategy, maxNumber);
while (v.Count() > 0) {
int32 index = rand() % (v.Count());
Key key = v.IteratorForIndex(index)->Key();
v.Remove(key);
v.Remove(key);
}
}
void EraseTest(int32 maxNumber)
{
EntryStrategy entryStrategy;
TestClass v;
Fill(v, entryStrategy, maxNumber);
for (int32 i = maxNumber - 1; i >= 0; i--) {
int32 index = rand() % (i + 1);
v.Erase(v.IteratorForIndex(index));
}
}
void MakeEmptyTest(int32 maxNumber)
{
EntryStrategy entryStrategy;
TestClass v;
v.MakeEmpty();
Fill(v, entryStrategy, maxNumber);
v.MakeEmpty();
v.MakeEmpty();
}
void FindTest(int32 maxNumber)
{
EntryStrategy entryStrategy;
TestClass v;
Fill(v, entryStrategy, maxNumber);
const TestClass& cv = v;
// find the values in the set
for (int32 i = 0; i < maxNumber; i++) {
Key key = v.IteratorForIndex(i)->Key();
Iterator it = v.Find(key);
ConstIterator cit = cv.Find(key);
CPPUNIT_ASSERT(it->Key() == key);
CPPUNIT_ASSERT(it->Key() == cit->Key());
CPPUNIT_ASSERT((*it).Key() == (*it).Key());
CPPUNIT_ASSERT(&it->Value() == &cit->Value());
CPPUNIT_ASSERT(&(*it).Value() == &(*it).Value());
}
// try to find some random values
for (int32 i = 0; i < maxNumber; i++) {
Key key = v.IteratorForIndex(i)->Key();
Iterator it = v.Find(key);
ConstIterator cit = cv.Find(key);
if (it != v.End()) {
CPPUNIT_ASSERT(it->Key() == key);
CPPUNIT_ASSERT(it->Key() == cit->Key());
CPPUNIT_ASSERT((*it).Key() == (*it).Key());
CPPUNIT_ASSERT(&it->Value() == &cit->Value());
CPPUNIT_ASSERT(&(*it).Value() == &(*it).Value());
}
}
}
void FindCloseTest(int32 maxNumber)
{
EntryStrategy entryStrategy;
TestClass v;
Fill(v, entryStrategy, maxNumber);
const TestClass& cv = v;
// find the values in the set
for (int32 i = 0; i < maxNumber; i++) {
Key key = v.IteratorForIndex(i)->Key();
// less
Iterator it = v.FindClose(key, true);
ConstIterator cit = cv.FindClose(key, true);
CPPUNIT_ASSERT(it->Key() == key);
CPPUNIT_ASSERT(it->Key() == cit->Key());
CPPUNIT_ASSERT((*it).Key() == (*it).Key());
CPPUNIT_ASSERT(&it->Value() == &cit->Value());
CPPUNIT_ASSERT(&(*it).Value() == &(*it).Value());
// greater
it = v.FindClose(key, false);
cit = cv.FindClose(key, false);
CPPUNIT_ASSERT(it->Key() == key);
CPPUNIT_ASSERT(it->Key() == cit->Key());
CPPUNIT_ASSERT((*it).Key() == (*it).Key());
CPPUNIT_ASSERT(&it->Value() == &cit->Value());
CPPUNIT_ASSERT(&(*it).Value() == &(*it).Value());
}
// try to find some random values
for (int32 i = 0; i < maxNumber; i++) {
Key key = entryStrategy.GenerateKey();
// less
Iterator it = v.FindClose(key, true);
ConstIterator cit = cv.FindClose(key, true);
if (it != v.End()) {
CPPUNIT_ASSERT(it->Key() == cit->Key());
CPPUNIT_ASSERT((*it).Key() == (*it).Key());
CPPUNIT_ASSERT(&it->Value() == &cit->Value());
CPPUNIT_ASSERT(&(*it).Value() == &(*it).Value());
}
// greater
it = v.FindClose(key, false);
cit = cv.FindClose(key, false);
if (it != v.End()) {
CPPUNIT_ASSERT(it->Key() == cit->Key());
CPPUNIT_ASSERT((*it).Key() == (*it).Key());
CPPUNIT_ASSERT(&it->Value() == &cit->Value());
CPPUNIT_ASSERT(&(*it).Value() == &(*it).Value());
}
}
}
void IteratorTest(int32 maxNumber)
{
EntryStrategy entryStrategy;
TestClass v;
Fill(v, entryStrategy, maxNumber);
const TestClass& cv = v;
Iterator it = v.Begin();
ConstIterator cit = cv.Begin();
for (; it != v.End(); ++it, ++cit) {
CPPUNIT_ASSERT(it->Key() == cit->Key());
CPPUNIT_ASSERT(&it->Value() == &cit->Value());
CPPUNIT_ASSERT(it->Key() == (*it).Key());
CPPUNIT_ASSERT(cit->Key() == (*cit).Key());
CPPUNIT_ASSERT(&it->Value() == &(*it).Value());
CPPUNIT_ASSERT(&cit->Value() == &(*cit).Value());
CPPUNIT_ASSERT(it->Key() == it.operator->().Key());
CPPUNIT_ASSERT(&it->Value() == &it.operator->().Value());
CPPUNIT_ASSERT(cit->Key() == cit.operator->().Key());
CPPUNIT_ASSERT(&cit->Value() == &cit.operator->().Value());
CPPUNIT_ASSERT(it);
CPPUNIT_ASSERT(cit);
}
CPPUNIT_ASSERT(cit == cv.End());
while (it != v.Begin()) {
--it;
--cit;
CPPUNIT_ASSERT(it->Key() == cit->Key());
CPPUNIT_ASSERT(&it->Value() == &cit->Value());
CPPUNIT_ASSERT(it->Key() == (*it).Key());
CPPUNIT_ASSERT(cit->Key() == (*cit).Key());
CPPUNIT_ASSERT(&it->Value() == &(*it).Value());
CPPUNIT_ASSERT(&cit->Value() == &(*cit).Value());
CPPUNIT_ASSERT(it->Key() == it.operator->().Key());
CPPUNIT_ASSERT(&it->Value() == &it.operator->().Value());
CPPUNIT_ASSERT(cit->Key() == cit.operator->().Key());
CPPUNIT_ASSERT(&cit->Value() == &cit.operator->().Value());
CPPUNIT_ASSERT(it);
CPPUNIT_ASSERT(cit);
}
CPPUNIT_ASSERT(cit == cv.Begin());
CPPUNIT_ASSERT(!v.Null());
CPPUNIT_ASSERT(!cv.Null());
}
public:
void ConstructorTest()
{
MyMap v1;
CPPUNIT_ASSERT(v1.Count() == 0);
CPPUNIT_ASSERT(v1.IsEmpty());
}
void Put30ElementsTest() { PutTest(30); }
void Put200ElementsTest() { PutTest(200); }
void Get30ElementsTest() { GetTest(30); }
void Get200ElementsTest() { GetTest(200); }
void Insert30ElementsTest() { InsertTest(30); }
void Insert200ElementsTest() { InsertTest(200); }
void Remove30ElementsTest() { RemoveTest(30); }
void Remove200ElementsTest() { RemoveTest(200); }
void Erase30ElementsTest() { EraseTest(30); }
void Erase200ElementsTest() { EraseTest(200); }
void MakeEmpty30ElementsTest() { MakeEmptyTest(30); }
void MakeEmpty200ElementsTest() { MakeEmptyTest(200); }
void Find30ElementsTest() { FindTest(30); }
void Find200ElementsTest() { FindTest(200); }
void FindClose30ElementsTest() { FindCloseTest(30); }
void FindClose200ElementsTest() { FindCloseTest(200); }
void Iterator30ElementsTest() { IteratorTest(30); }
void Iterator200ElementsTest() { IteratorTest(200); }
};
// That's how it should work, if we had a working compiler. // That's how it should work, if we had a working compiler.
/* /*
@@ -39,7 +845,6 @@ typedef typename PairTestBase<int, int>::Strategy IntIntTestStrategy;
*/ */
// ugly work-around: // ugly work-around:
template<typename Key, typename Value> template<typename Key, typename Value>
struct PairTestBase { struct PairTestBase {
typedef SimpleValueStrategy<Key> KeyStrategy; typedef SimpleValueStrategy<Key> KeyStrategy;
@@ -48,37 +853,27 @@ struct PairTestBase {
template<typename CompareStrategy> template<typename CompareStrategy>
struct MyMap struct MyMap
: public VectorMap<Key, Value, VectorMapEntryStrategy::Pair<Key, Value, : public VectorMap<Key, Value, VectorMapEntryStrategy::Pair<Key, Value, CompareStrategy> > {
CompareStrategy> > {
}; };
}; };
#define DECLARE_TEST_STRATEGY(Key, Value, Map, Strategy, ClassName) \
#define DECLARE_TEST_STRATEGY(Key, Value, Map, Strategy) \
template<typename CS> struct Map : PairTestBase<Key, Value>::MyMap<CS> {}; \ template<typename CS> struct Map : PairTestBase<Key, Value>::MyMap<CS> {}; \
template<typename CS> \ template<typename CS> \
struct Strategy \ struct Strategy : public TestStrategy<Map, PairTestBase<Key, Value>::EntryStrategy, CS> {};
: public TestStrategy<Map, PairTestBase<Key, Value>::EntryStrategy, \
CS> { \
static const char *kClassName; \
}; \
template<typename CS> const char *Strategy<CS>::kClassName = ClassName;
DECLARE_TEST_STRATEGY(int, int, IntIntMap, IntIntTestStrategy,
"VectorMap<int, int, Pair>") DECLARE_TEST_STRATEGY(int, int, IntIntMap, IntIntTestStrategy)
DECLARE_TEST_STRATEGY(int, string, IntStringMap, IntStringTestStrategy, DECLARE_TEST_STRATEGY(int, string, IntStringMap, IntStringTestStrategy)
"VectorMap<int, string, Pair>") DECLARE_TEST_STRATEGY(string, int, StringIntMap, StringIntTestStrategy)
DECLARE_TEST_STRATEGY(string, int, StringIntMap, StringIntTestStrategy, DECLARE_TEST_STRATEGY(string, string, StringStringMap, StringStringTestStrategy)
"VectorMap<string, int, Pair>")
DECLARE_TEST_STRATEGY(string, string, StringStringMap,
StringStringTestStrategy,
"VectorMap<string, string, Pair>")
// TestStrategy for the ImplicitKey entry strategy // TestStrategy for the ImplicitKey entry strategy
// string_hash (from the Dragon Book: a slightly modified hashpjw()) // string_hash (from the Dragon Book: a slightly modified hashpjw())
static inline static inline int
int
string_hash(const char* name) string_hash(const char* name)
{ {
uint32 h = 0; uint32 h = 0;
@@ -90,53 +885,45 @@ string_hash(const char *name)
return (int)h; return (int)h;
} }
struct ImplicitKeyTestGetKey { struct ImplicitKeyTestGetKey {
int operator()(string value) const int operator()(string value) const { return string_hash(value.c_str()); }
{
return string_hash(value.c_str());
}
}; };
template<typename CompareStrategy> template<typename CompareStrategy>
struct ImplicitKeyTestMap struct ImplicitKeyTestMap : public VectorMap<int, string,
: public VectorMap<int, string, VectorMapEntryStrategy::ImplicitKey<int, string,
VectorMapEntryStrategy::ImplicitKey<int, string, ImplicitKeyTestGetKey, ImplicitKeyTestGetKey, CompareStrategy> > {};
CompareStrategy> > {
};
typedef ImplicitKeyStrategy<SimpleValueStrategy<int>,
SimpleValueStrategy<string>, typedef ImplicitKeyStrategy<SimpleValueStrategy<int>, SimpleValueStrategy<string>,
ImplicitKeyTestGetKey> ImplicitKeyTestGetKey>
ImplicitKeyTestEntryStrategy; ImplicitKeyTestEntryStrategy;
template<class CompareStrategy> template<class CompareStrategy>
struct ImplicitKeyTestStrategy : public TestStrategy< struct ImplicitKeyTestStrategy
ImplicitKeyTestMap, ImplicitKeyTestEntryStrategy, CompareStrategy> { : public TestStrategy<ImplicitKeyTestMap, ImplicitKeyTestEntryStrategy, CompareStrategy> {};
static const char *kClassName;
};
template<class CompareStrategy>
const char *ImplicitKeyTestStrategy<CompareStrategy>::kClassName
= "VectorMap<int, string, ImplicitKey>";
// constructor CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorMapTest<IntIntTestStrategy<Ascending> >,
VectorMapTest::VectorMapTest(std::string name) getTestSuiteName());
: BTestCase(name) CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorMapTest<IntIntTestStrategy<Descending> >,
{ getTestSuiteName());
} CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorMapTest<IntStringTestStrategy<Ascending> >,
getTestSuiteName());
// Suite CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorMapTest<IntStringTestStrategy<Descending> >,
CppUnit::Test* getTestSuiteName());
VectorMapTest::Suite() CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorMapTest<StringIntTestStrategy<Ascending> >,
{ getTestSuiteName());
CppUnit::TestSuite *suite = new CppUnit::TestSuite("VectorMap"); CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorMapTest<StringIntTestStrategy<Descending> >,
getTestSuiteName());
suite->addTest(OrderedMapTest<IntIntTestStrategy>::Suite()); CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorMapTest<StringStringTestStrategy<Ascending> >,
suite->addTest(OrderedMapTest<IntStringTestStrategy>::Suite()); getTestSuiteName());
suite->addTest(OrderedMapTest<StringIntTestStrategy>::Suite()); CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorMapTest<StringStringTestStrategy<Descending> >,
suite->addTest(OrderedMapTest<StringStringTestStrategy>::Suite()); getTestSuiteName());
suite->addTest(OrderedMapTest<ImplicitKeyTestStrategy>::Suite()); CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorMapTest<ImplicitKeyTestStrategy<Ascending> >,
getTestSuiteName());
return suite; CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorMapTest<ImplicitKeyTestStrategy<Descending> >,
} getTestSuiteName());
src/tests/system/kernel/util/VectorMapTest.h
-13
View File
@@ -1,13 +0,0 @@
#ifndef _vector_map_test_h_
#define _vector_map_test_h_
#include <TestCase.h>
class VectorMapTest : public BTestCase {
public:
VectorMapTest(std::string name = "");
static CppUnit::Test* Suite();
};
#endif // _vector_map_test_h_
src/tests/system/kernel/util/VectorSetTest.cpp
+184 -401
View File
@@ -1,92 +1,43 @@
/*
* Copyright 2003-2026, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <set> #include <set>
using std::set; #include <string>
#include <TestUtils.h> #include <TestSuiteAddon.h>
#include <cppunit/Test.h> #include <cppunit/TestFixture.h>
#include <cppunit/TestCaller.h> #include <cppunit/extensions/HelperMacros.h>
#include <cppunit/TestSuite.h>
#include <VectorSet.h> #include <VectorSet.h>
#include "common.h"
#include "VectorSetTest.h"
using VectorSetOrder::Ascending; using VectorSetOrder::Ascending;
using VectorSetOrder::Descending; using VectorSetOrder::Descending;
VectorSetTest::VectorSetTest(std::string name)
: BTestCase(name)
{
}
CppUnit::Test* template<typename Value, typename TestSet, typename MyIterator, typename ReferenceIterator>
VectorSetTest::Suite()
{
CppUnit::TestSuite *suite = new CppUnit::TestSuite("VectorSet");
ADD_TEST4(VectorSet, suite, VectorSetTest, ConstructorTest);
ADD_TEST4(VectorSet, suite, VectorSetTest, InsertTest);
ADD_TEST4(VectorSet, suite, VectorSetTest, RemoveTest);
ADD_TEST4(VectorSet, suite, VectorSetTest, EraseTest);
ADD_TEST4(VectorSet, suite, VectorSetTest, MakeEmptyTest);
ADD_TEST4(VectorSet, suite, VectorSetTest, FindTest);
ADD_TEST4(VectorSet, suite, VectorSetTest, FindCloseTest);
ADD_TEST4(VectorSet, suite, VectorSetTest, IteratorTest);
return suite;
}
//! ConstructorTest
void
VectorSetTest::ConstructorTest()
{
NextSubTest();
VectorSet<int> v1(100);
CHK(v1.Count() == 0);
CHK(v1.IsEmpty());
NextSubTest();
VectorSet<string> v2(100);
CHK(v2.Count() == 0);
CHK(v2.IsEmpty());
NextSubTest();
VectorSet<int> v3(0);
CHK(v3.Count() == 0);
CHK(v3.IsEmpty());
NextSubTest();
VectorSet<string> v4(0);
CHK(v4.Count() == 0);
CHK(v4.IsEmpty());
}
// TestIterator
template<typename Value, typename TestSet, typename MyIterator,
typename ReferenceIterator>
class TestIterator { class TestIterator {
private: typedef TestIterator<Value, TestSet, MyIterator, ReferenceIterator> Iterator;
typedef TestIterator<Value, TestSet, MyIterator, ReferenceIterator>
Iterator;
public: public:
inline TestIterator(TestSet* s, MyIterator myIt, ReferenceIterator refIt) inline TestIterator(TestSet* s, MyIterator myIt, ReferenceIterator refIt)
: fSet(s), :
fSet(s),
fMyIterator(myIt), fMyIterator(myIt),
fReferenceIterator(refIt) fReferenceIterator(refIt)
{ {
} }
inline TestIterator(const Iterator& other) inline TestIterator(const Iterator& other)
: fSet(other.fSet), :
fSet(other.fSet),
fMyIterator(other.fMyIterator), fMyIterator(other.fMyIterator),
fReferenceIterator(other.fReferenceIterator) fReferenceIterator(other.fReferenceIterator)
{ {
CHK(fMyIterator == other.fMyIterator); CPPUNIT_ASSERT(fMyIterator == other.fMyIterator);
} }
inline Iterator& operator++() inline Iterator& operator++()
@@ -94,9 +45,9 @@ public:
MyIterator& myResult = ++fMyIterator; MyIterator& myResult = ++fMyIterator;
ReferenceIterator& refResult = ++fReferenceIterator; ReferenceIterator& refResult = ++fReferenceIterator;
if (refResult == fSet->fReferenceSet.end()) if (refResult == fSet->fReferenceSet.end())
CHK(myResult == fSet->fMySet.End()); CPPUNIT_ASSERT(myResult == fSet->fMySet.End());
else else
CHK(*myResult == *refResult); CPPUNIT_ASSERT(*myResult == *refResult);
return *this; return *this;
} }
@@ -105,11 +56,11 @@ public:
MyIterator oldMyResult = fMyIterator; MyIterator oldMyResult = fMyIterator;
MyIterator myResult = fMyIterator++; MyIterator myResult = fMyIterator++;
ReferenceIterator refResult = fReferenceIterator++; ReferenceIterator refResult = fReferenceIterator++;
CHK(oldMyResult == myResult); CPPUNIT_ASSERT(oldMyResult == myResult);
if (refResult == fSet->fReferenceSet.end()) if (refResult == fSet->fReferenceSet.end())
CHK(myResult == fSet->fMySet.End()); CPPUNIT_ASSERT(myResult == fSet->fMySet.End());
else else
CHK(*myResult == *refResult); CPPUNIT_ASSERT(*myResult == *refResult);
return Iterator(fSet, myResult, refResult); return Iterator(fSet, myResult, refResult);
} }
@@ -117,7 +68,7 @@ public:
{ {
MyIterator& myResult = --fMyIterator; MyIterator& myResult = --fMyIterator;
ReferenceIterator& refResult = --fReferenceIterator; ReferenceIterator& refResult = --fReferenceIterator;
CHK(*myResult == *refResult); CPPUNIT_ASSERT(*myResult == *refResult);
return *this; return *this;
} }
@@ -126,8 +77,8 @@ public:
MyIterator oldMyResult = fMyIterator; MyIterator oldMyResult = fMyIterator;
MyIterator myResult = fMyIterator--; MyIterator myResult = fMyIterator--;
ReferenceIterator refResult = fReferenceIterator--; ReferenceIterator refResult = fReferenceIterator--;
CHK(oldMyResult == myResult); CPPUNIT_ASSERT(oldMyResult == myResult);
CHK(*myResult == *refResult); CPPUNIT_ASSERT(*myResult == *refResult);
return Iterator(fSet, myResult, refResult); return Iterator(fSet, myResult, refResult);
} }
@@ -136,42 +87,42 @@ public:
fSet = other.fSet; fSet = other.fSet;
fMyIterator = other.fMyIterator; fMyIterator = other.fMyIterator;
fReferenceIterator = other.fReferenceIterator; fReferenceIterator = other.fReferenceIterator;
CHK(fMyIterator == other.fMyIterator); CPPUNIT_ASSERT(fMyIterator == other.fMyIterator);
return *this; return *this;
} }
inline bool operator==(const Iterator& other) const inline bool operator==(const Iterator& other) const
{ {
bool result = (fMyIterator == other.fMyIterator); bool result = (fMyIterator == other.fMyIterator);
CHK((fReferenceIterator == other.fReferenceIterator) == result); CPPUNIT_ASSERT((fReferenceIterator == other.fReferenceIterator) == result);
return result; return result;
} }
inline bool operator!=(const Iterator& other) const inline bool operator!=(const Iterator& other) const
{ {
bool result = (fMyIterator != other.fMyIterator); bool result = (fMyIterator != other.fMyIterator);
CHK((fReferenceIterator != other.fReferenceIterator) == result); CPPUNIT_ASSERT((fReferenceIterator != other.fReferenceIterator) == result);
return result; return result;
} }
inline Value& operator*() const inline Value& operator*() const
{ {
Value& result = *fMyIterator; Value& result = *fMyIterator;
CHK(result == *fReferenceIterator); CPPUNIT_ASSERT(result == *fReferenceIterator);
return result; return result;
} }
inline Value* operator->() const inline Value* operator->() const
{ {
Value* result = fMyIterator.operator->(); Value* result = fMyIterator.operator->();
CHK(*result == *fReferenceIterator); CPPUNIT_ASSERT(*result == *fReferenceIterator);
return result; return result;
} }
inline operator bool() const inline operator bool() const
{ {
bool result = fMyIterator; bool result = fMyIterator;
CHK((fMyIterator == fSet->fMySet.Null()) != result); CPPUNIT_ASSERT((fMyIterator == fSet->fMySet.Null()) != result);
return result; return result;
} }
@@ -181,9 +132,8 @@ public:
ReferenceIterator fReferenceIterator; ReferenceIterator fReferenceIterator;
}; };
// TestSet
template<typename Value, typename MySet, typename ReferenceSet, template<typename Value, typename MySet, typename ReferenceSet, typename Compare>
typename Compare>
class TestSet { class TestSet {
public: public:
typedef TestSet<Value, MySet, ReferenceSet, Compare> Class; typedef TestSet<Value, MySet, ReferenceSet, Compare> Class;
@@ -192,13 +142,13 @@ public:
typedef typename ReferenceSet::iterator ReferenceIterator; typedef typename ReferenceSet::iterator ReferenceIterator;
typedef typename MySet::ConstIterator MyConstIterator; typedef typename MySet::ConstIterator MyConstIterator;
typedef typename ReferenceSet::const_iterator ReferenceConstIterator; typedef typename ReferenceSet::const_iterator ReferenceConstIterator;
typedef TestIterator<Value, Class, MyIterator, typedef TestIterator<Value, Class, MyIterator, ReferenceIterator> Iterator;
ReferenceIterator> Iterator; typedef TestIterator<const Value, const Class, MyConstIterator, ReferenceConstIterator>
typedef TestIterator<const Value, const Class, MyConstIterator, ConstIterator;
ReferenceConstIterator> ConstIterator;
TestSet() TestSet()
: fMySet(), :
fMySet(),
fReferenceSet(), fReferenceSet(),
fChecking(true) fChecking(true)
{ {
@@ -206,7 +156,7 @@ public:
void Insert(const Value& value, bool replace = true) void Insert(const Value& value, bool replace = true)
{ {
CHK(fMySet.Insert(value, replace) == B_OK); CPPUNIT_ASSERT(fMySet.Insert(value, replace) == B_OK);
ReferenceIterator it = fReferenceSet.find(value); ReferenceIterator it = fReferenceSet.find(value);
if (it != fReferenceSet.end()) if (it != fReferenceSet.end())
fReferenceSet.erase(it); fReferenceSet.erase(it);
@@ -219,17 +169,16 @@ public:
int32 oldCount = Count(); int32 oldCount = Count();
fReferenceSet.erase(value); fReferenceSet.erase(value);
int32 newCount = fReferenceSet.size(); int32 newCount = fReferenceSet.size();
CHK(fMySet.Remove(value) == oldCount - newCount); CPPUNIT_ASSERT(fMySet.Remove(value) == oldCount - newCount);
Check(); Check();
} }
Iterator Erase(const Iterator& iterator) Iterator Erase(const Iterator& iterator)
{ {
bool outOfRange bool outOfRange = (iterator.fReferenceIterator == fReferenceSet.end());
= (iterator.fReferenceIterator == fReferenceSet.end());
MyIterator myIt = fMySet.Erase(iterator.fMyIterator); MyIterator myIt = fMySet.Erase(iterator.fMyIterator);
if (outOfRange) { if (outOfRange) {
CHK(myIt == fMySet.Null()); CPPUNIT_ASSERT(myIt == fMySet.Null());
return Iterator(this, myIt, fReferenceSet.end()); return Iterator(this, myIt, fReferenceSet.end());
} }
Value nextValue; Value nextValue;
@@ -245,23 +194,23 @@ public:
refIt = fReferenceSet.find(nextValue); refIt = fReferenceSet.find(nextValue);
Check(); Check();
if (refIt == fReferenceSet.end()) if (refIt == fReferenceSet.end())
CHK(myIt == fMySet.End()); CPPUNIT_ASSERT(myIt == fMySet.End());
else else
CHK(*myIt == *refIt); CPPUNIT_ASSERT(*myIt == *refIt);
return Iterator(this, myIt, refIt); return Iterator(this, myIt, refIt);
} }
inline int32 Count() const inline int32 Count() const
{ {
int32 count = fReferenceSet.size(); int32 count = fReferenceSet.size();
CHK(fMySet.Count() == count); CPPUNIT_ASSERT(fMySet.Count() == count);
return count; return count;
} }
inline bool IsEmpty() const inline bool IsEmpty() const
{ {
bool result = fReferenceSet.empty(); bool result = fReferenceSet.empty();
CHK(fMySet.IsEmpty() == result); CPPUNIT_ASSERT(fMySet.IsEmpty() == result);
return result; return result;
} }
@@ -272,32 +221,19 @@ public:
Check(); Check();
} }
inline Iterator Begin() inline Iterator Begin() { return Iterator(this, fMySet.Begin(), fReferenceSet.begin()); }
{
return Iterator(this, fMySet.Begin(), fReferenceSet.begin());
}
inline ConstIterator Begin() const inline ConstIterator Begin() const
{ {
return ConstIterator(this, fMySet.Begin(), return ConstIterator(this, fMySet.Begin(), fReferenceSet.begin());
fReferenceSet.begin());
}
inline Iterator End()
{
return Iterator(this, fMySet.End(), fReferenceSet.end());
} }
inline Iterator End() { return Iterator(this, fMySet.End(), fReferenceSet.end()); }
inline ConstIterator End() const inline ConstIterator End() const
{ {
return ConstIterator(this, fMySet.End(), fReferenceSet.end()); return ConstIterator(this, fMySet.End(), fReferenceSet.end());
} }
inline Iterator Null() inline Iterator Null() { return Iterator(this, fMySet.Null(), fReferenceSet.end()); }
{
return Iterator(this, fMySet.Null(), fReferenceSet.end());
}
inline ConstIterator Null() const inline ConstIterator Null() const
{ {
return ConstIterator(this, fMySet.Null(), fReferenceSet.end()); return ConstIterator(this, fMySet.Null(), fReferenceSet.end());
@@ -336,9 +272,9 @@ public:
MyIterator myIt = fMySet.Find(value); MyIterator myIt = fMySet.Find(value);
ReferenceIterator refIt = fReferenceSet.find(value); ReferenceIterator refIt = fReferenceSet.find(value);
if (refIt == fReferenceSet.end()) if (refIt == fReferenceSet.end())
CHK(myIt = fMySet.End()); CPPUNIT_ASSERT(myIt = fMySet.End());
else else
CHK(*myIt == *refIt); CPPUNIT_ASSERT(*myIt == *refIt);
return Iterator(this, myIt, refIt); return Iterator(this, myIt, refIt);
} }
@@ -347,9 +283,9 @@ public:
MyConstIterator myIt = fMySet.Find(value); MyConstIterator myIt = fMySet.Find(value);
ReferenceConstIterator refIt = fReferenceSet.find(value); ReferenceConstIterator refIt = fReferenceSet.find(value);
if (refIt == fReferenceSet.end()) if (refIt == fReferenceSet.end())
CHK(myIt = fMySet.End()); CPPUNIT_ASSERT(myIt = fMySet.End());
else else
CHK(*myIt == *refIt); CPPUNIT_ASSERT(*myIt == *refIt);
return ConstIterator(this, myIt, refIt); return ConstIterator(this, myIt, refIt);
} }
@@ -359,24 +295,24 @@ public:
if (myIt == fMySet.End()) { if (myIt == fMySet.End()) {
if (fMySet.Count() > 0) { if (fMySet.Count() > 0) {
if (less) if (less)
CHK(fCompare(*fMySet.Begin(), value) > 0); CPPUNIT_ASSERT(fCompare(*fMySet.Begin(), value) > 0);
else else
CHK(fCompare(*--MyIterator(myIt), value) < 0); CPPUNIT_ASSERT(fCompare(*--MyIterator(myIt), value) < 0);
} }
return End(); return End();
} }
if (less) { if (less) {
CHK(fCompare(*myIt, value) <= 0); CPPUNIT_ASSERT(fCompare(*myIt, value) <= 0);
MyIterator nextMyIt(myIt); MyIterator nextMyIt(myIt);
++nextMyIt; ++nextMyIt;
if (nextMyIt != fMySet.End()) if (nextMyIt != fMySet.End())
CHK(fCompare(*nextMyIt, value) > 0); CPPUNIT_ASSERT(fCompare(*nextMyIt, value) > 0);
} else { } else {
CHK(fCompare(*myIt, value) >= 0); CPPUNIT_ASSERT(fCompare(*myIt, value) >= 0);
if (myIt != fMySet.Begin()) { if (myIt != fMySet.Begin()) {
MyIterator prevMyIt(myIt); MyIterator prevMyIt(myIt);
--prevMyIt; --prevMyIt;
CHK(fCompare(*prevMyIt, value) < 0); CPPUNIT_ASSERT(fCompare(*prevMyIt, value) < 0);
} }
} }
return Iterator(this, myIt, fReferenceSet.find(*myIt)); return Iterator(this, myIt, fReferenceSet.find(*myIt));
@@ -388,49 +324,45 @@ public:
if (myIt == fMySet.End()) { if (myIt == fMySet.End()) {
if (fMySet.Count() > 0) { if (fMySet.Count() > 0) {
if (less) if (less)
CHK(fCompare(*fMySet.Begin(), value) > 0); CPPUNIT_ASSERT(fCompare(*fMySet.Begin(), value) > 0);
else else
CHK(fCompare(*--MyConstIterator(myIt), value) < 0); CPPUNIT_ASSERT(fCompare(*--MyConstIterator(myIt), value) < 0);
} }
return End(); return End();
} }
if (less) { if (less) {
CHK(fCompare(*myIt, value) <= 0); CPPUNIT_ASSERT(fCompare(*myIt, value) <= 0);
MyConstIterator nextMyIt(myIt); MyConstIterator nextMyIt(myIt);
++nextMyIt; ++nextMyIt;
if (nextMyIt != fMySet.End()) if (nextMyIt != fMySet.End())
CHK(fCompare(*nextMyIt, value) > 0); CPPUNIT_ASSERT(fCompare(*nextMyIt, value) > 0);
} else { } else {
CHK(fCompare(*myIt, value) >= 0); CPPUNIT_ASSERT(fCompare(*myIt, value) >= 0);
if (myIt != fMySet.Begin()) { if (myIt != fMySet.Begin()) {
MyConstIterator prevMyIt(myIt); MyConstIterator prevMyIt(myIt);
--prevMyIt; --prevMyIt;
CHK(fCompare(*prevMyIt, value) < 0); CPPUNIT_ASSERT(fCompare(*prevMyIt, value) < 0);
} }
} }
return ConstIterator(this, myIt, fReferenceSet.find(*myIt)); return ConstIterator(this, myIt, fReferenceSet.find(*myIt));
} }
void SetChecking(bool enable) void SetChecking(bool enable) { fChecking = enable; }
{
fChecking = enable;
}
void Check() const void Check() const
{ {
if (fChecking) { if (fChecking) {
int32 count = fReferenceSet.size(); int32 count = fReferenceSet.size();
CHK(fMySet.Count() == count); CPPUNIT_ASSERT(fMySet.Count() == count);
CHK(fMySet.IsEmpty() == fReferenceSet.empty()); CPPUNIT_ASSERT(fMySet.IsEmpty() == fReferenceSet.empty());
MyConstIterator myIt = fMySet.Begin(); MyConstIterator myIt = fMySet.Begin();
ReferenceConstIterator refIt = fReferenceSet.begin(); ReferenceConstIterator refIt = fReferenceSet.begin();
for (int32 i = 0; i < count; i++, ++myIt, ++refIt) for (int32 i = 0; i < count; i++, ++myIt, ++refIt)
CHK(*myIt == *refIt); CPPUNIT_ASSERT(*myIt == *refIt);
CHK(myIt == fMySet.End()); CPPUNIT_ASSERT(myIt == fMySet.End());
} }
} }
//private:
public: public:
MySet fMySet; MySet fMySet;
ReferenceSet fReferenceSet; ReferenceSet fReferenceSet;
@@ -439,41 +371,39 @@ public:
}; };
// IntStrategy
class IntStrategy { class IntStrategy {
public: public:
typedef int Value; typedef int Value;
IntStrategy(int32 differentValues = 100000) IntStrategy(int32 differentValues = 100000)
: fDifferentValues(differentValues) :
fDifferentValues(differentValues)
{ {
srand(0); srand(0);
} }
Value Generate() Value Generate() { return rand() % fDifferentValues; }
{
return rand() % fDifferentValues;
}
private: private:
int32 fDifferentValues; int32 fDifferentValues;
}; };
// StringStrategy
class StringStrategy { class StringStrategy {
public: public:
typedef string Value; typedef std::string Value;
StringStrategy(int32 differentValues = 100000) StringStrategy(int32 differentValues = 100000)
: fDifferentValues(differentValues) :
fDifferentValues(differentValues)
{ {
srand(0); srand(0);
} }
Value Generate() Value Generate()
{ {
char buffer[10]; char buffer[12];
sprintf(buffer, "%ld", rand() % fDifferentValues); sprintf(buffer, "%" B_PRId32, rand() % fDifferentValues);
return string(buffer); return string(buffer);
} }
@@ -481,20 +411,17 @@ private:
int32 fDifferentValues; int32 fDifferentValues;
}; };
// CompareWrapper
template<typename Value, typename Compare> template<typename Value, typename Compare>
class CompareWrapper { class CompareWrapper {
public: public:
inline bool operator()(const Value &a, const Value &b) const inline bool operator()(const Value& a, const Value& b) const { return fCompare(a, b) < 0; }
{
return (fCompare(a, b) < 0);
}
private: private:
Compare fCompare; Compare fCompare;
}; };
// TestStrategy
template<typename _ValueStrategy, template<typename> class _CompareStrategy> template<typename _ValueStrategy, template<typename> class _CompareStrategy>
class TestStrategy { class TestStrategy {
public: public:
@@ -503,56 +430,53 @@ public:
typedef _CompareStrategy<Value> Compare; typedef _CompareStrategy<Value> Compare;
typedef CompareWrapper<Value, Compare> BoolCompare; typedef CompareWrapper<Value, Compare> BoolCompare;
typedef VectorSet<Value, Compare> MySet; typedef VectorSet<Value, Compare> MySet;
typedef set<Value, BoolCompare> ReferenceSet; typedef std::set<Value, BoolCompare> ReferenceSet;
typedef TestSet<Value, MySet, ReferenceSet, Compare> TestClass; typedef TestSet<Value, MySet, ReferenceSet, Compare> TestClass;
}; };
typedef TestStrategy<IntStrategy, Ascending> AIntTestStrategy;
typedef TestStrategy<StringStrategy, Ascending> AStringTestStrategy;
typedef TestStrategy<IntStrategy, Descending> DIntTestStrategy;
typedef TestStrategy<StringStrategy, Descending> DStringTestStrategy;
// GenericInsertTest typedef TestStrategy<IntStrategy, Ascending> IntAscTestStrategy;
template<typename _TestStrategy> typedef TestStrategy<IntStrategy, Descending> IntDescTestStrategy;
static typedef TestStrategy<StringStrategy, Ascending> StringAscTestStrategy;
void typedef TestStrategy<StringStrategy, Descending> StringDescTestStrategy;
GenericInsertTest(int32 maxNumber)
template<typename TestStrategy>
class VectorSetTest : public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(VectorSetTest);
CPPUNIT_TEST(Constructor100ElementsTest);
CPPUNIT_TEST(Constructor0ElementsTest);
CPPUNIT_TEST(Insert30ElementsTest);
CPPUNIT_TEST(Insert200ElementsTest);
CPPUNIT_TEST(Remove30ElementsTest);
CPPUNIT_TEST(Remove200ElementsTest);
CPPUNIT_TEST(Erase30ElementsTest);
CPPUNIT_TEST(Erase200ElementsTest);
CPPUNIT_TEST(MakeEmpty30ElementsTest);
CPPUNIT_TEST(MakeEmpty200ElementsTest);
CPPUNIT_TEST(Find30ElementsTest);
CPPUNIT_TEST(Find200ElementsTest);
CPPUNIT_TEST(FindClose30ElementsTest);
CPPUNIT_TEST(FindClose200ElementsTest);
CPPUNIT_TEST(Iterator30ElementsTest);
CPPUNIT_TEST(Iterator200ElementsTest);
CPPUNIT_TEST_SUITE_END();
typedef typename TestStrategy::ValueStrategy ValueStrategy;
typedef typename TestStrategy::Value Value;
typedef typename TestStrategy::TestClass TestClass;
typedef typename TestClass::Iterator Iterator;
typedef typename TestClass::ConstIterator ConstIterator;
void InsertTest(int32 maxNumber)
{ {
typedef typename _TestStrategy::ValueStrategy ValueStrategy;
typedef typename _TestStrategy::TestClass TestClass;
ValueStrategy strategy; ValueStrategy strategy;
TestClass v; TestClass v;
for (int32 i = 0; i < maxNumber; i++) for (int32 i = 0; i < maxNumber; i++)
v.Insert(strategy.Generate()); v.Insert(strategy.Generate());
} }
// InsertTest void Fill(TestClass& v, ValueStrategy strategy, int32 maxNumber)
void
VectorSetTest::InsertTest()
{
NextSubTest();
GenericInsertTest<AIntTestStrategy>(30);
NextSubTest();
GenericInsertTest<DIntTestStrategy>(30);
NextSubTest();
GenericInsertTest<AIntTestStrategy>(200);
NextSubTest();
GenericInsertTest<DIntTestStrategy>(200);
NextSubTest();
GenericInsertTest<AStringTestStrategy>(30);
NextSubTest();
GenericInsertTest<DStringTestStrategy>(30);
NextSubTest();
GenericInsertTest<AStringTestStrategy>(200);
NextSubTest();
GenericInsertTest<DStringTestStrategy>(200);
}
// GenericFill
template<typename TestClass, typename ValueStrategy>
static
void
GenericFill(TestClass &v, ValueStrategy strategy, int32 maxNumber)
{ {
v.SetChecking(false); v.SetChecking(false);
for (int32 i = 0; v.Count() < maxNumber; i++) for (int32 i = 0; v.Count() < maxNumber; i++)
@@ -561,18 +485,11 @@ GenericFill(TestClass &v, ValueStrategy strategy, int32 maxNumber)
v.Check(); v.Check();
} }
// GenericRemoveTest void RemoveTest(int32 maxNumber)
template<typename _TestStrategy>
static
void
GenericRemoveTest(int32 maxNumber)
{ {
typedef typename _TestStrategy::ValueStrategy ValueStrategy;
typedef typename _TestStrategy::Value Value;
typedef typename _TestStrategy::TestClass TestClass;
ValueStrategy strategy; ValueStrategy strategy;
TestClass v; TestClass v;
GenericFill(v, strategy, maxNumber); Fill(v, strategy, maxNumber);
while (v.Count() > 0) { while (v.Count() > 0) {
int32 index = rand() % (v.Count()); int32 index = rand() % (v.Count());
Value value = *v.IteratorForIndex(index); Value value = *v.IteratorForIndex(index);
@@ -581,126 +498,39 @@ GenericRemoveTest(int32 maxNumber)
} }
} }
// RemoveTest void EraseTest(int32 maxNumber)
void
VectorSetTest::RemoveTest()
{ {
NextSubTest();
GenericRemoveTest<AIntTestStrategy>(30);
NextSubTest();
GenericRemoveTest<DIntTestStrategy>(30);
NextSubTest();
GenericRemoveTest<AIntTestStrategy>(200);
NextSubTest();
GenericRemoveTest<DIntTestStrategy>(200);
NextSubTest();
GenericRemoveTest<AStringTestStrategy>(30);
NextSubTest();
GenericRemoveTest<DStringTestStrategy>(30);
NextSubTest();
GenericRemoveTest<AStringTestStrategy>(200);
NextSubTest();
GenericRemoveTest<DStringTestStrategy>(200);
}
// GenericEraseTest
template<typename _TestStrategy>
static
void
GenericEraseTest(int32 maxNumber)
{
typedef typename _TestStrategy::ValueStrategy ValueStrategy;
typedef typename _TestStrategy::TestClass TestClass;
ValueStrategy strategy; ValueStrategy strategy;
TestClass v; TestClass v;
GenericFill(v, strategy, maxNumber); Fill(v, strategy, maxNumber);
for (int32 i = maxNumber - 1; i >= 0; i--) { for (int32 i = maxNumber - 1; i >= 0; i--) {
int32 index = rand() % (i + 1); int32 index = rand() % (i + 1);
v.Erase(v.IteratorForIndex(index)); v.Erase(v.IteratorForIndex(index));
} }
} }
// EraseTest void MakeEmptyTest(int32 maxNumber)
void
VectorSetTest::EraseTest()
{ {
NextSubTest();
GenericEraseTest<AIntTestStrategy>(30);
NextSubTest();
GenericEraseTest<DIntTestStrategy>(30);
NextSubTest();
GenericEraseTest<AIntTestStrategy>(200);
NextSubTest();
GenericEraseTest<DIntTestStrategy>(200);
NextSubTest();
GenericEraseTest<AStringTestStrategy>(30);
NextSubTest();
GenericEraseTest<DStringTestStrategy>(30);
NextSubTest();
GenericEraseTest<AStringTestStrategy>(200);
NextSubTest();
GenericEraseTest<DStringTestStrategy>(200);
}
// GenericMakeEmptyTest
template<typename _TestStrategy>
static
void
GenericMakeEmptyTest(int32 maxNumber)
{
typedef typename _TestStrategy::ValueStrategy ValueStrategy;
typedef typename _TestStrategy::TestClass TestClass;
ValueStrategy strategy; ValueStrategy strategy;
TestClass v; TestClass v;
v.MakeEmpty(); v.MakeEmpty();
GenericFill(v, strategy, maxNumber); Fill(v, strategy, maxNumber);
v.MakeEmpty(); v.MakeEmpty();
v.MakeEmpty(); v.MakeEmpty();
} }
// MakeEmptyTest void FindTest(int32 maxNumber)
void
VectorSetTest::MakeEmptyTest()
{ {
NextSubTest();
GenericMakeEmptyTest<AIntTestStrategy>(30);
NextSubTest();
GenericMakeEmptyTest<DIntTestStrategy>(30);
NextSubTest();
GenericMakeEmptyTest<AIntTestStrategy>(200);
NextSubTest();
GenericMakeEmptyTest<DIntTestStrategy>(200);
NextSubTest();
GenericMakeEmptyTest<AStringTestStrategy>(30);
NextSubTest();
GenericMakeEmptyTest<DStringTestStrategy>(30);
NextSubTest();
GenericMakeEmptyTest<AStringTestStrategy>(200);
NextSubTest();
GenericMakeEmptyTest<DStringTestStrategy>(200);
}
// GenericFindTest
template<typename _TestStrategy>
static
void
GenericFindTest(int32 maxNumber)
{
typedef typename _TestStrategy::ValueStrategy ValueStrategy;
typedef typename _TestStrategy::Value Value;
typedef typename _TestStrategy::TestClass TestClass;
typedef typename TestClass::Iterator Iterator;
typedef typename TestClass::ConstIterator ConstIterator;
ValueStrategy strategy; ValueStrategy strategy;
TestClass v; TestClass v;
GenericFill(v, strategy, maxNumber); Fill(v, strategy, maxNumber);
const TestClass& cv = v; const TestClass& cv = v;
// find the values in the set // find the values in the set
for (int32 i = 0; i < maxNumber; i++) { for (int32 i = 0; i < maxNumber; i++) {
const Value& value = *v.IteratorForIndex(i); const Value& value = *v.IteratorForIndex(i);
Iterator it = v.Find(value); Iterator it = v.Find(value);
ConstIterator cit = cv.Find(value); ConstIterator cit = cv.Find(value);
CHK(&*it == &*cit); CPPUNIT_ASSERT(&*it == &*cit);
} }
// try to find some random values // try to find some random values
for (int32 i = 0; i < maxNumber; i++) { for (int32 i = 0; i < maxNumber; i++) {
@@ -708,46 +538,15 @@ GenericFindTest(int32 maxNumber)
Iterator it = v.Find(value); Iterator it = v.Find(value);
ConstIterator cit = cv.Find(value); ConstIterator cit = cv.Find(value);
if (it != v.End()) if (it != v.End())
CHK(&*it == &*cit); CPPUNIT_ASSERT(&*it == &*cit);
} }
} }
// FindTest void FindCloseTest(int32 maxNumber)
void
VectorSetTest::FindTest()
{ {
NextSubTest();
GenericFindTest<AIntTestStrategy>(30);
NextSubTest();
GenericFindTest<DIntTestStrategy>(30);
NextSubTest();
GenericFindTest<AIntTestStrategy>(200);
NextSubTest();
GenericFindTest<DIntTestStrategy>(200);
NextSubTest();
GenericFindTest<AStringTestStrategy>(30);
NextSubTest();
GenericFindTest<DStringTestStrategy>(30);
NextSubTest();
GenericFindTest<AStringTestStrategy>(200);
NextSubTest();
GenericFindTest<DStringTestStrategy>(200);
}
// GenericFindCloseTest
template<typename _TestStrategy>
static
void
GenericFindCloseTest(int32 maxNumber)
{
typedef typename _TestStrategy::ValueStrategy ValueStrategy;
typedef typename _TestStrategy::Value Value;
typedef typename _TestStrategy::TestClass TestClass;
typedef typename TestClass::Iterator Iterator;
typedef typename TestClass::ConstIterator ConstIterator;
ValueStrategy strategy; ValueStrategy strategy;
TestClass v; TestClass v;
GenericFill(v, strategy, maxNumber); Fill(v, strategy, maxNumber);
const TestClass& cv = v; const TestClass& cv = v;
// find the values in the set // find the values in the set
for (int32 i = 0; i < maxNumber; i++) { for (int32 i = 0; i < maxNumber; i++) {
@@ -755,13 +554,13 @@ GenericFindCloseTest(int32 maxNumber)
// less // less
Iterator it = v.FindClose(value, true); Iterator it = v.FindClose(value, true);
ConstIterator cit = cv.FindClose(value, true); ConstIterator cit = cv.FindClose(value, true);
CHK(*it == value); CPPUNIT_ASSERT(*it == value);
CHK(&*it == &*cit); CPPUNIT_ASSERT(&*it == &*cit);
// greater // greater
it = v.FindClose(value, false); it = v.FindClose(value, false);
cit = cv.FindClose(value, false); cit = cv.FindClose(value, false);
CHK(*it == value); CPPUNIT_ASSERT(*it == value);
CHK(&*it == &*cit); CPPUNIT_ASSERT(&*it == &*cit);
} }
// try to find some random values // try to find some random values
for (int32 i = 0; i < maxNumber; i++) { for (int32 i = 0; i < maxNumber; i++) {
@@ -770,94 +569,78 @@ GenericFindCloseTest(int32 maxNumber)
Iterator it = v.FindClose(value, true); Iterator it = v.FindClose(value, true);
ConstIterator cit = cv.FindClose(value, true); ConstIterator cit = cv.FindClose(value, true);
if (it != v.End()) if (it != v.End())
CHK(&*it == &*cit); CPPUNIT_ASSERT(&*it == &*cit);
// greater // greater
it = v.FindClose(value, false); it = v.FindClose(value, false);
cit = cv.FindClose(value, false); cit = cv.FindClose(value, false);
if (it != v.End()) if (it != v.End())
CHK(&*it == &*cit); CPPUNIT_ASSERT(&*it == &*cit);
} }
} }
// FindCloseTest void IteratorTest(int32 maxNumber)
void
VectorSetTest::FindCloseTest()
{ {
NextSubTest();
GenericFindCloseTest<AIntTestStrategy>(30);
NextSubTest();
GenericFindCloseTest<DIntTestStrategy>(30);
NextSubTest();
GenericFindCloseTest<AIntTestStrategy>(200);
NextSubTest();
GenericFindCloseTest<DIntTestStrategy>(200);
NextSubTest();
GenericFindCloseTest<AStringTestStrategy>(30);
NextSubTest();
GenericFindCloseTest<DStringTestStrategy>(30);
NextSubTest();
GenericFindCloseTest<AStringTestStrategy>(200);
NextSubTest();
GenericFindCloseTest<DStringTestStrategy>(200);
}
// GenericIteratorTest
template<typename _TestStrategy>
static
void
GenericIteratorTest(int32 maxNumber)
{
typedef typename _TestStrategy::ValueStrategy ValueStrategy;
typedef typename _TestStrategy::TestClass TestClass;
typedef typename TestClass::Iterator Iterator;
typedef typename TestClass::ConstIterator ConstIterator;
ValueStrategy strategy; ValueStrategy strategy;
TestClass v; TestClass v;
GenericFill(v, strategy, maxNumber); Fill(v, strategy, maxNumber);
const TestClass& cv = v; const TestClass& cv = v;
Iterator it = v.Begin(); Iterator it = v.Begin();
ConstIterator cit = cv.Begin(); ConstIterator cit = cv.Begin();
for (; it != v.End(); ++it, ++cit) { for (; it != v.End(); ++it, ++cit) {
CHK(&*it == &*cit); CPPUNIT_ASSERT(&*it == &*cit);
CHK(&*it == it.operator->()); CPPUNIT_ASSERT(&*it == it.operator->());
CHK(&*cit == cit.operator->()); CPPUNIT_ASSERT(&*cit == cit.operator->());
CHK(it); CPPUNIT_ASSERT(it);
CHK(cit); CPPUNIT_ASSERT(cit);
} }
CHK(cit == cv.End()); CPPUNIT_ASSERT(cit == cv.End());
while (it != v.Begin()) { while (it != v.Begin()) {
--it; --it;
--cit; --cit;
CHK(&*it == &*cit); CPPUNIT_ASSERT(&*it == &*cit);
CHK(&*it == it.operator->()); CPPUNIT_ASSERT(&*it == it.operator->());
CHK(&*cit == cit.operator->()); CPPUNIT_ASSERT(&*cit == cit.operator->());
CHK(it); CPPUNIT_ASSERT(it);
CHK(cit); CPPUNIT_ASSERT(cit);
} }
CHK(cit == cv.Begin()); CPPUNIT_ASSERT(cit == cv.Begin());
CHK(!v.Null()); CPPUNIT_ASSERT(!v.Null());
CHK(!cv.Null()); CPPUNIT_ASSERT(!cv.Null());
} }
// IteratorTest public:
void void Constructor100ElementsTest()
VectorSetTest::IteratorTest()
{ {
NextSubTest(); VectorSet<Value> vector(100);
GenericIteratorTest<AIntTestStrategy>(30); CPPUNIT_ASSERT(vector.Count() == 0);
NextSubTest(); CPPUNIT_ASSERT(vector.IsEmpty());
GenericIteratorTest<DIntTestStrategy>(30);
NextSubTest();
GenericIteratorTest<AIntTestStrategy>(200);
NextSubTest();
GenericIteratorTest<DIntTestStrategy>(200);
NextSubTest();
GenericIteratorTest<AStringTestStrategy>(30);
NextSubTest();
GenericIteratorTest<DStringTestStrategy>(30);
NextSubTest();
GenericIteratorTest<AStringTestStrategy>(200);
NextSubTest();
GenericIteratorTest<DStringTestStrategy>(200);
} }
void Constructor0ElementsTest()
{
VectorSet<Value> vector(0);
CPPUNIT_ASSERT(vector.Count() == 0);
CPPUNIT_ASSERT(vector.IsEmpty());
}
void Insert30ElementsTest() { InsertTest(30); }
void Insert200ElementsTest() { InsertTest(200); }
void Remove30ElementsTest() { RemoveTest(30); }
void Remove200ElementsTest() { RemoveTest(200); }
void Erase30ElementsTest() { EraseTest(30); }
void Erase200ElementsTest() { EraseTest(200); }
void MakeEmpty30ElementsTest() { MakeEmptyTest(30); }
void MakeEmpty200ElementsTest() { MakeEmptyTest(200); }
void Find30ElementsTest() { FindTest(30); }
void Find200ElementsTest() { FindTest(200); }
void FindClose30ElementsTest() { FindCloseTest(30); }
void FindClose200ElementsTest() { FindCloseTest(200); }
void Iterator30ElementsTest() { IteratorTest(30); }
void Iterator200ElementsTest() { IteratorTest(200); }
};
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorSetTest<IntAscTestStrategy>, getTestSuiteName());
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorSetTest<IntDescTestStrategy>, getTestSuiteName());
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorSetTest<StringAscTestStrategy>, getTestSuiteName());
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(VectorSetTest<StringDescTestStrategy>, getTestSuiteName());
src/tests/system/kernel/util/VectorSetTest.h
-27
View File
@@ -1,27 +0,0 @@
#ifndef _vector_set_test_h_
#define _vector_set_test_h_
#include <TestCase.h>
class VectorSetTest : public BTestCase {
public:
VectorSetTest(std::string name = "");
static CppUnit::Test* Suite();
void ConstructorTest();
void InsertTest();
void RemoveTest();
void EraseTest();
void MakeEmptyTest();
void IndexAccessTest();
void FindTest();
void FindCloseTest();
void IteratorTest();
private:
template <class List>
void TestList(List &list, typename List::ValueType *values, int valueCount);
};
#endif // _vector_set_test_h_
src/tests/system/kernel/util/VectorTest.cpp
+283 -449
View File
File diff suppressed because it is too large Load Diff
src/tests/system/kernel/util/VectorTest.h
-29
View File
@@ -1,29 +0,0 @@
#ifndef _vector_test_h_
#define _vector_test_h_
#include <TestCase.h>
class VectorTest : public BTestCase {
public:
VectorTest(std::string name = "");
static CppUnit::Test* Suite();
void ConstructorTest1();
void ConstructorTest2();
void PushPopFrontTest();
void PushPopBackTest();
void InsertTest();
void RemoveTest();
void EraseTest();
void MakeEmptyTest();
void IndexAccessTest();
void FindTest();
void IteratorTest();
private:
template <class List>
void TestList(List &list, typename List::ValueType *values, int valueCount);
};
#endif // _vector_test_h_