@@ -4,18 +4,19 @@

 #include <vector>

 // should only ever use this when copying a default constructed bucket

-AtomBucket& AtomBucket::operator=(const AtomBucket& other)

+// in the vector of buckets used in the allocator

+/*AtomBucket& AtomBucket::operator=(const AtomBucket& other)

 {

-    GAPS_ASSERT(!other.mFull);

+    GAPS_ASSERT(other.mSize == 0);

     GAPS_ASSERT(other.mPrev == NULL);

     GAPS_ASSERT(other.mNext == NULL);

     GAPS_ASSERT(other.mOverflow == NULL);

-    mFull = false;

+    mSize = 0;

     mPrev = NULL;

     mNext = NULL;

     mOverflow = NULL;

-}

+}*/

 /////////////////////// ALLOCATOR FOR OVERFLOW BUCKETS /////////////////////////

@@ -130,61 +131,114 @@ bool AtomNeighborhood::hasRight()

 // cases are fast

 AtomBucket::AtomBucket()

-    : mFull(false), mOverflow(NULL), mPrev(NULL), mNext(NULL)

+    : mSize(0), mOverflow(NULL), mPrev(NULL), mNext(NULL)

 {}

 unsigned AtomBucket::size() const

 {

-    unsigned thisSize = mFull ? 1 : 0;

-    return mOverflow == NULL ? thisSize : thisSize + mOverflow->size();

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+

+    return mOverflow == NULL ? mSize : mSize + mOverflow->size();

 }

 bool AtomBucket::isEmpty() const

 {

-    return !mFull;

+    return mSize == 0;

 }

 bool AtomBucket::contains(uint64_t pos) const

 {

-    if (mOverflow != NULL && pos > mBucket.pos)

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(pos > 0);

+

+    if (mOverflow != NULL && !mOverflow->isEmpty() && pos > mBucket[1].pos)

     {

         return mOverflow->contains(pos);

     }

     else

     {

-        return mFull ? pos == mBucket.pos : false;

+        switch (mSize)

+        {

+            case 0:

+                return false;

+            case 1:

+                return mBucket[0].pos == pos;

+            case 2:

+                return mBucket[0].pos == pos || mBucket[1].pos == pos;

+        }

     }

 }

 Atom* AtomBucket::operator[](unsigned index)

 {

-    return index == 0 ? &mBucket : mOverflow->operator[](index - 1);

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(index < size());

+

+    if (index > 1) // must be overflowed

+    {

+        return mOverflow->operator[](index - 2);

+    }

+    return &(mBucket[index]);

 }

 void AtomBucket::insert(uint64_t pos, float mass)

 {

-    if (!mFull)

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(pos > 0);

+

+    if (mSize == 0)

     {

-        mBucket = Atom(pos, mass);

-        mFull = true;

+        mBucket[0] = Atom(pos, mass);

+        ++mSize;

+    }

+    else if (mSize == 1)

+    {

+        if (pos < mBucket[0].pos)

+        {

+            mBucket[1] = mBucket[0];

+            mBucket[0] = Atom(pos, mass);

+        }

+        else

+        {

+            mBucket[1] = Atom(pos, mass);

+        }

+        ++mSize;

     }

     else

     {

+        // check if we need to allocate the overflow bucket

         if (mOverflow == NULL)

         {

             mOverflow = createAtomBucket();

             mOverflow->mPrev = this;

             mOverflow->mNext = mNext;

         }

-        

-        if (pos < mBucket.pos)

+        else if (mOverflow->isEmpty())

         {

-            mOverflow->insert(mBucket.pos, mBucket.mass);

-            mBucket = Atom(pos, mass);

+            mOverflow->mPrev = this;

+            mOverflow->mNext = mNext;

+        }

+

+        // push correct atom into overflow bucket

+        if (pos > mBucket[1].pos)

+        {

+            return mOverflow->insert(pos, mass);

+        }

+        mOverflow->insert(mBucket[1].pos, mBucket[1].mass);

+

+        // if inserting in this bucket, find correct position

+        if (pos < mBucket[0].pos)

+        {

+            mBucket[1] = mBucket[0];

+            mBucket[0] = Atom(pos, mass);

         }

         else

         {

-            mOverflow->insert(pos, mass);

+            mBucket[1] = Atom(pos, mass);

         }

     }

 }

