libs/utils/gtest/src/HashMapTestSuite.cc - celix - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  *  KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 #include <gtest/gtest.h>

 #include "celix_utils.h"
 #include "celix_string_hash_map.h"
 #include "celix_long_hash_map.h"
 #include <random>
 #include <atomic>

 class HashMapTestSuite : public ::testing::Test {
 public:
     /**
      * Create and fill string hash map with nrEntries entries.
      */
     celix_string_hash_map_t* createStringHashMap(int nrEntries) {
         auto* map = celix_stringHashMap_create();
         fillStringHashMap(map, nrEntries);
         return map;
     }

     /**
      * Fill string hash map with nrOfEntries long value entries where the key and value are based on the
      * i index value of the for loop.
      * This way the expected hash map entry value can be deducted from the key.
      */
     void fillStringHashMap(celix_string_hash_map_t* map, int nrEntries) {
         for (int i = 0; i < nrEntries; ++i) {
             std::string key = "key" + std::to_string(i);
             celix_stringHashMap_putLong(map, key.c_str(), i);
             EXPECT_EQ(i, celix_stringHashMap_getLong(map, key.c_str(), 0));
             EXPECT_EQ(celix_stringHashMap_size(map), i+1);
         }
     }

     /**
      * Randomly test nrOfEntriesToTest entries in a string hash map.
      * This assumes that the map is filled using fillStringHashMap.
      */
     void testGetEntriesFromStringMap(celix_string_hash_map_t* map, int nrOfEntriesToTest) {
         std::uniform_int_distribution<long> keyDistribution{0, (long)celix_stringHashMap_size(map)-1};
         for (int i = 0; i < nrOfEntriesToTest; ++i) {
             long rand = keyDistribution(generator);
             auto key = std::string{"key"} + std::to_string(rand);
             EXPECT_EQ(celix_stringHashMap_getLong(map, key.c_str(), 0), rand) << "got wrong result for key " << key;
         }
     }

     /**
      * Create and fill long hash map with nrEntries entries.
      */
     celix_long_hash_map_t * createLongHashMap(int nrEntries) {
         auto* map = celix_longHashMap_create();
         fillLongHashMap(map, nrEntries);
         return map;
     }

     /**
      * Fill long hash map with nrOfEntries long value entries where the key and value are based on the
      * i index value of the for loop.
      * This way the expected hash map entry value can be deducted from the key.
      */
     void fillLongHashMap(celix_long_hash_map_t* map, int nrEntries) {
         for (int i = 0; i < nrEntries; ++i) {
             celix_longHashMap_putLong(map, i, i);
             EXPECT_EQ(i, celix_longHashMap_getLong(map, i, 0));
             EXPECT_EQ(celix_longHashMap_size(map), i+1);
         }
     }

     /**
      * Randomly test nrOfEntriesToTest entries in a long hash map.
      * This assumes that the map is filled using fillLongHashMap.
      */
     void testGetEntriesFromLongMap(celix_long_hash_map_t* map, int nrOfEntriesToTest) {
         std::uniform_int_distribution<long> keyDistribution{0, (long)celix_longHashMap_size(map)-1};
         for (int i = 0; i< nrOfEntriesToTest; ++i) {
             long rand = keyDistribution(generator);
             EXPECT_EQ(celix_longHashMap_getLong(map, rand, 0), rand);
         }
     }
 private:
     std::default_random_engine generator{};
 };

 TEST_F(HashMapTestSuite, CreateDestroyHashMap) {
     auto* sMap = celix_stringHashMap_create();
     EXPECT_TRUE(sMap != nullptr);
     EXPECT_EQ(0, celix_stringHashMap_size(sMap));
     celix_stringHashMap_destroy(sMap);

     auto* lMap = celix_longHashMap_create();
     EXPECT_TRUE(lMap != nullptr);
     EXPECT_EQ(0, celix_longHashMap_size(lMap));
     celix_longHashMap_destroy(lMap);
 }

 TEST_F(HashMapTestSuite, PutPointerEntriesInStringHashMap) {
     auto* map = celix_stringHashMap_create();
     EXPECT_TRUE(map != nullptr);
     EXPECT_EQ(0, celix_stringHashMap_size(map));

     celix_stringHashMap_put(map, "key1", (void*)0x41);
     celix_stringHashMap_put(map, "key2", (void*)0x42);
     celix_stringHashMap_put(map, "key3", (void*)0x43);
     celix_stringHashMap_put(map, "key4", (void*)0x44);
     EXPECT_EQ(celix_stringHashMap_size(map), 4);

     EXPECT_TRUE(celix_stringHashMap_hasKey(map, "key1"));
     EXPECT_TRUE(celix_stringHashMap_hasKey(map, "key2"));
     EXPECT_TRUE(celix_stringHashMap_hasKey(map, "key3"));
     EXPECT_TRUE(celix_stringHashMap_hasKey(map, "key4"));
     EXPECT_FALSE(celix_stringHashMap_hasKey(map, "key5"));

     EXPECT_EQ(celix_stringHashMap_get(map, "key1"), (void*)0x41);
     EXPECT_EQ(celix_stringHashMap_get(map, "key2"), (void*)0x42);
     EXPECT_EQ(celix_stringHashMap_get(map, "key3"), (void*)0x43);
     EXPECT_EQ(celix_stringHashMap_get(map, "key4"), (void*)0x44);
     EXPECT_EQ(celix_stringHashMap_get(map, "key5"), nullptr);

     celix_stringHashMap_destroy(map);
 }

 TEST_F(HashMapTestSuite, PutPointerEntriesInLongHashMap) {
     auto* map = celix_longHashMap_create();
     EXPECT_TRUE(map != nullptr);
     EXPECT_EQ(0, celix_longHashMap_size(map));

     celix_longHashMap_put(map, 1, (void*)0x41);
     celix_longHashMap_put(map, 2, (void*)0x42);
     celix_longHashMap_put(map, 3, (void*)0x43);
     celix_longHashMap_put(map, 4, (void*)0x44);
     EXPECT_EQ(celix_longHashMap_size(map), 4);

     EXPECT_TRUE(celix_longHashMap_hasKey(map, 1));
     EXPECT_TRUE(celix_longHashMap_hasKey(map, 2));
     EXPECT_TRUE(celix_longHashMap_hasKey(map, 3));
     EXPECT_TRUE(celix_longHashMap_hasKey(map, 4));
     EXPECT_FALSE(celix_longHashMap_hasKey(map, 5));

     EXPECT_EQ(celix_longHashMap_get(map, 1), (void*)0x41);
     EXPECT_EQ(celix_longHashMap_get(map, 2), (void*)0x42);
     EXPECT_EQ(celix_longHashMap_get(map, 3), (void*)0x43);
     EXPECT_EQ(celix_longHashMap_get(map, 4), (void*)0x44);
     EXPECT_EQ(celix_longHashMap_get(map, 5), nullptr);

     celix_longHashMap_destroy(map);
 }

 TEST_F(HashMapTestSuite, StringKeyNullEntry) {
     auto* map = celix_stringHashMap_create();
     EXPECT_FALSE(celix_stringHashMap_hasKey(map, nullptr));
     celix_stringHashMap_put(map, nullptr, (void*)0x42);
     EXPECT_TRUE(celix_stringHashMap_hasKey(map, nullptr));
     EXPECT_EQ(1, celix_stringHashMap_size(map));
     celix_stringHashMap_destroy(map);
 }

 TEST_F(HashMapTestSuite, DestroyHashMapWithSimpleRemovedCallback) {
     celix_string_hash_map_create_options_t sOpts{};
     sOpts.simpleRemovedCallback = free;
     auto* sMap = celix_stringHashMap_createWithOptions(&sOpts);
     EXPECT_TRUE(sMap != nullptr);
     EXPECT_EQ(0, celix_stringHashMap_size(sMap));

     celix_stringHashMap_put(sMap, "key1", celix_utils_strdup("41"));
     celix_stringHashMap_put(sMap, "key2", celix_utils_strdup("42"));
     celix_stringHashMap_put(sMap, "key3", celix_utils_strdup("43"));
     celix_stringHashMap_put(sMap, "key4", celix_utils_strdup("44"));
     celix_stringHashMap_put(sMap, nullptr, celix_utils_strdup("null"));
     EXPECT_EQ(celix_stringHashMap_size(sMap), 5);
     EXPECT_STREQ((char*)celix_stringHashMap_get(sMap, nullptr), "null");

     bool removed = celix_stringHashMap_remove(sMap, "key3");
     EXPECT_TRUE(removed);
     removed = celix_stringHashMap_remove(sMap, "key3"); //double remove
     EXPECT_FALSE(removed);

     removed = celix_stringHashMap_remove(sMap, nullptr);
     EXPECT_TRUE(removed);
     removed = celix_stringHashMap_remove(sMap, nullptr); //double remove
     EXPECT_FALSE(removed);

     EXPECT_EQ(celix_stringHashMap_size(sMap), 3);
     celix_stringHashMap_destroy(sMap);

     celix_long_hash_map_create_options_t lOpts{};
     lOpts.simpledRemoveCallback = free;
     auto* lMap = celix_longHashMap_createWithOptions(&lOpts);
     EXPECT_TRUE(lMap != nullptr);
     EXPECT_EQ(0, celix_longHashMap_size(lMap));

     celix_longHashMap_put(lMap, 1, celix_utils_strdup("41"));
     celix_longHashMap_put(lMap, 2, celix_utils_strdup("42"));
     celix_longHashMap_put(lMap, 3, celix_utils_strdup("43"));
     celix_longHashMap_put(lMap, 4, celix_utils_strdup("44"));
     celix_longHashMap_put(lMap, 0, celix_utils_strdup("null"));
     EXPECT_EQ(celix_longHashMap_size(lMap), 5);
     EXPECT_STREQ((char*)celix_longHashMap_get(lMap, 0), "null");

     celix_longHashMap_remove(lMap, 3);
     celix_longHashMap_remove(lMap, 0);
     EXPECT_EQ(celix_longHashMap_size(lMap), 3);
     celix_longHashMap_destroy(lMap);
 }

 TEST_F(HashMapTestSuite, ClearHashMapWithRemovedCallback) {
     std::atomic<int> count{0};
     celix_string_hash_map_create_options_t sOpts{};
     sOpts.removedCallbackData = &count;
     sOpts.removedCallback = [](void *data, const char* key, celix_hash_map_value_t value) {
         auto* c = static_cast<std::atomic<int>*>(data);
         if (celix_utils_stringEquals(key, "key1")) {
             c->fetch_add(1);
             EXPECT_EQ(value.longValue, 1);
         } else if (celix_utils_stringEquals(key, "key2")) {
             c->fetch_add(1);
             EXPECT_EQ(value.longValue, 2);
         }
     };
     auto* sMap = celix_stringHashMap_createWithOptions(&sOpts);
     celix_stringHashMap_putLong(sMap, "key1", 1);
     celix_stringHashMap_putLong(sMap, "key2", 2);
     celix_stringHashMap_clear(sMap);
     EXPECT_EQ(count.load(), 2);
     EXPECT_EQ(celix_stringHashMap_size(sMap), 0);
     celix_stringHashMap_destroy(sMap);

     count = 0;
     celix_long_hash_map_create_options_t lOpts{};
     lOpts.removedCallbackData = &count;
     lOpts.removedCallback = [](void *data, long key, celix_hash_map_value_t value) {
         auto* c = static_cast<std::atomic<int>*>(data);
         if (key == 1) {
             c->fetch_add(1);
             EXPECT_EQ(value.longValue, 1);
         } else if (key == 2) {
             c->fetch_add(1);
             EXPECT_EQ(value.longValue, 2);
         }
     };
     auto* lMap = celix_longHashMap_createWithOptions(&lOpts);
     celix_longHashMap_putLong(lMap, 1, 1);
     celix_longHashMap_putLong(lMap, 2, 2);
     celix_longHashMap_clear(lMap);
     EXPECT_EQ(count.load(), 2);
     EXPECT_EQ(celix_longHashMap_size(lMap), 0);
     celix_longHashMap_destroy(lMap);
 }


 TEST_F(HashMapTestSuite, HashMapClearTests) {
     auto* sMap = createStringHashMap(3);
     EXPECT_EQ(celix_stringHashMap_size(sMap), 3);
     celix_stringHashMap_clear(sMap);
     EXPECT_EQ(celix_stringHashMap_size(sMap), 0);
     celix_stringHashMap_destroy(sMap);

     auto* lMap = createLongHashMap(3);
     EXPECT_EQ(celix_longHashMap_size(lMap), 3);
     celix_longHashMap_clear(lMap);
     EXPECT_EQ(celix_longHashMap_size(lMap), 0);
     celix_longHashMap_destroy(lMap);
 }


 template<typename T>
 void testMapsWithValues(const std::vector<std::tuple<std::string, long, T>>& values) {
     auto* sMap = celix_stringHashMap_create();
     auto* lMap = celix_longHashMap_create();

     //test hashmap put
     for (const auto& tuple : values) {
         if constexpr (std::is_same_v<void*, T>) {
             void* prev = celix_stringHashMap_put(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
             EXPECT_EQ(prev, nullptr);
             prev = celix_stringHashMap_put(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
             EXPECT_EQ(prev, std::get<2>(tuple));

             prev = celix_longHashMap_put(lMap, std::get<1>(tuple), std::get<2>(tuple));
             EXPECT_EQ(prev, nullptr);
             prev = celix_longHashMap_put(lMap, std::get<1>(tuple), std::get<2>(tuple));
             EXPECT_EQ(prev, std::get<2>(tuple));
         } else if constexpr (std::is_same_v<long, T>) {
             bool replaced = celix_stringHashMap_putLong(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
             EXPECT_FALSE(replaced);
             replaced = celix_stringHashMap_putLong(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
             EXPECT_TRUE(replaced);

             replaced = celix_longHashMap_putLong(lMap, std::get<1>(tuple), std::get<2>(tuple));
             EXPECT_FALSE(replaced);
             replaced = celix_longHashMap_putLong(lMap, std::get<1>(tuple), std::get<2>(tuple));
             EXPECT_TRUE(replaced);
         } else if constexpr (std::is_same_v<double, T>) {
             bool replaced = celix_stringHashMap_putDouble(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
             EXPECT_FALSE(replaced);
             replaced = celix_stringHashMap_putDouble(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
             EXPECT_TRUE(replaced);

             replaced = celix_longHashMap_putDouble(lMap, std::get<1>(tuple), std::get<2>(tuple));
             EXPECT_FALSE(replaced);
             replaced = celix_longHashMap_putDouble(lMap, std::get<1>(tuple), std::get<2>(tuple));
             EXPECT_TRUE(replaced);
         } else if constexpr (std::is_same_v<bool, T>) {
             bool replaced = celix_stringHashMap_putBool(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
             EXPECT_FALSE(replaced);
             replaced = celix_stringHashMap_putBool(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
             EXPECT_TRUE(replaced);

             replaced = celix_longHashMap_putBool(lMap, std::get<1>(tuple), std::get<2>(tuple));
             EXPECT_FALSE(replaced);
             replaced = celix_longHashMap_putBool(lMap, std::get<1>(tuple), std::get<2>(tuple));
             EXPECT_TRUE(replaced);
         } else {
             FAIL() << "expected of the following value types: void*, long, double or bool";
         }
     }
     ASSERT_EQ(values.size(), celix_stringHashMap_size(sMap));
     ASSERT_EQ(values.size(), celix_longHashMap_size(lMap));

     //test hashmap get
     for (const auto& tuple : values) {
         if constexpr (std::is_same_v<void*, T>) {
             auto* value = celix_stringHashMap_get(sMap, std::get<0>(tuple).c_str());
             EXPECT_EQ(value, std::get<2>(tuple));

             value = celix_longHashMap_get(lMap, std::get<1>(tuple));
             EXPECT_EQ(value, std::get<2>(tuple));
         } else if constexpr (std::is_same_v<long, T>) {
             auto value = celix_stringHashMap_getLong(sMap, std::get<0>(tuple).c_str(), 0);
             EXPECT_EQ(value, std::get<2>(tuple));

             value = celix_longHashMap_getLong(lMap, std::get<1>(tuple), 0);
             EXPECT_EQ(value, std::get<2>(tuple));
         } else if constexpr (std::is_same_v<double, T>) {
             auto value = celix_stringHashMap_getDouble(sMap, std::get<0>(tuple).c_str(), 0.0);
             EXPECT_EQ(value, std::get<2>(tuple));

             value = celix_longHashMap_getDouble(lMap, std::get<1>(tuple), 0.0);
             EXPECT_EQ(value, std::get<2>(tuple));
         } else if constexpr (std::is_same_v<bool, T>) {
             auto value = celix_stringHashMap_getBool(sMap, std::get<0>(tuple).c_str(), false);
             EXPECT_EQ(value, std::get<2>(tuple));

             value = celix_longHashMap_getBool(lMap, std::get<1>(tuple), false);
             EXPECT_EQ(value, std::get<2>(tuple));
         } else {
             FAIL() << "expected of the following value types: void*, long, double or bool";
         }
     }

     //test hashmap remove
     for (const auto& tuple : values) {
         celix_stringHashMap_remove(sMap, std::get<0>(tuple).c_str());
         celix_longHashMap_remove(lMap, std::get<1>(tuple));
     }
     ASSERT_EQ(0, celix_stringHashMap_size(sMap));
     ASSERT_EQ(0, celix_longHashMap_size(lMap));

     celix_stringHashMap_destroy(sMap);
     celix_longHashMap_destroy(lMap);
 }

 TEST_F(HashMapTestSuite, PutAndGetWithDifferentValueTypes) {
     std::vector<std::tuple<std::string, long, void*>> values1{
             {"key1", 1, (void*)0x42},
             {"key2", 2, (void*)0x43},
             {"key3", 3, (void*)0x44},
     };
     testMapsWithValues(values1);

     std::vector<std::tuple<std::string, long, long>> values2{
             {"key1", 1, 1},
             {"key2", 2, 2},
             {"key3", 3, 3},
     };
     testMapsWithValues(values2);

     std::vector<std::tuple<std::string, long, double>> values3{
             {"key1", 1, 1.0},
             {"key2", 2, 2.0},
             {"key3", 3, 3.0},
     };
     testMapsWithValues(values3);

     std::vector<std::tuple<std::string, long, bool>> values4{
             {"key1", 1, true},
             {"key2", 2, false},
             {"key3", 3, true},
     };
     testMapsWithValues(values4);
 }

 TEST_F(HashMapTestSuite, GetWithFallbackValues) {
     auto* sMap = celix_stringHashMap_create();
     EXPECT_EQ(celix_stringHashMap_get(sMap, "not-present"), nullptr);
     EXPECT_EQ(celix_stringHashMap_getLong(sMap, "not-present", -1), -1);
     EXPECT_EQ(celix_stringHashMap_getDouble(sMap, "not-present", 1.0), 1.0);
     EXPECT_EQ(celix_stringHashMap_getBool(sMap, "not-present", true), true);
     celix_stringHashMap_destroy(sMap);

     auto* lMap = celix_longHashMap_create();
     EXPECT_EQ(celix_longHashMap_get(lMap, 33), nullptr);
     EXPECT_EQ(celix_longHashMap_getLong(lMap, 33, 1), 1);
     EXPECT_EQ(celix_longHashMap_getDouble(lMap, 33, -1.0), -1.0);
     EXPECT_EQ(celix_longHashMap_getBool(lMap, 33, false), false);
     celix_longHashMap_destroy(lMap);
 }


 TEST_F(HashMapTestSuite, IterateTest) {
     auto* sMap = createStringHashMap(2);
     size_t count = 0;
     CELIX_STRING_HASH_MAP_ITERATE(sMap, iter) {
         EXPECT_EQ(count++, iter.index);
         if (iter.value.longValue == 0) {
             EXPECT_STREQ(iter.key, "key0");
         } else if (iter.value.longValue == 1) {
             EXPECT_STREQ(iter.key, "key1");
         } else {
             FAIL() << "Unexpected value " << iter.value.longValue;
         }
     }
     EXPECT_EQ(count, 2);
     celix_stringHashMap_destroy(sMap);

     auto* lMap = createLongHashMap(2);
     count = 0;
     CELIX_LONG_HASH_MAP_ITERATE(lMap, iter) {
         EXPECT_EQ(count++, iter.index);
         if (iter.value.longValue == 0) {
             EXPECT_EQ(iter.key, 0);
         } else if (iter.value.longValue == 1) {
             EXPECT_EQ(iter.key, 1);
         } else {
             FAIL() << "Unexpected value " << iter.value.longValue;
         }
     }
     EXPECT_EQ(count, 2);
     celix_longHashMap_destroy(lMap);
 }

 TEST_F(HashMapTestSuite, IterateStressTest) {
     int testCount = 1000;
     auto* sMap = createStringHashMap(testCount);
     EXPECT_EQ(testCount, celix_stringHashMap_size(sMap));
     int count = 0;
     CELIX_STRING_HASH_MAP_ITERATE(sMap, iter) {
         EXPECT_EQ(iter.index, count++);
     }
     EXPECT_EQ(testCount, count);
     testGetEntriesFromStringMap(sMap, 100);
     celix_stringHashMap_destroy(sMap);

     auto *lMap = createLongHashMap(testCount);
     EXPECT_EQ(testCount, celix_longHashMap_size(lMap));
     count = 0;
     CELIX_LONG_HASH_MAP_ITERATE(lMap, iter) {
         EXPECT_EQ(iter.index, count++);
     }
     EXPECT_EQ(testCount, count);
     testGetEntriesFromLongMap(lMap, 100);
     celix_longHashMap_destroy(lMap);
 }

 TEST_F(HashMapTestSuite, IterateStressCapacityAndLoadFactorTest) {
     celix_string_hash_map_create_options sOpts{};
     sOpts.loadFactor = 10; //high load factor to ensure buckets have multiple entries for testing
     sOpts.initialCapacity = 5;
     auto* sMap = celix_stringHashMap_createWithOptions(&sOpts);
     fillStringHashMap(sMap, 100);
     long value = celix_stringHashMap_getLong(sMap, "key50", 0);
     EXPECT_EQ(50, value);
     //remove last 50 entries
     for (long i = 50; i < 100; ++i) {
         auto key = std::string{"key"} + std::to_string(i);
         celix_stringHashMap_remove(sMap, key.c_str());
     }
     testGetEntriesFromStringMap(sMap, 50); //test entry 0-49
     celix_stringHashMap_destroy(sMap);


     celix_long_hash_map_create_options lOpts{};
     lOpts.loadFactor = 10; //high load factor to ensure buckets have multiple entries for testing
     lOpts.initialCapacity = 5;
     auto* lMap = celix_longHashMap_createWithOptions(&lOpts);
     fillLongHashMap(lMap, 100);
     value = celix_longHashMap_getLong(lMap, 50, 0);
     EXPECT_EQ(50, value);
     //remove last 50 entries
     for (long i = 50; i < 100; ++i) {
         celix_longHashMap_remove(lMap, i);
     }
     testGetEntriesFromLongMap(lMap, 50);
     celix_longHashMap_destroy(lMap);

 }

 TEST_F(HashMapTestSuite, IterateWithRemoveTest) {
     auto* sMap = createStringHashMap(6);
     auto iter1 = celix_stringHashMap_begin(sMap);
     while (!celix_stringHashMapIterator_isEnd(&iter1)) {
         if (iter1.index % 2 == 0) {
             //note only removing entries where the iter index is even
             celix_stringHashMapIterator_remove(&iter1);
         } else {
             celix_stringHashMapIterator_next(&iter1);
         }
     }
     EXPECT_EQ(3, celix_stringHashMap_size(sMap));
     EXPECT_TRUE(celix_stringHashMapIterator_isEnd(&iter1));
     celix_stringHashMapIterator_next(&iter1);
     EXPECT_TRUE(celix_stringHashMapIterator_isEnd(&iter1));
     celix_stringHashMap_destroy(sMap);

     auto* lMap = createLongHashMap(6);
     auto iter2 = celix_longHashMap_begin(lMap);
     while (!celix_longHashMapIterator_isEnd(&iter2)) {
         if (iter2.index % 2 == 0) {
             //note only removing entries where the iter index is even
             celix_longHashMapIterator_remove(&iter2);
         } else {
             celix_longHashMapIterator_next(&iter2);
         }
     }
     EXPECT_EQ(3, celix_longHashMap_size(lMap));
     EXPECT_TRUE(celix_longHashMapIterator_isEnd(&iter2));
     celix_longHashMapIterator_next(&iter2); //calling next on end iter, does nothing
     EXPECT_TRUE(celix_longHashMapIterator_isEnd(&iter2));
     celix_longHashMap_destroy(lMap);
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	#include <gtest/gtest.h>

	#include "celix_utils.h"
	#include "celix_string_hash_map.h"
	#include "celix_long_hash_map.h"
	#include <random>
	#include <atomic>

	class HashMapTestSuite : public ::testing::Test {
	public:
	/**
	* Create and fill string hash map with nrEntries entries.
	*/
	celix_string_hash_map_t* createStringHashMap(int nrEntries) {
	auto* map = celix_stringHashMap_create();
	fillStringHashMap(map, nrEntries);
	return map;
	}

	/**
	* Fill string hash map with nrOfEntries long value entries where the key and value are based on the
	* i index value of the for loop.
	* This way the expected hash map entry value can be deducted from the key.
	*/
	void fillStringHashMap(celix_string_hash_map_t* map, int nrEntries) {
	for (int i = 0; i < nrEntries; ++i) {
	std::string key = "key" + std::to_string(i);
	celix_stringHashMap_putLong(map, key.c_str(), i);
	EXPECT_EQ(i, celix_stringHashMap_getLong(map, key.c_str(), 0));
	EXPECT_EQ(celix_stringHashMap_size(map), i+1);
	}
	}

	/**
	* Randomly test nrOfEntriesToTest entries in a string hash map.
	* This assumes that the map is filled using fillStringHashMap.
	*/
	void testGetEntriesFromStringMap(celix_string_hash_map_t* map, int nrOfEntriesToTest) {
	std::uniform_int_distribution<long> keyDistribution{0, (long)celix_stringHashMap_size(map)-1};
	for (int i = 0; i < nrOfEntriesToTest; ++i) {
	long rand = keyDistribution(generator);
	auto key = std::string{"key"} + std::to_string(rand);
	EXPECT_EQ(celix_stringHashMap_getLong(map, key.c_str(), 0), rand) << "got wrong result for key " << key;
	}
	}

	/**
	* Create and fill long hash map with nrEntries entries.
	*/
	celix_long_hash_map_t * createLongHashMap(int nrEntries) {
	auto* map = celix_longHashMap_create();
	fillLongHashMap(map, nrEntries);
	return map;
	}

	/**
	* Fill long hash map with nrOfEntries long value entries where the key and value are based on the
	* i index value of the for loop.
	* This way the expected hash map entry value can be deducted from the key.
	*/
	void fillLongHashMap(celix_long_hash_map_t* map, int nrEntries) {
	for (int i = 0; i < nrEntries; ++i) {
	celix_longHashMap_putLong(map, i, i);
	EXPECT_EQ(i, celix_longHashMap_getLong(map, i, 0));
	EXPECT_EQ(celix_longHashMap_size(map), i+1);
	}
	}

	/**
	* Randomly test nrOfEntriesToTest entries in a long hash map.
	* This assumes that the map is filled using fillLongHashMap.
	*/
	void testGetEntriesFromLongMap(celix_long_hash_map_t* map, int nrOfEntriesToTest) {
	std::uniform_int_distribution<long> keyDistribution{0, (long)celix_longHashMap_size(map)-1};
	for (int i = 0; i< nrOfEntriesToTest; ++i) {
	long rand = keyDistribution(generator);
	EXPECT_EQ(celix_longHashMap_getLong(map, rand, 0), rand);
	}
	}
	private:
	std::default_random_engine generator{};
	};

	TEST_F(HashMapTestSuite, CreateDestroyHashMap) {
	auto* sMap = celix_stringHashMap_create();
	EXPECT_TRUE(sMap != nullptr);
	EXPECT_EQ(0, celix_stringHashMap_size(sMap));
	celix_stringHashMap_destroy(sMap);

	auto* lMap = celix_longHashMap_create();
	EXPECT_TRUE(lMap != nullptr);
	EXPECT_EQ(0, celix_longHashMap_size(lMap));
	celix_longHashMap_destroy(lMap);
	}

	TEST_F(HashMapTestSuite, PutPointerEntriesInStringHashMap) {
	auto* map = celix_stringHashMap_create();
	EXPECT_TRUE(map != nullptr);
	EXPECT_EQ(0, celix_stringHashMap_size(map));

	celix_stringHashMap_put(map, "key1", (void*)0x41);
	celix_stringHashMap_put(map, "key2", (void*)0x42);
	celix_stringHashMap_put(map, "key3", (void*)0x43);
	celix_stringHashMap_put(map, "key4", (void*)0x44);
	EXPECT_EQ(celix_stringHashMap_size(map), 4);

	EXPECT_TRUE(celix_stringHashMap_hasKey(map, "key1"));
	EXPECT_TRUE(celix_stringHashMap_hasKey(map, "key2"));
	EXPECT_TRUE(celix_stringHashMap_hasKey(map, "key3"));
	EXPECT_TRUE(celix_stringHashMap_hasKey(map, "key4"));
	EXPECT_FALSE(celix_stringHashMap_hasKey(map, "key5"));

	EXPECT_EQ(celix_stringHashMap_get(map, "key1"), (void*)0x41);
	EXPECT_EQ(celix_stringHashMap_get(map, "key2"), (void*)0x42);
	EXPECT_EQ(celix_stringHashMap_get(map, "key3"), (void*)0x43);
	EXPECT_EQ(celix_stringHashMap_get(map, "key4"), (void*)0x44);
	EXPECT_EQ(celix_stringHashMap_get(map, "key5"), nullptr);

	celix_stringHashMap_destroy(map);
	}

	TEST_F(HashMapTestSuite, PutPointerEntriesInLongHashMap) {
	auto* map = celix_longHashMap_create();
	EXPECT_TRUE(map != nullptr);
	EXPECT_EQ(0, celix_longHashMap_size(map));

	celix_longHashMap_put(map, 1, (void*)0x41);
	celix_longHashMap_put(map, 2, (void*)0x42);
	celix_longHashMap_put(map, 3, (void*)0x43);
	celix_longHashMap_put(map, 4, (void*)0x44);
	EXPECT_EQ(celix_longHashMap_size(map), 4);

	EXPECT_TRUE(celix_longHashMap_hasKey(map, 1));
	EXPECT_TRUE(celix_longHashMap_hasKey(map, 2));
	EXPECT_TRUE(celix_longHashMap_hasKey(map, 3));
	EXPECT_TRUE(celix_longHashMap_hasKey(map, 4));
	EXPECT_FALSE(celix_longHashMap_hasKey(map, 5));

	EXPECT_EQ(celix_longHashMap_get(map, 1), (void*)0x41);
	EXPECT_EQ(celix_longHashMap_get(map, 2), (void*)0x42);
	EXPECT_EQ(celix_longHashMap_get(map, 3), (void*)0x43);
	EXPECT_EQ(celix_longHashMap_get(map, 4), (void*)0x44);
	EXPECT_EQ(celix_longHashMap_get(map, 5), nullptr);

	celix_longHashMap_destroy(map);
	}

	TEST_F(HashMapTestSuite, StringKeyNullEntry) {
	auto* map = celix_stringHashMap_create();
	EXPECT_FALSE(celix_stringHashMap_hasKey(map, nullptr));
	celix_stringHashMap_put(map, nullptr, (void*)0x42);
	EXPECT_TRUE(celix_stringHashMap_hasKey(map, nullptr));
	EXPECT_EQ(1, celix_stringHashMap_size(map));
	celix_stringHashMap_destroy(map);
	}

	TEST_F(HashMapTestSuite, DestroyHashMapWithSimpleRemovedCallback) {
	celix_string_hash_map_create_options_t sOpts{};
	sOpts.simpleRemovedCallback = free;
	auto* sMap = celix_stringHashMap_createWithOptions(&sOpts);
	EXPECT_TRUE(sMap != nullptr);
	EXPECT_EQ(0, celix_stringHashMap_size(sMap));

	celix_stringHashMap_put(sMap, "key1", celix_utils_strdup("41"));
	celix_stringHashMap_put(sMap, "key2", celix_utils_strdup("42"));
	celix_stringHashMap_put(sMap, "key3", celix_utils_strdup("43"));
	celix_stringHashMap_put(sMap, "key4", celix_utils_strdup("44"));
	celix_stringHashMap_put(sMap, nullptr, celix_utils_strdup("null"));
	EXPECT_EQ(celix_stringHashMap_size(sMap), 5);
	EXPECT_STREQ((char*)celix_stringHashMap_get(sMap, nullptr), "null");

	bool removed = celix_stringHashMap_remove(sMap, "key3");
	EXPECT_TRUE(removed);
	removed = celix_stringHashMap_remove(sMap, "key3"); //double remove
	EXPECT_FALSE(removed);

	removed = celix_stringHashMap_remove(sMap, nullptr);
	EXPECT_TRUE(removed);
	removed = celix_stringHashMap_remove(sMap, nullptr); //double remove
	EXPECT_FALSE(removed);

	EXPECT_EQ(celix_stringHashMap_size(sMap), 3);
	celix_stringHashMap_destroy(sMap);

	celix_long_hash_map_create_options_t lOpts{};
	lOpts.simpledRemoveCallback = free;
	auto* lMap = celix_longHashMap_createWithOptions(&lOpts);
	EXPECT_TRUE(lMap != nullptr);
	EXPECT_EQ(0, celix_longHashMap_size(lMap));

	celix_longHashMap_put(lMap, 1, celix_utils_strdup("41"));
	celix_longHashMap_put(lMap, 2, celix_utils_strdup("42"));
	celix_longHashMap_put(lMap, 3, celix_utils_strdup("43"));
	celix_longHashMap_put(lMap, 4, celix_utils_strdup("44"));
	celix_longHashMap_put(lMap, 0, celix_utils_strdup("null"));
	EXPECT_EQ(celix_longHashMap_size(lMap), 5);
	EXPECT_STREQ((char*)celix_longHashMap_get(lMap, 0), "null");

	celix_longHashMap_remove(lMap, 3);
	celix_longHashMap_remove(lMap, 0);
	EXPECT_EQ(celix_longHashMap_size(lMap), 3);
	celix_longHashMap_destroy(lMap);
	}

	TEST_F(HashMapTestSuite, ClearHashMapWithRemovedCallback) {
	std::atomic<int> count{0};
	celix_string_hash_map_create_options_t sOpts{};
	sOpts.removedCallbackData = &count;
	sOpts.removedCallback = [](void data, const char key, celix_hash_map_value_t value) {
	auto* c = static_cast<std::atomic<int>*>(data);
	if (celix_utils_stringEquals(key, "key1")) {
	c->fetch_add(1);
	EXPECT_EQ(value.longValue, 1);
	} else if (celix_utils_stringEquals(key, "key2")) {
	c->fetch_add(1);
	EXPECT_EQ(value.longValue, 2);
	}
	};
	auto* sMap = celix_stringHashMap_createWithOptions(&sOpts);
	celix_stringHashMap_putLong(sMap, "key1", 1);
	celix_stringHashMap_putLong(sMap, "key2", 2);
	celix_stringHashMap_clear(sMap);
	EXPECT_EQ(count.load(), 2);
	EXPECT_EQ(celix_stringHashMap_size(sMap), 0);
	celix_stringHashMap_destroy(sMap);

	count = 0;
	celix_long_hash_map_create_options_t lOpts{};
	lOpts.removedCallbackData = &count;
	lOpts.removedCallback = [](void *data, long key, celix_hash_map_value_t value) {
	auto* c = static_cast<std::atomic<int>*>(data);
	if (key == 1) {
	c->fetch_add(1);
	EXPECT_EQ(value.longValue, 1);
	} else if (key == 2) {
	c->fetch_add(1);
	EXPECT_EQ(value.longValue, 2);
	}
	};
	auto* lMap = celix_longHashMap_createWithOptions(&lOpts);
	celix_longHashMap_putLong(lMap, 1, 1);
	celix_longHashMap_putLong(lMap, 2, 2);
	celix_longHashMap_clear(lMap);
	EXPECT_EQ(count.load(), 2);
	EXPECT_EQ(celix_longHashMap_size(lMap), 0);
	celix_longHashMap_destroy(lMap);
	}


	TEST_F(HashMapTestSuite, HashMapClearTests) {
	auto* sMap = createStringHashMap(3);
	EXPECT_EQ(celix_stringHashMap_size(sMap), 3);
	celix_stringHashMap_clear(sMap);
	EXPECT_EQ(celix_stringHashMap_size(sMap), 0);
	celix_stringHashMap_destroy(sMap);

	auto* lMap = createLongHashMap(3);
	EXPECT_EQ(celix_longHashMap_size(lMap), 3);
	celix_longHashMap_clear(lMap);
	EXPECT_EQ(celix_longHashMap_size(lMap), 0);
	celix_longHashMap_destroy(lMap);
	}


	template<typename T>
	void testMapsWithValues(const std::vector<std::tuple<std::string, long, T>>& values) {
	auto* sMap = celix_stringHashMap_create();
	auto* lMap = celix_longHashMap_create();

	//test hashmap put
	for (const auto& tuple : values) {
	if constexpr (std::is_same_v<void*, T>) {
	void* prev = celix_stringHashMap_put(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
	EXPECT_EQ(prev, nullptr);
	prev = celix_stringHashMap_put(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
	EXPECT_EQ(prev, std::get<2>(tuple));

	prev = celix_longHashMap_put(lMap, std::get<1>(tuple), std::get<2>(tuple));
	EXPECT_EQ(prev, nullptr);
	prev = celix_longHashMap_put(lMap, std::get<1>(tuple), std::get<2>(tuple));
	EXPECT_EQ(prev, std::get<2>(tuple));
	} else if constexpr (std::is_same_v<long, T>) {
	bool replaced = celix_stringHashMap_putLong(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
	EXPECT_FALSE(replaced);
	replaced = celix_stringHashMap_putLong(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
	EXPECT_TRUE(replaced);

	replaced = celix_longHashMap_putLong(lMap, std::get<1>(tuple), std::get<2>(tuple));
	EXPECT_FALSE(replaced);
	replaced = celix_longHashMap_putLong(lMap, std::get<1>(tuple), std::get<2>(tuple));
	EXPECT_TRUE(replaced);
	} else if constexpr (std::is_same_v<double, T>) {
	bool replaced = celix_stringHashMap_putDouble(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
	EXPECT_FALSE(replaced);
	replaced = celix_stringHashMap_putDouble(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
	EXPECT_TRUE(replaced);

	replaced = celix_longHashMap_putDouble(lMap, std::get<1>(tuple), std::get<2>(tuple));
	EXPECT_FALSE(replaced);
	replaced = celix_longHashMap_putDouble(lMap, std::get<1>(tuple), std::get<2>(tuple));
	EXPECT_TRUE(replaced);
	} else if constexpr (std::is_same_v<bool, T>) {
	bool replaced = celix_stringHashMap_putBool(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
	EXPECT_FALSE(replaced);
	replaced = celix_stringHashMap_putBool(sMap, std::get<0>(tuple).c_str(), std::get<2>(tuple));
	EXPECT_TRUE(replaced);

	replaced = celix_longHashMap_putBool(lMap, std::get<1>(tuple), std::get<2>(tuple));
	EXPECT_FALSE(replaced);
	replaced = celix_longHashMap_putBool(lMap, std::get<1>(tuple), std::get<2>(tuple));
	EXPECT_TRUE(replaced);
	} else {
	FAIL() << "expected of the following value types: void*, long, double or bool";
	}
	}
	ASSERT_EQ(values.size(), celix_stringHashMap_size(sMap));
	ASSERT_EQ(values.size(), celix_longHashMap_size(lMap));

	//test hashmap get
	for (const auto& tuple : values) {
	if constexpr (std::is_same_v<void*, T>) {
	auto* value = celix_stringHashMap_get(sMap, std::get<0>(tuple).c_str());
	EXPECT_EQ(value, std::get<2>(tuple));

	value = celix_longHashMap_get(lMap, std::get<1>(tuple));
	EXPECT_EQ(value, std::get<2>(tuple));
	} else if constexpr (std::is_same_v<long, T>) {
	auto value = celix_stringHashMap_getLong(sMap, std::get<0>(tuple).c_str(), 0);
	EXPECT_EQ(value, std::get<2>(tuple));

	value = celix_longHashMap_getLong(lMap, std::get<1>(tuple), 0);
	EXPECT_EQ(value, std::get<2>(tuple));
	} else if constexpr (std::is_same_v<double, T>) {
	auto value = celix_stringHashMap_getDouble(sMap, std::get<0>(tuple).c_str(), 0.0);
	EXPECT_EQ(value, std::get<2>(tuple));

	value = celix_longHashMap_getDouble(lMap, std::get<1>(tuple), 0.0);
	EXPECT_EQ(value, std::get<2>(tuple));
	} else if constexpr (std::is_same_v<bool, T>) {
	auto value = celix_stringHashMap_getBool(sMap, std::get<0>(tuple).c_str(), false);
	EXPECT_EQ(value, std::get<2>(tuple));

	value = celix_longHashMap_getBool(lMap, std::get<1>(tuple), false);
	EXPECT_EQ(value, std::get<2>(tuple));
	} else {
	FAIL() << "expected of the following value types: void*, long, double or bool";
	}
	}

	//test hashmap remove
	for (const auto& tuple : values) {
	celix_stringHashMap_remove(sMap, std::get<0>(tuple).c_str());
	celix_longHashMap_remove(lMap, std::get<1>(tuple));
	}
	ASSERT_EQ(0, celix_stringHashMap_size(sMap));
	ASSERT_EQ(0, celix_longHashMap_size(lMap));

	celix_stringHashMap_destroy(sMap);
	celix_longHashMap_destroy(lMap);
	}

	TEST_F(HashMapTestSuite, PutAndGetWithDifferentValueTypes) {
	std::vector<std::tuple<std::string, long, void*>> values1{
	{"key1", 1, (void*)0x42},
	{"key2", 2, (void*)0x43},
	{"key3", 3, (void*)0x44},
	};
	testMapsWithValues(values1);

	std::vector<std::tuple<std::string, long, long>> values2{
	{"key1", 1, 1},
	{"key2", 2, 2},
	{"key3", 3, 3},
	};
	testMapsWithValues(values2);

	std::vector<std::tuple<std::string, long, double>> values3{
	{"key1", 1, 1.0},
	{"key2", 2, 2.0},
	{"key3", 3, 3.0},
	};
	testMapsWithValues(values3);

	std::vector<std::tuple<std::string, long, bool>> values4{
	{"key1", 1, true},
	{"key2", 2, false},
	{"key3", 3, true},
	};
	testMapsWithValues(values4);
	}

	TEST_F(HashMapTestSuite, GetWithFallbackValues) {
	auto* sMap = celix_stringHashMap_create();
	EXPECT_EQ(celix_stringHashMap_get(sMap, "not-present"), nullptr);
	EXPECT_EQ(celix_stringHashMap_getLong(sMap, "not-present", -1), -1);
	EXPECT_EQ(celix_stringHashMap_getDouble(sMap, "not-present", 1.0), 1.0);
	EXPECT_EQ(celix_stringHashMap_getBool(sMap, "not-present", true), true);
	celix_stringHashMap_destroy(sMap);

	auto* lMap = celix_longHashMap_create();
	EXPECT_EQ(celix_longHashMap_get(lMap, 33), nullptr);
	EXPECT_EQ(celix_longHashMap_getLong(lMap, 33, 1), 1);
	EXPECT_EQ(celix_longHashMap_getDouble(lMap, 33, -1.0), -1.0);
	EXPECT_EQ(celix_longHashMap_getBool(lMap, 33, false), false);
	celix_longHashMap_destroy(lMap);
	}


	TEST_F(HashMapTestSuite, IterateTest) {
	auto* sMap = createStringHashMap(2);
	size_t count = 0;
	CELIX_STRING_HASH_MAP_ITERATE(sMap, iter) {
	EXPECT_EQ(count++, iter.index);
	if (iter.value.longValue == 0) {
	EXPECT_STREQ(iter.key, "key0");
	} else if (iter.value.longValue == 1) {
	EXPECT_STREQ(iter.key, "key1");
	} else {
	FAIL() << "Unexpected value " << iter.value.longValue;
	}
	}
	EXPECT_EQ(count, 2);
	celix_stringHashMap_destroy(sMap);

	auto* lMap = createLongHashMap(2);
	count = 0;
	CELIX_LONG_HASH_MAP_ITERATE(lMap, iter) {
	EXPECT_EQ(count++, iter.index);
	if (iter.value.longValue == 0) {
	EXPECT_EQ(iter.key, 0);
	} else if (iter.value.longValue == 1) {
	EXPECT_EQ(iter.key, 1);
	} else {
	FAIL() << "Unexpected value " << iter.value.longValue;
	}
	}
	EXPECT_EQ(count, 2);
	celix_longHashMap_destroy(lMap);
	}

	TEST_F(HashMapTestSuite, IterateStressTest) {
	int testCount = 1000;
	auto* sMap = createStringHashMap(testCount);
	EXPECT_EQ(testCount, celix_stringHashMap_size(sMap));
	int count = 0;
	CELIX_STRING_HASH_MAP_ITERATE(sMap, iter) {
	EXPECT_EQ(iter.index, count++);
	}
	EXPECT_EQ(testCount, count);
	testGetEntriesFromStringMap(sMap, 100);
	celix_stringHashMap_destroy(sMap);

	auto *lMap = createLongHashMap(testCount);
	EXPECT_EQ(testCount, celix_longHashMap_size(lMap));
	count = 0;
	CELIX_LONG_HASH_MAP_ITERATE(lMap, iter) {
	EXPECT_EQ(iter.index, count++);
	}
	EXPECT_EQ(testCount, count);
	testGetEntriesFromLongMap(lMap, 100);
	celix_longHashMap_destroy(lMap);
	}

	TEST_F(HashMapTestSuite, IterateStressCapacityAndLoadFactorTest) {
	celix_string_hash_map_create_options sOpts{};
	sOpts.loadFactor = 10; //high load factor to ensure buckets have multiple entries for testing
	sOpts.initialCapacity = 5;
	auto* sMap = celix_stringHashMap_createWithOptions(&sOpts);
	fillStringHashMap(sMap, 100);
	long value = celix_stringHashMap_getLong(sMap, "key50", 0);
	EXPECT_EQ(50, value);
	//remove last 50 entries
	for (long i = 50; i < 100; ++i) {
	auto key = std::string{"key"} + std::to_string(i);
	celix_stringHashMap_remove(sMap, key.c_str());
	}
	testGetEntriesFromStringMap(sMap, 50); //test entry 0-49
	celix_stringHashMap_destroy(sMap);


	celix_long_hash_map_create_options lOpts{};
	lOpts.loadFactor = 10; //high load factor to ensure buckets have multiple entries for testing
	lOpts.initialCapacity = 5;
	auto* lMap = celix_longHashMap_createWithOptions(&lOpts);
	fillLongHashMap(lMap, 100);
	value = celix_longHashMap_getLong(lMap, 50, 0);
	EXPECT_EQ(50, value);
	//remove last 50 entries
	for (long i = 50; i < 100; ++i) {
	celix_longHashMap_remove(lMap, i);
	}
	testGetEntriesFromLongMap(lMap, 50);
	celix_longHashMap_destroy(lMap);

	}

	TEST_F(HashMapTestSuite, IterateWithRemoveTest) {
	auto* sMap = createStringHashMap(6);
	auto iter1 = celix_stringHashMap_begin(sMap);
	while (!celix_stringHashMapIterator_isEnd(&iter1)) {
	if (iter1.index % 2 == 0) {
	//note only removing entries where the iter index is even
	celix_stringHashMapIterator_remove(&iter1);
	} else {
	celix_stringHashMapIterator_next(&iter1);
	}
	}
	EXPECT_EQ(3, celix_stringHashMap_size(sMap));
	EXPECT_TRUE(celix_stringHashMapIterator_isEnd(&iter1));
	celix_stringHashMapIterator_next(&iter1);
	EXPECT_TRUE(celix_stringHashMapIterator_isEnd(&iter1));
	celix_stringHashMap_destroy(sMap);

	auto* lMap = createLongHashMap(6);
	auto iter2 = celix_longHashMap_begin(lMap);
	while (!celix_longHashMapIterator_isEnd(&iter2)) {
	if (iter2.index % 2 == 0) {
	//note only removing entries where the iter index is even
	celix_longHashMapIterator_remove(&iter2);
	} else {
	celix_longHashMapIterator_next(&iter2);
	}
	}
	EXPECT_EQ(3, celix_longHashMap_size(lMap));
	EXPECT_TRUE(celix_longHashMapIterator_isEnd(&iter2));
	celix_longHashMapIterator_next(&iter2); //calling next on end iter, does nothing
	EXPECT_TRUE(celix_longHashMapIterator_isEnd(&iter2));
	celix_longHashMap_destroy(lMap);
	}