util_test.cpp File Reference

#include "tests/test.h"
#include "souffle/utility/CacheUtil.h"
#include "souffle/utility/ContainerUtil.h"
#include "souffle/utility/FunctionalUtil.h"
#include "souffle/utility/StreamUtil.h"
#include "souffle/utility/StringUtil.h"
#include <algorithm>
#include <map>
#include <set>
#include <string>
#include <typeinfo>
#include <vector>

Include dependency graph for util_test.cpp:

Go to the source code of this file.

Functions
	TEST (Util, LambdaTraits)
	TEST (Util, LRUCache)
	TEST (Util, LRUCache_S0)
	TEST (Util, LRUCache_S1)
	TEST (Util, LRUCache_S2)
	TEST (Util, printMap)
	TEST (Util, printSet)
	TEST (Util, printVector)
	TEST (Util, Range)
	TEST (Util, toString)
	TEST (Util, toVector)

Function Documentation

TEST() [1/11]

TEST	(	Util	,
		LambdaTraits
	)

Definition at line 73 of file util_test.cpp.

                         {
    auto lambda = [](int) -> bool { return true; };
 
    EXPECT_EQ(typeid(bool).name(), typeid(lambda_traits<decltype(lambda)>::result_type).name());
    EXPECT_EQ(typeid(int).name(), typeid(lambda_traits<decltype(lambda)>::arg0_type).name());
}

References EXPECT_EQ.

TEST() [2/11]

TEST	(	Util	,
		LRUCache
	)

Definition at line 80 of file util_test.cpp.

                     {
    using cache = LRUCache<int, 4>;
    cache c;
 
    // check initial state
    EXPECT_EQ("0,0,0,0", toString(c));
 
    // fill cache with new entries
    c.access(4);
    EXPECT_EQ("4,0,0,0", toString(c));
 
    c.access(3);
    EXPECT_EQ("3,4,0,0", toString(c));
 
    c.access(7);
    EXPECT_EQ("7,3,4,0", toString(c));
 
    c.access(2);
    EXPECT_EQ("2,7,3,4", toString(c));
 
    c.access(5);
    EXPECT_EQ("5,2,7,3", toString(c));
 
    // access elements present
    c.access(5);
    EXPECT_EQ("5,2,7,3", toString(c));
 
    c.access(2);
    EXPECT_EQ("2,5,7,3", toString(c));
 
    c.access(7);
    EXPECT_EQ("7,2,5,3", toString(c));
 
    c.access(3);
    EXPECT_EQ("3,7,2,5", toString(c));
 
    c.access(2);
    EXPECT_EQ("2,3,7,5", toString(c));
 
    // test clearing
    c.clear();
    EXPECT_EQ("0,0,0,0", toString(c));
 
    c.clear(5);
    EXPECT_EQ("5,5,5,5", toString(c));
}

References EXPECT_EQ, and souffle::toString().

Here is the call graph for this function:

TEST() [3/11]

TEST	(	Util	,
		LRUCache_S0
	)

Definition at line 192 of file util_test.cpp.

                        {
    using cache = LRUCache<int, 0>;
    cache c;
 
    // check initial state
    EXPECT_EQ("-empty-", toString(c));
 
    // fill cache with new entries
    c.access(4);
    EXPECT_EQ("-empty-", toString(c));
 
    c.access(3);
    EXPECT_EQ("-empty-", toString(c));
 
    // access elements present
    c.access(3);
    EXPECT_EQ("-empty-", toString(c));
 
    // and again not present
    c.access(2);
    EXPECT_EQ("-empty-", toString(c));
 
    // test clearing
    c.clear();
    EXPECT_EQ("-empty-", toString(c));
 
    c.clear(5);
    EXPECT_EQ("-empty-", toString(c));
}

References EXPECT_EQ, and souffle::toString().

Here is the call graph for this function:

TEST() [4/11]

TEST	(	Util	,
		LRUCache_S1
	)

Definition at line 162 of file util_test.cpp.

                        {
    using cache = LRUCache<int, 1>;
    cache c;
 
    // check initial state
    EXPECT_EQ("0", toString(c));
 
    // fill cache with new entries
    c.access(4);
    EXPECT_EQ("4", toString(c));
 
    c.access(3);
    EXPECT_EQ("3", toString(c));
 
    // access elements present
    c.access(3);
    EXPECT_EQ("3", toString(c));
 
    // and again not present
    c.access(2);
    EXPECT_EQ("2", toString(c));
 
    // test clearing
    c.clear();
    EXPECT_EQ("0", toString(c));
 
    c.clear(5);
    EXPECT_EQ("5", toString(c));
}