@@ -192,55 +246,100 @@ void AtomBucket::insert(uint64_t pos, float mass)

 // assumes pos is contained in this chain

 void AtomBucket::erase(uint64_t pos)

 {

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(pos > 0);

+    GAPS_ASSERT(mSize > 0);

     GAPS_ASSERT(contains(pos));

-    if (mBucket.pos == pos)

+

+    if (mSize == 1)

     {

+        connectAdjacent();

+        mSize = 0;

+    }

+    else if (mSize == 2)

+    {

+        // check if this position is in overflow bucket    

+        if (pos > mBucket[1].pos)

+        {

+            return mOverflow->erase(pos);

+        }

+

+        // shift top position down if needed

+        if (mBucket[0].pos == pos)

+        {

+            mBucket[0] = mBucket[1];

+        }

+        

+        // pull first atom from overflow if it's there

         if (mOverflow != NULL && !mOverflow->isEmpty())

         {

-            mBucket = *(mOverflow->front());

+            mBucket[1] = *(mOverflow->front());

             mOverflow->eraseFront();

         }

-        else

+        else // just delete atom at last position

         {

-            mFull = false;

-            connectAdjacent();

+            --mSize;

         }

     }

-    else

-    {

-        mOverflow->erase(pos);

-    }

 }

 void AtomBucket::eraseFront()

 {

-    if (mOverflow != NULL && !mOverflow->isEmpty())

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+

+    GAPS_ASSERT(mSize > 0);

+

+    if (mSize == 1)

     {

-        mBucket = *(mOverflow->front());

-        mOverflow->eraseFront();

+        connectAdjacent();

+        mSize = 0;

     }

-    else

+    else if (mSize == 2)

     {

-        mFull = false;

-        connectAdjacent();

+        mBucket[0] = mBucket[1];

+        

+        // pull first atom from overflow if it's there

+        if (mOverflow != NULL && !mOverflow->isEmpty())

+        {

+            mBucket[1] = *(mOverflow->front());

+            mOverflow->eraseFront();

+        }

+        else

+        {

+            --mSize;

+        }

     }

 }

 AtomNeighborhood AtomBucket::getNeighbors(unsigned index)

 {

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(index < size());

+

     return AtomNeighborhood(getLeft(index), this->operator[](index), getRight(index));

 }

 AtomNeighborhood AtomBucket::getRightNeighbor(unsigned index)

 {

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(index < size());

+

     return AtomNeighborhood(NULL, this->operator[](index), getRight(index));

 }

-// needs to propogate through overflow

+// needs to propogate through overflow so that the last overflow will know

+// where the next bucket is

 void AtomBucket::setRightAdjacentBucket(AtomBucket *bucket)

 {

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+

     mNext = bucket;

-    if (mOverflow != NULL)

+    if (mOverflow != NULL && !mOverflow->isEmpty())

     {

         mOverflow->setRightAdjacentBucket(bucket);

     }

@@ -248,12 +347,20 @@ void AtomBucket::setRightAdjacentBucket(AtomBucket *bucket)

 void AtomBucket::setLeftAdjacentBucket(AtomBucket *bucket)

 {

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(bucket == NULL || !bucket->isEmpty());

+

     mPrev = bucket;

 }

 void AtomBucket::connectAdjacent()

 {

-    if (mNext != NULL)

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+

+    // be careful when connecting overflow buckets

+    if (mNext != NULL && (mPrev == NULL || mPrev->mOverflow != this))

     {

         mNext->setLeftAdjacentBucket(mPrev);

     }

@@ -261,61 +368,87 @@ void AtomBucket::connectAdjacent()

     {

         mPrev->setRightAdjacentBucket(mNext);

     }

+

+    mNext = NULL;

+    mPrev = NULL;

 }

 Atom* AtomBucket::front()

 {

-    return &mBucket;

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(mSize > 0);

+    GAPS_ASSERT(mBucket[0].pos > 0);

+

+    return &(mBucket[0]);

 }

 Atom* AtomBucket::back()

 {

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(mSize > 0);

+

     if (mOverflow == NULL || (mOverflow != NULL && mOverflow->isEmpty()))

     {

-        return &mBucket;

+        return &(mBucket[mSize - 1]);

     }

     return mOverflow->back();

 }

 Atom* AtomBucket::getLeft(unsigned index)

 {

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(mSize > 0);

+    GAPS_ASSERT(index < size());

+

     if (index == 0)

     {

-        return mPrev != NULL ? mPrev->back() : NULL;

+        GAPS_ASSERT(mPrev == NULL || mPrev->mOverflow != this);

+        return mPrev != NULL ? mPrev->back() : NULL; // mPrev can't be overflow here

     }

-    else if (index == 1)

+    else if (index < 3)

     {

-        return &mBucket;

+        return &(mBucket[index - 1]);

     }

     else

     {

-        return mOverflow->getLeft(index - 1);

+        GAPS_ASSERT(mOverflow != NULL);

+        return mOverflow->getLeft(index - 2);

     }    

 }

 Atom* AtomBucket::getRight(unsigned index)

 {

-    if (index == 0)

+    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

+    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

+    GAPS_ASSERT(mSize > 0);

+    GAPS_ASSERT(index < size());

+

+    if (index == mSize - 1) // this is last atom in bucket

     {

         if (mOverflow != NULL && !mOverflow->isEmpty())

         {

             return mOverflow->front();

         }

-        else

-        {

-            return mNext != NULL ? mNext->front() : NULL;

-        }

+        return mNext != NULL ? mNext->front() : NULL;

+    }        

+    else if (index == 0)

+    {

+        GAPS_ASSERT(mBucket[1].pos > 0);

+        return &(mBucket[1]);

     }

-    else // must be overflowed

+    else

     {

-        return mOverflow->getRight(index - 1);

+        mOverflow->getRight(index - 2);

     }

 }

 Archive& operator<<(Archive &ar, AtomBucket &b)

 {

     bool hasOverflow = (b.mOverflow != NULL);

-    ar << b.mBucket << b.mFull << hasOverflow;

+    ar << b.mBucket[0] << b.mBucket[1] << b.mSize << hasOverflow;

     if (hasOverflow)

     {

@@ -327,11 +460,11 @@ Archive& operator<<(Archive &ar, AtomBucket &b)

 Archive& operator>>(Archive& ar, AtomBucket &b)

 {

     bool hasOverflow = false;

-    ar >> b.mBucket >> b.mFull >> hasOverflow;

+    ar >> b.mBucket[0] >> b.mBucket[1] >> b.mSize >> hasOverflow;

     if (hasOverflow)

     {

-        b.mOverflow = new AtomBucket();

+        b.mOverflow = createAtomBucket();

         ar >> *b.mOverflow;

     }

     return ar;

@@ -420,23 +553,25 @@ void AtomHashMap::insert(uint64_t pos, float mass)

     if (mHashMap[index].isEmpty())

     {

         mHashMap[index].insert(pos, mass);

+        GAPS_ASSERT(mHashMap[index].contains(pos));

         std::set<unsigned>::iterator it = mFullBuckets.insert(index).first;

         if (it != mFullBuckets.begin())

         {

             --it;

-            mHashMap[*it].setRightAdjacentBucket(&mHashMap[index]);

             mHashMap[index].setLeftAdjacentBucket(&mHashMap[*it]);

+            mHashMap[*it].setRightAdjacentBucket(&mHashMap[index]);

             ++it;

         }

         if (++it != mFullBuckets.end())

         {

-            mHashMap[*it].setLeftAdjacentBucket(&mHashMap[index]);

             mHashMap[index].setRightAdjacentBucket(&mHashMap[*it]);

+            mHashMap[*it].setLeftAdjacentBucket(&mHashMap[index]);

         }

     }

     else

     {

         mHashMap[index].insert(pos, mass);

+        GAPS_ASSERT(mHashMap[index].contains(pos));

     }

     GAPS_ASSERT(mHashMap[index].contains(pos));

@@ -55,9 +55,6 @@ public:

     void setRightAdjacentBucket(AtomBucket *bucket);

     void setLeftAdjacentBucket(AtomBucket *bucket);

-    AtomBucket& operator=(const AtomBucket& other);

-

-    unsigned getIndex(uint64_t pos);

     Atom* getLeft(unsigned index);

     Atom* getRight(unsigned index);

@@ -65,8 +62,8 @@ public:

 private:

 #endif

-    Atom mBucket;

-    bool mFull;

+    Atom mBucket[2];

+    uint32_t mSize;

     AtomBucket *mOverflow;

     AtomBucket *mPrev;

@@ -76,6 +73,8 @@ private:

     void connectAdjacent();

     Atom* back();

+

+    AtomBucket& operator=(const AtomBucket& other); // prevent copies

     friend Archive& operator<<(Archive& ar, AtomBucket &b);

     friend Archive& operator>>(Archive& ar, AtomBucket &b);

@@ -21,6 +21,7 @@ OBJECTS =   AtomicDomain.o \

             math/Math.o \

             math/Random.o \

             cpp_tests/testAlgorithms.o \

+            cpp_tests/testAtomicDomain.o \

             cpp_tests/testEfficientSets.o \

             cpp_tests/testFileParsers.o \

             cpp_tests/testMatrix.o \

@@ -1 +1,655 @@

-// TODO

\ No newline at end of file

+#include "catch.h"

+#include "../AtomicDomain.h"

+#include "../GapsPrint.h"

+

+// used to create aligned buckets for testing

+AtomBucket* getAlignedBucket()

+{

+    return new AtomBucket();

+}

+

+TEST_CASE("AtomBucket")

+{

+    GapsRng::setSeed(12345);

+

+    SECTION("Properties of Default Constructed Buckets")

+    {

+        AtomBucket *bucket = getAlignedBucket();

+        REQUIRE(bucket->isEmpty());

+        REQUIRE(bucket->size() == 0);

+        REQUIRE(!bucket->contains(1));

+

+        // verify internal state

+        #ifdef GAPS_INTERNAL_TESTS

+        REQUIRE(bucket->mOverflow == NULL);

+        #endif

+    }

+

+    SECTION("Insert")

+    {

+        AtomBucket *bucket = getAlignedBucket();

+

+        // insert first atom

+        bucket->insert(1, 1.f);

+

+        REQUIRE(!bucket->isEmpty());

+        REQUIRE(bucket->size() == 1);

+

+        REQUIRE(bucket->contains(1));

+        REQUIRE(!bucket->contains(2));

+        REQUIRE(!bucket->contains(3));

+

+        REQUIRE(bucket->front()->pos == 1);

+        REQUIRE(bucket->front()->mass == 1.f);

+        REQUIRE((*bucket)[0]->pos == 1);

+        REQUIRE((*bucket)[0]->mass == 1.f);

+

+        // insert second atom

+        bucket->insert(3, 3.f);

+

+        REQUIRE(!bucket->isEmpty());

+        REQUIRE(bucket->size() == 2);

+

+        REQUIRE(bucket->contains(1));

+        REQUIRE(!bucket->contains(2));

+        REQUIRE(bucket->contains(3));

+

+        REQUIRE(bucket->front()->pos == 1);

+        REQUIRE(bucket->front()->mass == 1.f);

+        REQUIRE((*bucket)[0]->pos == 1);

+        REQUIRE((*bucket)[0]->mass == 1.f);

+        REQUIRE((*bucket)[1]->pos == 3);

+        REQUIRE((*bucket)[1]->mass == 3.f);

+

+        // insert third atom

+        bucket->insert(2, 2.f);

+

+        REQUIRE(!bucket->isEmpty());

+        REQUIRE(bucket->size() == 3);

+

+        REQUIRE(bucket->contains(1));

+        REQUIRE(bucket->contains(2));

+        REQUIRE(bucket->contains(3));

+

+        REQUIRE(bucket->front()->pos == 1);

+        REQUIRE(bucket->front()->mass == 1.f);

+        REQUIRE((*bucket)[0]->pos == 1);

+        REQUIRE((*bucket)[0]->mass == 1.f);

+        REQUIRE((*bucket)[1]->pos == 2);

+        REQUIRE((*bucket)[1]->mass == 2.f);

+        REQUIRE((*bucket)[2]->pos == 3);

+        REQUIRE((*bucket)[2]->mass == 3.f);

+

+        // verify internal state

+        #ifdef GAPS_INTERNAL_TESTS

+        REQUIRE(bucket->mOverflow == NULL);

+        REQUIRE(bucket->back()->pos == 3);

+        REQUIRE(bucket->back()->mass == 3.f);

+        REQUIRE(bucket->getLeft(1)->pos == 1);

+        REQUIRE(bucket->getLeft(1)->mass == 1.f);

+        REQUIRE(bucket->getRight(1)->pos == 3);

+        REQUIRE(bucket->getRight(1)->mass == 3.f);

+        #endif

+    }

+

+    SECTION("Erase")

+    {

+        AtomBucket *bucket = getAlignedBucket();

+

+        // erase one atom

+        bucket->insert(1, 1.f);

+        bucket->erase(1);

+        REQUIRE(bucket->isEmpty());

+        REQUIRE(bucket->size() == 0);

+        REQUIRE(!bucket->contains(1));

+

+        // erase two atoms

+        bucket->insert(1, 1.f);

+        bucket->insert(3, 3.f);

+

+        bucket->erase(1);

+        REQUIRE(!bucket->isEmpty());

+        REQUIRE(bucket->size() == 1);

+        REQUIRE(!bucket->contains(1));

+        REQUIRE(bucket->contains(3));

+        REQUIRE(bucket->front()->pos == 3);

+        REQUIRE((*bucket)[0]->pos == 3);

+        bucket->insert(1, 1.f);

+

+        bucket->erase(3);

+        REQUIRE(!bucket->isEmpty());

+        REQUIRE(bucket->size() == 1);

+        REQUIRE(bucket->contains(1));

+        REQUIRE(!bucket->contains(3));

+        REQUIRE(bucket->front()->pos == 1);

+        REQUIRE((*bucket)[0]->pos == 1);

+        bucket->insert(3, 3.f);

+

+        bucket->erase(1);

+        bucket->erase(3);

+        REQUIRE(bucket->isEmpty());

+        REQUIRE(bucket->size() == 0);

+        REQUIRE(!bucket->contains(1));

+        REQUIRE(!bucket->contains(3));

+    

+        // erase three atoms

+        bucket->insert(1, 1.f);

+        bucket->insert(3, 3.f);

+        bucket->insert(2, 2.f);

+

+        bucket->erase(2);

+        REQUIRE(!bucket->isEmpty());

+        REQUIRE(bucket->size() == 2);

+        REQUIRE(!bucket->contains(2));

+        REQUIRE(bucket->contains(1));

+        REQUIRE(bucket->contains(3));

+        REQUIRE(bucket->front()->pos == 1);

+        REQUIRE((*bucket)[0]->pos == 1);

+        REQUIRE((*bucket)[1]->pos == 3);

+        bucket->insert(2, 2.f);

+

+        bucket->erase(1);

+        bucket->erase(2);

+        REQUIRE(!bucket->isEmpty());

+        REQUIRE(bucket->size() == 1);

+        REQUIRE(!bucket->contains(1));

+        REQUIRE(!bucket->contains(2));

+        REQUIRE(bucket->contains(3));

+        REQUIRE(bucket->front()->pos == 3);

+        REQUIRE((*bucket)[0]->pos == 3);

+        bucket->insert(1, 1.f);

+        bucket->insert(2, 2.f);

+

+        bucket->erase(1);

+        bucket->erase(2);

+        bucket->erase(3);

+        REQUIRE(bucket->isEmpty());

+        REQUIRE(bucket->size() == 0);

+        REQUIRE(!bucket->contains(1));

+        REQUIRE(!bucket->contains(2));

+        REQUIRE(!bucket->contains(3));

+

+        // verify internal state

+        #ifdef GAPS_INTERNAL_TESTS

+        REQUIRE(bucket->mOverflow == NULL);

+        #endif

+    }

+

+    SECTION("Handling Overflow")

+    {

+        AtomBucket *bucket = getAlignedBucket();

+

+        // insert 1-100 at indices 0-99 (cant use 0 for position)

+        for (unsigned i = 100; i > 0; --i)

+        {

+            bucket->insert(i, static_cast<float>(i));

+        }

+

+        REQUIRE(!bucket->isEmpty());

+        REQUIRE(bucket->size() == 100);

+        REQUIRE(bucket->contains(100));

+        REQUIRE(!bucket->contains(101));

+        REQUIRE(bucket->front()->pos == 1);

+

+        #ifdef GAPS_INTERNAL_TESTS

+        for (unsigned i = 1; i < 99; ++i)

+        {

+            REQUIRE((*bucket)[i]->pos == i + 1);

+            REQUIRE(bucket->contains(i + 1));

+            REQUIRE(bucket->getLeft(i)->pos == i);

+            REQUIRE(bucket->getRight(i)->pos == i + 2);

+        }

+

+        REQUIRE(bucket->mOverflow != NULL);

+        REQUIRE(boost::alignment::is_aligned(64, bucket->mOverflow));

+        REQUIRE(bucket->back()->pos == 100);

+        #endif

+    }

+

+    SECTION("Special Overflow Case")

+    {

+        AtomBucket *bucket6 = getAlignedBucket();

+        bucket6->insert(1, 1.f);

+        bucket6->insert(2, 2.f);

+        bucket6->insert(3, 3.f);

+        bucket6->insert(4, 4.f);

+        bucket6->insert(5, 5.f);

+        bucket6->insert(6, 6.f);

+        bucket6->insert(7, 7.f);

+

+        REQUIRE(bucket6->size() == 7);

+        bucket6->erase(7);

+        REQUIRE(bucket6->size() == 6);

+        bucket6->erase(6);

+        REQUIRE(bucket6->size() == 5);

+    }

+

+    #ifdef GAPS_INTERNAL_TESTS

+    SECTION("Traversing Adjacent Blocks")

+    {

+        // create buckets

+        AtomBucket *first = getAlignedBucket();

+        AtomBucket *second = getAlignedBucket();

+        AtomBucket *third = getAlignedBucket();

+

+        // set up order

+        first->setRightAdjacentBucket(second);

+        second->setRightAdjacentBucket(third);

+

+        third->setLeftAdjacentBucket(second);

+        second->setLeftAdjacentBucket(first);

+

+        // insert into all buckets

+        for (unsigned i = 10; i <= 19; ++i)

+        {

+            first->insert(i, static_cast<float>(i));

+        }

+        for (unsigned i = 20; i <= 29; ++i)

+        {

+            second->insert(i, static_cast<float>(i));

+        }

+        for (unsigned i = 30; i <= 39; ++i)

+        {

+            third->insert(i, static_cast<float>(i));

+        }

+

+        // check properties

+        REQUIRE(!first->isEmpty());

+        REQUIRE(!second->isEmpty());

+        REQUIRE(!third->isEmpty());

+        REQUIRE(first->size() == 10);

+        REQUIRE(second->size() == 10);

+        REQUIRE(third->size() == 10);

+

+        // get neighbors across boundaries

+        REQUIRE(first->getRight(9)->pos == 20);

+        REQUIRE(second->getRight(9)->pos == 30);

+

+        REQUIRE(second->getLeft(0)->pos == 19);

+        REQUIRE(third->getLeft(0)->pos == 29);

+

+        // delete middle, get neighbors again

+        second->connectAdjacent();

+        REQUIRE(first->getRight(9)->pos == 30);

+        REQUIRE(third->getLeft(0)->pos == 19);

+    }

+    #endif

+

+    SECTION("Querying Neighborhood")

+    {

+        // create buckets

+        AtomBucket *first = getAlignedBucket();

+        AtomBucket *second = getAlignedBucket();

+        AtomBucket *third = getAlignedBucket();

+

+        // insert into all buckets

+        for (unsigned i = 10; i <= 19; ++i)

+        {

+            first->insert(i, static_cast<float>(i));

+        }

+        for (unsigned i = 20; i <= 29; ++i)

+        {

+            second->insert(i, static_cast<float>(i));

+        }

+        for (unsigned i = 30; i <= 39; ++i)

+        {

+            third->insert(i, static_cast<float>(i));

+        }

+

+        // set up order

+        first->setRightAdjacentBucket(second);

+        second->setRightAdjacentBucket(third);

+

+        third->setLeftAdjacentBucket(second);

+        second->setLeftAdjacentBucket(first);

+

+        // get neighbors of border atoms

+        REQUIRE(first->getNeighbors(9).left->pos == 18);

+        REQUIRE(first->getNeighbors(9).center->pos == 19);

+        REQUIRE(first->getNeighbors(9).right->pos == 20);

+        REQUIRE(first->getRightNeighbor(9).center->pos == 19);

+        REQUIRE(first->getRightNeighbor(9).right->pos == 20);

+

+        REQUIRE(second->getNeighbors(9).left->pos == 28);

+        REQUIRE(second->getNeighbors(9).center->pos == 29);

+        REQUIRE(second->getNeighbors(9).right->pos == 30);

+        REQUIRE(second->getRightNeighbor(9).center->pos == 29);

+        REQUIRE(second->getRightNeighbor(9).right->pos == 30);

+

+        REQUIRE(second->getNeighbors(0).left->pos == 19);

+        REQUIRE(second->getNeighbors(0).center->pos == 20);

+        REQUIRE(second->getNeighbors(0).right->pos == 21);

+        REQUIRE(second->getRightNeighbor(0).center->pos == 20);

+        REQUIRE(second->getRightNeighbor(0).right->pos == 21);

+

+        REQUIRE(third->getNeighbors(0).left->pos == 29);

+        REQUIRE(third->getNeighbors(0).center->pos == 30);

+        REQUIRE(third->getNeighbors(0).right->pos == 31);

+        REQUIRE(third->getRightNeighbor(0).center->pos == 30);

+        REQUIRE(third->getRightNeighbor(0).right->pos == 31);

+

+        // get neighbors of edge atoms (they shouldn't be there)

+        AtomNeighborhood hood1 = first->getNeighbors(0);

+        REQUIRE(!hood1.hasLeft());

+        REQUIRE(hood1.hasRight());

+

+        AtomNeighborhood hood3 = third->getNeighbors(9);

+        REQUIRE(hood3.hasLeft());

+        REQUIRE(!hood3.hasRight());

+

+        #ifdef GAPS_INTERNAL_TESTS

+        // delete middle, get neighbors again

+        second->connectAdjacent();

+        REQUIRE(first->getNeighbors(9).left->pos == 18);

+        REQUIRE(first->getNeighbors(9).center->pos == 19);

+        REQUIRE(first->getNeighbors(9).right->pos == 30);

+        REQUIRE(first->getRightNeighbor(9).center->pos == 19);

+        REQUIRE(first->getRightNeighbor(9).right->pos == 30);

+

+        REQUIRE(third->getNeighbors(0).left->pos == 19);

+        REQUIRE(third->getNeighbors(0).center->pos == 30);

+        REQUIRE(third->getNeighbors(0).right->pos == 31);

+        REQUIRE(third->getRightNeighbor(0).center->pos == 30);

+        REQUIRE(third->getRightNeighbor(0).right->pos == 31);

+        #endif

+    }

+}

+

+TEST_CASE("AtomHashMap")

+{

+    SECTION("Default Construction")

+    {

+        AtomHashMap map(100);

+        REQUIRE(map.size() == 0);

+    }

+

+    SECTION("Length Calculation and Hashing")

+    {

+        // nice size

+        AtomHashMap map(100);

+        map.setTotalLength(1000);

+        

+        #ifdef GAPS_INTERNAL_TESTS

+        REQUIRE(map.mTotalLength == 1000);

+        REQUIRE(map.mBucketLength == 10);

+

+        REQUIRE(map.hash(1) == 0);

+        REQUIRE(map.hash(9) == 0);

+        REQUIRE(map.hash(10) == 1);

+        REQUIRE(map.hash(19) == 1);

+        REQUIRE(map.hash(20) == 2);

+        REQUIRE(map.hash(1000) == 100);

+        #endif

+    }

+

+    SECTION("Insert")

+    {

+        AtomHashMap map(100);

+        map.setTotalLength(1000);

+

+        map.insert(1, 1.f);

+        REQUIRE(map.size() == 1);

+        REQUIRE(map.contains(1));

+        REQUIRE(map.front()->pos == 1);

+

+        map.insert(2, 3.f);

+        map.insert(3, 3.f);

+        REQUIRE(map.size() == 3);

+        REQUIRE(map.contains(2));

+        REQUIRE(map.contains(3));

+        REQUIRE(map.front()->pos == 1);

+    }

+

+    SECTION("Erase")

+    {