Gtest Text Fixture tests return almost nothing - c++

Question

I have two classes MultiContainert and MultiContainerTest with Fixture:
My main problem is that some of my tests work well and return results, but after the "Remove" test, the terminal does not stop and display no message and or results, so I presume it blocks. My question is that I do not see where the problems would come from? I have no message to help me or guide me.
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/key.hpp>
#include <iostream>
#include <mutex>
#include <memory>
template <typename Tkey, typename Tval>
class MultiContainer
{
private:
using value_type = std::pair<Tkey, Tval>;
unsigned int capacity;
boost::multi_index_container<
value_type,
boost::multi_index::indexed_by<
boost::multi_index::sequenced<>,
boost::multi_index::hashed_unique<boost::multi_index::key<&value_type::first>>>>
container;
std::mutex mtx;
static std::unique_ptr<MultiContainer> instance;
MultiContainer(unsigned int icapacity) : capacity(icapacity) {}
public:
static MultiContainer &getInstance(unsigned int capacity)
{
if (!instance)
instance.reset(new MultiContainer(capacity));
return *instance;
}
int size()
{
std::lock_guard<std::mutex> lock(mtx);
return container.size();
}
bool isCapacityReached()
{
std::lock_guard<std::mutex> lock(mtx);
return container.size() >= capacity;
}
void removeLRU()
{
std::lock_guard<std::mutex> lock(mtx);
if (!container.empty())
container.erase(container.template get<0>().begin());
}
/*
void removeMRU()
{
std::lock_guardstd::mutex lock(mtx);
if (!container.empty())
container.erase(container.template get<0>().end() - 1);
}
*/
bool empty()
{
std::lock_guard<std::mutex> lock(mtx);
return container.empty();
}
void clear()
{
std::lock_guard<std::mutex> lock(mtx);
container.clear();
}
bool contains(const Tkey &key)
{
std::lock_guard<std::mutex> lock(mtx);
const auto &lookup = container.template get<1>();
return lookup.find(key) != lookup.end();
}
void remove(const Tkey &key)
{
std::lock_guard<std::mutex> lock(mtx);
auto &lookup = container.template get<1>();
lookup.erase(key);
}
void put(const Tkey &key, const Tval &val)
{
if (isCapacityReached())
{
std::lock_guard<std::mutex> lock(mtx);
removeLRU();
}
auto &lookup = container.template get<1>();
auto it = lookup.find(key);
if (it != lookup.end())
{
container.relocate(container.template get<0>().begin(), container.template project<0>(it));
lookup.modify(it, [&](value_type &x)
{ x.second = val; });
}
else
{
std::lock_guard<std::mutex> lock(mtx);
it = lookup.emplace(value_type(key, val)).first;
}
}
Tval get(const Tkey &key, const Tval &default_val = Tval())
{
std::lock_guard<std::mutex> lock(mtx);
const auto &lookup = container.template get<1>();
const auto it = lookup.find(key);
if (it == lookup.end())
{
return default_val;
}
container.relocate(container.template get<0>().begin(), container.template project<0>(it));
return it->second;
}
};
template <typename Tkey, typename Tval>
std::unique_ptr<MultiContainer<Tkey, Tval>> MultiContainer<Tkey, Tval>::instance = nullptr;
int main() {
MultiContainer<std::string, std::string> &container = MultiContainer<std::string, std::string>::getInstance(3);
container.put("key1", "value1");
container.put("key2", "value2");
container.put("key3", "value3");
std::cout << "Size : " << container.size() << std::endl;
std::cout << "Capacity reached : " << container.isCapacityReached() << std::endl;
std::cout << "Contains key1 : " << container.contains("key1") << std::endl;
std::cout << "Value for key1 : " << container.get("key1") << std::endl;
container.remove("key1");
std::cout << "Size : " << container.size() << std::endl;
std::cout << "Contains key1 : " << container.contains("key1") << std::endl;
container.clear();
std::cout << "Size : " << container.size() << std::endl;
std::cout << "Empty : " << container.empty() << std::endl;
return 0;
}
Classe MultiContainerTest:
#include <../googletest/include/gtest/gtest.h>
#include "multiContainer.hpp"
#include <chrono>
#include <thread>
class MultiContainerTest : public ::testing::Test
{
protected:
MultiContainer<int, std::string> &container = MultiContainer<int, std::string>::getInstance(3);
MultiContainer<int, std::string> &container2 = MultiContainer<int, std::string>::getInstance(5);
unsigned int cache_size = 1000;
MultiContainer<int, int> &cache = MultiContainer<int, int>::getInstance(cache_size);
virtual void TearDown()
{
cache.clear();
}
~MultiContainerTest() { } // remove exception specification
};
TEST_F(MultiContainerTest, CreateInstance)
{
EXPECT_EQ(container.size(), 0);
EXPECT_FALSE(container.isCapacityReached());
}
TEST_F(MultiContainerTest, Size)
{
container.put(1, "hello");
container.put(2, "world");
EXPECT_EQ(container.size(), 2);
}
TEST_F(MultiContainerTest, CapacityReached)
{
container.put(1, "hello");
container.put(2, "world");
container.put(3, "!");
EXPECT_TRUE(container.isCapacityReached());
}
TEST_F(MultiContainerTest, RemoveLRU)
{
container.put(1, "hello");
container.put(2, "world");
container.put(3, "!");
container.removeLRU();
EXPECT_FALSE(container.contains(1));
EXPECT_EQ(container.size(), 2);
}
TEST_F(MultiContainerTest, Empty)
{
EXPECT_TRUE(container.empty());
container.put(1, "hello");
EXPECT_FALSE(container.empty());
}
TEST_F(MultiContainerTest, Clear)
{
container.put(1, "hello");
container.put(2, "world");
container.clear();
EXPECT_TRUE(container.empty());
}
TEST_F(MultiContainerTest, Contains)
{
container.put(1, "hello");
container.put(2, "world");
EXPECT_TRUE(container.contains(1));
EXPECT_FALSE(container.contains(3));
}
TEST_F(MultiContainerTest, Remove)
{
container.put(1, "hello");
container.put(2, "world");
container.remove(1);
EXPECT_FALSE(container.contains(1));
EXPECT_EQ(container.size(), 1);
}
TEST_F(MultiContainerTest, CheckSingleton)
{
EXPECT_EQ(&container, &container2);
EXPECT_EQ(container.size(), container2.size());
container.put(1, "hello");
EXPECT_EQ(container2.get(1), "hello");
}
// Hit rate: the number of times an item is found in the cache divided by the total number of lookups
TEST_F(MultiContainerTest, HitRateTest)
{
int total_lookups = 1000000;
int hits = 0;
for (int i = 0; i < total_lookups; i++)
{
int key = rand() % cache_size;
int val = rand();
cache.put(key, val);
if (cache.contains(key))
{
hits++;
}
}
double hit_rate = (double)hits / total_lookups;
EXPECT_GT(hit_rate, 0.8);
}
TEST_F(MultiContainerTest, ConcurrencyTest)
{
std::vector<std::thread> threads;
for (int i = 0; i < 10; i++)
{
threads.push_back(std::thread([&]()
{
for (int j = 0; j < 100; j++)
{
int key = rand() % cache_size;
int val = rand();
cache.put(key, val);
} }));
}
for (auto &t : threads)
{
t.join();
}
// check that all elements are in the cache
for (int i = 0; i < cache_size; i++)
{
EXPECT_TRUE(cache.contains(i));
}
}
TEST_F(MultiContainerTest, TimeComplexityTest)
{
int num_elements = 100000;
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < num_elements; i++)
{
cache.put(i, i);
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
// check that the time taken to insert the elements is below a certain threshold
EXPECT_LT(duration.count(), 2000000);
}
TEST_F(MultiContainerTest, TimeComplexityGet)
{
int num_elements = 100000;
for (int i = 0; i < num_elements; i++)
{
cache.put(i, i);
}
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < num_elements; i++)
{
cache.get(i);
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
// check that the time taken to get the elements is below a certain threshold
EXPECT_LT(duration.count(), 2000000);
}
TEST_F(MultiContainerTest, TimeComplexityRemove)
{
int num_elements = 100000;
for (int i = 0; i < num_elements; i++)
{
cache.put(i, i);
}
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < num_elements; i++)
{
cache.remove(i);
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
// check that the time taken to remove the elements is below a certain threshold
EXPECT_LT(duration.count(), 2000000);
}
TEST_F(MultiContainerTest, TimeComplexityRemoveLRU)
{
int num_elements = 100000;
for (int i = 0; i < num_elements; i++)
{
cache.put(i, i);
}
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < num_elements; i++)
{
cache.removeLRU();
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
// check that the time taken to remove the LRU elements is below a certain threshold
EXPECT_LT(duration.count(), 2000000);
}
int main(int argc, char* argv[]) {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}