References EXPECT_EQ, and souffle::toString().

Here is the call graph for this function:

TEST() [5/11]

TEST	(	Util	,
		LRUCache_S2
	)

Definition at line 127 of file util_test.cpp.

                        {
    using cache = LRUCache<int, 2>;
    cache c;
 
    // check initial state
    EXPECT_EQ("0,0", toString(c));
 
    // fill cache with new entries
    c.access(4);
    EXPECT_EQ("4,0", toString(c));
 
    c.access(3);
    EXPECT_EQ("3,4", toString(c));
 
    c.access(7);
    EXPECT_EQ("7,3", toString(c));
 
    // access elements present
    c.access(7);
    EXPECT_EQ("7,3", toString(c));
 
    c.access(3);
    EXPECT_EQ("3,7", toString(c));
 
    c.access(7);
    EXPECT_EQ("7,3", toString(c));
 
    // test clearing
    c.clear();
    EXPECT_EQ("0,0", toString(c));
 
    c.clear(5);
    EXPECT_EQ("5,5", toString(c));
}

References EXPECT_EQ, and souffle::toString().

Here is the call graph for this function:

TEST() [6/11]

TEST	(	Util	,
		printMap
	)

Definition at line 63 of file util_test.cpp.

                     {
    std::map<int, std::string> m;
 
    EXPECT_EQ("{}", toString(m));
    m[12] = "Hello";
    EXPECT_EQ("{12->Hello}", toString(m));
    m[14] = "World";
    EXPECT_EQ("{12->Hello,14->World}", toString(m));
}

References EXPECT_EQ, m, and souffle::toString().

Here is the call graph for this function:

TEST() [7/11]

TEST	(	Util	,
		printSet
	)

Definition at line 53 of file util_test.cpp.

                     {
    std::set<int> v;
 
    EXPECT_EQ("{}", toString(v));
    v.insert(12);
    EXPECT_EQ("{12}", toString(v));
    v.insert(14);
    EXPECT_EQ("{12,14}", toString(v));
}

References EXPECT_EQ, and souffle::toString().

Here is the call graph for this function:

TEST() [8/11]

TEST	(	Util	,
		printVector
	)

Definition at line 43 of file util_test.cpp.

                        {
    std::vector<int> v;
 
    EXPECT_EQ("[]", toString(v));
    v.push_back(12);
    EXPECT_EQ("[12]", toString(v));
    v.push_back(14);
    EXPECT_EQ("[12,14]", toString(v));
}

References EXPECT_EQ, and souffle::toString().

Here is the call graph for this function:

TEST() [9/11]

TEST	(	Util	,
		Range
	)

Definition at line 222 of file util_test.cpp.

                  {
    using container = std::vector<int>;
    using iter = container::const_iterator;
 
    std::vector<int> list(9);
 
    for (int i = 0; i < 9; i++) {
        list[i] = i;
    }
 
    range<iter> range(list.begin(), list.end());
 
    {
        int last = -1;
        for (const auto& p : range.partition(4)) {
            auto size = p.end() - p.begin();
            EXPECT_TRUE(2 <= size && size <= 3);
            for (const auto& cur : p) {
                EXPECT_EQ(last + 1, cur);
                last = cur;
            }
        }
        EXPECT_EQ(last, 8);
    }
 
    {
        int last = -1;
        for (const auto& p : range.partition(7)) {
            auto size = p.end() - p.begin();
            EXPECT_TRUE(1 <= size && size <= 2);
            for (const auto& cur : p) {
                EXPECT_EQ(last + 1, cur);
                last = cur;
            }
        }
        EXPECT_EQ(last, 8);
    }
}

References EXPECT_EQ, EXPECT_TRUE, i, p, souffle::range< Iter >::partition(), and TCB_SPAN_NAMESPACE_NAME::detail::size().

Here is the call graph for this function:

TEST() [10/11]

TEST	(	Util	,
		toString
	)

Definition at line 33 of file util_test.cpp.

                     {
    EXPECT_EQ("12", toString(12));
    EXPECT_EQ("Hello", toString("Hello"));
}

References EXPECT_EQ, and souffle::toString().

Here is the call graph for this function:

TEST() [11/11]

TEST	(	Util	,
		toVector
	)

Definition at line 38 of file util_test.cpp.

                     {
    EXPECT_EQ("[1,2,3]", toString(toVector(1, 2, 3)));
    EXPECT_EQ("[]", toString(toVector<int>()));
}

References EXPECT_EQ, souffle::toString(), and souffle::toVector().

Here is the call graph for this function: