summaryrefslogtreecommitdiffstats
path: root/vespalib
diff options
context:
space:
mode:
Diffstat (limited to 'vespalib')
-rw-r--r--vespalib/src/tests/array/CMakeLists.txt1
-rw-r--r--vespalib/src/tests/array/sort_benchmark.cpp46
-rw-r--r--vespalib/src/tests/bits/CMakeLists.txt1
-rw-r--r--vespalib/src/tests/bits/bits_test.cpp37
-rw-r--r--vespalib/src/tests/btree/CMakeLists.txt1
-rw-r--r--vespalib/src/tests/btree/frozenbtree_test.cpp40
-rw-r--r--vespalib/src/tests/compress/CMakeLists.txt1
-rw-r--r--vespalib/src/tests/compress/compress_test.cpp64
-rw-r--r--vespalib/src/tests/crc/CMakeLists.txt1
-rw-r--r--vespalib/src/tests/crc/crc_test.cpp35
-rw-r--r--vespalib/src/tests/data/databuffer/CMakeLists.txt1
-rw-r--r--vespalib/src/tests/data/databuffer/databuffer_test.cpp184
12 files changed, 189 insertions, 223 deletions
diff --git a/vespalib/src/tests/array/CMakeLists.txt b/vespalib/src/tests/array/CMakeLists.txt
index 3f08aa07b4d..11e81cc42ce 100644
--- a/vespalib/src/tests/array/CMakeLists.txt
+++ b/vespalib/src/tests/array/CMakeLists.txt
@@ -11,5 +11,6 @@ vespa_add_executable(vespalib_sort_benchmark_app
sort_benchmark.cpp
DEPENDS
vespalib
+ GTest::gtest
)
vespa_add_test(NAME vespalib_sort_benchmark_app COMMAND vespalib_sort_benchmark_app BENCHMARK)
diff --git a/vespalib/src/tests/array/sort_benchmark.cpp b/vespalib/src/tests/array/sort_benchmark.cpp
index ba95c663332..db5c3c80f5f 100644
--- a/vespalib/src/tests/array/sort_benchmark.cpp
+++ b/vespalib/src/tests/array/sort_benchmark.cpp
@@ -1,6 +1,6 @@
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/vespalib/testkit/testapp.h>
#include <vespa/vespalib/util/rusage.h>
+#include <vespa/vespalib/gtest/gtest.h>
#include <vespa/vespalib/util/array.hpp>
#include <csignal>
#include <algorithm>
@@ -10,19 +10,32 @@ LOG_SETUP("sort_benchmark");
using namespace vespalib;
-class Test : public TestApp
+class SortBenchmark : public ::testing::Test
{
+ int _argc;
+ char** _argv;
public:
-private:
+ SortBenchmark(int argc, char **argv);
+ ~SortBenchmark() override;
+ void TestBody() override;
+protected:
template<typename T>
vespalib::Array<T> create(size_t count);
template<typename T>
void sortDirect(size_t count);
template<typename T>
void sortInDirect(size_t count);
- int Main() override;
};
+SortBenchmark::SortBenchmark(int argc, char** argv)
+ : testing::Test(),
+ _argc(argc),
+ _argv(argv)
+{
+}
+
+SortBenchmark::~SortBenchmark() = default;
+
template<size_t N>
class TT
{
@@ -46,7 +59,7 @@ private:
template<typename T>
vespalib::Array<T>
-Test::create(size_t count)
+SortBenchmark::create(size_t count)
{
vespalib::Array<T> v;
v.reserve(count);
@@ -58,7 +71,7 @@ Test::create(size_t count)
}
template<typename T>
-void Test::sortDirect(size_t count)
+void SortBenchmark::sortDirect(size_t count)
{
vespalib::Array<T> v(create<T>(count));
LOG(info, "Running sortDirect with %ld count and payload of %ld", v.size(), sizeof(T));
@@ -69,7 +82,7 @@ void Test::sortDirect(size_t count)
}
template<typename T>
-void Test::sortInDirect(size_t count)
+void SortBenchmark::sortInDirect(size_t count)
{
vespalib::Array<T> k(create<T>(count));
LOG(info, "Running sortInDirect with %ld count and payload of %ld", k.size(), sizeof(T));
@@ -84,8 +97,8 @@ void Test::sortInDirect(size_t count)
}
}
-int
-Test::Main()
+void
+SortBenchmark::TestBody()
{
std::string type("sortdirect");
size_t count = 1000000;
@@ -99,8 +112,7 @@ Test::Main()
if (_argc > 3) {
payLoad = strtol(_argv[3], NULL, 0);
}
- TEST_INIT("sort_benchmark");
- steady_time start(steady_clock::now());
+ steady_time start(steady_clock::now());
if (payLoad < 8) {
using T = TT<8>;
if (type == "sortdirect") {
@@ -176,9 +188,13 @@ Test::Main()
}
}
LOG(info, "rusage = {\n%s\n}", vespalib::RUsage::createSelf(start).toString().c_str());
- ASSERT_EQUAL(0, kill(0, SIGPROF));
- TEST_DONE();
+ ASSERT_EQ(0, kill(0, SIGPROF));
}
-TEST_APPHOOK(Test);
-
+int main(int argc, char** argv) {
+ ::testing::InitGoogleTest(&argc, argv);
+ ::testing::RegisterTest("SortBenchmark", "benchmark", nullptr, "",
+ __FILE__, __LINE__,
+ [=]() -> SortBenchmark* { return new SortBenchmark(argc, argv); });
+ return RUN_ALL_TESTS();
+}
diff --git a/vespalib/src/tests/bits/CMakeLists.txt b/vespalib/src/tests/bits/CMakeLists.txt
index 71a977a295a..3ba0c6afc1c 100644
--- a/vespalib/src/tests/bits/CMakeLists.txt
+++ b/vespalib/src/tests/bits/CMakeLists.txt
@@ -4,5 +4,6 @@ vespa_add_executable(vespalib_bits_test_app TEST
bits_test.cpp
DEPENDS
vespalib
+ GTest::gtest
)
vespa_add_test(NAME vespalib_bits_test_app COMMAND vespalib_bits_test_app)
diff --git a/vespalib/src/tests/bits/bits_test.cpp b/vespalib/src/tests/bits/bits_test.cpp
index 6341477c2a7..6b01b2cd63a 100644
--- a/vespalib/src/tests/bits/bits_test.cpp
+++ b/vespalib/src/tests/bits/bits_test.cpp
@@ -1,23 +1,25 @@
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/vespalib/testkit/testapp.h>
#include <vespa/vespalib/util/bits.h>
+#include <vespa/vespalib/gtest/gtest.h>
using namespace vespalib;
-class Test : public TestApp
+class BitsTest : public ::testing::Test
{
-public:
- int Main() override;
+protected:
+ BitsTest();
+ ~BitsTest() override;
template <typename T>
void testFixed(const T * v, size_t sz, const T * exp);
void testBuffer();
};
-int
-Test::Main()
+BitsTest::BitsTest() = default;
+BitsTest::~BitsTest() = default;
+
+TEST_F(BitsTest, test_bits)
{
- TEST_INIT("bits_test");
uint8_t u8[5] = { 0, 0x1, 0x7f, 0x87, 0xff };
uint8_t exp8[5] = { 0, 0x80, 0xfe, 0xe1, 0xff };
testFixed(u8, sizeof(u8)/sizeof(u8[0]), exp8);
@@ -31,29 +33,28 @@ Test::Main()
uint64_t exp64[5] = { 0, 0x8000000000000000, 0xfe00000000000000, 0xe100000000000000, 0xff00000000000000 };
testFixed(u64, sizeof(u64)/sizeof(u64[0]), exp64);
testBuffer();
- TEST_DONE();
}
template <typename T>
-void Test::testFixed(const T * v, size_t sz, const T * exp)
+void BitsTest::testFixed(const T * v, size_t sz, const T * exp)
{
- EXPECT_EQUAL(0u, Bits::reverse(static_cast<T>(0)));
- EXPECT_EQUAL(1ul << (sizeof(T)*8 - 1), Bits::reverse(static_cast<T>(1)));
- EXPECT_EQUAL(static_cast<T>(-1), Bits::reverse(static_cast<T>(-1)));
+ EXPECT_EQ(0u, Bits::reverse(static_cast<T>(0)));
+ EXPECT_EQ(1ul << (sizeof(T)*8 - 1), Bits::reverse(static_cast<T>(1)));
+ EXPECT_EQ(static_cast<T>(-1), Bits::reverse(static_cast<T>(-1)));
for (size_t i(0); i < sz; i++) {
- EXPECT_EQUAL(Bits::reverse(v[i]), exp[i]);
- EXPECT_EQUAL(Bits::reverse(Bits::reverse(v[i])), v[i]);
+ EXPECT_EQ(Bits::reverse(v[i]), exp[i]);
+ EXPECT_EQ(Bits::reverse(Bits::reverse(v[i])), v[i]);
}
}
-void Test::testBuffer()
+void BitsTest::testBuffer()
{
uint64_t a(0x0102040810204080ul);
uint64_t b(a);
Bits::reverse(&a, sizeof(a));
- EXPECT_EQUAL(a, Bits::reverse(b));
+ EXPECT_EQ(a, Bits::reverse(b));
Bits::reverse(&a, sizeof(a));
- EXPECT_EQUAL(a, b);
+ EXPECT_EQ(a, b);
}
-TEST_APPHOOK(Test)
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/vespalib/src/tests/btree/CMakeLists.txt b/vespalib/src/tests/btree/CMakeLists.txt
index 79bda87867e..bf4edc9e5e9 100644
--- a/vespalib/src/tests/btree/CMakeLists.txt
+++ b/vespalib/src/tests/btree/CMakeLists.txt
@@ -12,6 +12,7 @@ vespa_add_executable(vespalib_frozenbtree_test_app TEST
frozenbtree_test.cpp
DEPENDS
vespalib
+ GTest::gtest
)
vespa_add_test(NAME vespalib_frozenbtree_test_app COMMAND vespalib_frozenbtree_test_app COST 30)
vespa_add_executable(vespalib_btreeaggregation_test_app TEST
diff --git a/vespalib/src/tests/btree/frozenbtree_test.cpp b/vespalib/src/tests/btree/frozenbtree_test.cpp
index b16a7013db4..ffe8b4516aa 100644
--- a/vespalib/src/tests/btree/frozenbtree_test.cpp
+++ b/vespalib/src/tests/btree/frozenbtree_test.cpp
@@ -2,12 +2,12 @@
#define DEBUG_FROZENBTREE
#define LOG_FROZENBTREEXX
-#include <vespa/vespalib/testkit/testapp.h>
#include <vespa/vespalib/btree/btreeroot.h>
#include <vespa/vespalib/btree/btreeiterator.hpp>
#include <vespa/vespalib/btree/btreeroot.hpp>
#include <vespa/vespalib/btree/btreenodeallocator.hpp>
#include <vespa/vespalib/datastore/buffer_type.hpp>
+#include <vespa/vespalib/gtest/gtest.h>
#include <vespa/vespalib/util/rand48.h>
#include <map>
@@ -24,11 +24,11 @@ using vespalib::GenerationHandler;
namespace vespalib {
-class FrozenBTreeTest : public vespalib::TestApp
+class FrozenBTreeTest : public ::testing::Test
{
public:
using KeyType = int;
-private:
+protected:
std::vector<KeyType> _randomValues;
std::vector<KeyType> _sortedRandomValues;
@@ -43,7 +43,7 @@ public:
using LeafNodeType = Tree::LeafNodeType;
using Iterator = Tree::Iterator;
using ConstIterator = Tree::ConstIterator;
-private:
+protected:
GenerationHandler *_generationHandler;
NodeAllocator *_allocator;
Tree *_tree;
@@ -70,21 +70,21 @@ private:
}
public:
FrozenBTreeTest();
- ~FrozenBTreeTest();
-
- int Main() override;
+ ~FrozenBTreeTest() override;
};
FrozenBTreeTest::FrozenBTreeTest()
- : vespalib::TestApp(),
+ : ::testing::Test(),
_randomValues(),
_sortedRandomValues(),
_generationHandler(NULL),
_allocator(NULL),
_tree(NULL),
_randomGenerator()
-{}
-FrozenBTreeTest::~FrozenBTreeTest() {}
+{
+}
+
+FrozenBTreeTest::~FrozenBTreeTest() = default;
void
FrozenBTreeTest::allocTree()
@@ -410,11 +410,8 @@ FrozenBTreeTest::printEnumTree(const Tree *tree,
-int
-FrozenBTreeTest::Main()
+TEST_F(FrozenBTreeTest, test_frozen_btree)
{
- TEST_INIT("frozenbtree_test");
-
fillRandomValues(1000);
sortRandomValues();
@@ -451,21 +448,8 @@ FrozenBTreeTest::Main()
true);
insertRandomValues(*_tree, *_allocator, _randomValues);
freeTree(true);
-
- fillRandomValues(1000000);
- sortRandomValues();
-
- allocTree();
- insertRandomValues(*_tree, *_allocator, _randomValues);
- traverseTreeIterator(*_tree,
- *_allocator,
- _sortedRandomValues,
- false);
- freeTree(false);
-
- TEST_DONE();
}
}
-TEST_APPHOOK(vespalib::FrozenBTreeTest);
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/vespalib/src/tests/compress/CMakeLists.txt b/vespalib/src/tests/compress/CMakeLists.txt
index 3085aec6bd8..31679e1f479 100644
--- a/vespalib/src/tests/compress/CMakeLists.txt
+++ b/vespalib/src/tests/compress/CMakeLists.txt
@@ -4,5 +4,6 @@ vespa_add_executable(vespalib_compress_test_app TEST
compress_test.cpp
DEPENDS
vespalib
+ GTest::gtest
)
vespa_add_test(NAME vespalib_compress_test_app COMMAND vespalib_compress_test_app)
diff --git a/vespalib/src/tests/compress/compress_test.cpp b/vespalib/src/tests/compress/compress_test.cpp
index c4383a1c193..7ad69b54e06 100644
--- a/vespalib/src/tests/compress/compress_test.cpp
+++ b/vespalib/src/tests/compress/compress_test.cpp
@@ -1,58 +1,59 @@
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/vespalib/testkit/testapp.h>
#include <vespa/vespalib/util/compress.h>
+#include <vespa/vespalib/gtest/gtest.h>
#include <vespa/vespalib/util/exceptions.h>
using namespace vespalib;
using compress::Integer;
-class CompressTest : public TestApp
+class CompressTest : public ::testing::Test
{
-private:
+protected:
+ CompressTest();
+ ~CompressTest() override;
void verifyPositiveNumber(uint64_t n, const uint8_t * expected, size_t sz);
void verifyNumber(int64_t n, const uint8_t * expected, size_t sz);
- void requireThatPositiveNumberCompressCorrectly();
- void requireThatNumberCompressCorrectly();
-public:
- int Main() override;
};
+CompressTest::CompressTest() = default;
+CompressTest::~CompressTest() = default;
+
void
CompressTest::verifyPositiveNumber(uint64_t n, const uint8_t * expected, size_t sz) {
uint8_t buf[8];
- EXPECT_EQUAL(sz, Integer::compressPositive(n, buf));
- EXPECT_EQUAL(sz, Integer::compressedPositiveLength(n));
+ EXPECT_EQ(sz, Integer::compressPositive(n, buf));
+ EXPECT_EQ(sz, Integer::compressedPositiveLength(n));
for (size_t i(0); i < sz; i++) {
- EXPECT_EQUAL(expected[i], buf[i]);
+ EXPECT_EQ(expected[i], buf[i]);
}
EXPECT_FALSE(Integer::check_decompress_positive_space(expected, 0u));
EXPECT_FALSE(Integer::check_decompress_positive_space(expected, sz - 1));
EXPECT_TRUE(Integer::check_decompress_positive_space(expected, sz));
uint64_t v(0);
- EXPECT_EQUAL(sz, Integer::decompressPositive(v, expected));
- EXPECT_EQUAL(n, v);
+ EXPECT_EQ(sz, Integer::decompressPositive(v, expected));
+ EXPECT_EQ(n, v);
}
void
CompressTest::verifyNumber(int64_t n, const uint8_t * expected, size_t sz) {
uint8_t buf[8];
- EXPECT_EQUAL(sz, Integer::compress(n, buf));
- EXPECT_EQUAL(sz, Integer::compressedLength(n));
+ EXPECT_EQ(sz, Integer::compress(n, buf));
+ EXPECT_EQ(sz, Integer::compressedLength(n));
for (size_t i(0); i < sz; i++) {
- EXPECT_EQUAL(expected[i], buf[i]);
+ EXPECT_EQ(expected[i], buf[i]);
}
EXPECT_FALSE(Integer::check_decompress_space(expected, 0u));
EXPECT_FALSE(Integer::check_decompress_space(expected, sz - 1));
EXPECT_TRUE(Integer::check_decompress_space(expected, sz));
int64_t v(0);
- EXPECT_EQUAL(sz, Integer::decompress(v, expected));
- EXPECT_EQUAL(n, v);
+ EXPECT_EQ(sz, Integer::decompress(v, expected));
+ EXPECT_EQ(n, v);
}
#define VERIFY_POSITIVE(n, p) verifyPositiveNumber(n, p, sizeof(p))
-void
-CompressTest::requireThatPositiveNumberCompressCorrectly()
+
+TEST_F(CompressTest, require_that_positive_number_compress_correctly)
{
const uint8_t zero[1] = {0};
VERIFY_POSITIVE(0, zero);
@@ -73,19 +74,19 @@ CompressTest::requireThatPositiveNumberCompressCorrectly()
VERIFY_POSITIVE(0x40000000, x40000000);
EXPECT_TRUE(false);
} catch (const IllegalArgumentException & e) {
- EXPECT_EQUAL("Number '1073741824' too big, must extend encoding", e.getMessage());
+ EXPECT_EQ("Number '1073741824' too big, must extend encoding", e.getMessage());
}
try {
VERIFY_POSITIVE(-1, x40000000);
EXPECT_TRUE(false);
} catch (const IllegalArgumentException & e) {
- EXPECT_EQUAL("Number '18446744073709551615' too big, must extend encoding", e.getMessage());
+ EXPECT_EQ("Number '18446744073709551615' too big, must extend encoding", e.getMessage());
}
}
#define VERIFY_NUMBER(n, p) verifyNumber(n, p, sizeof(p))
-void
-CompressTest::requireThatNumberCompressCorrectly()
+
+TEST_F(CompressTest, require_that_number_compress_correctly)
{
const uint8_t zero[1] = {0};
VERIFY_NUMBER(0, zero);
@@ -106,7 +107,7 @@ CompressTest::requireThatNumberCompressCorrectly()
VERIFY_NUMBER(0x20000000, x20000000);
EXPECT_TRUE(false);
} catch (const IllegalArgumentException & e) {
- EXPECT_EQUAL("Number '536870912' too big, must extend encoding", e.getMessage());
+ EXPECT_EQ("Number '536870912' too big, must extend encoding", e.getMessage());
}
const uint8_t mzero[1] = {0x81};
VERIFY_NUMBER(-1, mzero);
@@ -127,19 +128,8 @@ CompressTest::requireThatNumberCompressCorrectly()
VERIFY_NUMBER(-0x20000000, mx20000000);
EXPECT_TRUE(false);
} catch (const IllegalArgumentException & e) {
- EXPECT_EQUAL("Number '-536870912' too big, must extend encoding", e.getMessage());
+ EXPECT_EQ("Number '-536870912' too big, must extend encoding", e.getMessage());
}
}
-int
-CompressTest::Main()
-{
- TEST_INIT("compress_test");
-
- requireThatPositiveNumberCompressCorrectly();
- requireThatNumberCompressCorrectly();
-
- TEST_DONE();
-}
-
-TEST_APPHOOK(CompressTest)
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/vespalib/src/tests/crc/CMakeLists.txt b/vespalib/src/tests/crc/CMakeLists.txt
index 49907cb36fb..a7de5d1fa7a 100644
--- a/vespalib/src/tests/crc/CMakeLists.txt
+++ b/vespalib/src/tests/crc/CMakeLists.txt
@@ -4,5 +4,6 @@ vespa_add_executable(vespalib_crc_test_app TEST
crc_test.cpp
DEPENDS
vespalib
+ GTest::gtest
)
vespa_add_test(NAME vespalib_crc_test_app COMMAND vespalib_crc_test_app boost)
diff --git a/vespalib/src/tests/crc/crc_test.cpp b/vespalib/src/tests/crc/crc_test.cpp
index 180cd8934dc..82ad8b4c013 100644
--- a/vespalib/src/tests/crc/crc_test.cpp
+++ b/vespalib/src/tests/crc/crc_test.cpp
@@ -1,51 +1,34 @@
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/vespalib/testkit/testapp.h>
#include <vespa/vespalib/util/crc.h>
+#include <vespa/vespalib/gtest/gtest.h>
#include <vector>
using namespace vespalib;
-class Test : public TestApp
-{
-public:
- int Main() override;
- void testCorrectNess();
- void testBenchmark(size_t bufSz, size_t numRep);
-};
-
-int
-Test::Main()
-{
- TEST_INIT("crc_test");
- testCorrectNess();
- testBenchmark(1024, 1000*1000);
- TEST_DONE();
-}
-
-void
-Test::testCorrectNess()
+TEST(FCrcTest, test_correctness)
{
const char *a[7] = { "", "a", "ab", "abc", "abcd", "abcde", "doc:crawler:http://www.ntnu.no/" };
uint32_t expected[7] = {0, 0xe8b7be43, 0x9e83486d, 0x352441c2, 0xed82cd11, 0x8587d865, 0x86287fc5};
for (size_t i(0); i < sizeof(a)/sizeof(a[0]); i++) {
uint32_t vespaCrc32 = crc_32_type::crc(a[i], strlen(a[i]));
- EXPECT_EQUAL(vespaCrc32, expected[i]);
+ EXPECT_EQ(vespaCrc32, expected[i]);
vespalib::crc_32_type calculator2;
calculator2.process_bytes(a[i], strlen(a[i]));
- EXPECT_EQUAL(vespaCrc32, calculator2.checksum());
+ EXPECT_EQ(vespaCrc32, calculator2.checksum());
}
vespalib::crc_32_type calculator;
uint32_t accum_expected[7] = {0, 0xe8b7be43, 0x690e2297, 0x8d7284f9, 0x7ed0c389, 0x61bc2a26, 0x1816e339};
for (size_t i(0); i < sizeof(a)/sizeof(a[0]); i++) {
calculator.process_bytes(a[i], strlen(a[i]));
- EXPECT_EQUAL(calculator.checksum(), accum_expected[i]);
+ EXPECT_EQ(calculator.checksum(), accum_expected[i]);
}
}
-void
-Test::testBenchmark(size_t bufSz, size_t numRep)
+TEST(CrcTest, benchmark)
{
+ constexpr size_t bufSz = 1024;
+ constexpr size_t numRep = 1000 * 1000;
std::vector<char> a(numRep+bufSz);
for(size_t i(0), m(a.size()); i < m; i++) {
a[i] = i&0xff;
@@ -60,4 +43,4 @@ Test::testBenchmark(size_t bufSz, size_t numRep)
printf("sum = %x\n", sum);
}
-TEST_APPHOOK(Test)
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/vespalib/src/tests/data/databuffer/CMakeLists.txt b/vespalib/src/tests/data/databuffer/CMakeLists.txt
index b3998dce56b..858b86aee78 100644
--- a/vespalib/src/tests/data/databuffer/CMakeLists.txt
+++ b/vespalib/src/tests/data/databuffer/CMakeLists.txt
@@ -4,5 +4,6 @@ vespa_add_executable(vespalib_data_databuffer_test_app TEST
databuffer_test.cpp
DEPENDS
vespalib
+ GTest::gtest
)
vespa_add_test(NAME vespalib_data_databuffer_test_app COMMAND vespalib_data_databuffer_test_app)
diff --git a/vespalib/src/tests/data/databuffer/databuffer_test.cpp b/vespalib/src/tests/data/databuffer/databuffer_test.cpp
index 84ba70685ea..9248142872c 100644
--- a/vespalib/src/tests/data/databuffer/databuffer_test.cpp
+++ b/vespalib/src/tests/data/databuffer/databuffer_test.cpp
@@ -1,143 +1,129 @@
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/vespalib/testkit/testapp.h>
#include <vespa/vespalib/util/size_literals.h>
#include <vespa/vespalib/data/databuffer.h>
+#include <vespa/vespalib/gtest/gtest.h>
#include <iostream>
using namespace vespalib;
-class Test : public vespalib::TestApp {
-private:
- void testBasic();
-public:
- int Main() override {
- TEST_INIT("databuffer_test");
-
- testBasic(); TEST_FLUSH();
-
- TEST_DONE();
- }
-};
-
-TEST_APPHOOK(Test);
-
-void
-Test::testBasic()
+TEST(DataBufferTest, test_basic)
{
DataBuffer a(50);
- EXPECT_EQUAL(256u, a.getBufSize());
- EXPECT_EQUAL(a.getFreeLen(), a.getBufSize());
+ EXPECT_EQ(256u, a.getBufSize());
+ EXPECT_EQ(a.getFreeLen(), a.getBufSize());
a.ensureFree(1000);
- EXPECT_EQUAL(1_Ki, a.getBufSize());
- EXPECT_EQUAL(a.getFreeLen(), a.getBufSize());
- EXPECT_EQUAL(0u, a.getDeadLen());
- EXPECT_EQUAL(0u, a.getDataLen());
- EXPECT_EQUAL(a.getData(), a.getDead());
- EXPECT_EQUAL(a.getData(), a.getFree());
- EXPECT_EQUAL(a.getBufSize(), a.getFreeLen());
+ EXPECT_EQ(1_Ki, a.getBufSize());
+ EXPECT_EQ(a.getFreeLen(), a.getBufSize());
+ EXPECT_EQ(0u, a.getDeadLen());
+ EXPECT_EQ(0u, a.getDataLen());
+ EXPECT_EQ(a.getData(), a.getDead());
+ EXPECT_EQ(a.getData(), a.getFree());
+ EXPECT_EQ(a.getBufSize(), a.getFreeLen());
a.assertValid();
a.writeInt16(7);
- EXPECT_EQUAL(0u, a.getDeadLen());
- EXPECT_EQUAL(2u, a.getDataLen());
- EXPECT_EQUAL(a.getBufSize()-2, a.getFreeLen());
- EXPECT_EQUAL(a.getData(), a.getDead());
- EXPECT_EQUAL(a.getData()+2, a.getFree());
+ EXPECT_EQ(0u, a.getDeadLen());
+ EXPECT_EQ(2u, a.getDataLen());
+ EXPECT_EQ(a.getBufSize()-2, a.getFreeLen());
+ EXPECT_EQ(a.getData(), a.getDead());
+ EXPECT_EQ(a.getData()+2, a.getFree());
a.clear();
- EXPECT_EQUAL(0u, a.getDeadLen());
- EXPECT_EQUAL(0u, a.getDataLen());
- EXPECT_EQUAL(a.getBufSize(), a.getFreeLen());
+ EXPECT_EQ(0u, a.getDeadLen());
+ EXPECT_EQ(0u, a.getDataLen());
+ EXPECT_EQ(a.getBufSize(), a.getFreeLen());
a.writeInt8(0xaau);
- EXPECT_EQUAL(1u, a.getDataLen());
- EXPECT_EQUAL(0xaau, a.peekInt8(0));
- EXPECT_EQUAL(1u, a.getDataLen());
- EXPECT_EQUAL(0xaau, a.readInt8());
- EXPECT_EQUAL(0u, a.getDataLen());
+ EXPECT_EQ(1u, a.getDataLen());
+ EXPECT_EQ(0xaau, a.peekInt8(0));
+ EXPECT_EQ(1u, a.getDataLen());
+ EXPECT_EQ(0xaau, a.readInt8());
+ EXPECT_EQ(0u, a.getDataLen());
a.writeInt16(0xaabbu);
- EXPECT_EQUAL(2u, a.getDataLen());
- EXPECT_EQUAL(0xaabbu, a.peekInt16(0));
- EXPECT_EQUAL(2u, a.getDataLen());
- EXPECT_EQUAL(0xaabbu, a.readInt16());
- EXPECT_EQUAL(0u, a.getDataLen());
+ EXPECT_EQ(2u, a.getDataLen());
+ EXPECT_EQ(0xaabbu, a.peekInt16(0));
+ EXPECT_EQ(2u, a.getDataLen());
+ EXPECT_EQ(0xaabbu, a.readInt16());
+ EXPECT_EQ(0u, a.getDataLen());
a.writeInt16(0xaabbu);
- EXPECT_EQUAL(2u, a.getDataLen());
- EXPECT_EQUAL(0xbbaau, a.peekInt16Reverse(0));
- EXPECT_EQUAL(2u, a.getDataLen());
- EXPECT_EQUAL(0xbbaau, a.readInt16Reverse());
- EXPECT_EQUAL(0u, a.getDataLen());
-
+ EXPECT_EQ(2u, a.getDataLen());
+ EXPECT_EQ(0xbbaau, a.peekInt16Reverse(0));
+ EXPECT_EQ(2u, a.getDataLen());
+ EXPECT_EQ(0xbbaau, a.readInt16Reverse());
+ EXPECT_EQ(0u, a.getDataLen());
+
a.writeInt32(0xaabbccddu);
- EXPECT_EQUAL(4u, a.getDataLen());
- EXPECT_EQUAL(0xaabbccddu, a.peekInt32(0));
- EXPECT_EQUAL(4u, a.getDataLen());
- EXPECT_EQUAL(0xaabbccddu, a.readInt32());
- EXPECT_EQUAL(0u, a.getDataLen());
+ EXPECT_EQ(4u, a.getDataLen());
+ EXPECT_EQ(0xaabbccddu, a.peekInt32(0));
+ EXPECT_EQ(4u, a.getDataLen());
+ EXPECT_EQ(0xaabbccddu, a.readInt32());
+ EXPECT_EQ(0u, a.getDataLen());
a.writeInt32(0xaabbccddu);
- EXPECT_EQUAL(4u, a.getDataLen());
- EXPECT_EQUAL(0xddccbbaau, a.peekInt32Reverse(0));
- EXPECT_EQUAL(4u, a.getDataLen());
- EXPECT_EQUAL(0xddccbbaau, a.readInt32Reverse());
- EXPECT_EQUAL(0u, a.getDataLen());
+ EXPECT_EQ(4u, a.getDataLen());
+ EXPECT_EQ(0xddccbbaau, a.peekInt32Reverse(0));
+ EXPECT_EQ(4u, a.getDataLen());
+ EXPECT_EQ(0xddccbbaau, a.readInt32Reverse());
+ EXPECT_EQ(0u, a.getDataLen());
a.writeInt64(0xaabbccddeeff9988ul);
- EXPECT_EQUAL(8u, a.getDataLen());
- EXPECT_EQUAL(0xaabbccddeeff9988ul, a.peekInt64(0));
- EXPECT_EQUAL(8u, a.getDataLen());
- EXPECT_EQUAL(0xaabbccddeeff9988ul, a.readInt64());
- EXPECT_EQUAL(0u, a.getDataLen());
+ EXPECT_EQ(8u, a.getDataLen());
+ EXPECT_EQ(0xaabbccddeeff9988ul, a.peekInt64(0));
+ EXPECT_EQ(8u, a.getDataLen());
+ EXPECT_EQ(0xaabbccddeeff9988ul, a.readInt64());
+ EXPECT_EQ(0u, a.getDataLen());
a.writeInt64(0xaabbccddeeff9988ul);
- EXPECT_EQUAL(8u, a.getDataLen());
- EXPECT_EQUAL(0x8899ffeeddccbbaaul, a.peekInt64Reverse(0));
- EXPECT_EQUAL(8u, a.getDataLen());
- EXPECT_EQUAL(0x8899ffeeddccbbaaul, a.readInt64Reverse());
- EXPECT_EQUAL(0u, a.getDataLen());
+ EXPECT_EQ(8u, a.getDataLen());
+ EXPECT_EQ(0x8899ffeeddccbbaaul, a.peekInt64Reverse(0));
+ EXPECT_EQ(8u, a.getDataLen());
+ EXPECT_EQ(0x8899ffeeddccbbaaul, a.readInt64Reverse());
+ EXPECT_EQ(0u, a.getDataLen());
a.writeFloat(8.9f);
- EXPECT_EQUAL(4u, a.getDataLen());
- EXPECT_EQUAL(8.9f, a.readFloat());
- EXPECT_EQUAL(0u, a.getDataLen());
+ EXPECT_EQ(4u, a.getDataLen());
+ EXPECT_EQ(8.9f, a.readFloat());
+ EXPECT_EQ(0u, a.getDataLen());
a.writeDouble(8.9);
- EXPECT_EQUAL(8u, a.getDataLen());
- EXPECT_EQUAL(8.9, a.readDouble());
- EXPECT_EQUAL(0u, a.getDataLen());
+ EXPECT_EQ(8u, a.getDataLen());
+ EXPECT_EQ(8.9, a.readDouble());
+ EXPECT_EQ(0u, a.getDataLen());
const char *c = "abc";
char b[3];
a.writeBytes(c, 3);
- EXPECT_EQUAL(3u, a.getDataLen());
- EXPECT_EQUAL(0, memcmp(c, a.getData(), a.getDataLen()));
+ EXPECT_EQ(3u, a.getDataLen());
+ EXPECT_EQ(0, memcmp(c, a.getData(), a.getDataLen()));
a.peekBytes(b, 3, 0);
- EXPECT_EQUAL(3u, a.getDataLen());
- EXPECT_EQUAL(0, memcmp(c, b, sizeof(b)));
+ EXPECT_EQ(3u, a.getDataLen());
+ EXPECT_EQ(0, memcmp(c, b, sizeof(b)));
a.readBytes(b, sizeof(b));
- EXPECT_EQUAL(0u, a.getDataLen());
- EXPECT_EQUAL(0, memcmp(c, b, sizeof(b)));
+ EXPECT_EQ(0u, a.getDataLen());
+ EXPECT_EQ(0, memcmp(c, b, sizeof(b)));
a.writeInt64(67);
- EXPECT_EQUAL(8u, a.getDataLen());
+ EXPECT_EQ(8u, a.getDataLen());
EXPECT_FALSE(a.shrink(1025));
EXPECT_FALSE(a.shrink(7));
EXPECT_TRUE(a.shrink(16));
- EXPECT_EQUAL(8u, a.getDataLen());
- EXPECT_EQUAL(16u, a.getBufSize());
+ EXPECT_EQ(8u, a.getDataLen());
+ EXPECT_EQ(16u, a.getBufSize());
a.writeInt64(89);
- EXPECT_EQUAL(16u, a.getDataLen());
- EXPECT_EQUAL(16u, a.getBufSize());
- EXPECT_EQUAL(0u, a.getDeadLen());
- EXPECT_EQUAL(67u, a.readInt64());
- EXPECT_EQUAL(8u, a.getDataLen());
- EXPECT_EQUAL(8u, a.getDeadLen());
- EXPECT_EQUAL(16u, a.getBufSize());
+ EXPECT_EQ(16u, a.getDataLen());
+ EXPECT_EQ(16u, a.getBufSize());
+ EXPECT_EQ(0u, a.getDeadLen());
+ EXPECT_EQ(67u, a.readInt64());
+ EXPECT_EQ(8u, a.getDataLen());
+ EXPECT_EQ(8u, a.getDeadLen());
+ EXPECT_EQ(16u, a.getBufSize());
a.pack(16);
- EXPECT_EQUAL(8u, a.getDataLen());
- EXPECT_EQUAL(0u, a.getDeadLen());
- EXPECT_EQUAL(256u, a.getBufSize());
- EXPECT_EQUAL(89u, a.readInt64());
- EXPECT_EQUAL(0u, a.getDataLen());
- EXPECT_EQUAL(256u, a.getBufSize());
+ EXPECT_EQ(8u, a.getDataLen());
+ EXPECT_EQ(0u, a.getDeadLen());
+ EXPECT_EQ(256u, a.getBufSize());
+ EXPECT_EQ(89u, a.readInt64());
+ EXPECT_EQ(0u, a.getDataLen());
+ EXPECT_EQ(256u, a.getBufSize());
}
+
+GTEST_MAIN_RUN_ALL_TESTS()