From 7dd0e264a2778660ec22fdcad98e0118acf39d9e Mon Sep 17 00:00:00 2001 From: Tor Egge Date: Tue, 16 Apr 2019 08:56:00 +0200 Subject: Migrate document unit tests from cppunit to gtest. --- document/src/tests/CMakeLists.txt | 24 +- document/src/tests/arrayfieldvaluetest.cpp | 138 ++++--- document/src/tests/arrayfieldvaluetest.h | 29 -- document/src/tests/bucketselectortest.cpp | 28 +- document/src/tests/buckettest.cpp | 220 +++++------- document/src/tests/documentselectparsertest.cpp | 264 ++++++-------- document/src/tests/documentselecttest.h | 34 -- document/src/tests/documenttestcase.cpp | 459 +++++++++++------------- document/src/tests/documenttypetestcase.cpp | 138 +++---- document/src/tests/fieldpathupdatetestcase.cpp | 429 ++++++++-------------- document/src/tests/fieldsettest.cpp | 176 ++++----- document/src/tests/fixed_bucket_spaces_test.cpp | 56 ++- document/src/tests/forcelinktest.cpp | 15 +- document/src/tests/gid_filter_test.cpp | 282 ++++++--------- document/src/tests/globalidtest.cpp | 145 +++----- 15 files changed, 977 insertions(+), 1460 deletions(-) delete mode 100644 document/src/tests/arrayfieldvaluetest.h delete mode 100644 document/src/tests/documentselecttest.h (limited to 'document') diff --git a/document/src/tests/CMakeLists.txt b/document/src/tests/CMakeLists.txt index bb668287a8c..9de4e8cc7d0 100644 --- a/document/src/tests/CMakeLists.txt +++ b/document/src/tests/CMakeLists.txt @@ -4,9 +4,21 @@ # NOTE: All new test classes should be added here. vespa_add_executable(document_gtest_runner_app TEST SOURCES + arrayfieldvaluetest.cpp + bucketselectortest.cpp + buckettest.cpp documentcalculatortestcase.cpp documentidtest.cpp + documentselectparsertest.cpp + documenttestcase.cpp + documenttypetestcase.cpp documentupdatetestcase.cpp + fieldpathupdatetestcase.cpp + fieldsettest.cpp + fixed_bucket_spaces_test.cpp + forcelinktest.cpp + gid_filter_test.cpp + globalidtest.cpp gtest_runner.cpp teststringutil.cpp DEPENDS @@ -26,28 +38,16 @@ vespa_add_executable(document_testrunner_app TEST SOURCES testbytebuffer.cpp stringtokenizertest.cpp - buckettest.cpp - globalidtest.cpp - documenttypetestcase.cpp primitivefieldvaluetest.cpp - arrayfieldvaluetest.cpp weightedsetfieldvaluetest.cpp structfieldvaluetest.cpp - documenttestcase.cpp testdocmantest.cpp - fieldpathupdatetestcase.cpp - documentselectparsertest.cpp - bucketselectortest.cpp testxml.cpp - forcelinktest.cpp orderingselectortest.cpp testrunner.cpp heapdebuggerother.cpp positiontypetest.cpp urltypetest.cpp - fieldsettest.cpp - gid_filter_test.cpp - fixed_bucket_spaces_test.cpp DEPENDS document AFTER diff --git a/document/src/tests/arrayfieldvaluetest.cpp b/document/src/tests/arrayfieldvaluetest.cpp index 74243ab1511..014884e44cd 100644 --- a/document/src/tests/arrayfieldvaluetest.cpp +++ b/document/src/tests/arrayfieldvaluetest.cpp @@ -2,26 +2,17 @@ #include #include -#include #include #include #include +#include +#include using vespalib::nbostream; +using namespace ::testing; namespace document { -struct ArrayFieldValueTest : public CppUnit::TestFixture { - void testArray(); - - CPPUNIT_TEST_SUITE(ArrayFieldValueTest); - CPPUNIT_TEST(testArray); - CPPUNIT_TEST_SUITE_END(); - -}; - -CPPUNIT_TEST_SUITE_REGISTRATION(ArrayFieldValueTest); - namespace { template void deserialize(const ByteBuffer &buffer, T &value) { @@ -33,41 +24,41 @@ void deserialize(const ByteBuffer &buffer, T &value) { } } // namespace -void ArrayFieldValueTest::testArray() +TEST(ArrayFieldValueTest, testArray) { ArrayDataType type(*DataType::INT); ArrayFieldValue value(type); // Initially empty - CPPUNIT_ASSERT_EQUAL(size_t(0), value.size()); - CPPUNIT_ASSERT(value.isEmpty()); - CPPUNIT_ASSERT(!value.contains(IntFieldValue(1))); + EXPECT_EQ(size_t(0), value.size()); + EXPECT_TRUE(value.isEmpty()); + EXPECT_TRUE(!value.contains(IntFieldValue(1))); - CPPUNIT_ASSERT(value.add(IntFieldValue(1))); + EXPECT_TRUE(value.add(IntFieldValue(1))); // Not empty - CPPUNIT_ASSERT_EQUAL(size_t(1), value.size()); - CPPUNIT_ASSERT(!value.isEmpty()); - CPPUNIT_ASSERT(value.contains(IntFieldValue(1))); + EXPECT_EQ(size_t(1), value.size()); + EXPECT_TRUE(!value.isEmpty()); + EXPECT_TRUE(value.contains(IntFieldValue(1))); // Adding some more - CPPUNIT_ASSERT(value.add(IntFieldValue(2))); - CPPUNIT_ASSERT(value.add(IntFieldValue(3))); + EXPECT_TRUE(value.add(IntFieldValue(2))); + EXPECT_TRUE(value.add(IntFieldValue(3))); // Not empty - CPPUNIT_ASSERT_EQUAL(size_t(3), value.size()); - CPPUNIT_ASSERT(!value.isEmpty()); - CPPUNIT_ASSERT_EQUAL(IntFieldValue(1), (IntFieldValue&) value[0]); - CPPUNIT_ASSERT_EQUAL(IntFieldValue(2), (IntFieldValue&) value[1]); - CPPUNIT_ASSERT_EQUAL(IntFieldValue(3), (IntFieldValue&) value[2]); + ASSERT_EQ(size_t(3), value.size()); + EXPECT_TRUE(!value.isEmpty()); + EXPECT_EQ(IntFieldValue(1), (IntFieldValue&) value[0]); + EXPECT_EQ(IntFieldValue(2), (IntFieldValue&) value[1]); + EXPECT_EQ(IntFieldValue(3), (IntFieldValue&) value[2]); // Serialize & equality std::unique_ptr buffer(value.serialize()); buffer->flip(); ArrayFieldValue value2(type); - CPPUNIT_ASSERT(value != value2); + EXPECT_TRUE(value != value2); deserialize(*buffer, value2); - CPPUNIT_ASSERT_EQUAL(value, value2); + EXPECT_EQ(value, value2); // Various ways of removing { @@ -75,44 +66,44 @@ void ArrayFieldValueTest::testArray() buffer->setPos(0); deserialize(*buffer, value2); value2.remove(1); - CPPUNIT_ASSERT(!value2.contains(IntFieldValue(2))); - CPPUNIT_ASSERT_EQUAL(size_t(2), value2.size()); + EXPECT_TRUE(!value2.contains(IntFieldValue(2))); + EXPECT_EQ(size_t(2), value2.size()); // By value buffer->setPos(0); deserialize(*buffer, value2); - CPPUNIT_ASSERT(value2.remove(IntFieldValue(1))); - CPPUNIT_ASSERT(!value2.contains(IntFieldValue(1))); - CPPUNIT_ASSERT_EQUAL(size_t(2), value2.size()); + EXPECT_TRUE(value2.remove(IntFieldValue(1))); + EXPECT_TRUE(!value2.contains(IntFieldValue(1))); + EXPECT_EQ(size_t(2), value2.size()); // By value with multiple present buffer->setPos(0); deserialize(*buffer, value2); value2.add(IntFieldValue(1)); - CPPUNIT_ASSERT(value2.remove(IntFieldValue(1))); - CPPUNIT_ASSERT(!value2.contains(IntFieldValue(1))); - CPPUNIT_ASSERT_EQUAL(size_t(2), value2.size()); + EXPECT_TRUE(value2.remove(IntFieldValue(1))); + EXPECT_TRUE(!value2.contains(IntFieldValue(1))); + EXPECT_EQ(size_t(2), value2.size()); // Clearing all buffer->setPos(0); deserialize(*buffer, value2); value2.clear(); - CPPUNIT_ASSERT(!value2.contains(IntFieldValue(1))); - CPPUNIT_ASSERT_EQUAL(size_t(0), value2.size()); - CPPUNIT_ASSERT(value2.isEmpty()); + EXPECT_TRUE(!value2.contains(IntFieldValue(1))); + EXPECT_EQ(size_t(0), value2.size()); + EXPECT_TRUE(value2.isEmpty()); } // Updating value2 = value; - CPPUNIT_ASSERT_EQUAL(value, value2); + EXPECT_EQ(value, value2); value2[1].assign(IntFieldValue(5)); - CPPUNIT_ASSERT(!value2.contains(IntFieldValue(2))); - CPPUNIT_ASSERT_EQUAL(IntFieldValue(5), (IntFieldValue&) value2[1]); - CPPUNIT_ASSERT(value != value2); + EXPECT_TRUE(!value2.contains(IntFieldValue(2))); + EXPECT_EQ(IntFieldValue(5), (IntFieldValue&) value2[1]); + EXPECT_TRUE(value != value2); value2.assign(value); - CPPUNIT_ASSERT_EQUAL(value, value2); + EXPECT_EQ(value, value2); ArrayFieldValue::UP valuePtr(value2.clone()); - CPPUNIT_ASSERT_EQUAL(value, *valuePtr); + EXPECT_EQ(value, *valuePtr); // Iterating const ArrayFieldValue& constVal(value); @@ -121,7 +112,7 @@ void ArrayFieldValueTest::testArray() { const FieldValue& fval1(*it); (void) fval1; - CPPUNIT_ASSERT_EQUAL((uint32_t) IntFieldValue::classId, + EXPECT_EQ((uint32_t) IntFieldValue::classId, it->getClass().id()); } value2 = value; @@ -130,28 +121,28 @@ void ArrayFieldValueTest::testArray() (*it).assign(IntFieldValue(7)); it->assign(IntFieldValue(7)); } - CPPUNIT_ASSERT(value != value2); - CPPUNIT_ASSERT(value2.contains(IntFieldValue(7))); - CPPUNIT_ASSERT(value2.remove(IntFieldValue(7))); - CPPUNIT_ASSERT(value2.isEmpty()); + EXPECT_TRUE(value != value2); + EXPECT_TRUE(value2.contains(IntFieldValue(7))); + EXPECT_TRUE(value2.remove(IntFieldValue(7))); + EXPECT_TRUE(value2.isEmpty()); // Comparison value2 = value; - CPPUNIT_ASSERT_EQUAL(0, value.compare(value2)); + EXPECT_EQ(0, value.compare(value2)); value2.remove(1); - CPPUNIT_ASSERT(value.compare(value2) > 0); - CPPUNIT_ASSERT(value2.compare(value) < 0); + EXPECT_TRUE(value.compare(value2) > 0); + EXPECT_TRUE(value2.compare(value) < 0); value2 = value; value2[1].assign(IntFieldValue(5)); - CPPUNIT_ASSERT(value.compare(value2) < 0); - CPPUNIT_ASSERT(value2.compare(value) > 0); + EXPECT_TRUE(value.compare(value2) < 0); + EXPECT_TRUE(value2.compare(value) > 0); // Output - CPPUNIT_ASSERT_EQUAL(std::string("Array(size: 3,\n 1,\n 2,\n 3\n)"), + EXPECT_EQ(std::string("Array(size: 3,\n 1,\n 2,\n 3\n)"), value.toString(false)); - CPPUNIT_ASSERT_EQUAL(std::string("Array(size: 3,\n. 1,\n. 2,\n. 3\n.)"), + EXPECT_EQ(std::string("Array(size: 3,\n. 1,\n. 2,\n. 3\n.)"), value.toString(true, ".")); - CPPUNIT_ASSERT_EQUAL(std::string( + EXPECT_EQ(std::string( "\n" " 1\n" " 2\n" @@ -172,39 +163,39 @@ void ArrayFieldValueTest::testArray() ArrayFieldValue value4(type4); try{ value3 = value4; - CPPUNIT_FAIL("Failed to check type equality in operator="); + FAIL() << "Failed to check type equality in operator="; } catch (std::exception& e) { - CPPUNIT_ASSERT_CONTAIN("Cannot assign value of type", e.what()); + EXPECT_THAT(e.what(), HasSubstr("Cannot assign value of type")); } try{ value3.assign(value4); - CPPUNIT_FAIL("Failed to check type equality in assign()"); + FAIL() << "Failed to check type equality in assign()"; } catch (std::exception& e) { - CPPUNIT_ASSERT_CONTAIN("Cannot assign value of type", e.what()); + EXPECT_THAT(e.what(), HasSubstr("Cannot assign value of type")); } try{ ArrayFieldValue subValue(type2); subValue.add(LongFieldValue(4)); value3.add(subValue); - CPPUNIT_FAIL("Failed to check type equality in add()"); + FAIL() << "Failed to check type equality in add()"; } catch (std::exception& e) { - CPPUNIT_ASSERT_CONTAIN("Cannot add value of type",e.what()); + EXPECT_THAT(e.what(), HasSubstr("Cannot add value of type")); } try{ ArrayFieldValue subValue(type2); subValue.add(LongFieldValue(4)); value3.contains(subValue); - CPPUNIT_FAIL("Failed to check type equality in contains()"); + FAIL() << "Failed to check type equality in contains()"; } catch (std::exception& e) { - CPPUNIT_ASSERT_CONTAIN("can't possibly be in array of type", e.what()); + EXPECT_THAT(e.what(), HasSubstr("can't possibly be in array of type")); } try{ ArrayFieldValue subValue(type2); subValue.add(LongFieldValue(4)); value3.remove(subValue); - CPPUNIT_FAIL("Failed to check type equality in remove()"); + FAIL() << "Failed to check type equality in remove()"; } catch (std::exception& e) { - CPPUNIT_ASSERT_CONTAIN("can't possibly be in array of type", e.what()); + EXPECT_THAT(e.what(), HasSubstr("can't possibly be in array of type")); } // Verify that compare sees difference { @@ -216,19 +207,18 @@ void ArrayFieldValueTest::testArray() value4.clear(); value3.add(subValue1); value4.add(subValue2); - CPPUNIT_ASSERT(value3.compare(value4) != 0); + EXPECT_TRUE(value3.compare(value4) != 0); } // Removing non-existing element value2 = value; try{ value2.remove(5); - CPPUNIT_FAIL("Failed to throw out of bounds exception on remove(int)"); + FAIL() << "Failed to throw out of bounds exception on remove(int)"; } catch (std::exception& e) { - CPPUNIT_ASSERT_CONTAIN("Cannot remove index 5 from an array of size 3", - e.what()); + EXPECT_THAT(e.what(), HasSubstr("Cannot remove index 5 from an array of size 3")); } - CPPUNIT_ASSERT(!value2.remove(IntFieldValue(15))); + EXPECT_TRUE(!value2.remove(IntFieldValue(15))); } } // document diff --git a/document/src/tests/arrayfieldvaluetest.h b/document/src/tests/arrayfieldvaluetest.h deleted file mode 100644 index b8ae6a20b8d..00000000000 --- a/document/src/tests/arrayfieldvaluetest.h +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -/* $Id$*/ - -#pragma once - -#include - -class ArrayFieldValue_Test : public CppUnit::TestFixture { - CPPUNIT_TEST_SUITE( ArrayFieldValue_Test); - CPPUNIT_TEST(testArray); - CPPUNIT_TEST(testArray2); - CPPUNIT_TEST(testArrayRaw); - CPPUNIT_TEST(testTextSerialize); - CPPUNIT_TEST(testArrayRemove); - CPPUNIT_TEST_SUITE_END(); - -public: - void setUp(); - - void tearDown(); -protected: - void testArray(); - void testArray2(); - void testArrayRaw(); - void testTextSerialize(); - void testArrayRemove(); -}; - - diff --git a/document/src/tests/bucketselectortest.cpp b/document/src/tests/bucketselectortest.cpp index e0857a32dba..fcd254a9fc6 100644 --- a/document/src/tests/bucketselectortest.cpp +++ b/document/src/tests/bucketselectortest.cpp @@ -3,26 +3,18 @@ #include #include -#include #include #include +#include #include +#include +#include using document::select::Node; using document::select::Parser; namespace document { -struct BucketSelectorTest : public CppUnit::TestFixture { - void testSimple(); - - CPPUNIT_TEST_SUITE(BucketSelectorTest); - CPPUNIT_TEST(testSimple); - CPPUNIT_TEST_SUITE_END(); -}; - -CPPUNIT_TEST_SUITE_REGISTRATION(BucketSelectorTest); - #define ASSERT_BUCKET_COUNT(expression, count) \ { \ TestDocRepo testRepo; \ @@ -30,14 +22,14 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BucketSelectorTest); BucketSelector selector(idfactory); \ Parser parser(testRepo.getTypeRepo(), idfactory); \ std::unique_ptr node(parser.parse(expression)); \ - CPPUNIT_ASSERT(node.get() != 0); \ + ASSERT_TRUE(node.get() != 0); \ std::unique_ptr buckets( \ selector.select(*node)); \ size_t bcount(buckets.get() ? buckets->size() : 0); \ std::ostringstream ost; \ ost << "Expression " << expression << " did not contain " << count \ << " buckets as expected"; \ - CPPUNIT_ASSERT_EQUAL_MSG(ost.str(), (size_t) count, bcount); \ + EXPECT_EQ((size_t) count, bcount) << ost.str(); \ } #define ASSERT_BUCKET(expression, bucket) \ @@ -47,7 +39,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BucketSelectorTest); BucketSelector selector(idfactory); \ Parser parser(testRepo.getTypeRepo(), idfactory); \ std::unique_ptr node(parser.parse(expression)); \ - CPPUNIT_ASSERT(node.get() != 0); \ + ASSERT_TRUE(node.get() != 0); \ std::unique_ptr buckets( \ selector.select(*node)); \ std::ostringstream ost; \ @@ -58,12 +50,12 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BucketSelectorTest); } else { \ ost << ". Matches all buckets"; \ } \ - CPPUNIT_ASSERT_MSG(ost.str(), buckets.get() && \ - std::find(buckets->begin(), buckets->end(), \ - bucket) != buckets->end()); \ + EXPECT_TRUE(buckets.get() && \ + std::find(buckets->begin(), buckets->end(), \ + bucket) != buckets->end()) << ost.str(); \ } -void BucketSelectorTest::testSimple() +TEST(BucketSelectorTest, testSimple) { ASSERT_BUCKET_COUNT("id = \"userdoc:ns:123:foobar\"", 1u); ASSERT_BUCKET_COUNT("id = \"userdoc:ns:123:foo*\"", 0u); diff --git a/document/src/tests/buckettest.cpp b/document/src/tests/buckettest.cpp index 2aae0c87102..3de6d02b4b3 100644 --- a/document/src/tests/buckettest.cpp +++ b/document/src/tests/buckettest.cpp @@ -1,39 +1,14 @@ // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include #include #include #include #include #include +#include namespace document { -class BucketTest : public CppUnit::TestFixture { - CPPUNIT_TEST_SUITE(BucketTest); - CPPUNIT_TEST(testBucketId); - CPPUNIT_TEST(testBucketGeneration); - CPPUNIT_TEST(testBucketSerialization); - CPPUNIT_TEST(testReverseBucket); - CPPUNIT_TEST(testContains); - CPPUNIT_TEST(testGetBit); - CPPUNIT_TEST(testToString); - CPPUNIT_TEST(testOperators); - CPPUNIT_TEST_SUITE_END(); - -public: - void testBucketId(); - void testBucketGeneration(); - void testBucketSerialization(); - void testReverseBucket(); - void testContains(); - void testGetBit(); - void testToString(); - void testOperators(); -}; - -CPPUNIT_TEST_SUITE_REGISTRATION(BucketTest); - struct Hex { BucketId::Type val; @@ -46,62 +21,62 @@ inline std::ostream& operator<<(std::ostream& out, const Hex& h) { return out; } -void BucketTest::testBucketId() +TEST(BucketTest, testBucketId) { // Test empty (invalid) buckets BucketId id1; BucketId id2; - CPPUNIT_ASSERT_EQUAL(id1, id2); - CPPUNIT_ASSERT(!(id1 < id2) && !(id2 < id1)); - CPPUNIT_ASSERT_EQUAL(Hex(0), Hex(id1.getId())); - CPPUNIT_ASSERT_EQUAL(Hex(0), Hex(id1.getRawId())); - CPPUNIT_ASSERT_EQUAL(vespalib::string("BucketId(0x0000000000000000)"), + EXPECT_EQ(id1, id2); + EXPECT_TRUE(!(id1 < id2) && !(id2 < id1)); + EXPECT_EQ(Hex(0), Hex(id1.getId())); + EXPECT_EQ(Hex(0), Hex(id1.getRawId())); + EXPECT_EQ(vespalib::string("BucketId(0x0000000000000000)"), id1.toString()); - CPPUNIT_ASSERT_EQUAL(0u, id1.getUsedBits()); + EXPECT_EQ(0u, id1.getUsedBits()); // Test bucket with a value id2 = BucketId((BucketId::Type(16) << 58) | 0x123); - CPPUNIT_ASSERT(id1 != id2); - CPPUNIT_ASSERT((id1 < id2) && !(id2 < id1)); - CPPUNIT_ASSERT_EQUAL(Hex(0x4000000000000123ull), Hex(id2.getId())); - CPPUNIT_ASSERT_EQUAL(Hex(0x4000000000000123ull), Hex(id2.getRawId())); - CPPUNIT_ASSERT_EQUAL(vespalib::string("BucketId(0x4000000000000123)"), - id2.toString()); - CPPUNIT_ASSERT_EQUAL(16u, id2.getUsedBits()); + EXPECT_TRUE(id1 != id2); + EXPECT_TRUE((id1 < id2) && !(id2 < id1)); + EXPECT_EQ(Hex(0x4000000000000123ull), Hex(id2.getId())); + EXPECT_EQ(Hex(0x4000000000000123ull), Hex(id2.getRawId())); + EXPECT_EQ(vespalib::string("BucketId(0x4000000000000123)"), + id2.toString()); + EXPECT_EQ(16u, id2.getUsedBits()); // Test copy constructor and operator= BucketId id3(id2); - CPPUNIT_ASSERT_EQUAL(id2, id3); + EXPECT_EQ(id2, id3); id3 = id1; - CPPUNIT_ASSERT(!(id2 == id3)); + EXPECT_TRUE(!(id2 == id3)); id3 = id2; - CPPUNIT_ASSERT_EQUAL(id2, id3); + EXPECT_EQ(id2, id3); } -void BucketTest::testGetBit() +TEST(BucketTest, testGetBit) { for (uint32_t i = 0; i < 58; ++i) { - CPPUNIT_ASSERT_EQUAL(0, (int)document::BucketId(16, 0).getBit(i)); + EXPECT_EQ(0, (int)document::BucketId(16, 0).getBit(i)); } for (uint32_t i = 0; i < 4; ++i) { - CPPUNIT_ASSERT_EQUAL(0, (int)document::BucketId(16, 16).getBit(i)); + EXPECT_EQ(0, (int)document::BucketId(16, 16).getBit(i)); } - CPPUNIT_ASSERT_EQUAL(1, (int)document::BucketId(16, 16).getBit(4)); + EXPECT_EQ(1, (int)document::BucketId(16, 16).getBit(4)); for (uint32_t i = 5; i < 59; ++i) { - CPPUNIT_ASSERT_EQUAL(0, (int)document::BucketId(16, 16).getBit(i)); + EXPECT_EQ(0, (int)document::BucketId(16, 16).getBit(i)); } - CPPUNIT_ASSERT_EQUAL(0, (int)document::BucketId(17, 0x0ffff).getBit(16)); + EXPECT_EQ(0, (int)document::BucketId(17, 0x0ffff).getBit(16)); for (uint32_t i = 0; i < 16; ++i) { - CPPUNIT_ASSERT_EQUAL(1, (int)document::BucketId(17, 0x0ffff).getBit(i)); + EXPECT_EQ(1, (int)document::BucketId(17, 0x0ffff).getBit(i)); } } -void BucketTest::testBucketGeneration() +TEST(BucketTest, testBucketGeneration) { BucketIdFactory factory; DocumentId doc1("doc:ns:spec"); @@ -136,49 +111,49 @@ void BucketTest::testBucketGeneration() BucketId orderDocBucket5(factory.getBucketId(orderDoc5)); BucketId orderDocBucket6(factory.getBucketId(orderDoc6)); - CPPUNIT_ASSERT_EQUAL(Hex(0xe99703f200000012ull), Hex(userDocBucket1.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xebfa518a00000012ull), Hex(userDocBucket2.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xeac1850800000013ull), Hex(userDocBucket3.getRawId())); + EXPECT_EQ(Hex(0xe99703f200000012ull), Hex(userDocBucket1.getRawId())); + EXPECT_EQ(Hex(0xebfa518a00000012ull), Hex(userDocBucket2.getRawId())); + EXPECT_EQ(Hex(0xeac1850800000013ull), Hex(userDocBucket3.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xeae764e90000000dull), Hex(orderDocBucket1.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xeacb85f10000000dull), Hex(orderDocBucket2.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xea68ddf10000000dull), Hex(orderDocBucket3.getRawId())); + EXPECT_EQ(Hex(0xeae764e90000000dull), Hex(orderDocBucket1.getRawId())); + EXPECT_EQ(Hex(0xeacb85f10000000dull), Hex(orderDocBucket2.getRawId())); + EXPECT_EQ(Hex(0xea68ddf10000000dull), Hex(orderDocBucket3.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xe87526540000000dull), Hex(orderDocBucket4.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xea59f8f20000000dull), Hex(orderDocBucket5.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xe9eb703d0000000dull), Hex(orderDocBucket6.getRawId())); + EXPECT_EQ(Hex(0xe87526540000000dull), Hex(orderDocBucket4.getRawId())); + EXPECT_EQ(Hex(0xea59f8f20000000dull), Hex(orderDocBucket5.getRawId())); + EXPECT_EQ(Hex(0xe9eb703d0000000dull), Hex(orderDocBucket6.getRawId())); userDocBucket1.setUsedBits(16); - CPPUNIT_ASSERT_EQUAL(Hex(0x4000000000000012ull), Hex(userDocBucket1.getId())); + EXPECT_EQ(Hex(0x4000000000000012ull), Hex(userDocBucket1.getId())); userDocBucket2.setUsedBits(16); - CPPUNIT_ASSERT_EQUAL(Hex(0x4000000000000012ull), Hex(userDocBucket2.getId())); + EXPECT_EQ(Hex(0x4000000000000012ull), Hex(userDocBucket2.getId())); userDocBucket3.setUsedBits(16); - CPPUNIT_ASSERT_EQUAL(Hex(0x4000000000000013ull), Hex(userDocBucket3.getId())); + EXPECT_EQ(Hex(0x4000000000000013ull), Hex(userDocBucket3.getId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xe90ce4b09a1acd50ull), Hex(groupDocBucket1.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xe9cedaa49a1acd50ull), Hex(groupDocBucket2.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xe8cdb18bafe81f24ull), Hex(groupDocBucket3.getRawId())); + EXPECT_EQ(Hex(0xe90ce4b09a1acd50ull), Hex(groupDocBucket1.getRawId())); + EXPECT_EQ(Hex(0xe9cedaa49a1acd50ull), Hex(groupDocBucket2.getRawId())); + EXPECT_EQ(Hex(0xe8cdb18bafe81f24ull), Hex(groupDocBucket3.getRawId())); groupDocBucket1.setUsedBits(16); - CPPUNIT_ASSERT_EQUAL(Hex(0x400000000000cd50ull), Hex(groupDocBucket1.getId())); + EXPECT_EQ(Hex(0x400000000000cd50ull), Hex(groupDocBucket1.getId())); groupDocBucket2.setUsedBits(16); - CPPUNIT_ASSERT_EQUAL(Hex(0x400000000000cd50ull), Hex(groupDocBucket2.getId())); + EXPECT_EQ(Hex(0x400000000000cd50ull), Hex(groupDocBucket2.getId())); groupDocBucket3.setUsedBits(16); - CPPUNIT_ASSERT_EQUAL(Hex(0x4000000000001f24ull), Hex(groupDocBucket3.getId())); + EXPECT_EQ(Hex(0x4000000000001f24ull), Hex(groupDocBucket3.getId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xe980c9abd5fd8d11ull), Hex(docBucket1.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xeafe870c5f9c37b9ull), Hex(docBucket2.getRawId())); - CPPUNIT_ASSERT_EQUAL(Hex(0xeaebe9473ecbcd69ull), Hex(docBucket3.getRawId())); + EXPECT_EQ(Hex(0xe980c9abd5fd8d11ull), Hex(docBucket1.getRawId())); + EXPECT_EQ(Hex(0xeafe870c5f9c37b9ull), Hex(docBucket2.getRawId())); + EXPECT_EQ(Hex(0xeaebe9473ecbcd69ull), Hex(docBucket3.getRawId())); docBucket1.setUsedBits(16); - CPPUNIT_ASSERT_EQUAL(Hex(0x4000000000008d11ull), Hex(docBucket1.getId())); + EXPECT_EQ(Hex(0x4000000000008d11ull), Hex(docBucket1.getId())); docBucket2.setUsedBits(16); - CPPUNIT_ASSERT_EQUAL(Hex(0x40000000000037b9ull), Hex(docBucket2.getId())); + EXPECT_EQ(Hex(0x40000000000037b9ull), Hex(docBucket2.getId())); docBucket3.setUsedBits(16); - CPPUNIT_ASSERT_EQUAL(Hex(0x400000000000cd69ull), Hex(docBucket3.getId())); + EXPECT_EQ(Hex(0x400000000000cd69ull), Hex(docBucket3.getId())); } -void BucketTest::testBucketSerialization() +TEST(BucketTest, testBucketSerialization) { BucketIdFactory factory; DocumentId doc(DocIdString("ns", "spec")); @@ -186,7 +161,7 @@ void BucketTest::testBucketSerialization() std::ostringstream ost; ost << bucket.getRawId(); - CPPUNIT_ASSERT_EQUAL(std::string("16825669947722927377"), + EXPECT_EQ(std::string("16825669947722927377"), ost.str()); BucketId::Type id; @@ -194,96 +169,99 @@ void BucketTest::testBucketSerialization() ist >> id; BucketId bucket2(id); - CPPUNIT_ASSERT_EQUAL(bucket, bucket2); + EXPECT_EQ(bucket, bucket2); } -void BucketTest::testReverseBucket() +TEST(BucketTest, testReverseBucket) { { BucketId id(0x3000000000000012ull); - CPPUNIT_ASSERT_EQUAL(Hex(0x480000000000000cull), Hex(id.toKey())); - CPPUNIT_ASSERT_EQUAL(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); + EXPECT_EQ(Hex(0x480000000000000cull), Hex(id.toKey())); + EXPECT_EQ(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); } { BucketId id(0x4000000000000012ull); - CPPUNIT_ASSERT_EQUAL(Hex(0x4800000000000010ull), Hex(id.toKey())); - CPPUNIT_ASSERT_EQUAL(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); + EXPECT_EQ(Hex(0x4800000000000010ull), Hex(id.toKey())); + EXPECT_EQ(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); } { BucketId id(0x600000000000ffffull); - CPPUNIT_ASSERT_EQUAL(Hex(0xffff000000000018ull), Hex(id.toKey())); - CPPUNIT_ASSERT_EQUAL(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); + EXPECT_EQ(Hex(0xffff000000000018ull), Hex(id.toKey())); + EXPECT_EQ(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); } { BucketId id(0x540000000001ffffull); - CPPUNIT_ASSERT_EQUAL(Hex(0xffff800000000015ull), Hex(id.toKey())); - CPPUNIT_ASSERT_EQUAL(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); + EXPECT_EQ(Hex(0xffff800000000015ull), Hex(id.toKey())); + EXPECT_EQ(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); } { BucketId id(0xa80000000003ffffull); - CPPUNIT_ASSERT_EQUAL(Hex(0xffffc0000000002aull), Hex(id.toKey())); - CPPUNIT_ASSERT_EQUAL(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); + EXPECT_EQ(Hex(0xffffc0000000002aull), Hex(id.toKey())); + EXPECT_EQ(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); } { BucketId id(0xbc0000000007ffffull); - CPPUNIT_ASSERT_EQUAL(Hex(0xffffe0000000002full), Hex(id.toKey())); - CPPUNIT_ASSERT_EQUAL(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); + EXPECT_EQ(Hex(0xffffe0000000002full), Hex(id.toKey())); + EXPECT_EQ(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); } { BucketId id(0xcc0000000002ffffull); - CPPUNIT_ASSERT_EQUAL(Hex(0xffff400000000033ull), Hex(id.toKey())); - CPPUNIT_ASSERT_EQUAL(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); + EXPECT_EQ(Hex(0xffff400000000033ull), Hex(id.toKey())); + EXPECT_EQ(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); } { BucketId id(0xebffffffffffffffull); - CPPUNIT_ASSERT_EQUAL(Hex(0xfffffffffffffffaull), Hex(id.toKey())); - CPPUNIT_ASSERT_EQUAL(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); + EXPECT_EQ(Hex(0xfffffffffffffffaull), Hex(id.toKey())); + EXPECT_EQ(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); } { BucketId id(0xeaaaaaaaaaaaaaaaull); - CPPUNIT_ASSERT_EQUAL(Hex(0x555555555555557aull), Hex(id.toKey())); - CPPUNIT_ASSERT_EQUAL(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); + EXPECT_EQ(Hex(0x555555555555557aull), Hex(id.toKey())); + EXPECT_EQ(Hex(id.getId()), Hex(document::BucketId::keyToBucketId(id.stripUnused().toKey()))); } } -void BucketTest::testContains() { +TEST(BucketTest, testContains) +{ BucketId id(18, 0x123456789ULL); - CPPUNIT_ASSERT(id.contains(BucketId(20, 0x123456789ULL))); - CPPUNIT_ASSERT(id.contains(BucketId(18, 0x888f56789ULL))); - CPPUNIT_ASSERT(id.contains(BucketId(24, 0x888456789ULL))); - CPPUNIT_ASSERT(!id.contains(BucketId(24, 0x888886789ULL))); - CPPUNIT_ASSERT(!id.contains(BucketId(16, 0x123456789ULL))); + EXPECT_TRUE(id.contains(BucketId(20, 0x123456789ULL))); + EXPECT_TRUE(id.contains(BucketId(18, 0x888f56789ULL))); + EXPECT_TRUE(id.contains(BucketId(24, 0x888456789ULL))); + EXPECT_TRUE(!id.contains(BucketId(24, 0x888886789ULL))); + EXPECT_TRUE(!id.contains(BucketId(16, 0x123456789ULL))); } -void BucketTest::testToString() { +TEST(BucketTest, testToString) +{ BucketSpace bucketSpace(0x123450006789ULL); - CPPUNIT_ASSERT_EQUAL(vespalib::string("BucketSpace(0x0000123450006789)"), bucketSpace.toString()); + EXPECT_EQ(vespalib::string("BucketSpace(0x0000123450006789)"), bucketSpace.toString()); Bucket bucket(bucketSpace, BucketId(0x123456789ULL)); - CPPUNIT_ASSERT_EQUAL( + EXPECT_EQ( vespalib::string("Bucket(BucketSpace(0x0000123450006789), BucketId(0x0000000123456789))"), bucket.toString()); } -void BucketTest::testOperators() { - CPPUNIT_ASSERT(BucketSpace(0x1) == BucketSpace(0x1)); - CPPUNIT_ASSERT(BucketSpace(0x1) != BucketSpace(0x2)); - CPPUNIT_ASSERT(BucketSpace(0x1) < BucketSpace(0x2)); - - CPPUNIT_ASSERT(Bucket(BucketSpace(0x1), BucketId(0x123456789ULL)) == - Bucket(BucketSpace(0x1), BucketId(0x123456789ULL))); - CPPUNIT_ASSERT(Bucket(BucketSpace(0x1), BucketId(0x123456789ULL)) != - Bucket(BucketSpace(0x2), BucketId(0x123456789ULL))); - CPPUNIT_ASSERT(Bucket(BucketSpace(0x1), BucketId(0x123456789ULL)) != - Bucket(BucketSpace(0x1), BucketId(0x987654321ULL))); - CPPUNIT_ASSERT(Bucket(BucketSpace(0x1), BucketId(0x123456789ULL)) < - Bucket(BucketSpace(0x1), BucketId(0x987654321ULL))); - CPPUNIT_ASSERT(Bucket(BucketSpace(0x1), BucketId(0x123456789ULL)) < - Bucket(BucketSpace(0x2), BucketId(0x123456789ULL))); +TEST(BucketTest, testOperators) +{ + EXPECT_TRUE(BucketSpace(0x1) == BucketSpace(0x1)); + EXPECT_TRUE(BucketSpace(0x1) != BucketSpace(0x2)); + EXPECT_TRUE(BucketSpace(0x1) < BucketSpace(0x2)); + + EXPECT_TRUE(Bucket(BucketSpace(0x1), BucketId(0x123456789ULL)) == + Bucket(BucketSpace(0x1), BucketId(0x123456789ULL))); + EXPECT_TRUE(Bucket(BucketSpace(0x1), BucketId(0x123456789ULL)) != + Bucket(BucketSpace(0x2), BucketId(0x123456789ULL))); + EXPECT_TRUE(Bucket(BucketSpace(0x1), BucketId(0x123456789ULL)) != + Bucket(BucketSpace(0x1), BucketId(0x987654321ULL))); + EXPECT_TRUE(Bucket(BucketSpace(0x1), BucketId(0x123456789ULL)) < + Bucket(BucketSpace(0x1), BucketId(0x987654321ULL))); + EXPECT_TRUE(Bucket(BucketSpace(0x1), BucketId(0x123456789ULL)) < + Bucket(BucketSpace(0x2), BucketId(0x123456789ULL))); } } // document diff --git a/document/src/tests/documentselectparsertest.cpp b/document/src/tests/documentselectparsertest.cpp index 93b2eadaa0d..9ba38f5ca6b 100644 --- a/document/src/tests/documentselectparsertest.cpp +++ b/document/src/tests/documentselectparsertest.cpp @@ -1,7 +1,5 @@ // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include -#include #include #include #include @@ -21,34 +19,14 @@ #include #include #include +#include using namespace document::config_builder; namespace document { -class DocumentSelectParserTest : public CppUnit::TestFixture { - CPPUNIT_TEST_SUITE(DocumentSelectParserTest); - CPPUNIT_TEST(testParseTerminals); - CPPUNIT_TEST(testParseBranches); - CPPUNIT_TEST(testOperators); - CPPUNIT_TEST(testVisitor); - CPPUNIT_TEST(testUtf8); - CPPUNIT_TEST(testThatSimpleFieldValuesHaveCorrectFieldName); - CPPUNIT_TEST(testThatComplexFieldValuesHaveCorrectFieldNames); - CPPUNIT_TEST(testBodyFieldDetection); - CPPUNIT_TEST(testDocumentUpdates); - CPPUNIT_TEST(testDocumentIdsInRemoves); - CPPUNIT_TEST(test_syntax_error_reporting); - CPPUNIT_TEST(test_operator_precedence); - CPPUNIT_TEST(test_token_used_as_ident_preserves_casing); - CPPUNIT_TEST(test_ambiguous_field_spec_expression_is_handled_correctly); - CPPUNIT_TEST(test_can_build_field_value_from_field_expr_node); - CPPUNIT_TEST(test_can_build_function_call_from_field_expr_node); - CPPUNIT_TEST(test_function_call_on_doctype_throws_exception); - CPPUNIT_TEST(test_parse_utilities_handle_well_formed_input); - CPPUNIT_TEST(test_parse_utilities_handle_malformed_input); - CPPUNIT_TEST_SUITE_END(); - +class DocumentSelectParserTest : public ::testing::Test { +protected: BucketIdFactory _bucketIdFactory; std::unique_ptr _parser; std::vector _doc; @@ -71,17 +49,13 @@ class DocumentSelectParserTest : public CppUnit::TestFixture { const ContainsType& t); std::string parse_to_tree(const std::string& str); -public: DocumentSelectParserTest() : _bucketIdFactory() {} - void setUp() override; + void SetUp() override; void createDocs(); - void testParseTerminals(); - void testParseBranches(); - void testOperators(); void testOperators0(); void testOperators1(); void testOperators2(); @@ -92,36 +66,19 @@ public: void testOperators7(); void testOperators8(); void testOperators9(); - void testVisitor(); - void testUtf8(); - void testThatSimpleFieldValuesHaveCorrectFieldName(); - void testThatComplexFieldValuesHaveCorrectFieldNames(); - void testBodyFieldDetection(); - void testDocumentUpdates(); void testDocumentUpdates0(); void testDocumentUpdates1(); void testDocumentUpdates2(); void testDocumentUpdates3(); void testDocumentUpdates4(); - void testDocumentIdsInRemoves(); - void test_syntax_error_reporting(); - void test_operator_precedence(); - void test_token_used_as_ident_preserves_casing(); - void test_ambiguous_field_spec_expression_is_handled_correctly(); - void test_can_build_field_value_from_field_expr_node(); - void test_can_build_function_call_from_field_expr_node(); - void test_function_call_on_doctype_throws_exception(); - void test_parse_utilities_handle_well_formed_input(); - void test_parse_utilities_handle_malformed_input(); }; -CPPUNIT_TEST_SUITE_REGISTRATION(DocumentSelectParserTest); namespace { std::shared_ptr _repo; } -void DocumentSelectParserTest::setUp() +void DocumentSelectParserTest::SetUp() { DocumenttypesConfigBuilderHelper builder(TestDocRepo::getDefaultConfig()); builder.document(535424777, "notandor", @@ -295,24 +252,24 @@ DocumentSelectParserTest::createDocs() namespace { void doVerifyParse(select::Node *node, const std::string &query, const char *expected) { std::string message("Query "+query+" failed to parse."); - CPPUNIT_ASSERT_MESSAGE(message, node != 0); + ASSERT_TRUE(node != nullptr) << message; std::ostringstream actual; actual << *node; - std::string exp(expected != 0 ? std::string(expected) : query); - CPPUNIT_ASSERT_EQUAL(exp, actual.str()); + std::string exp(expected != nullptr ? std::string(expected) : query); + EXPECT_EQ(exp, actual.str()); // Test that cloning gives the same result std::unique_ptr clonedNode(node->clone()); std::ostringstream clonedStr; clonedStr << *clonedNode; - CPPUNIT_ASSERT_EQUAL(exp, clonedStr.str()); + EXPECT_EQ(exp, clonedStr.str()); } void verifySimpleParse(const std::string& query, const char* expected = 0) { BucketIdFactory factory; select::simple::SelectionParser parser(factory); std::string message("Query "+query+" failed to parse."); - CPPUNIT_ASSERT_MESSAGE(message, parser.parse(query)); + EXPECT_TRUE(parser.parse(query)) << message; std::unique_ptr node(parser.getNode()); doVerifyParse(node.get(), query, expected); } @@ -330,19 +287,20 @@ void verifyParse(const std::string& query, const char* expected = 0) { TestDocRepo test_repo; select::Parser parser(test_repo.getTypeRepo(), factory); std::unique_ptr node(parser.parse(query)); - CPPUNIT_FAIL("Expected exception parsing query '"+query+"'"); + FAIL() << "Expected exception parsing query '" << query << "'"; } catch (select::ParsingFailedException& e) { std::string message(e.what()); if (message.size() > error.size()) message = message.substr(0, error.size()); std::string failure("Expected: " + error + "\n- Actual : " + std::string(e.what())); - CPPUNIT_ASSERT_MESSAGE(failure, error == message); + EXPECT_EQ(error, message) << failure; } } } -void DocumentSelectParserTest::test_syntax_error_reporting() { +TEST_F(DocumentSelectParserTest, test_syntax_error_reporting) +{ createDocs(); verifyFailedParse("testdoctype1.headerval == aaa", "ParsingFailedException: " @@ -376,7 +334,7 @@ void DocumentSelectParserTest::test_syntax_error_reporting() { "doctype, bool or comparison at column 1 when parsing selection '(1 + 2)'"); } -void DocumentSelectParserTest::testParseTerminals() +TEST_F(DocumentSelectParserTest, testParseTerminals) { createDocs(); @@ -401,8 +359,8 @@ void DocumentSelectParserTest::testParseTerminals() const select::StringValueNode& vnode( dynamic_cast(compnode.getRight())); - CPPUNIT_ASSERT_EQUAL(vespalib::string("headerval"), fnode.getFieldName()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("test"), vnode.getValue()); + EXPECT_EQ(vespalib::string("headerval"), fnode.getFieldName()); + EXPECT_EQ(vespalib::string("test"), vnode.getValue()); // Test whitespace verifyParse("testdoctype1.headerval == \"te st \""); verifyParse(" \t testdoctype1.headerval\t== \t \"test\"\t", @@ -416,7 +374,7 @@ void DocumentSelectParserTest::testParseTerminals() select::Compare& escapednode(dynamic_cast(*node)); const select::StringValueNode& escval( dynamic_cast(escapednode.getRight())); - CPPUNIT_ASSERT_EQUAL(vespalib::string("\ttH \n"), escval.getValue()); + EXPECT_EQ(vespalib::string("\ttH \n"), escval.getValue()); // Test <= <, > >= verifyParse("testdoctype1.headerval >= 123"); verifyParse("testdoctype1.headerval > 123"); @@ -503,7 +461,7 @@ void DocumentSelectParserTest::testParseTerminals() verifyParse("usergroup"); } -void DocumentSelectParserTest::testParseBranches() +TEST_F(DocumentSelectParserTest, testParseBranches) { createDocs(); @@ -540,25 +498,23 @@ DocumentSelectParserTest::doParse(vespalib::stringref expr, oss << "for expr: " << expr << "\n"; select::ResultList tracedResult(root->trace(t, oss)); - CPPUNIT_ASSERT_EQUAL_MESSAGE(expr, result, clonedResult); - CPPUNIT_ASSERT_EQUAL_MESSAGE(oss.str(), result, tracedResult); + EXPECT_EQ(result, clonedResult) << expr; + EXPECT_EQ(result, tracedResult) << oss.str(); return result; } #define PARSE(expr, doc, result) \ - CPPUNIT_ASSERT_EQUAL_MESSAGE(expr, select::ResultList(select::Result::result), \ - doParse(expr, (doc))); + EXPECT_EQ(select::ResultList(select::Result::result), \ + doParse(expr, (doc))) << expr; #define PARSEI(expr, doc, result) \ - CPPUNIT_ASSERT_EQUAL_MESSAGE(std::string("Doc: ") + expr, \ - select::ResultList(select::Result::result), \ - doParse(expr, (doc))); \ - CPPUNIT_ASSERT_EQUAL_MESSAGE(std::string("Doc id: ") + expr, \ - select::ResultList(select::Result::result), \ - doParse(expr, (doc).getId())); - -void DocumentSelectParserTest::testOperators() + EXPECT_EQ(select::ResultList(select::Result::result), \ + doParse(expr, (doc))) << (std::string("Doc: ") + expr); \ + EXPECT_EQ(select::ResultList(select::Result::result), \ + doParse(expr, (doc).getId())) << (std::string("Doc id: ") + expr); + +TEST_F(DocumentSelectParserTest, testOperators) { testOperators0(); testOperators1(); @@ -1000,7 +956,7 @@ namespace { } -void DocumentSelectParserTest::testVisitor() +TEST_F(DocumentSelectParserTest, testVisitor) { createDocs(); @@ -1018,10 +974,10 @@ void DocumentSelectParserTest::testVisitor() "COMPARE(testdoctype1.hstringval = \"ola\"))), " "COMPARE(testdoctype1.headerval != null)))"; - CPPUNIT_ASSERT_EQUAL(expected, v.getVisitString()); + EXPECT_EQ(expected, v.getVisitString()); } -void DocumentSelectParserTest::testBodyFieldDetection() +TEST_F(DocumentSelectParserTest, testBodyFieldDetection) { { @@ -1029,8 +985,8 @@ void DocumentSelectParserTest::testBodyFieldDetection() select::BodyFieldDetector detector(*_repo); root->visit(detector); - CPPUNIT_ASSERT(!detector.foundBodyField); - CPPUNIT_ASSERT(detector.foundHeaderField); + EXPECT_TRUE(!detector.foundBodyField); + EXPECT_TRUE(detector.foundHeaderField); } { @@ -1038,8 +994,8 @@ void DocumentSelectParserTest::testBodyFieldDetection() select::BodyFieldDetector detector(*_repo); root->visit(detector); - CPPUNIT_ASSERT(!detector.foundBodyField); - CPPUNIT_ASSERT(detector.foundHeaderField); + EXPECT_TRUE(!detector.foundBodyField); + EXPECT_TRUE(detector.foundHeaderField); } { @@ -1047,8 +1003,8 @@ void DocumentSelectParserTest::testBodyFieldDetection() select::BodyFieldDetector detector(*_repo); root->visit(detector); - CPPUNIT_ASSERT(!detector.foundBodyField); - CPPUNIT_ASSERT(detector.foundHeaderField); + EXPECT_TRUE(!detector.foundBodyField); + EXPECT_TRUE(detector.foundHeaderField); } { @@ -1056,7 +1012,7 @@ void DocumentSelectParserTest::testBodyFieldDetection() select::BodyFieldDetector detector(*_repo); root->visit(detector); - CPPUNIT_ASSERT(detector.foundBodyField); + EXPECT_TRUE(detector.foundBodyField); } { @@ -1067,12 +1023,12 @@ void DocumentSelectParserTest::testBodyFieldDetection() select::BodyFieldDetector detector(*_repo); root->visit(detector); - CPPUNIT_ASSERT(!detector.foundBodyField); + EXPECT_TRUE(!detector.foundBodyField); } } -void DocumentSelectParserTest::testDocumentUpdates() +TEST_F(DocumentSelectParserTest, testDocumentUpdates) { testDocumentUpdates0(); testDocumentUpdates1(); @@ -1239,7 +1195,7 @@ void DocumentSelectParserTest::testDocumentUpdates4() PARSEI("-6 % 10 = -6", *_update[0], True); } -void DocumentSelectParserTest::testDocumentIdsInRemoves() +TEST_F(DocumentSelectParserTest, testDocumentIdsInRemoves) { PARSE("testdoctype1", DocumentId("id:ns:testdoctype1::1"), True); PARSE("testdoctype1", DocumentId("id:ns:null::1"), False); @@ -1252,15 +1208,15 @@ void DocumentSelectParserTest::testDocumentIdsInRemoves() PARSE("testdoctype1 and testdoctype1.headerval == 0", DocumentId("id:ns:testdoctype1::1"), Invalid); } -void DocumentSelectParserTest::testUtf8() +TEST_F(DocumentSelectParserTest, testUtf8) { createDocs(); std::string utf8name(u8"H\u00e5kon"); - CPPUNIT_ASSERT_EQUAL(size_t(6), utf8name.size()); + EXPECT_EQ(size_t(6), utf8name.size()); /// \todo TODO (was warning): UTF8 test for glob/regex support in selection language disabled. Known not to work // boost::u32regex rx = boost::make_u32regex("H.kon"); -// CPPUNIT_ASSERT_EQUAL(true, boost::u32regex_match(utf8name, rx)); +// EXPECT_EQ(true, boost::u32regex_match(utf8name, rx)); _doc.push_back(createDoc( "testdoctype1", "doc:myspace:utf8doc", 24, 2.0, utf8name, "bar")); @@ -1274,22 +1230,24 @@ DocumentSelectParserTest::parseFieldValue(const std::string& expression) { dynamic_cast(*_parser->parse(expression)).getLeft().clone().release())); } -void DocumentSelectParserTest::testThatSimpleFieldValuesHaveCorrectFieldName() { - CPPUNIT_ASSERT_EQUAL( +TEST_F(DocumentSelectParserTest, testThatSimpleFieldValuesHaveCorrectFieldName) +{ + EXPECT_EQ( vespalib::string("headerval"), parseFieldValue("testdoctype1.headerval")->getRealFieldName()); } -void DocumentSelectParserTest::testThatComplexFieldValuesHaveCorrectFieldNames() { - CPPUNIT_ASSERT_EQUAL( +TEST_F(DocumentSelectParserTest, testThatComplexFieldValuesHaveCorrectFieldNames) +{ + EXPECT_EQ( vespalib::string("headerval"), parseFieldValue("testdoctype1.headerval{test}")->getRealFieldName()); - CPPUNIT_ASSERT_EQUAL( + EXPECT_EQ( vespalib::string("headerval"), parseFieldValue("testdoctype1.headerval[42]")->getRealFieldName()); - CPPUNIT_ASSERT_EQUAL( + EXPECT_EQ( vespalib::string("headerval"), parseFieldValue("testdoctype1.headerval.meow.meow{test}")->getRealFieldName()); } @@ -1399,84 +1357,88 @@ std::string DocumentSelectParserTest::parse_to_tree(const std::string& str) { return node_to_string(*root); } -void DocumentSelectParserTest::test_operator_precedence() { +TEST_F(DocumentSelectParserTest, test_operator_precedence) +{ createDocs(); using namespace std::string_literals; - CPPUNIT_ASSERT_EQUAL("(AND true false)"s, parse_to_tree("true and false")); - CPPUNIT_ASSERT_EQUAL("(AND (NOT false) true)"s, parse_to_tree("not false and true")); - CPPUNIT_ASSERT_EQUAL("(NOT (AND false true))"s, parse_to_tree("not (false and true)")); - CPPUNIT_ASSERT_EQUAL("(NOT (DOCTYPE testdoctype1))"s, parse_to_tree("not testdoctype1")); - CPPUNIT_ASSERT_EQUAL("(NOT (DOCTYPE (testdoctype1)))"s, parse_to_tree("not (testdoctype1)")); - CPPUNIT_ASSERT_EQUAL("(NOT (DOCTYPE (testdoctype1)))"s, parse_to_tree("(not (testdoctype1))")); - CPPUNIT_ASSERT_EQUAL("(OR (== 1 2) (== 3 4))"s, parse_to_tree("1==2 or 3==4")); - CPPUNIT_ASSERT_EQUAL("(!= (+ (+ 1 2) 3) 0)"s, parse_to_tree("1+2+3 != 0")); - CPPUNIT_ASSERT_EQUAL("(!= (+ (+ 1.1 2.2) 3.3) 4.4)"s, parse_to_tree("1.1+2.2+3.3 != 4.4")); - CPPUNIT_ASSERT_EQUAL("(!= (- (- 1 2) 3) 0)"s, parse_to_tree("1-2-3 != 0")); - CPPUNIT_ASSERT_EQUAL("(!= (+ (+ 1 2) 3) 0)"s, parse_to_tree("1 + 2 + 3 != 0")); - CPPUNIT_ASSERT_EQUAL("(!= (+ 1 (* 2 3)) 0)"s, parse_to_tree("1 + 2 * 3 != 0")); - CPPUNIT_ASSERT_EQUAL("(!= (- (/ (* 1 2) 3) 4) 0)"s, parse_to_tree("1 * 2 / 3 - 4 != 0")); - CPPUNIT_ASSERT_EQUAL("(!= (/ (* 1 2) (- 3 4)) 0)"s, parse_to_tree("1 * 2 / (3 - 4) != 0")); - CPPUNIT_ASSERT_EQUAL("(OR (AND true (NOT (== 1 2))) false)"s, + EXPECT_EQ("(AND true false)"s, parse_to_tree("true and false")); + EXPECT_EQ("(AND (NOT false) true)"s, parse_to_tree("not false and true")); + EXPECT_EQ("(NOT (AND false true))"s, parse_to_tree("not (false and true)")); + EXPECT_EQ("(NOT (DOCTYPE testdoctype1))"s, parse_to_tree("not testdoctype1")); + EXPECT_EQ("(NOT (DOCTYPE (testdoctype1)))"s, parse_to_tree("not (testdoctype1)")); + EXPECT_EQ("(NOT (DOCTYPE (testdoctype1)))"s, parse_to_tree("(not (testdoctype1))")); + EXPECT_EQ("(OR (== 1 2) (== 3 4))"s, parse_to_tree("1==2 or 3==4")); + EXPECT_EQ("(!= (+ (+ 1 2) 3) 0)"s, parse_to_tree("1+2+3 != 0")); + EXPECT_EQ("(!= (+ (+ 1.1 2.2) 3.3) 4.4)"s, parse_to_tree("1.1+2.2+3.3 != 4.4")); + EXPECT_EQ("(!= (- (- 1 2) 3) 0)"s, parse_to_tree("1-2-3 != 0")); + EXPECT_EQ("(!= (+ (+ 1 2) 3) 0)"s, parse_to_tree("1 + 2 + 3 != 0")); + EXPECT_EQ("(!= (+ 1 (* 2 3)) 0)"s, parse_to_tree("1 + 2 * 3 != 0")); + EXPECT_EQ("(!= (- (/ (* 1 2) 3) 4) 0)"s, parse_to_tree("1 * 2 / 3 - 4 != 0")); + EXPECT_EQ("(!= (/ (* 1 2) (- 3 4)) 0)"s, parse_to_tree("1 * 2 / (3 - 4) != 0")); + EXPECT_EQ("(OR (AND true (NOT (== 1 2))) false)"s, parse_to_tree("true and not 1 == 2 or false")); - CPPUNIT_ASSERT_EQUAL("(AND (AND (AND (< 1 2) (> 3 4)) (<= 5 6)) (>= 7 8))"s, + EXPECT_EQ("(AND (AND (AND (< 1 2) (> 3 4)) (<= 5 6)) (>= 7 8))"s, parse_to_tree("1 < 2 and 3 > 4 and 5 <= 6 and 7 >= 8")); - CPPUNIT_ASSERT_EQUAL("(OR (AND (AND (< 1 2) (> 3 4)) (<= 5 6)) (>= 7 8))"s, + EXPECT_EQ("(OR (AND (AND (< 1 2) (> 3 4)) (<= 5 6)) (>= 7 8))"s, parse_to_tree("1 < 2 and 3 > 4 and 5 <= 6 or 7 >= 8")); - CPPUNIT_ASSERT_EQUAL("(OR (AND (< 1 2) (> 3 4)) (AND (<= 5 6) (>= 7 8)))"s, + EXPECT_EQ("(OR (AND (< 1 2) (> 3 4)) (AND (<= 5 6) (>= 7 8)))"s, parse_to_tree("1 < 2 and 3 > 4 or 5 <= 6 and 7 >= 8")); // Unary plus is simply ignored by the parser. - CPPUNIT_ASSERT_EQUAL("(== 1 -2)"s, parse_to_tree("+1==-2")); - CPPUNIT_ASSERT_EQUAL("(== 1.23 -2.56)"s, parse_to_tree("+1.23==-2.56")); - CPPUNIT_ASSERT_EQUAL("(== (+ 1 2) (- 3 -4))"s, parse_to_tree("1 + +2==3 - -4")); - CPPUNIT_ASSERT_EQUAL("(== (+ 1 2) (- 3 -4))"s, parse_to_tree("1++2==3--4")); + EXPECT_EQ("(== 1 -2)"s, parse_to_tree("+1==-2")); + EXPECT_EQ("(== 1.23 -2.56)"s, parse_to_tree("+1.23==-2.56")); + EXPECT_EQ("(== (+ 1 2) (- 3 -4))"s, parse_to_tree("1 + +2==3 - -4")); + EXPECT_EQ("(== (+ 1 2) (- 3 -4))"s, parse_to_tree("1++2==3--4")); // Due to the way parentheses are handled by the AST, ((foo)) always gets // reduced down to (foo). - CPPUNIT_ASSERT_EQUAL("(DOCTYPE (testdoctype1))"s, parse_to_tree("(((testdoctype1)))")); - CPPUNIT_ASSERT_EQUAL("(AND (DOCTYPE (testdoctype1)) (DOCTYPE (testdoctype2)))"s, + EXPECT_EQ("(DOCTYPE (testdoctype1))"s, parse_to_tree("(((testdoctype1)))")); + EXPECT_EQ("(AND (DOCTYPE (testdoctype1)) (DOCTYPE (testdoctype2)))"s, parse_to_tree("((((testdoctype1))) and ((testdoctype2)))")); - CPPUNIT_ASSERT_EQUAL("(== (ID id) \"foo\")"s, parse_to_tree("id == 'foo'")); - CPPUNIT_ASSERT_EQUAL("(== (ID id.group) \"foo\")"s, parse_to_tree("id.group == 'foo'")); + EXPECT_EQ("(== (ID id) \"foo\")"s, parse_to_tree("id == 'foo'")); + EXPECT_EQ("(== (ID id.group) \"foo\")"s, parse_to_tree("id.group == 'foo'")); // id_spec function apply - CPPUNIT_ASSERT_EQUAL("(== (hash (ID id)) 12345)"s, parse_to_tree("id.hash() == 12345")); + EXPECT_EQ("(== (hash (ID id)) 12345)"s, parse_to_tree("id.hash() == 12345")); // Combination of id_spec function apply and arith_expr function apply - CPPUNIT_ASSERT_EQUAL("(== (abs (hash (ID id))) 12345)"s, parse_to_tree("id.hash().abs() == 12345")); + EXPECT_EQ("(== (abs (hash (ID id))) 12345)"s, parse_to_tree("id.hash().abs() == 12345")); } -void DocumentSelectParserTest::test_token_used_as_ident_preserves_casing() { +TEST_F(DocumentSelectParserTest, test_token_used_as_ident_preserves_casing) +{ createDocs(); using namespace std::string_literals; // TYPE, SCHEME, ORDER etc are tokens that may also be used as identifiers // without introducing parsing ambiguities. In this context their original // casing should be preserved. - CPPUNIT_ASSERT_EQUAL("(== (VAR Type) 123)"s, parse_to_tree("$Type == 123")); - CPPUNIT_ASSERT_EQUAL("(== (VAR giD) 123)"s, parse_to_tree("$giD == 123")); - CPPUNIT_ASSERT_EQUAL("(== (VAR ORDER) 123)"s, parse_to_tree("$ORDER == 123")); + EXPECT_EQ("(== (VAR Type) 123)"s, parse_to_tree("$Type == 123")); + EXPECT_EQ("(== (VAR giD) 123)"s, parse_to_tree("$giD == 123")); + EXPECT_EQ("(== (VAR ORDER) 123)"s, parse_to_tree("$ORDER == 123")); } -void DocumentSelectParserTest::test_ambiguous_field_spec_expression_is_handled_correctly() { +TEST_F(DocumentSelectParserTest, test_ambiguous_field_spec_expression_is_handled_correctly) +{ createDocs(); using namespace std::string_literals; // In earlier revisions of LR(1)-grammar, this triggered a reduce/reduce conflict between // logical_expr and arith_expr for the sequence '(' field_spec ')', which failed to // parse in an expected manner. Test that we don't get regressions here. - CPPUNIT_ASSERT_EQUAL("(!= (FIELD testdoctype1 foo) null)"s, parse_to_tree("(testdoctype1.foo)")); - CPPUNIT_ASSERT_EQUAL("(AND (!= (FIELD testdoctype1 foo) null) (!= (FIELD testdoctype1 bar) null))"s, + EXPECT_EQ("(!= (FIELD testdoctype1 foo) null)"s, parse_to_tree("(testdoctype1.foo)")); + EXPECT_EQ("(AND (!= (FIELD testdoctype1 foo) null) (!= (FIELD testdoctype1 bar) null))"s, parse_to_tree("(testdoctype1.foo) AND (testdoctype1.bar)")); } -void DocumentSelectParserTest::test_can_build_field_value_from_field_expr_node() { +TEST_F(DocumentSelectParserTest, test_can_build_field_value_from_field_expr_node) +{ using select::FieldExprNode; { // Simple field expression auto lhs = std::make_unique("mydoctype"); auto root = std::make_unique(std::move(lhs), "foo"); auto fv = root->convert_to_field_value(); - CPPUNIT_ASSERT_EQUAL(vespalib::string("mydoctype"), fv->getDocType()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("foo"), fv->getFieldName()); + EXPECT_EQ(vespalib::string("mydoctype"), fv->getDocType()); + EXPECT_EQ(vespalib::string("foo"), fv->getFieldName()); } { // Nested field expression @@ -1484,12 +1446,13 @@ void DocumentSelectParserTest::test_can_build_field_value_from_field_expr_node() auto lhs2 = std::make_unique(std::move(lhs1), "foo"); auto root = std::make_unique(std::move(lhs2), "bar"); auto fv = root->convert_to_field_value(); - CPPUNIT_ASSERT_EQUAL(vespalib::string("mydoctype"), fv->getDocType()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("foo.bar"), fv->getFieldName()); + EXPECT_EQ(vespalib::string("mydoctype"), fv->getDocType()); + EXPECT_EQ(vespalib::string("foo.bar"), fv->getFieldName()); } } -void DocumentSelectParserTest::test_can_build_function_call_from_field_expr_node() { +TEST_F(DocumentSelectParserTest, test_can_build_function_call_from_field_expr_node) +{ using select::FieldExprNode; { // doctype.foo.lowercase() @@ -1499,20 +1462,21 @@ void DocumentSelectParserTest::test_can_build_function_call_from_field_expr_node auto lhs2 = std::make_unique(std::move(lhs1), "foo"); auto root = std::make_unique(std::move(lhs2), "lowercase"); auto func = root->convert_to_function_call(); - CPPUNIT_ASSERT_EQUAL(vespalib::string("lowercase"), func->getFunctionName()); + EXPECT_EQ(vespalib::string("lowercase"), func->getFunctionName()); // TODO vespalib::string? - CPPUNIT_ASSERT_EQUAL(std::string("(FIELD mydoctype foo)"), node_to_string(func->getChild())); + EXPECT_EQ(std::string("(FIELD mydoctype foo)"), node_to_string(func->getChild())); } } -void DocumentSelectParserTest::test_function_call_on_doctype_throws_exception() { +TEST_F(DocumentSelectParserTest, test_function_call_on_doctype_throws_exception) +{ using select::FieldExprNode; auto lhs = std::make_unique("mydoctype"); auto root = std::make_unique(std::move(lhs), "lowercase"); try { root->convert_to_function_call(); } catch (const vespalib::IllegalArgumentException& e) { - CPPUNIT_ASSERT_EQUAL(vespalib::string("Cannot call function 'lowercase' directly on document type"), + EXPECT_EQ(vespalib::string("Cannot call function 'lowercase' directly on document type"), e.getMessage()); } } @@ -1522,33 +1486,34 @@ namespace { void check_parse_i64(vespalib::stringref str, bool expect_ok, int64_t expected_output) { int64_t out = 0; bool ok = select::util::parse_i64(str.data(), str.size(), out); - CPPUNIT_ASSERT_EQUAL_MESSAGE("Parsing did not returned expected success status for i64 input " + str, expect_ok, ok); + EXPECT_EQ(expect_ok, ok) << "Parsing did not returned expected success status for i64 input " << str; if (expect_ok) { - CPPUNIT_ASSERT_EQUAL_MESSAGE("Parse output not as expected for i64 input " + str, expected_output, out); + EXPECT_EQ(expected_output, out) << "Parse output not as expected for i64 input " << str; } } void check_parse_hex_i64(vespalib::stringref str, bool expect_ok, int64_t expected_output) { int64_t out = 0; bool ok = select::util::parse_hex_i64(str.data(), str.size(), out); - CPPUNIT_ASSERT_EQUAL_MESSAGE("Parsing did not returned expected success status for hex i64 input " + str, expect_ok, ok); + EXPECT_EQ(expect_ok, ok) << "Parsing did not returned expected success status for hex i64 input " << str; if (expect_ok) { - CPPUNIT_ASSERT_EQUAL_MESSAGE("Parse output not as expected for hex i64 input " + str, expected_output, out); + EXPECT_EQ(expected_output, out) << "Parse output not as expected for hex i64 input " << str; } } void check_parse_double(vespalib::stringref str, bool expect_ok, double expected_output) { double out = 0; bool ok = select::util::parse_double(str.data(), str.size(), out); - CPPUNIT_ASSERT_EQUAL_MESSAGE("Parsing did not returned expected success status for hex i64 input " + str, expect_ok, ok); + EXPECT_EQ(expect_ok, ok) << "Parsing did not returned expected success status for hex i64 input " << str; if (expect_ok) { - CPPUNIT_ASSERT_EQUAL_MESSAGE("Parse output not as expected for double input " + str, expected_output, out); + EXPECT_EQ(expected_output, out) << "Parse output not as expected for double input " << str; } } } -void DocumentSelectParserTest::test_parse_utilities_handle_well_formed_input() { +TEST_F(DocumentSelectParserTest, test_parse_utilities_handle_well_formed_input) +{ check_parse_i64("0", true, 0); check_parse_i64("1", true, 1); check_parse_i64("9223372036854775807", true, INT64_MAX); @@ -1568,7 +1533,8 @@ void DocumentSelectParserTest::test_parse_utilities_handle_well_formed_input() { check_parse_double("1.79769e+308", true, 1.79769e+308); // DBL_MAX } -void DocumentSelectParserTest::test_parse_utilities_handle_malformed_input() { +TEST_F(DocumentSelectParserTest, test_parse_utilities_handle_malformed_input) +{ check_parse_i64("9223372036854775808", false, 0); // INT64_MAX + 1 check_parse_i64("18446744073709551615", false, 0); // UINT64_MAX check_parse_i64("", false, 0); diff --git a/document/src/tests/documentselecttest.h b/document/src/tests/documentselecttest.h deleted file mode 100644 index e50dd984b65..00000000000 --- a/document/src/tests/documentselecttest.h +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -/* $Id$*/ -#pragma once - -#include - -class DocumentSelect_Test : public CppUnit::TestFixture { - CPPUNIT_TEST_SUITE( DocumentSelect_Test); - CPPUNIT_TEST(testEquals); - CPPUNIT_TEST(testLt); - CPPUNIT_TEST(testGt); - CPPUNIT_TEST(testAnd); - CPPUNIT_TEST(testOr); - CPPUNIT_TEST(testNot); - CPPUNIT_TEST(testConfig1); - CPPUNIT_TEST(testConfig2); - CPPUNIT_TEST_SUITE_END(); - -public: - void setUp(); - - void tearDown(); -protected: - void testEquals(); - void testLt(); - void testGt(); - void testAnd(); - void testOr(); - void testNot(); - void testConfig1(); - void testConfig2(); -}; - - diff --git a/document/src/tests/documenttestcase.cpp b/document/src/tests/documenttestcase.cpp index ee49259e982..bb07f63a83b 100644 --- a/document/src/tests/documenttestcase.cpp +++ b/document/src/tests/documenttestcase.cpp @@ -2,8 +2,6 @@ #include #include -#include - #include #include #include @@ -15,9 +13,12 @@ #include #include #include +#include +#include using vespalib::nbostream; using vespalib::compression::CompressionConfig; +using namespace ::testing; using namespace document::config_builder; @@ -25,67 +26,15 @@ namespace document { using namespace fieldvalue; -struct DocumentTest : public CppUnit::TestFixture { - void testTraversing(); - void testFieldPath(); - void testModifyDocument(); - void testVariables(); - void testSimpleUsage(); - void testReadSerializedFile(); - void testReadSerializedFileCompressed(); - void testReadSerializedAllVersions(); - void testGenerateSerializedFile(); - void testGetURIFromSerialized(); - void testBogusserialize(); - void testCRC32(); - void testHasChanged(); - void testSplitSerialization(); - void testSliceSerialize(); - void testCompression(); - void testCompressionConfigured(); - void testUnknownEntries(); - void testAnnotationDeserialization(); - void testGetSerializedSize(); - void testDeserializeMultiple(); - void testSizeOf(); - - CPPUNIT_TEST_SUITE(DocumentTest); - CPPUNIT_TEST(testFieldPath); - CPPUNIT_TEST(testTraversing); - CPPUNIT_TEST(testModifyDocument); - CPPUNIT_TEST(testVariables); - CPPUNIT_TEST(testSimpleUsage); - CPPUNIT_TEST(testReadSerializedFile); - CPPUNIT_TEST(testReadSerializedFileCompressed); - CPPUNIT_TEST(testReadSerializedAllVersions); - CPPUNIT_TEST(testGenerateSerializedFile); - CPPUNIT_TEST(testGetURIFromSerialized); - CPPUNIT_TEST(testBogusserialize); - CPPUNIT_TEST(testCRC32); - CPPUNIT_TEST(testHasChanged); - CPPUNIT_TEST(testSplitSerialization); - CPPUNIT_TEST(testSliceSerialize); - CPPUNIT_TEST(testCompression); - CPPUNIT_TEST(testCompressionConfigured); - CPPUNIT_TEST(testUnknownEntries); - CPPUNIT_TEST(testAnnotationDeserialization); - CPPUNIT_TEST(testGetSerializedSize); - CPPUNIT_TEST(testDeserializeMultiple); - CPPUNIT_TEST(testSizeOf); - CPPUNIT_TEST_SUITE_END(); -}; - -CPPUNIT_TEST_SUITE_REGISTRATION(DocumentTest); - -void DocumentTest::testSizeOf() +TEST(DocumentTest, testSizeOf) { - CPPUNIT_ASSERT_EQUAL(136ul, sizeof(Document)); - CPPUNIT_ASSERT_EQUAL(72ul, sizeof(StructFieldValue)); - CPPUNIT_ASSERT_EQUAL(24ul, sizeof(StructuredFieldValue)); - CPPUNIT_ASSERT_EQUAL(64ul, sizeof(SerializableArray)); + EXPECT_EQ(136ul, sizeof(Document)); + EXPECT_EQ(72ul, sizeof(StructFieldValue)); + EXPECT_EQ(24ul, sizeof(StructuredFieldValue)); + EXPECT_EQ(64ul, sizeof(SerializableArray)); } -void DocumentTest::testFieldPath() +TEST(DocumentTest, testFieldPath) { const vespalib::string testValues[] = { "{}", "", "", "{}r", "", "r", @@ -104,8 +53,8 @@ void DocumentTest::testFieldPath() for (size_t i(0); i < sizeof(testValues)/sizeof(testValues[0]); i+=3) { vespalib::stringref tmp = testValues[i]; vespalib::string key = FieldPathEntry::parseKey(tmp); - CPPUNIT_ASSERT_EQUAL(testValues[i+1], key); - CPPUNIT_ASSERT_EQUAL(testValues[i+2], vespalib::string(tmp)); + EXPECT_EQ(testValues[i+1], key); + EXPECT_EQ(testValues[i+2], vespalib::string(tmp)); } } @@ -133,7 +82,7 @@ Handler::Handler() = default; Handler::~Handler() = default; -void DocumentTest::testTraversing() +TEST(DocumentTest, testTraversing) { Field primitive1("primitive1", 1, *DataType::INT, true); Field primitive2("primitive2", 2, *DataType::INT, true); @@ -191,7 +140,7 @@ void DocumentTest::testTraversing() Handler fullTraverser; FieldPath empty; doc.iterateNested(empty.getFullRange(), fullTraverser); - CPPUNIT_ASSERT_EQUAL(fullTraverser.getResult(), + EXPECT_EQ(fullTraverser.getResult(), std::string("<0:P-0<0:P-0<0:P-0P-0[P-0P-1P-2][<0:P-0P-0><1:P-1P-1>]>>>")); } @@ -212,8 +161,7 @@ public: VariableIteratorHandler::VariableIteratorHandler() {} VariableIteratorHandler::~VariableIteratorHandler() {} -void -DocumentTest::testVariables() +TEST(DocumentTest, testVariables) { ArrayDataType iarr(*DataType::INT); ArrayDataType iiarr(static_cast(iarr)); @@ -274,7 +222,7 @@ DocumentTest::testVariables() "x: 2,y: 2,z: 1, - 18\n" "x: 2,y: 2,z: 2, - 27\n"; - CPPUNIT_ASSERT_EQUAL(fasit, handler.retVal); + EXPECT_EQ(fasit, handler.retVal); } } @@ -296,8 +244,7 @@ public: } }; -void -DocumentTest::testModifyDocument() +TEST(DocumentTest, testModifyDocument) { // Create test document type and content Field primitive1("primitive1", 1, *DataType::INT, true); @@ -405,7 +352,7 @@ DocumentTest::testModifyDocument() doc->print(std::cerr, true, ""); } -void DocumentTest::testSimpleUsage() +TEST(DocumentTest, testSimpleUsage) { DocumentType::SP type(new DocumentType("test")); Field intF("int", 1, *DataType::INT, true); @@ -420,33 +367,33 @@ void DocumentTest::testSimpleUsage() Document value(*repo.getDocumentType("test"), DocumentId("doc::testdoc")); // Initially empty - CPPUNIT_ASSERT_EQUAL(size_t(0), value.getSetFieldCount()); - CPPUNIT_ASSERT(!value.hasValue(intF)); + EXPECT_EQ(size_t(0), value.getSetFieldCount()); + EXPECT_TRUE(!value.hasValue(intF)); value.setValue(intF, IntFieldValue(1)); // Not empty - CPPUNIT_ASSERT_EQUAL(size_t(1), value.getSetFieldCount()); - CPPUNIT_ASSERT(value.hasValue(intF)); + EXPECT_EQ(size_t(1), value.getSetFieldCount()); + EXPECT_TRUE(value.hasValue(intF)); // Adding some more value.setValue(longF, LongFieldValue(2)); // Not empty - CPPUNIT_ASSERT_EQUAL(size_t(2), value.getSetFieldCount()); - CPPUNIT_ASSERT_EQUAL(1, value.getValue(intF)->getAsInt()); - CPPUNIT_ASSERT_EQUAL(2, value.getValue(longF)->getAsInt()); + EXPECT_EQ(size_t(2), value.getSetFieldCount()); + EXPECT_EQ(1, value.getValue(intF)->getAsInt()); + EXPECT_EQ(2, value.getValue(longF)->getAsInt()); // Serialize & equality std::unique_ptr buffer(value.serialize()); buffer->flip(); Document value2(*repo.getDocumentType("test"), DocumentId("userdoc::3:foo")); - CPPUNIT_ASSERT(value != value2); + EXPECT_TRUE(value != value2); value2.deserialize(repo, *buffer); - CPPUNIT_ASSERT(value2.hasValue(intF)); - CPPUNIT_ASSERT_EQUAL(value, value2); - CPPUNIT_ASSERT_EQUAL(DocumentId("doc::testdoc"), value2.getId()); + EXPECT_TRUE(value2.hasValue(intF)); + EXPECT_EQ(value, value2); + EXPECT_EQ(DocumentId("doc::testdoc"), value2.getId()); // Various ways of removing { @@ -454,29 +401,29 @@ void DocumentTest::testSimpleUsage() buffer->setPos(0); value2.deserialize(repo, *buffer); value2.remove(intF); - CPPUNIT_ASSERT(!value2.hasValue(intF)); - CPPUNIT_ASSERT_EQUAL(size_t(1), value2.getSetFieldCount()); + EXPECT_TRUE(!value2.hasValue(intF)); + EXPECT_EQ(size_t(1), value2.getSetFieldCount()); // Clearing all buffer->setPos(0); value2.deserialize(repo, *buffer); value2.clear(); - CPPUNIT_ASSERT(!value2.hasValue(intF)); - CPPUNIT_ASSERT_EQUAL(size_t(0), value2.getSetFieldCount()); + EXPECT_TRUE(!value2.hasValue(intF)); + EXPECT_EQ(size_t(0), value2.getSetFieldCount()); } // Updating value2 = value; - CPPUNIT_ASSERT_EQUAL(value, value2); + EXPECT_EQ(value, value2); value2.setValue(strF, StringFieldValue("foo")); - CPPUNIT_ASSERT(value2.hasValue(strF)); - CPPUNIT_ASSERT_EQUAL(vespalib::string("foo"), + EXPECT_TRUE(value2.hasValue(strF)); + EXPECT_EQ(vespalib::string("foo"), value2.getValue(strF)->getAsString()); - CPPUNIT_ASSERT(value != value2); + EXPECT_TRUE(value != value2); value2.assign(value); - CPPUNIT_ASSERT_EQUAL(value, value2); + EXPECT_EQ(value, value2); Document::UP valuePtr(value2.clone()); - CPPUNIT_ASSERT_EQUAL(value, *valuePtr); + EXPECT_EQ(value, *valuePtr); // Iterating const Document& constVal(value); @@ -488,20 +435,20 @@ void DocumentTest::testSimpleUsage() // Comparison value2 = value; - CPPUNIT_ASSERT_EQUAL(0, value.compare(value2)); + EXPECT_EQ(0, value.compare(value2)); value2.remove(intF); - CPPUNIT_ASSERT(value.compare(value2) < 0); - CPPUNIT_ASSERT(value2.compare(value) > 0); + EXPECT_TRUE(value.compare(value2) < 0); + EXPECT_TRUE(value2.compare(value) > 0); value2 = value; value2.setValue(intF, IntFieldValue(5)); - CPPUNIT_ASSERT(value.compare(value2) < 0); - CPPUNIT_ASSERT(value2.compare(value) > 0); + EXPECT_TRUE(value.compare(value2) < 0); + EXPECT_TRUE(value2.compare(value) > 0); // Output - CPPUNIT_ASSERT_EQUAL( + EXPECT_EQ( std::string("Document(doc::testdoc, DocumentType(test))"), value.toString(false)); - CPPUNIT_ASSERT_EQUAL( + EXPECT_EQ( std::string( " Document(doc::testdoc\n" " DocumentType(test, id -877171244)\n" @@ -516,7 +463,7 @@ void DocumentTest::testSimpleUsage() " long: 2\n" " )"), " " + value.toString(true, " ")); - CPPUNIT_ASSERT_EQUAL( + EXPECT_EQ( std::string( "\n" " 1\n" @@ -530,81 +477,81 @@ void DocumentTest::testSimpleUsage() // (Would be nice if this failed, but whole idea to fetch by field // objects is to improve performance.) Field anotherIntF("int", 17, *DataType::INT, true); - CPPUNIT_ASSERT(!value.hasValue(anotherIntF)); - CPPUNIT_ASSERT(value.getValue(anotherIntF).get() == 0); + EXPECT_TRUE(!value.hasValue(anotherIntF)); + EXPECT_TRUE(!value.getValue(anotherIntF)); // Refuse to accept non-document types try{ StructDataType otherType("foo", 4); Document value6(otherType, DocumentId("doc::")); - CPPUNIT_FAIL("Didn't complain about non-document type"); + FAIL() << "Didn't complain about non-document type"; } catch (std::exception& e) { - CPPUNIT_ASSERT_CONTAIN("Cannot generate a document with " - "non-document type", e.what()); + EXPECT_THAT(e.what(), HasSubstr("Cannot generate a document with " + "non-document type")); } // Refuse to set wrong types try{ value2.setValue(intF, StringFieldValue("bar")); - CPPUNIT_FAIL("Failed to check type equality in setValue"); + FAIL() << "Failed to check type equality in setValue"; } catch (std::exception& e) { - CPPUNIT_ASSERT_CONTAIN("Cannot assign value of type", e.what()); + EXPECT_THAT(e.what(), HasSubstr("Cannot assign value of type")); } } void verifyJavaDocument(Document& doc) { IntFieldValue intVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("intfield"), intVal)); - CPPUNIT_ASSERT_EQUAL(5, intVal.getAsInt()); + EXPECT_TRUE(doc.getValue(doc.getField("intfield"), intVal)); + EXPECT_EQ(5, intVal.getAsInt()); FloatFieldValue floatVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("floatfield"), floatVal)); - CPPUNIT_ASSERT(floatVal.getAsFloat() == (float) -9.23); + EXPECT_TRUE(doc.getValue(doc.getField("floatfield"), floatVal)); + EXPECT_TRUE(floatVal.getAsFloat() == (float) -9.23); StringFieldValue stringVal(""); - CPPUNIT_ASSERT(doc.getValue(doc.getField("stringfield"), stringVal)); - CPPUNIT_ASSERT_EQUAL(vespalib::string("This is a string."), + EXPECT_TRUE(doc.getValue(doc.getField("stringfield"), stringVal)); + EXPECT_EQ(vespalib::string("This is a string."), stringVal.getAsString()); LongFieldValue longVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("longfield"), longVal)); - CPPUNIT_ASSERT_EQUAL((int64_t)398420092938472983LL, longVal.getAsLong()); + EXPECT_TRUE(doc.getValue(doc.getField("longfield"), longVal)); + EXPECT_EQ((int64_t)398420092938472983LL, longVal.getAsLong()); DoubleFieldValue doubleVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("doublefield"), doubleVal)); - CPPUNIT_ASSERT_EQUAL(doubleVal.getAsDouble(), 98374532.398820); + EXPECT_TRUE(doc.getValue(doc.getField("doublefield"), doubleVal)); + EXPECT_EQ(doubleVal.getAsDouble(), 98374532.398820); ByteFieldValue byteVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("bytefield"), byteVal)); - CPPUNIT_ASSERT_EQUAL(-2, byteVal.getAsInt()); + EXPECT_TRUE(doc.getValue(doc.getField("bytefield"), byteVal)); + EXPECT_EQ(-2, byteVal.getAsInt()); RawFieldValue rawVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("rawfield"), rawVal)); - CPPUNIT_ASSERT(memcmp(rawVal.getAsRaw().first, "RAW DATA", 8) == 0); + EXPECT_TRUE(doc.getValue(doc.getField("rawfield"), rawVal)); + EXPECT_TRUE(memcmp(rawVal.getAsRaw().first, "RAW DATA", 8) == 0); Document embedDocVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("docfield"), embedDocVal)); + EXPECT_TRUE(doc.getValue(doc.getField("docfield"), embedDocVal)); ArrayFieldValue array(doc.getField("arrayoffloatfield").getDataType()); - CPPUNIT_ASSERT(doc.getValue(doc.getField("arrayoffloatfield"), array)); - CPPUNIT_ASSERT_EQUAL((float)1.0, array[0].getAsFloat()); - CPPUNIT_ASSERT_EQUAL((float)2.0, array[1].getAsFloat()); + EXPECT_TRUE(doc.getValue(doc.getField("arrayoffloatfield"), array)); + EXPECT_EQ((float)1.0, array[0].getAsFloat()); + EXPECT_EQ((float)2.0, array[1].getAsFloat()); WeightedSetFieldValue wset(doc.getField("wsfield").getDataType()); - CPPUNIT_ASSERT(doc.getValue(doc.getField("wsfield"), wset)); - CPPUNIT_ASSERT_EQUAL(50, wset.get(StringFieldValue("Weighted 0"))); - CPPUNIT_ASSERT_EQUAL(199, wset.get(StringFieldValue("Weighted 1"))); + EXPECT_TRUE(doc.getValue(doc.getField("wsfield"), wset)); + EXPECT_EQ(50, wset.get(StringFieldValue("Weighted 0"))); + EXPECT_EQ(199, wset.get(StringFieldValue("Weighted 1"))); MapFieldValue map(doc.getField("mapfield").getDataType()); - CPPUNIT_ASSERT(doc.getValue(doc.getField("mapfield"), map)); - CPPUNIT_ASSERT(map.get(StringFieldValue("foo1")).get()); - CPPUNIT_ASSERT(map.get(StringFieldValue("foo2")).get()); - CPPUNIT_ASSERT_EQUAL(StringFieldValue("bar1"), dynamic_cast(*map.get(StringFieldValue("foo1")))); - CPPUNIT_ASSERT_EQUAL(StringFieldValue("bar2"), dynamic_cast(*map.get(StringFieldValue("foo2")))); + EXPECT_TRUE(doc.getValue(doc.getField("mapfield"), map)); + EXPECT_TRUE(map.get(StringFieldValue("foo1")).get()); + EXPECT_TRUE(map.get(StringFieldValue("foo2")).get()); + EXPECT_EQ(StringFieldValue("bar1"), dynamic_cast(*map.get(StringFieldValue("foo1")))); + EXPECT_EQ(StringFieldValue("bar2"), dynamic_cast(*map.get(StringFieldValue("foo2")))); } -void DocumentTest::testReadSerializedFile() +TEST(DocumentTest, testReadSerializedFile) { // Reads a file serialized from java const std::string file_name = TEST_PATH("data/crossplatform-java-cpp-doctypes.cfg"); @@ -629,16 +576,16 @@ void DocumentTest::testReadSerializedFile() Document doc2(repo, *buf2); verifyJavaDocument(doc2); - CPPUNIT_ASSERT_EQUAL(len, buf2->getPos()); - CPPUNIT_ASSERT(memcmp(buf2->getBuffer(), buf.getBuffer(), buf2->getPos()) == 0); + EXPECT_EQ(len, buf2->getPos()); + EXPECT_TRUE(memcmp(buf2->getBuffer(), buf.getBuffer(), buf2->getPos()) == 0); doc2.setValue("stringfield", StringFieldValue("hei")); std::unique_ptr buf3 = doc2.serialize(); - CPPUNIT_ASSERT(len != buf3->getPos()); + EXPECT_TRUE(len != buf3->getPos()); } -void DocumentTest::testReadSerializedFileCompressed() +TEST(DocumentTest, testReadSerializedFileCompressed) { // Reads a file serialized from java const std::string file_name = TEST_PATH("data/crossplatform-java-cpp-doctypes.cfg"); @@ -698,7 +645,7 @@ namespace { * When adding new fields to the documents, use the version tagged with each * file to ignore these field for old types. */ -void DocumentTest::testReadSerializedAllVersions() +TEST(DocumentTest,testReadSerializedAllVersions) { const int array_id = 1650586661; const int wset_id = 1328286588; @@ -760,12 +707,12 @@ void DocumentTest::testReadSerializedAllVersions() { //doc.setCompression(CompressionConfig(CompressionConfig::NONE, 0, 0)); std::unique_ptr buf = doc.serialize(); - CPPUNIT_ASSERT_EQUAL(buf->getLength(), buf->getPos()); + EXPECT_EQ(buf->getLength(), buf->getPos()); int fd = open(TEST_PATH("data/document-cpp-currentversion-uncompressed.dat").c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644); - CPPUNIT_ASSERT(fd > 0); + EXPECT_TRUE(fd > 0); size_t len = write(fd, buf->getBuffer(), buf->getPos()); - CPPUNIT_ASSERT_EQUAL(buf->getPos(), len); + EXPECT_EQ(buf->getPos(), len); close(fd); } { @@ -773,12 +720,12 @@ void DocumentTest::testReadSerializedAllVersions() CompressionConfig newCfg(CompressionConfig::LZ4, 9, 95); const_cast(doc.getType().getFieldsType()).setCompressionConfig(newCfg); std::unique_ptr buf = doc.serialize(); - CPPUNIT_ASSERT(buf->getPos() <= buf->getLength()); + EXPECT_TRUE(buf->getPos() <= buf->getLength()); int fd = open(TEST_PATH("data/document-cpp-currentversion-lz4-9.dat").c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644); - CPPUNIT_ASSERT(fd > 0); + EXPECT_TRUE(fd > 0); size_t len = write(fd, buf->getBuffer(), buf->getPos()); - CPPUNIT_ASSERT_EQUAL(buf->getPos(), len); + EXPECT_EQ(buf->getPos(), len); close(fd); const_cast(doc.getType().getFieldsType()).setCompressionConfig(oldCfg); } @@ -795,7 +742,7 @@ void DocumentTest::testReadSerializedAllVersions() std::string name = tests[i]._dataFile; std::cerr << name << std::endl; if (!vespalib::fileExists(name)) { - CPPUNIT_FAIL("File " + name + " does not exist."); + FAIL() << "File " << name << " does not exist."; } int fd = open(tests[i]._dataFile.c_str(), O_RDONLY); int len = lseek(fd,0,SEEK_END); @@ -809,54 +756,54 @@ void DocumentTest::testReadSerializedAllVersions() Document doc(repo, buf); IntFieldValue intVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("intfield"), intVal)); - CPPUNIT_ASSERT_EQUAL(5, intVal.getAsInt()); + EXPECT_TRUE(doc.getValue(doc.getField("intfield"), intVal)); + EXPECT_EQ(5, intVal.getAsInt()); FloatFieldValue floatVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("floatfield"), floatVal)); - CPPUNIT_ASSERT(floatVal.getAsFloat() == (float) -9.23); + EXPECT_TRUE(doc.getValue(doc.getField("floatfield"), floatVal)); + EXPECT_TRUE(floatVal.getAsFloat() == (float) -9.23); StringFieldValue stringVal(""); - CPPUNIT_ASSERT(doc.getValue(doc.getField("stringfield"), stringVal)); - CPPUNIT_ASSERT_EQUAL(vespalib::string("This is a string."), + EXPECT_TRUE(doc.getValue(doc.getField("stringfield"), stringVal)); + EXPECT_EQ(vespalib::string("This is a string."), stringVal.getAsString()); LongFieldValue longVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("longfield"), longVal)); - CPPUNIT_ASSERT_EQUAL(static_cast(398420092938472983LL), + EXPECT_TRUE(doc.getValue(doc.getField("longfield"), longVal)); + EXPECT_EQ(static_cast(398420092938472983LL), longVal.getAsLong()); DoubleFieldValue doubleVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("doublefield"), doubleVal)); - CPPUNIT_ASSERT_EQUAL(doubleVal.getAsDouble(), 98374532.398820); + EXPECT_TRUE(doc.getValue(doc.getField("doublefield"), doubleVal)); + EXPECT_EQ(doubleVal.getAsDouble(), 98374532.398820); ByteFieldValue byteVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("bytefield"), byteVal)); - CPPUNIT_ASSERT_EQUAL(-2, byteVal.getAsInt()); + EXPECT_TRUE(doc.getValue(doc.getField("bytefield"), byteVal)); + EXPECT_EQ(-2, byteVal.getAsInt()); RawFieldValue rawVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("rawfield"), rawVal)); - CPPUNIT_ASSERT(memcmp(rawVal.getAsRaw().first, "RAW DATA", 8) == 0); + EXPECT_TRUE(doc.getValue(doc.getField("rawfield"), rawVal)); + EXPECT_TRUE(memcmp(rawVal.getAsRaw().first, "RAW DATA", 8) == 0); if (version > 6) { Document docInDoc; - CPPUNIT_ASSERT(doc.getValue(doc.getField("docfield"), docInDoc)); + EXPECT_TRUE(doc.getValue(doc.getField("docfield"), docInDoc)); - CPPUNIT_ASSERT(docInDoc.getValue( + EXPECT_TRUE(docInDoc.getValue( docInDoc.getField("stringindocfield"), stringVal)); - CPPUNIT_ASSERT_EQUAL(vespalib::string("Elvis is dead"), + EXPECT_EQ(vespalib::string("Elvis is dead"), stringVal.getAsString()); } ArrayFieldValue array(doc.getField("arrayoffloatfield").getDataType()); - CPPUNIT_ASSERT(doc.getValue(doc.getField("arrayoffloatfield"), array)); - CPPUNIT_ASSERT_EQUAL((float)1.0, array[0].getAsFloat()); - CPPUNIT_ASSERT_EQUAL((float)2.0, array[1].getAsFloat()); + EXPECT_TRUE(doc.getValue(doc.getField("arrayoffloatfield"), array)); + EXPECT_EQ((float)1.0, array[0].getAsFloat()); + EXPECT_EQ((float)2.0, array[1].getAsFloat()); WeightedSetFieldValue wset(doc.getField("wsfield").getDataType()); - CPPUNIT_ASSERT(doc.getValue(doc.getField("wsfield"), wset)); - CPPUNIT_ASSERT_EQUAL(50, wset.get(StringFieldValue("Weighted 0"))); - CPPUNIT_ASSERT_EQUAL(199, wset.get(StringFieldValue("Weighted 1"))); + EXPECT_TRUE(doc.getValue(doc.getField("wsfield"), wset)); + EXPECT_EQ(50, wset.get(StringFieldValue("Weighted 0"))); + EXPECT_EQ(199, wset.get(StringFieldValue("Weighted 1"))); // Check that serialization doesn't cause any problems. std::unique_ptr buf2 = doc.serialize(); @@ -882,7 +829,7 @@ size_t getSerializedSizeBody(const Document &doc) { return stream.size(); } -void DocumentTest::testGenerateSerializedFile() +TEST(DocumentTest, testGenerateSerializedFile) { const std::string file_name = TEST_PATH("data/crossplatform-java-cpp-doctypes.cfg"); DocumentTypeRepo repo(readDocumenttypesConfig(file_name)); @@ -900,7 +847,7 @@ void DocumentTest::testGenerateSerializedFile() doc.set("rawfield", "RAW DATA"); const DocumentType *docindoc_type = repo.getDocumentType("docindoc"); - CPPUNIT_ASSERT(docindoc_type); + EXPECT_TRUE(docindoc_type); Document embedDoc(*docindoc_type, DocumentId(DocIdString("docindoc", "http://embedded"))); @@ -964,7 +911,8 @@ void DocumentTest::testGenerateSerializedFile() } close(fd); } -void DocumentTest::testGetURIFromSerialized() + +TEST(DocumentTest, testGetURIFromSerialized) { TestDocRepo test_repo; Document doc(*test_repo.getDocumentType("testdoctype1"), @@ -974,11 +922,11 @@ void DocumentTest::testGetURIFromSerialized() std::unique_ptr serialized = doc.serialize(); serialized->flip(); - CPPUNIT_ASSERT_EQUAL( + EXPECT_EQ( vespalib::string(DocIdString("ns", "testdoc").toString()), Document::getIdFromSerialized(*serialized).toString()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("testdoctype1"), + EXPECT_EQ(vespalib::string("testdoctype1"), Document::getDocTypeFromSerialized( test_repo.getTypeRepo(), *serialized)->getName()); @@ -989,34 +937,34 @@ void DocumentTest::testGetURIFromSerialized() serialized->flip(); Document doc2(test_repo.getTypeRepo(), *serialized, false, NULL); - CPPUNIT_ASSERT_EQUAL( + EXPECT_EQ( vespalib::string(DocIdString("ns", "testdoc").toString()), doc2.getId().toString()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("testdoctype1"), doc2.getType().getName()); + EXPECT_EQ(vespalib::string("testdoctype1"), doc2.getType().getName()); } -}; +} -void DocumentTest::testBogusserialize() +TEST(DocumentTest, testBogusserialize) { TestDocRepo test_repo; try { std::unique_ptr buf( new ByteBuffer("aoifjweprjwoejr203r+2+4r823++!",100)); Document doc(test_repo.getTypeRepo(), *buf); - CPPUNIT_ASSERT(false); + FAIL() << "Failed to throw exception deserializing bogus data"; } catch (DeserializeException& e) { - CPPUNIT_ASSERT_CONTAIN("Unrecognized serialization version", e.what()); + EXPECT_THAT(e.what(), HasSubstr("Unrecognized serialization version")); } try { std::unique_ptr buf(new ByteBuffer("",0)); Document doc(test_repo.getTypeRepo(), *buf); - CPPUNIT_ASSERT(false); + FAIL() << "Failed to throw exception deserializing empty buffer"; } catch (DeserializeException& e) { - CPPUNIT_ASSERT_CONTAIN("Buffer out of bounds", e.what()); + EXPECT_THAT(e.what(), HasSubstr("Buffer out of bounds")); } } -void DocumentTest::testCRC32() +TEST(DocumentTest, testCRC32) { TestDocRepo test_repo; Document doc(*test_repo.getDocumentType("testdoctype1"), @@ -1026,7 +974,7 @@ void DocumentTest::testCRC32() StringFieldValue("bla bla bla bla bla")); uint32_t crc = doc.calculateChecksum(); - CPPUNIT_ASSERT_EQUAL(277496115u, crc); + EXPECT_EQ(277496115u, crc); std::unique_ptr buf = doc.serialize(); buf->flip(); @@ -1040,9 +988,9 @@ void DocumentTest::testCRC32() try { Document doc2(test_repo.getTypeRepo(), *buf); buf->setPos(0); - CPPUNIT_ASSERT(crc != doc2.calculateChecksum()); + EXPECT_TRUE(crc != doc2.calculateChecksum()); } catch (document::DeserializeException& e) { - CPPUNIT_ASSERT(false); + EXPECT_TRUE(false); } // Return original value and retry buf->getBuffer()[pos] ^= 72; @@ -1050,19 +998,18 @@ void DocumentTest::testCRC32() /// \todo TODO (was warning): Cannot test for in memory representation altered, as there is no syntax for getting internal refs to data from document. Add test when this is added. } -void -DocumentTest::testHasChanged() +TEST(DocumentTest, testHasChanged) { TestDocRepo test_repo; Document doc(*test_repo.getDocumentType("testdoctype1"), DocumentId(DocIdString("crawler", "http://www.ntnu.no/"))); // Before deserialization we are changed. - CPPUNIT_ASSERT(doc.hasChanged()); + EXPECT_TRUE(doc.hasChanged()); doc.setValue(doc.getField("hstringval"), StringFieldValue("bla bla bla bla bla")); // Still changed after setting a value of course. - CPPUNIT_ASSERT(doc.hasChanged()); + EXPECT_TRUE(doc.hasChanged()); std::unique_ptr buf = doc.serialize(); buf->flip(); @@ -1071,10 +1018,10 @@ DocumentTest::testHasChanged() { buf->setPos(0); Document doc2(test_repo.getTypeRepo(), *buf); - CPPUNIT_ASSERT(!doc2.hasChanged()); + EXPECT_TRUE(!doc2.hasChanged()); doc2.set("headerval", 13); - CPPUNIT_ASSERT(doc2.hasChanged()); + EXPECT_TRUE(doc2.hasChanged()); } // Overwriting a value in doc tags us changed. { @@ -1082,7 +1029,7 @@ DocumentTest::testHasChanged() Document doc2(test_repo.getTypeRepo(), *buf); doc2.set("hstringval", "bla bla bla bla bla"); - CPPUNIT_ASSERT(doc2.hasChanged()); + EXPECT_TRUE(doc2.hasChanged()); } // Clearing value tags us changed. { @@ -1090,13 +1037,12 @@ DocumentTest::testHasChanged() Document doc2(test_repo.getTypeRepo(), *buf); doc2.clear(); - CPPUNIT_ASSERT(doc2.hasChanged()); + EXPECT_TRUE(doc2.hasChanged()); } // Add more tests here when we allow non-const refs to internals } -void -DocumentTest::testSplitSerialization() +TEST(DocumentTest, testSplitSerialization) { TestDocMan testDocMan; Document::UP doc = testDocMan.createDocument(); @@ -1110,22 +1056,22 @@ DocumentTest::testSplitSerialization() doc->serializeBody(buf2); buf2.flip(); - CPPUNIT_ASSERT_EQUAL(size_t(65), buf.getLength()); - CPPUNIT_ASSERT_EQUAL(size_t(73), buf2.getLength()); + EXPECT_EQ(size_t(65), buf.getLength()); + EXPECT_EQ(size_t(73), buf2.getLength()); Document headerDoc(testDocMan.getTypeRepo(), buf); - CPPUNIT_ASSERT(headerDoc.hasValue("headerval")); - CPPUNIT_ASSERT(!headerDoc.hasValue("content")); + EXPECT_TRUE(headerDoc.hasValue("headerval")); + EXPECT_TRUE(!headerDoc.hasValue("content")); buf.setPos(0); Document fullDoc(testDocMan.getTypeRepo(), buf, buf2); - CPPUNIT_ASSERT(fullDoc.hasValue("headerval")); - CPPUNIT_ASSERT(fullDoc.hasValue("content")); + EXPECT_TRUE(fullDoc.hasValue("headerval")); + EXPECT_TRUE(fullDoc.hasValue("content")); - CPPUNIT_ASSERT_EQUAL(*doc, fullDoc); + EXPECT_EQ(*doc, fullDoc); } -void DocumentTest::testSliceSerialize() +TEST(DocumentTest, testSliceSerialize) { // Test that document doesn't need its own bytebuffer, such that we // can serialize multiple documents after each other in the same @@ -1143,23 +1089,23 @@ void DocumentTest::testSliceSerialize() ByteBuffer buf(getSerializedSize(*doc) + getSerializedSize(*doc2)); doc->serialize(buf); - CPPUNIT_ASSERT_EQUAL(getSerializedSize(*doc), buf.getPos()); + EXPECT_EQ(getSerializedSize(*doc), buf.getPos()); doc2->serialize(buf); - CPPUNIT_ASSERT_EQUAL(getSerializedSize(*doc) + getSerializedSize(*doc2), + EXPECT_EQ(getSerializedSize(*doc) + getSerializedSize(*doc2), buf.getPos()); buf.flip(); Document doc3(testDocMan.getTypeRepo(), buf); - CPPUNIT_ASSERT_EQUAL(getSerializedSize(*doc), buf.getPos()); + EXPECT_EQ(getSerializedSize(*doc), buf.getPos()); Document doc4(testDocMan.getTypeRepo(), buf); - CPPUNIT_ASSERT_EQUAL(getSerializedSize(*doc) + getSerializedSize(*doc2), + EXPECT_EQ(getSerializedSize(*doc) + getSerializedSize(*doc2), buf.getPos()); - CPPUNIT_ASSERT_EQUAL(*doc, doc3); - CPPUNIT_ASSERT_EQUAL(*doc2, doc4); + EXPECT_EQ(*doc, doc3); + EXPECT_EQ(*doc2, doc4); } -void DocumentTest::testCompression() +TEST(DocumentTest, testCompression) { TestDocMan testDocMan; Document::UP doc = testDocMan.createDocument(); @@ -1181,14 +1127,14 @@ void DocumentTest::testCompression() const_cast(doc->getType().getFieldsType()).setCompressionConfig(oldCfg); - CPPUNIT_ASSERT(buf_lz4->getRemaining() < buf_uncompressed->getRemaining()); + EXPECT_TRUE(buf_lz4->getRemaining() < buf_uncompressed->getRemaining()); Document doc_lz4(testDocMan.getTypeRepo(), *buf_lz4); - CPPUNIT_ASSERT_EQUAL(*doc, doc_lz4); + EXPECT_EQ(*doc, doc_lz4); } -void DocumentTest::testCompressionConfigured() +TEST(DocumentTest, testCompressionConfigured) { DocumenttypesConfigBuilderHelper builder; builder.document(43, "serializetest", @@ -1225,23 +1171,22 @@ void DocumentTest::testCompressionConfigured() buf_compressed->flip(); size_t compressedSize = buf_compressed->getRemaining(); - CPPUNIT_ASSERT(compressedSize < uncompressedSize); + EXPECT_TRUE(compressedSize < uncompressedSize); Document doc2(repo2, *buf_compressed); std::unique_ptr buf_compressed2 = doc2.serialize(); buf_compressed2->flip(); - CPPUNIT_ASSERT_EQUAL(compressedSize, buf_compressed2->getRemaining()); + EXPECT_EQ(compressedSize, buf_compressed2->getRemaining()); Document doc3(repo2, *buf_compressed2); - CPPUNIT_ASSERT_EQUAL(doc2, doc_uncompressed); - CPPUNIT_ASSERT_EQUAL(doc2, doc3); + EXPECT_EQ(doc2, doc_uncompressed); + EXPECT_EQ(doc2, doc3); } -void -DocumentTest::testUnknownEntries() +TEST(DocumentTest, testUnknownEntries) { // We should be able to deserialize a document with unknown values in it. DocumentType type1("test", 0); @@ -1289,40 +1234,40 @@ DocumentTest::testUnknownEntries() doc3.deserializeHeader(repo, header); doc3.deserializeBody(repo, body); - CPPUNIT_ASSERT_EQUAL(std::string( + EXPECT_EQ(std::string( "\n" "3\n" "4\n" ""), doc2.toXml()); - CPPUNIT_ASSERT_EQUAL(std::string( + EXPECT_EQ(std::string( "\n" "3\n" "4\n" ""), doc3.toXml()); - CPPUNIT_ASSERT_EQUAL(3, doc2.getValue(field3)->getAsInt()); - CPPUNIT_ASSERT_EQUAL(4, doc2.getValue(field4)->getAsInt()); - CPPUNIT_ASSERT_EQUAL(3, doc3.getValue(field3)->getAsInt()); - CPPUNIT_ASSERT_EQUAL(4, doc3.getValue(field4)->getAsInt()); + EXPECT_EQ(3, doc2.getValue(field3)->getAsInt()); + EXPECT_EQ(4, doc2.getValue(field4)->getAsInt()); + EXPECT_EQ(3, doc3.getValue(field3)->getAsInt()); + EXPECT_EQ(4, doc3.getValue(field4)->getAsInt()); // The fields are actually accessible as long as you ask with field of // correct type. - CPPUNIT_ASSERT(doc2.hasValue(field1)); - CPPUNIT_ASSERT(doc2.hasValue(field2)); - CPPUNIT_ASSERT(doc3.hasValue(field1)); - CPPUNIT_ASSERT(doc3.hasValue(field2)); + EXPECT_TRUE(doc2.hasValue(field1)); + EXPECT_TRUE(doc2.hasValue(field2)); + EXPECT_TRUE(doc3.hasValue(field1)); + EXPECT_TRUE(doc3.hasValue(field2)); - CPPUNIT_ASSERT_EQUAL(1, doc2.getValue(field1)->getAsInt()); - CPPUNIT_ASSERT_EQUAL(2, doc2.getValue(field2)->getAsInt()); - CPPUNIT_ASSERT_EQUAL(1, doc3.getValue(field1)->getAsInt()); - CPPUNIT_ASSERT_EQUAL(2, doc3.getValue(field2)->getAsInt()); + EXPECT_EQ(1, doc2.getValue(field1)->getAsInt()); + EXPECT_EQ(2, doc2.getValue(field2)->getAsInt()); + EXPECT_EQ(1, doc3.getValue(field1)->getAsInt()); + EXPECT_EQ(2, doc3.getValue(field2)->getAsInt()); - CPPUNIT_ASSERT_EQUAL(size_t(2), doc2.getSetFieldCount()); - CPPUNIT_ASSERT_EQUAL(size_t(2), doc3.getSetFieldCount()); + EXPECT_EQ(size_t(2), doc2.getSetFieldCount()); + EXPECT_EQ(size_t(2), doc3.getSetFieldCount()); } -void DocumentTest::testAnnotationDeserialization() +TEST(DocumentTest, testAnnotationDeserialization) { DocumenttypesConfigBuilderHelper builder; builder.document(-1326249427, "dokk", Struct("dokk.header"), @@ -1358,7 +1303,7 @@ void DocumentTest::testAnnotationDeserialization() Document doc(repo, buf); StringFieldValue strVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("story"), strVal)); + EXPECT_TRUE(doc.getValue(doc.getField("story"), strVal)); vespalib::nbostream stream; VespaDocumentSerializer serializer(stream); @@ -1368,49 +1313,47 @@ void DocumentTest::testAnnotationDeserialization() VespaDocumentDeserializer deserializer(fixedRepo, stream, 8); StringFieldValue strVal2; deserializer.read(strVal2); - CPPUNIT_ASSERT_EQUAL(strVal.toString(), strVal2.toString()); - CPPUNIT_ASSERT_EQUAL(strVal.toString(true), strVal2.toString(true)); + EXPECT_EQ(strVal.toString(), strVal2.toString()); + EXPECT_EQ(strVal.toString(true), strVal2.toString(true)); - CPPUNIT_ASSERT_EQUAL(vespalib::string("help me help me i'm stuck inside a computer!"), + EXPECT_EQ(vespalib::string("help me help me i'm stuck inside a computer!"), strVal.getAsString()); StringFieldValue::SpanTrees trees = strVal.getSpanTrees(); const SpanTree *span_tree = StringFieldValue::findTree(trees, "fruits"); - CPPUNIT_ASSERT(span_tree); - CPPUNIT_ASSERT_EQUAL(size_t(8), span_tree->numAnnotations()); + EXPECT_TRUE(span_tree); + EXPECT_EQ(size_t(8), span_tree->numAnnotations()); span_tree = StringFieldValue::findTree(trees, "ballooo"); - CPPUNIT_ASSERT(span_tree); - CPPUNIT_ASSERT_EQUAL(size_t(8), span_tree->numAnnotations()); + EXPECT_TRUE(span_tree); + EXPECT_EQ(size_t(8), span_tree->numAnnotations()); ByteFieldValue byteVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("age"), byteVal)); - CPPUNIT_ASSERT_EQUAL( 123, byteVal.getAsInt()); + EXPECT_TRUE(doc.getValue(doc.getField("age"), byteVal)); + EXPECT_EQ( 123, byteVal.getAsInt()); IntFieldValue intVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("date"), intVal)); - CPPUNIT_ASSERT_EQUAL(13829297, intVal.getAsInt()); + EXPECT_TRUE(doc.getValue(doc.getField("date"), intVal)); + EXPECT_EQ(13829297, intVal.getAsInt()); LongFieldValue longVal; - CPPUNIT_ASSERT(doc.getValue(doc.getField("friend"), longVal)); - CPPUNIT_ASSERT_EQUAL((int64_t)2384LL, longVal.getAsLong()); + EXPECT_TRUE(doc.getValue(doc.getField("friend"), longVal)); + EXPECT_EQ((int64_t)2384LL, longVal.getAsLong()); } -void -DocumentTest::testGetSerializedSize() +TEST(DocumentTest, testGetSerializedSize) { TestDocMan testDocMan; Document::UP doc = testDocMan.createDocument(); - CPPUNIT_ASSERT_EQUAL(getSerializedSize(*doc), doc->getSerializedSize()); + EXPECT_EQ(getSerializedSize(*doc), doc->getSerializedSize()); } -void -DocumentTest::testDeserializeMultiple() +TEST(DocumentTest, testDeserializeMultiple) { TestDocRepo testDocRepo; const DocumentTypeRepo& repo(testDocRepo.getTypeRepo()); const DocumentType* docTypePtr(repo.getDocumentType("testdoctype1")); - CPPUNIT_ASSERT(docTypePtr != 0); + EXPECT_TRUE(docTypePtr != nullptr); const DocumentType & docType = *docTypePtr; StructFieldValue sv1(docType.getField("mystruct").getDataType()); @@ -1435,7 +1378,7 @@ DocumentTest::testDeserializeMultiple() correct.setValue(correct.getField("key"), IntFieldValue(1234)); correct.setValue(correct.getField("value"), StringFieldValue("badger")); - CPPUNIT_ASSERT_EQUAL(correct, sv3); + EXPECT_EQ(correct, sv3); } -} // document +} diff --git a/document/src/tests/documenttypetestcase.cpp b/document/src/tests/documenttypetestcase.cpp index d6707bc610a..649367d76f3 100644 --- a/document/src/tests/documenttypetestcase.cpp +++ b/document/src/tests/documenttypetestcase.cpp @@ -4,70 +4,40 @@ #include #include #include -#include #include #include +#include +#include using document::config_builder::Struct; using document::config_builder::Wset; using document::config_builder::Array; using document::config_builder::Map; +using namespace ::testing; namespace document { -struct DocumentTypeTest : public CppUnit::TestFixture { - void setUp() override; - void tearDown() override; - - void testSetGet(); - void testHeaderContent(); - void testFieldSetCanContainFieldsNotInDocType(); - void testInheritance(); - void testInheritanceConfig(); - void testMultipleInheritance(); - void testOutputOperator(); - - CPPUNIT_TEST_SUITE( DocumentTypeTest); - CPPUNIT_TEST(testSetGet); - CPPUNIT_TEST(testFieldSetCanContainFieldsNotInDocType); - CPPUNIT_TEST(testInheritance); - CPPUNIT_TEST(testInheritanceConfig); - CPPUNIT_TEST(testMultipleInheritance); - CPPUNIT_TEST(testOutputOperator); - CPPUNIT_TEST(testHeaderContent); - CPPUNIT_TEST_SUITE_END(); -}; - -CPPUNIT_TEST_SUITE_REGISTRATION(DocumentTypeTest); - -void DocumentTypeTest::setUp() +TEST(DocumentTypeTest, testSetGet) { -} - -void DocumentTypeTest::tearDown() -{ -} - -void DocumentTypeTest::testSetGet() { DocumentType docType("doctypetestdoc", 0); docType.addField(Field("stringattr", 3, *DataType::STRING, true)); docType.addField(Field("nalle", 0, *DataType::INT, false)); - const Field& fetch1=docType.getField("stringattr"); - const Field& fetch2=docType.getField("stringattr"); + const Field& fetch1 = docType.getField("stringattr"); + const Field& fetch2 = docType.getField("stringattr"); - CPPUNIT_ASSERT(fetch1==fetch2); - CPPUNIT_ASSERT(fetch1.getName() == "stringattr"); + EXPECT_TRUE(fetch1 == fetch2); + EXPECT_TRUE(fetch1.getName() == "stringattr"); const Field& fetch3 = docType.getField(3); - CPPUNIT_ASSERT(fetch1==fetch3); + EXPECT_TRUE(fetch1 == fetch3); - const Field& fetch4=docType.getField(0); + const Field& fetch4 = docType.getField(0); - CPPUNIT_ASSERT(fetch4!=fetch1); + EXPECT_TRUE(fetch4 != fetch1); } void @@ -86,24 +56,22 @@ categorizeFields(const Field::Set& fields, } } -void -DocumentTypeTest::testInheritanceConfig() +TEST(DocumentTypeTest, testInheritanceConfig) { DocumentTypeRepo repo(readDocumenttypesConfig(TEST_PATH("data/inheritancetest.cfg"))); { const DocumentType* type(repo.getDocumentType("music")); - CPPUNIT_ASSERT(type != NULL); + EXPECT_TRUE(type != NULL); } { const DocumentType* type(repo.getDocumentType("books")); - CPPUNIT_ASSERT(type != NULL); + EXPECT_TRUE(type != NULL); } } -void -DocumentTypeTest::testHeaderContent() +TEST(DocumentTypeTest, testHeaderContent) { DocumentTypeRepo repo(readDocumenttypesConfig(TEST_PATH("data/doctypesconfigtest.cfg"))); @@ -116,18 +84,18 @@ DocumentTypeTest::testHeaderContent() std::vector bodies; categorizeFields(fields, headers, bodies); - CPPUNIT_ASSERT(headers.size() == 4); - CPPUNIT_ASSERT(headers[0]->getName() == "field1"); - CPPUNIT_ASSERT(headers[1]->getName() == "field2"); - CPPUNIT_ASSERT(headers[2]->getName() == "field4"); - CPPUNIT_ASSERT(headers[3]->getName() == "fieldarray1"); + EXPECT_TRUE(headers.size() == 4); + EXPECT_TRUE(headers[0]->getName() == "field1"); + EXPECT_TRUE(headers[1]->getName() == "field2"); + EXPECT_TRUE(headers[2]->getName() == "field4"); + EXPECT_TRUE(headers[3]->getName() == "fieldarray1"); - CPPUNIT_ASSERT(bodies.size() == 2); - CPPUNIT_ASSERT(bodies[0]->getName() == "field3"); - CPPUNIT_ASSERT(bodies[1]->getName() == "field5"); + EXPECT_TRUE(bodies.size() == 2); + EXPECT_TRUE(bodies[0]->getName() == "field3"); + EXPECT_TRUE(bodies[1]->getName() == "field5"); } -void DocumentTypeTest::testMultipleInheritance() +TEST(DocumentTypeTest, testMultipleInheritance) { config_builder::DocumenttypesConfigBuilderHelper builder; builder.document(42, "test1", Struct("test1.header"), @@ -145,10 +113,10 @@ void DocumentTypeTest::testMultipleInheritance() DocumentTypeRepo repo(builder.config()); const DocumentType* docType3(repo.getDocumentType("test3")); - CPPUNIT_ASSERT(docType3->hasField("stringattr")); - CPPUNIT_ASSERT(docType3->hasField("nalle")); - CPPUNIT_ASSERT(docType3->hasField("tmp")); - CPPUNIT_ASSERT(docType3->hasField("tall")); + EXPECT_TRUE(docType3->hasField("stringattr")); + EXPECT_TRUE(docType3->hasField("nalle")); + EXPECT_TRUE(docType3->hasField("tmp")); + EXPECT_TRUE(docType3->hasField("tall")); Document doc(*docType3, DocumentId(DocIdString("test", "test"))); @@ -158,9 +126,9 @@ void DocumentTypeTest::testMultipleInheritance() StringFieldValue stringVal("tmp"); doc.setValue(doc.getField("tmp"), stringVal); - CPPUNIT_ASSERT(doc.getValue(doc.getField("nalle"))->getAsInt()==3); - CPPUNIT_ASSERT_EQUAL(vespalib::string("tmp"), - doc.getValue(doc.getField("tmp"))->getAsString()); + EXPECT_TRUE(doc.getValue(doc.getField("nalle"))->getAsInt()==3); + EXPECT_EQ(vespalib::string("tmp"), + doc.getValue(doc.getField("tmp"))->getAsString()); } namespace { @@ -171,7 +139,8 @@ bool containsField(const DocumentType::FieldSet &fieldSet, const vespalib::strin } -void DocumentTypeTest::testFieldSetCanContainFieldsNotInDocType() { +TEST(DocumentTypeTest, testFieldSetCanContainFieldsNotInDocType) +{ DocumentType docType("test1"); docType.addField(Field("stringattr", 3, *DataType::STRING, false)); docType.addField(Field("nalle", 0, *DataType::INT, false)); @@ -182,12 +151,12 @@ void DocumentTypeTest::testFieldSetCanContainFieldsNotInDocType() { docType.addFieldSet("a", tmp); } auto fieldSet = docType.getFieldSet("a"); - CPPUNIT_ASSERT_EQUAL((size_t)2, fieldSet->getFields().size()); - CPPUNIT_ASSERT(containsField(*fieldSet, "nalle")); - CPPUNIT_ASSERT(containsField(*fieldSet, "nulle")); + EXPECT_EQ((size_t)2, fieldSet->getFields().size()); + EXPECT_TRUE(containsField(*fieldSet, "nalle")); + EXPECT_TRUE(containsField(*fieldSet, "nulle")); } -void DocumentTypeTest::testInheritance() +TEST(DocumentTypeTest, testInheritance) { // Inheritance of conflicting but equal datatype ok DocumentType docType("test1"); @@ -200,10 +169,10 @@ void DocumentTypeTest::testInheritance() docType2.addField(Field("tall", 10, *DataType::INT, false)); docType.inherit(docType2); - CPPUNIT_ASSERT(docType.hasField("stringattr")); - CPPUNIT_ASSERT(docType.hasField("nalle")); - CPPUNIT_ASSERT(docType.hasField("tmp")); - CPPUNIT_ASSERT(docType.hasField("tall")); + EXPECT_TRUE(docType.hasField("stringattr")); + EXPECT_TRUE(docType.hasField("nalle")); + EXPECT_TRUE(docType.hasField("tmp")); + EXPECT_TRUE(docType.hasField("tall")); DocumentType docType3("test3"); docType3.addField(Field("stringattr", 3, *DataType::RAW, false)); @@ -211,29 +180,29 @@ void DocumentTypeTest::testInheritance() try{ docType2.inherit(docType3); - //CPPUNIT_FAIL("Supposed to fail"); + // FAIL() << "Supposed to fail"; } catch (std::exception& e) { - CPPUNIT_ASSERT_EQUAL(std::string("foo"), std::string(e.what())); + EXPECT_EQ(std::string("foo"), std::string(e.what())); } try{ docType.inherit(docType3); - //CPPUNIT_FAIL("Supposed to fail"); + // FAIL() << "Supposed to fail"; } catch (std::exception& e) { - CPPUNIT_ASSERT_EQUAL(std::string("foo"), std::string(e.what())); + EXPECT_EQ(std::string("foo"), std::string(e.what())); } DocumentType docType4("test4"); docType4.inherit(docType3); - CPPUNIT_ASSERT(docType4.hasField("stringattr")); - CPPUNIT_ASSERT(docType4.hasField("tall")); + EXPECT_TRUE(docType4.hasField("stringattr")); + EXPECT_TRUE(docType4.hasField("tall")); try{ docType3.inherit(docType4); - CPPUNIT_FAIL("Accepted cyclic inheritance"); + FAIL() << "Accepted cyclic inheritance"; } catch (std::exception& e) { - CPPUNIT_ASSERT_CONTAIN("Cannot add cyclic dependencies", e.what()); + EXPECT_THAT(e.what(), HasSubstr("Cannot add cyclic dependencies")); } DocumentType docType5("test5"); @@ -241,18 +210,19 @@ void DocumentTypeTest::testInheritance() try{ docType4.inherit(docType5); - //CPPUNIT_FAIL("Supposed to fail"); + // FAIL() << "Supposed to fail"; } catch (std::exception& e) { - CPPUNIT_ASSERT_EQUAL(std::string("foo"), std::string(e.what())); + EXPECT_EQ(std::string("foo"), std::string(e.what())); } } -void DocumentTypeTest::testOutputOperator() { +TEST(DocumentTypeTest,testOutputOperator) +{ DocumentType docType("test1"); std::ostringstream ost; ost << docType; std::string expected("DocumentType(test1)"); - CPPUNIT_ASSERT_EQUAL(expected, ost.str()); + EXPECT_EQ(expected, ost.str()); } } // document diff --git a/document/src/tests/fieldpathupdatetestcase.cpp b/document/src/tests/fieldpathupdatetestcase.cpp index 35b851ca895..74e2c20ad86 100644 --- a/document/src/tests/fieldpathupdatetestcase.cpp +++ b/document/src/tests/fieldpathupdatetestcase.cpp @@ -5,7 +5,6 @@ #include #include -#include #include #include @@ -17,6 +16,7 @@ #include #include #include +#include using vespalib::Identifiable; using namespace document::config_builder; @@ -25,103 +25,19 @@ namespace document { using namespace fieldvalue; -struct FieldPathUpdateTestCase : public CppUnit::TestFixture { +class FieldPathUpdateTestCase : public ::testing::Test { +protected: std::shared_ptr _repo; DocumentType _foobar_type; + ~FieldPathUpdateTestCase(); + + void SetUp() override; + void TearDown() override; - void setUp() override; - void tearDown() override; - - void testWhereClause(); - void testBrokenWhereClause(); - void testNoIterateMapValues(); - void testRemoveField(); - void testApplyRemoveEntireListField(); - void testApplyRemoveMultiList(); - void testApplyRemoveMultiList2(); - void testApplyRemoveMultiWset(); - void testApplyAssignSingle(); - void testApplyAssignMath(); - void testApplyAssignMathDivZero(); - void testApplyAssignMathByteToZero(); - void testApplyAssignMathNotModifiedOnUnderflow(); - void testApplyAssignMathNotModifiedOnOverflow(); - void testApplyAssignFieldNotExistingInExpression(); - void testApplyAssignFieldNotExistingInPath(); - void testApplyAssignTargetNotExisting(); - void testAssignSimpleMapValueWithVariable(); - void testApplyAssignMathRemoveIfZero(); - void testApplyAssignMultiList(); - void testApplyAssignMultiWset(); - void testAssignWsetRemoveIfZero(); - void testApplyAddMultiList(); - void testAddAndAssignList(); - void testAssignMap(); - void testAssignMapStruct(); - void testAssignMapStructVariable(); - void testAssignMapNoExist(); - void testAssignMapNoExistNoCreate(); - void testQuotedStringKey(); - void testEqualityComparison(); - void testAffectsDocumentBody(); - void testIncompatibleDataTypeFails(); - void testSerializeAssign(); - void testSerializeAdd(); - void testSerializeRemove(); - void testSerializeAssignMath(); - void testReadSerializedFile(); - void testGenerateSerializedFile(); - void array_element_update_for_invalid_index_is_ignored(); - - CPPUNIT_TEST_SUITE(FieldPathUpdateTestCase); - CPPUNIT_TEST(testWhereClause); - CPPUNIT_TEST(testBrokenWhereClause); - CPPUNIT_TEST(testNoIterateMapValues); - CPPUNIT_TEST(testRemoveField); - CPPUNIT_TEST(testApplyRemoveEntireListField); - CPPUNIT_TEST(testApplyRemoveMultiList); - CPPUNIT_TEST(testApplyRemoveMultiList2); - CPPUNIT_TEST(testApplyRemoveMultiWset); - CPPUNIT_TEST(testApplyAssignSingle); - CPPUNIT_TEST(testApplyAssignMath); - CPPUNIT_TEST(testApplyAssignMathDivZero); - CPPUNIT_TEST(testApplyAssignMathByteToZero); - CPPUNIT_TEST(testApplyAssignMathNotModifiedOnUnderflow); - CPPUNIT_TEST(testApplyAssignMathNotModifiedOnOverflow); - CPPUNIT_TEST(testApplyAssignFieldNotExistingInExpression); - CPPUNIT_TEST(testApplyAssignFieldNotExistingInPath); - CPPUNIT_TEST(testApplyAssignTargetNotExisting); - CPPUNIT_TEST(testAssignSimpleMapValueWithVariable); - CPPUNIT_TEST(testApplyAssignMathRemoveIfZero); - CPPUNIT_TEST(testApplyAssignMultiList); - CPPUNIT_TEST(testApplyAssignMultiWset); - CPPUNIT_TEST(testAssignWsetRemoveIfZero); - CPPUNIT_TEST(testApplyAddMultiList); - CPPUNIT_TEST(testAddAndAssignList); - CPPUNIT_TEST(testAssignMap); - CPPUNIT_TEST(testAssignMapStruct); - CPPUNIT_TEST(testAssignMapStructVariable); - CPPUNIT_TEST(testAssignMapNoExist); - CPPUNIT_TEST(testAssignMapNoExistNoCreate); - CPPUNIT_TEST(testQuotedStringKey); - CPPUNIT_TEST(testEqualityComparison); - CPPUNIT_TEST(testAffectsDocumentBody); - CPPUNIT_TEST(testIncompatibleDataTypeFails); - CPPUNIT_TEST(testSerializeAssign); - CPPUNIT_TEST(testSerializeAdd); - CPPUNIT_TEST(testSerializeRemove); - CPPUNIT_TEST(testSerializeAssignMath); - CPPUNIT_TEST(testReadSerializedFile); - CPPUNIT_TEST(testGenerateSerializedFile); - CPPUNIT_TEST(array_element_update_for_invalid_index_is_ignored); - CPPUNIT_TEST_SUITE_END(); -private: DocumentUpdate::UP createDocumentUpdateForSerialization(const DocumentTypeRepo& repo); }; -CPPUNIT_TEST_SUITE_REGISTRATION(FieldPathUpdateTestCase); - namespace { document::DocumenttypesConfig getRepoConfig() { @@ -233,29 +149,28 @@ void testSerialize(const DocumentTypeRepo& repo, const DocumentUpdate& a) { bb->flip(); DocumentUpdate::UP b(DocumentUpdate::createHEAD(repo, *bb)); - CPPUNIT_ASSERT_EQUAL(size_t(0), bb->getRemaining()); - CPPUNIT_ASSERT_EQUAL(a.getId().toString(), b->getId().toString()); - CPPUNIT_ASSERT_EQUAL(a.getUpdates().size(), b->getUpdates().size()); + EXPECT_EQ(size_t(0), bb->getRemaining()); + EXPECT_EQ(a.getId().toString(), b->getId().toString()); + EXPECT_EQ(a.getUpdates().size(), b->getUpdates().size()); for (size_t i(0); i < a.getUpdates().size(); i++) { const FieldUpdate & ua = a.getUpdates()[i]; const FieldUpdate & ub = b->getUpdates()[i]; - CPPUNIT_ASSERT_EQUAL(&ua.getField(), &ub.getField()); - CPPUNIT_ASSERT_EQUAL(ua.getUpdates().size(), + EXPECT_EQ(&ua.getField(), &ub.getField()); + EXPECT_EQ(ua.getUpdates().size(), ub.getUpdates().size()); for (size_t j(0); j < ua.getUpdates().size(); j++) { - CPPUNIT_ASSERT_EQUAL(ua.getUpdates()[j]->getType(), - ub.getUpdates()[j]->getType()); + EXPECT_EQ(ua.getUpdates()[j]->getType(), ub.getUpdates()[j]->getType()); } } - CPPUNIT_ASSERT_EQUAL(a.getFieldPathUpdates().size(), b->getFieldPathUpdates().size()); + EXPECT_EQ(a.getFieldPathUpdates().size(), b->getFieldPathUpdates().size()); for (size_t i(0); i < a.getFieldPathUpdates().size(); i++) { const FieldPathUpdate::CP& ua = a.getFieldPathUpdates()[i]; const FieldPathUpdate::CP& ub = b->getFieldPathUpdates()[i]; - CPPUNIT_ASSERT_EQUAL(*ua, *ub); + EXPECT_EQ(*ua, *ub); } - CPPUNIT_ASSERT_EQUAL(a, *b); + EXPECT_EQ(a, *b); } catch (std::exception& e) { std::cerr << "Failed while testing document field path update:\n" << a.toString(true) << "\n"; @@ -320,8 +235,10 @@ TestFieldPathUpdate::TestFieldPathUpdate(const TestFieldPathUpdate& other) { } +FieldPathUpdateTestCase::~FieldPathUpdateTestCase() = default; + void -FieldPathUpdateTestCase::setUp() +FieldPathUpdateTestCase::SetUp() { DocumenttypesConfigBuilderHelper builder; builder.document(42, "foobar", @@ -344,62 +261,57 @@ FieldPathUpdateTestCase::setUp() } void -FieldPathUpdateTestCase::tearDown() +FieldPathUpdateTestCase::TearDown() { } -void -FieldPathUpdateTestCase::testWhereClause() +TEST_F(FieldPathUpdateTestCase, testWhereClause) { DocumentTypeRepo repo(getRepoConfig()); Document::UP doc(createTestDocument(repo)); std::string where = "test.l1s1.structmap.value.smap{$x} == \"dicaprio\""; TestFieldPathUpdate update("l1s1.structmap.value.smap{$x}", where); update.applyTo(*doc); - CPPUNIT_ASSERT_EQUAL(std::string("dicaprio"), update._str); + EXPECT_EQ(std::string("dicaprio"), update._str); } -void -FieldPathUpdateTestCase::testBrokenWhereClause() +TEST_F(FieldPathUpdateTestCase, testBrokenWhereClause) { DocumentTypeRepo repo(getRepoConfig()); Document::UP doc(createTestDocument(repo)); std::string where = "l1s1.structmap.value.smap{$x} == \"dicaprio\""; TestFieldPathUpdate update("l1s1.structmap.value.smap{$x}", where); update.applyTo(*doc); - CPPUNIT_ASSERT_EQUAL(std::string(""), update._str); + EXPECT_EQ(std::string(""), update._str); } -void -FieldPathUpdateTestCase::testNoIterateMapValues() +TEST_F(FieldPathUpdateTestCase, testNoIterateMapValues) { DocumentTypeRepo repo(getRepoConfig()); Document::UP doc(createTestDocument(repo)); TestFieldPathUpdate update("l1s1.structwset.primitive1", "true"); update.applyTo(*doc); - CPPUNIT_ASSERT_EQUAL(std::string("3;5"), update._str); + EXPECT_EQ(std::string("3;5"), update._str); } -void -FieldPathUpdateTestCase::testRemoveField() +TEST_F(FieldPathUpdateTestCase, testRemoveField) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:things:thangs"))); - CPPUNIT_ASSERT(doc->hasValue("strfoo") == false); + EXPECT_TRUE(doc->hasValue("strfoo") == false); doc->setValue("strfoo", StringFieldValue("cocacola")); - CPPUNIT_ASSERT_EQUAL(vespalib::string("cocacola"), doc->getValue("strfoo")->getAsString()); + EXPECT_EQ(vespalib::string("cocacola"), doc->getValue("strfoo")->getAsString()); //doc->print(std::cerr, true, ""); DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP(new RemoveFieldPathUpdate("strfoo"))); docUp.applyTo(*doc); - CPPUNIT_ASSERT(doc->hasValue("strfoo") == false); + EXPECT_TRUE(doc->hasValue("strfoo") == false); } -void -FieldPathUpdateTestCase::testApplyRemoveMultiList() +TEST_F(FieldPathUpdateTestCase, testApplyRemoveMultiList) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:things:thangs"))); doc->setRepo(*_repo); - CPPUNIT_ASSERT(doc->hasValue("strarray") == false); + EXPECT_TRUE(doc->hasValue("strarray") == false); { ArrayFieldValue strArray(doc->getType().getField("strarray").getDataType()); strArray.add(StringFieldValue("crouching tiger, hidden field")); @@ -407,7 +319,7 @@ FieldPathUpdateTestCase::testApplyRemoveMultiList() strArray.add(StringFieldValue("hello hello")); doc->setValue("strarray", strArray); } - CPPUNIT_ASSERT(doc->hasValue("strarray")); + EXPECT_TRUE(doc->hasValue("strarray")); //doc->print(std::cerr, true, ""); DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP( @@ -415,18 +327,17 @@ FieldPathUpdateTestCase::testApplyRemoveMultiList() docUp.applyTo(*doc); { std::unique_ptr strArray = doc->getAs(doc->getField("strarray")); - CPPUNIT_ASSERT_EQUAL(std::size_t(2), strArray->size()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("crouching tiger, hidden field"), (*strArray)[0].getAsString()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("hello hello"), (*strArray)[1].getAsString()); + ASSERT_EQ(std::size_t(2), strArray->size()); + EXPECT_EQ(vespalib::string("crouching tiger, hidden field"), (*strArray)[0].getAsString()); + EXPECT_EQ(vespalib::string("hello hello"), (*strArray)[1].getAsString()); } } -void -FieldPathUpdateTestCase::testApplyRemoveMultiList2() +TEST_F(FieldPathUpdateTestCase, testApplyRemoveMultiList2) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:things:thangs"))); doc->setRepo(*_repo); - CPPUNIT_ASSERT(doc->hasValue("strarray") == false); + EXPECT_TRUE(doc->hasValue("strarray") == false); { ArrayFieldValue strArray(doc->getType().getField("strarray").getDataType()); strArray.add(StringFieldValue("remove val 1")); @@ -434,7 +345,7 @@ FieldPathUpdateTestCase::testApplyRemoveMultiList2() strArray.add(StringFieldValue("hello hello")); doc->setValue("strarray", strArray); } - CPPUNIT_ASSERT(doc->hasValue("strarray")); + EXPECT_TRUE(doc->hasValue("strarray")); //doc->print(std::cerr, true, ""); DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP( @@ -442,16 +353,15 @@ FieldPathUpdateTestCase::testApplyRemoveMultiList2() docUp.applyTo(*doc); { std::unique_ptr strArray = doc->getAs(doc->getField("strarray")); - CPPUNIT_ASSERT_EQUAL(std::size_t(1), strArray->size()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("hello hello"), (*strArray)[0].getAsString()); + ASSERT_EQ(std::size_t(1), strArray->size()); + EXPECT_EQ(vespalib::string("hello hello"), (*strArray)[0].getAsString()); } } -void -FieldPathUpdateTestCase::testApplyRemoveEntireListField() +TEST_F(FieldPathUpdateTestCase, testApplyRemoveEntireListField) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:things:thangs"))); - CPPUNIT_ASSERT(doc->hasValue("strarray") == false); + EXPECT_TRUE(doc->hasValue("strarray") == false); { ArrayFieldValue strArray(doc->getType().getField("strarray").getDataType()); strArray.add(StringFieldValue("this list")); @@ -463,54 +373,51 @@ FieldPathUpdateTestCase::testApplyRemoveEntireListField() DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP(new RemoveFieldPathUpdate("strarray", ""))); docUp.applyTo(*doc); - CPPUNIT_ASSERT(!doc->hasValue("strarray")); + EXPECT_TRUE(!doc->hasValue("strarray")); } -void -FieldPathUpdateTestCase::testApplyRemoveMultiWset() +TEST_F(FieldPathUpdateTestCase, testApplyRemoveMultiWset) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:helan:halvan"))); - CPPUNIT_ASSERT(doc->hasValue("strwset") == false); + EXPECT_TRUE(doc->hasValue("strwset") == false); { WeightedSetFieldValue strWset(doc->getType().getField("strwset").getDataType()); strWset.add(StringFieldValue("hello hello"), 10); strWset.add(StringFieldValue("remove val 1"), 20); doc->setValue("strwset", strWset); } - CPPUNIT_ASSERT(doc->hasValue("strwset")); + EXPECT_TRUE(doc->hasValue("strwset")); //doc->print(std::cerr, true, ""); DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP(new RemoveFieldPathUpdate("strwset{remove val 1}"))); docUp.applyTo(*doc); { std::unique_ptr strWset = doc->getAs(doc->getField("strwset")); - CPPUNIT_ASSERT_EQUAL(std::size_t(1), strWset->size()); - CPPUNIT_ASSERT_EQUAL(10, strWset->get(StringFieldValue("hello hello"))); + ASSERT_EQ(std::size_t(1), strWset->size()); + EXPECT_EQ(10, strWset->get(StringFieldValue("hello hello"))); } } -void -FieldPathUpdateTestCase::testApplyAssignSingle() +TEST_F(FieldPathUpdateTestCase, testApplyAssignSingle) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:drekka:karsk"))); - CPPUNIT_ASSERT(doc->hasValue("strfoo") == false); + EXPECT_TRUE(doc->hasValue("strfoo") == false); // Test assignment of non-existing DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP( new AssignFieldPathUpdate(*doc->getDataType(), "strfoo", std::string(), StringFieldValue("himert")))); docUp.applyTo(*doc); - CPPUNIT_ASSERT(doc->hasValue("strfoo")); - CPPUNIT_ASSERT_EQUAL(vespalib::string("himert"), doc->getValue("strfoo")->getAsString()); + EXPECT_TRUE(doc->hasValue("strfoo")); + EXPECT_EQ(vespalib::string("himert"), doc->getValue("strfoo")->getAsString()); // Test overwriting existing DocumentUpdate docUp2(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp2.addFieldPathUpdate(FieldPathUpdate::CP( new AssignFieldPathUpdate(*doc->getDataType(), "strfoo", std::string(), StringFieldValue("wunderbaum")))); docUp2.applyTo(*doc); - CPPUNIT_ASSERT_EQUAL(vespalib::string("wunderbaum"), doc->getValue("strfoo")->getAsString()); + EXPECT_EQ(vespalib::string("wunderbaum"), doc->getValue("strfoo")->getAsString()); } -void -FieldPathUpdateTestCase::testApplyAssignMath() +TEST_F(FieldPathUpdateTestCase, testApplyAssignMath) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:bat:man"))); doc->setValue("num", IntFieldValue(34)); @@ -518,11 +425,10 @@ FieldPathUpdateTestCase::testApplyAssignMath() DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP(new AssignFieldPathUpdate("num", "", "($value * 2) / $value"))); docUp.applyTo(*doc); - CPPUNIT_ASSERT_EQUAL(static_cast(IntFieldValue(2)), *doc->getValue("num")); + EXPECT_EQ(static_cast(IntFieldValue(2)), *doc->getValue("num")); } -void -FieldPathUpdateTestCase::testApplyAssignMathByteToZero() +TEST_F(FieldPathUpdateTestCase, testApplyAssignMathByteToZero) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:bat:man"))); doc->setValue("byteval", ByteFieldValue(3)); @@ -530,11 +436,10 @@ FieldPathUpdateTestCase::testApplyAssignMathByteToZero() DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP(new AssignFieldPathUpdate("byteval", "", "$value - 3"))); docUp.applyTo(*doc); - CPPUNIT_ASSERT_EQUAL(static_cast(ByteFieldValue(0)), *doc->getValue("byteval")); + EXPECT_EQ(static_cast(ByteFieldValue(0)), *doc->getValue("byteval")); } -void -FieldPathUpdateTestCase::testApplyAssignMathNotModifiedOnUnderflow() +TEST_F(FieldPathUpdateTestCase, testApplyAssignMathNotModifiedOnUnderflow) { int low_value = -126; Document::UP doc(new Document(_foobar_type, DocumentId("doc:bat:man"))); @@ -544,11 +449,10 @@ FieldPathUpdateTestCase::testApplyAssignMathNotModifiedOnUnderflow() docUp.addFieldPathUpdate(FieldPathUpdate::CP(new AssignFieldPathUpdate("byteval", "", "$value - 4"))); docUp.applyTo(*doc); // Over/underflow will happen. You must have control of your data types. - CPPUNIT_ASSERT_EQUAL(static_cast(ByteFieldValue((char)(low_value - 4))), *doc->getValue("byteval")); + EXPECT_EQ(static_cast(ByteFieldValue((char)(low_value - 4))), *doc->getValue("byteval")); } -void -FieldPathUpdateTestCase::testApplyAssignMathNotModifiedOnOverflow() +TEST_F(FieldPathUpdateTestCase, testApplyAssignMathNotModifiedOnOverflow) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:bat:man"))); doc->setValue("byteval", ByteFieldValue(127)); @@ -557,38 +461,35 @@ FieldPathUpdateTestCase::testApplyAssignMathNotModifiedOnOverflow() docUp.addFieldPathUpdate(FieldPathUpdate::CP(new AssignFieldPathUpdate("byteval", "", "$value + 200"))); docUp.applyTo(*doc); // Over/underflow will happen. You must have control of your data types. - CPPUNIT_ASSERT_EQUAL(static_cast(ByteFieldValue(static_cast(static_cast(127+200)))), *doc->getValue("byteval")); + EXPECT_EQ(static_cast(ByteFieldValue(static_cast(static_cast(127+200)))), *doc->getValue("byteval")); } -void -FieldPathUpdateTestCase::testApplyAssignMathDivZero() +TEST_F(FieldPathUpdateTestCase, testApplyAssignMathDivZero) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:bat:man"))); - CPPUNIT_ASSERT(doc->hasValue("num") == false); + EXPECT_TRUE(doc->hasValue("num") == false); doc->setValue("num", IntFieldValue(10)); DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP(new AssignFieldPathUpdate("num", "", "$value / ($value - 10)"))); docUp.applyTo(*doc); - CPPUNIT_ASSERT_EQUAL(static_cast(IntFieldValue(10)), *doc->getValue("num")); + EXPECT_EQ(static_cast(IntFieldValue(10)), *doc->getValue("num")); } -void -FieldPathUpdateTestCase::testApplyAssignFieldNotExistingInExpression() +TEST_F(FieldPathUpdateTestCase, testApplyAssignFieldNotExistingInExpression) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:bat:man"))); doc->setRepo(*_repo); - CPPUNIT_ASSERT(doc->hasValue("num") == false); + EXPECT_TRUE(doc->hasValue("num") == false); doc->setValue("num", IntFieldValue(10)); DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP(new AssignFieldPathUpdate("num", "", "foobar.num2 + $value"))); docUp.applyTo(*doc); - CPPUNIT_ASSERT_EQUAL(static_cast(IntFieldValue(10)), *doc->getValue("num")); + EXPECT_EQ(static_cast(IntFieldValue(10)), *doc->getValue("num")); } -void -FieldPathUpdateTestCase::testApplyAssignFieldNotExistingInPath() +TEST_F(FieldPathUpdateTestCase, testApplyAssignFieldNotExistingInPath) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:bat:man"))); doc->setRepo(*_repo); @@ -597,25 +498,23 @@ FieldPathUpdateTestCase::testApplyAssignFieldNotExistingInPath() try { docUp.addFieldPathUpdate(FieldPathUpdate::CP(new AssignFieldPathUpdate("nosuchnum", "", "foobar.num + $value"))); docUp.applyTo(*doc); - CPPUNIT_ASSERT(false); + EXPECT_TRUE(false); } catch (const FieldNotFoundException&) { } } -void -FieldPathUpdateTestCase::testApplyAssignTargetNotExisting() +TEST_F(FieldPathUpdateTestCase, testApplyAssignTargetNotExisting) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:bat:man"))); - CPPUNIT_ASSERT(doc->hasValue("num") == false); + EXPECT_TRUE(doc->hasValue("num") == false); DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); docUp.addFieldPathUpdate(FieldPathUpdate::CP(new AssignFieldPathUpdate("num", "", "$value + 5"))); docUp.applyTo(*doc); - CPPUNIT_ASSERT_EQUAL(static_cast(IntFieldValue(5)), *doc->getValue("num")); + EXPECT_EQ(static_cast(IntFieldValue(5)), *doc->getValue("num")); } -void -FieldPathUpdateTestCase::testAssignSimpleMapValueWithVariable() +TEST_F(FieldPathUpdateTestCase, testAssignSimpleMapValueWithVariable) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:bug:hunter"))); doc->setRepo(*_repo); @@ -634,22 +533,21 @@ FieldPathUpdateTestCase::testAssignSimpleMapValueWithVariable() std::unique_ptr valueNow(doc->getAs(doc->getField("strmap"))); - CPPUNIT_ASSERT_EQUAL(std::size_t(2), valueNow->size()); - CPPUNIT_ASSERT_EQUAL( + ASSERT_EQ(std::size_t(2), valueNow->size()); + EXPECT_EQ( static_cast(StringFieldValue("shinyvalue")), *valueNow->get(StringFieldValue("foo"))); - CPPUNIT_ASSERT_EQUAL( + EXPECT_EQ( static_cast(StringFieldValue("bananas")), *valueNow->get(StringFieldValue("baz"))); } -void -FieldPathUpdateTestCase::testApplyAssignMathRemoveIfZero() +TEST_F(FieldPathUpdateTestCase, testApplyAssignMathRemoveIfZero) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:bat:man"))); - CPPUNIT_ASSERT(doc->hasValue("num") == false); + EXPECT_TRUE(doc->hasValue("num") == false); doc->setValue("num", IntFieldValue(34)); - CPPUNIT_ASSERT(doc->hasValue("num") == true); + EXPECT_TRUE(doc->hasValue("num") == true); DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); FieldPathUpdate::CP up1(new AssignFieldPathUpdate("num", "", "($value * 2) / $value - 2")); @@ -657,21 +555,20 @@ FieldPathUpdateTestCase::testApplyAssignMathRemoveIfZero() docUp.addFieldPathUpdate(up1); docUp.applyTo(*doc); - CPPUNIT_ASSERT(doc->hasValue("num") == false); + EXPECT_TRUE(doc->hasValue("num") == false); } -void -FieldPathUpdateTestCase::testApplyAssignMultiList() +TEST_F(FieldPathUpdateTestCase, testApplyAssignMultiList) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:fest:skinnvest"))); - CPPUNIT_ASSERT(doc->hasValue("strarray") == false); + EXPECT_TRUE(doc->hasValue("strarray") == false); { ArrayFieldValue strArray(doc->getType().getField("strarray").getDataType()); strArray.add(StringFieldValue("hello hello")); strArray.add(StringFieldValue("blah blargh")); doc->setValue("strarray", strArray); - CPPUNIT_ASSERT(doc->hasValue("strarray")); + EXPECT_TRUE(doc->hasValue("strarray")); } ArrayFieldValue updateArray(doc->getType().getField("strarray").getDataType()); @@ -685,25 +582,24 @@ FieldPathUpdateTestCase::testApplyAssignMultiList() { std::unique_ptr strArray = doc->getAs(doc->getField("strarray")); - CPPUNIT_ASSERT_EQUAL(std::size_t(2), strArray->size()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("assigned val 0"), (*strArray)[0].getAsString()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("assigned val 1"), (*strArray)[1].getAsString()); + ASSERT_EQ(std::size_t(2), strArray->size()); + EXPECT_EQ(vespalib::string("assigned val 0"), (*strArray)[0].getAsString()); + EXPECT_EQ(vespalib::string("assigned val 1"), (*strArray)[1].getAsString()); } } -void -FieldPathUpdateTestCase::testApplyAssignMultiWset() +TEST_F(FieldPathUpdateTestCase, testApplyAssignMultiWset) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:fest:skinnvest"))); - CPPUNIT_ASSERT(doc->hasValue("strarray") == false); + EXPECT_TRUE(doc->hasValue("strarray") == false); { WeightedSetFieldValue strWset(doc->getType().getField("strwset").getDataType()); strWset.add(StringFieldValue("hello gentlemen"), 10); strWset.add(StringFieldValue("what you say"), 20); doc->setValue("strwset", strWset); - CPPUNIT_ASSERT(doc->hasValue("strwset")); + EXPECT_TRUE(doc->hasValue("strwset")); } WeightedSetFieldValue assignWset(doc->getType().getField("strwset").getDataType()); @@ -718,24 +614,23 @@ FieldPathUpdateTestCase::testApplyAssignMultiWset() //doc->print(std::cerr, true, ""); { std::unique_ptr strWset = doc->getAs(doc->getField("strwset")); - CPPUNIT_ASSERT_EQUAL(std::size_t(2), strWset->size()); - CPPUNIT_ASSERT_EQUAL(5, strWset->get(StringFieldValue("assigned val 0"))); - CPPUNIT_ASSERT_EQUAL(10, strWset->get(StringFieldValue("assigned val 1"))); + ASSERT_EQ(std::size_t(2), strWset->size()); + EXPECT_EQ(5, strWset->get(StringFieldValue("assigned val 0"))); + EXPECT_EQ(10, strWset->get(StringFieldValue("assigned val 1"))); } } -void -FieldPathUpdateTestCase::testAssignWsetRemoveIfZero() +TEST_F(FieldPathUpdateTestCase, testAssignWsetRemoveIfZero) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:tronder:bataljon"))); - CPPUNIT_ASSERT(doc->hasValue("strarray") == false); + EXPECT_TRUE(doc->hasValue("strarray") == false); { WeightedSetFieldValue strWset(doc->getType().getField("strwset").getDataType()); strWset.add(StringFieldValue("you say goodbye"), 164); strWset.add(StringFieldValue("but i say hello"), 243); doc->setValue("strwset", strWset); - CPPUNIT_ASSERT(doc->hasValue("strwset")); + EXPECT_TRUE(doc->hasValue("strwset")); } { @@ -750,17 +645,16 @@ FieldPathUpdateTestCase::testAssignWsetRemoveIfZero() //doc->print(std::cerr, true, ""); { std::unique_ptr strWset = doc->getAs(doc->getField("strwset")); - CPPUNIT_ASSERT_EQUAL(std::size_t(1), strWset->size()); - CPPUNIT_ASSERT_EQUAL(243, strWset->get(StringFieldValue("but i say hello"))); + ASSERT_EQ(std::size_t(1), strWset->size()); + EXPECT_EQ(243, strWset->get(StringFieldValue("but i say hello"))); } } } -void -FieldPathUpdateTestCase::testApplyAddMultiList() +TEST_F(FieldPathUpdateTestCase, testApplyAddMultiList) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:george:costanza"))); - CPPUNIT_ASSERT(doc->hasValue("strarray") == false); + EXPECT_TRUE(doc->hasValue("strarray") == false); ArrayFieldValue adds(doc->getType().getField("strarray").getDataType()); adds.add(StringFieldValue("serenity now")); @@ -773,21 +667,20 @@ FieldPathUpdateTestCase::testApplyAddMultiList() //doc->print(std::cerr, true, ""); docUp.applyTo(*doc); //doc->print(std::cerr, true, ""); - CPPUNIT_ASSERT(doc->hasValue("strarray")); + EXPECT_TRUE(doc->hasValue("strarray")); } -void -FieldPathUpdateTestCase::testAddAndAssignList() +TEST_F(FieldPathUpdateTestCase, testAddAndAssignList) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:fancy:pants"))); - CPPUNIT_ASSERT(doc->hasValue("strarray") == false); + EXPECT_TRUE(doc->hasValue("strarray") == false); { ArrayFieldValue strArray(doc->getType().getField("strarray").getDataType()); strArray.add(StringFieldValue("hello hello")); strArray.add(StringFieldValue("blah blargh")); doc->setValue("strarray", strArray); - CPPUNIT_ASSERT(doc->hasValue("strarray")); + EXPECT_TRUE(doc->hasValue("strarray")); } DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); @@ -805,10 +698,10 @@ FieldPathUpdateTestCase::testAddAndAssignList() //doc->print(std::cerr, true, ""); { std::unique_ptr strArray = doc->getAs(doc->getField("strarray")); - CPPUNIT_ASSERT_EQUAL(std::size_t(3), strArray->size()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("hello hello"), (*strArray)[0].getAsString()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("assigned val 1"), (*strArray)[1].getAsString()); - CPPUNIT_ASSERT_EQUAL(vespalib::string("new value"), (*strArray)[2].getAsString()); + ASSERT_EQ(std::size_t(3), strArray->size()); + EXPECT_EQ(vespalib::string("hello hello"), (*strArray)[0].getAsString()); + EXPECT_EQ(vespalib::string("assigned val 1"), (*strArray)[1].getAsString()); + EXPECT_EQ(vespalib::string("new value"), (*strArray)[2].getAsString()); } } @@ -866,8 +759,7 @@ Fixture::Fixture(const DocumentType &doc_type, const Keys &k) } // namespace -void -FieldPathUpdateTestCase::testAssignMap() +TEST_F(FieldPathUpdateTestCase, testAssignMap) { Keys k; Fixture f(_foobar_type, k); @@ -878,17 +770,16 @@ FieldPathUpdateTestCase::testAssignMap() docUp.applyTo(*f.doc); std::unique_ptr valueNow = f.doc->getAs(f.doc->getField("structmap")); - CPPUNIT_ASSERT_EQUAL(std::size_t(3), valueNow->size()); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv1), + ASSERT_EQ(std::size_t(3), valueNow->size()); + EXPECT_EQ(static_cast(f.fv1), *valueNow->get(StringFieldValue(k.key1))); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv4), + EXPECT_EQ(static_cast(f.fv4), *valueNow->get(StringFieldValue(k.key2))); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv3), + EXPECT_EQ(static_cast(f.fv3), *valueNow->get(StringFieldValue(k.key3))); } -void -FieldPathUpdateTestCase::testAssignMapStruct() +TEST_F(FieldPathUpdateTestCase, testAssignMapStruct) { Keys k; Fixture f(_foobar_type, k); @@ -900,17 +791,16 @@ FieldPathUpdateTestCase::testAssignMapStruct() docUp.applyTo(*f.doc); std::unique_ptr valueNow = f.doc->getAs(f.doc->getField("structmap")); - CPPUNIT_ASSERT_EQUAL(std::size_t(3), valueNow->size()); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv1), + ASSERT_EQ(std::size_t(3), valueNow->size()); + EXPECT_EQ(static_cast(f.fv1), *valueNow->get(StringFieldValue(k.key1))); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv4), + EXPECT_EQ(static_cast(f.fv4), *valueNow->get(StringFieldValue(k.key2))); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv3), + EXPECT_EQ(static_cast(f.fv3), *valueNow->get(StringFieldValue(k.key3))); } -void -FieldPathUpdateTestCase::testAssignMapStructVariable() +TEST_F(FieldPathUpdateTestCase, testAssignMapStructVariable) { Keys k; Fixture f(_foobar_type, k); @@ -923,17 +813,16 @@ FieldPathUpdateTestCase::testAssignMapStructVariable() docUp.applyTo(*f.doc); std::unique_ptr valueNow = f.doc->getAs(f.doc->getField("structmap")); - CPPUNIT_ASSERT_EQUAL(std::size_t(3), valueNow->size()); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv1), + ASSERT_EQ(std::size_t(3), valueNow->size()); + EXPECT_EQ(static_cast(f.fv1), *valueNow->get(StringFieldValue(k.key1))); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv4), + EXPECT_EQ(static_cast(f.fv4), *valueNow->get(StringFieldValue(k.key2))); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv3), + EXPECT_EQ(static_cast(f.fv3), *valueNow->get(StringFieldValue(k.key3))); } -void -FieldPathUpdateTestCase::testAssignMapNoExist() +TEST_F(FieldPathUpdateTestCase, testAssignMapNoExist) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:planet:express"))); MapFieldValue mfv(doc->getType().getField("structmap").getDataType()); @@ -951,12 +840,11 @@ FieldPathUpdateTestCase::testAssignMapNoExist() std::unique_ptr valueNow = doc->getAs(doc->getField("structmap")); - CPPUNIT_ASSERT_EQUAL(std::size_t(1), valueNow->size()); - CPPUNIT_ASSERT_EQUAL(static_cast(fv1), *valueNow->get(StringFieldValue("foo"))); + ASSERT_EQ(std::size_t(1), valueNow->size()); + EXPECT_EQ(static_cast(fv1), *valueNow->get(StringFieldValue("foo"))); } -void -FieldPathUpdateTestCase::testAssignMapNoExistNoCreate() +TEST_F(FieldPathUpdateTestCase, testAssignMapNoExistNoCreate) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:planet:express"))); MapFieldValue mfv(doc->getType().getField("structmap").getDataType()); @@ -976,11 +864,10 @@ FieldPathUpdateTestCase::testAssignMapNoExistNoCreate() //doc->print(std::cerr, true, ""); std::unique_ptr valueNow = doc->getAs(doc->getField("structmap")); - CPPUNIT_ASSERT(valueNow.get() == 0); + EXPECT_TRUE(valueNow.get() == 0); } -void -FieldPathUpdateTestCase::testQuotedStringKey() +TEST_F(FieldPathUpdateTestCase, testQuotedStringKey) { Keys k; k.key2 = "here is a \"fancy\" 'map' :-} key :-{"; @@ -993,17 +880,16 @@ FieldPathUpdateTestCase::testQuotedStringKey() docUp.applyTo(*f.doc); std::unique_ptr valueNow = f.doc->getAs(f.doc->getField("structmap")); - CPPUNIT_ASSERT_EQUAL(std::size_t(3), valueNow->size()); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv1), + ASSERT_EQ(std::size_t(3), valueNow->size()); + EXPECT_EQ(static_cast(f.fv1), *valueNow->get(StringFieldValue(k.key1))); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv4), + EXPECT_EQ(static_cast(f.fv4), *valueNow->get(StringFieldValue(k.key2))); - CPPUNIT_ASSERT_EQUAL(static_cast(f.fv3), + EXPECT_EQ(static_cast(f.fv3), *valueNow->get(StringFieldValue(k.key3))); } -void -FieldPathUpdateTestCase::testEqualityComparison() +TEST_F(FieldPathUpdateTestCase, testEqualityComparison) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:foo:zoo"))); MapFieldValue mfv(doc->getType().getField("structmap").getDataType()); @@ -1015,14 +901,14 @@ FieldPathUpdateTestCase::testEqualityComparison() { DocumentUpdate docUp1(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); DocumentUpdate docUp2(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); - CPPUNIT_ASSERT(docUp1 == docUp2); + EXPECT_TRUE(docUp1 == docUp2); FieldPathUpdate::CP assignUp1(new AssignFieldPathUpdate(*doc->getDataType(), "structmap{here be dragons}", std::string(), fv4)); docUp1.addFieldPathUpdate(assignUp1); - CPPUNIT_ASSERT(docUp1 != docUp2); + EXPECT_TRUE(docUp1 != docUp2); docUp2.addFieldPathUpdate(assignUp1); - CPPUNIT_ASSERT(docUp1 == docUp2); + EXPECT_TRUE(docUp1 == docUp2); } { DocumentUpdate docUp1(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); @@ -1034,7 +920,7 @@ FieldPathUpdateTestCase::testEqualityComparison() "structmap{here be dragons}", "false", fv4)); docUp1.addFieldPathUpdate(assignUp1); docUp2.addFieldPathUpdate(assignUp2); - CPPUNIT_ASSERT(docUp1 != docUp2); + EXPECT_TRUE(docUp1 != docUp2); } { DocumentUpdate docUp1(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); @@ -1046,13 +932,12 @@ FieldPathUpdateTestCase::testEqualityComparison() "structmap{here be kittens}", std::string(), fv4)); docUp1.addFieldPathUpdate(assignUp1); docUp2.addFieldPathUpdate(assignUp2); - CPPUNIT_ASSERT(docUp1 != docUp2); + EXPECT_TRUE(docUp1 != docUp2); } } -void -FieldPathUpdateTestCase::testAffectsDocumentBody() +TEST_F(FieldPathUpdateTestCase, testAffectsDocumentBody) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:things:stuff"))); MapFieldValue mfv(doc->getType().getField("structmap").getDataType()); @@ -1082,8 +967,7 @@ FieldPathUpdateTestCase::testAffectsDocumentBody() } -void -FieldPathUpdateTestCase::testIncompatibleDataTypeFails() +TEST_F(FieldPathUpdateTestCase, testIncompatibleDataTypeFails) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:things:stuff"))); MapFieldValue mfv(doc->getType().getField("structmap").getDataType()); @@ -1093,14 +977,13 @@ FieldPathUpdateTestCase::testIncompatibleDataTypeFails() try { FieldPathUpdate::CP update1(new AssignFieldPathUpdate(*doc->getDataType(), "structmap{foo}", std::string(), StringFieldValue("bad things"))); - CPPUNIT_ASSERT(false); + EXPECT_TRUE(false); } catch (const vespalib::IllegalArgumentException& e) { // OK } } -void -FieldPathUpdateTestCase::testSerializeAssign() +TEST_F(FieldPathUpdateTestCase, testSerializeAssign) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:weloveto:serializestuff"))); MapFieldValue mfv(doc->getType().getField("structmap").getDataType()); @@ -1118,11 +1001,10 @@ FieldPathUpdateTestCase::testSerializeAssign() testSerialize(*_repo, docUp); } -void -FieldPathUpdateTestCase::testSerializeAdd() +TEST_F(FieldPathUpdateTestCase, testSerializeAdd) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:george:costanza"))); - CPPUNIT_ASSERT(doc->hasValue("strarray") == false); + EXPECT_TRUE(doc->hasValue("strarray") == false); ArrayFieldValue adds(doc->getType().getField("strarray").getDataType()); adds.add(StringFieldValue("serenity now")); @@ -1137,8 +1019,7 @@ FieldPathUpdateTestCase::testSerializeAdd() testSerialize(*_repo, docUp); } -void -FieldPathUpdateTestCase::testSerializeRemove() +TEST_F(FieldPathUpdateTestCase, testSerializeRemove) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:weloveto:serializestuff"))); MapFieldValue mfv(doc->getType().getField("structmap").getDataType()); @@ -1151,11 +1032,10 @@ FieldPathUpdateTestCase::testSerializeRemove() testSerialize(*_repo, docUp); } -void -FieldPathUpdateTestCase::testSerializeAssignMath() +TEST_F(FieldPathUpdateTestCase, testSerializeAssignMath) { Document::UP doc(new Document(_foobar_type, DocumentId("doc:bat:man"))); - CPPUNIT_ASSERT(doc->hasValue("num") == false); + EXPECT_TRUE(doc->hasValue("num") == false); doc->setValue("num", IntFieldValue(34)); DocumentUpdate docUp(*_repo, _foobar_type, DocumentId("doc:barbar:foofoo")); @@ -1184,8 +1064,7 @@ FieldPathUpdateTestCase::createDocumentUpdateForSerialization(const DocumentType return docUp; } -void -FieldPathUpdateTestCase::testReadSerializedFile() +TEST_F(FieldPathUpdateTestCase, testReadSerializedFile) { // Reads a file serialized from java const std::string cfg_file_name = TEST_PATH("data/crossplatform-java-cpp-doctypes.cfg"); @@ -1205,11 +1084,10 @@ FieldPathUpdateTestCase::testReadSerializedFile() DocumentUpdate& upd(*updp); DocumentUpdate::UP compare(createDocumentUpdateForSerialization(repo)); - CPPUNIT_ASSERT_EQUAL(*compare, upd); + EXPECT_EQ(*compare, upd); } -void -FieldPathUpdateTestCase::testGenerateSerializedFile() +TEST_F(FieldPathUpdateTestCase, testGenerateSerializedFile) { const std::string cfg_file_name = TEST_PATH("data/crossplatform-java-cpp-doctypes.cfg"); DocumentTypeRepo repo(readDocumenttypesConfig(cfg_file_name)); @@ -1226,7 +1104,8 @@ FieldPathUpdateTestCase::testGenerateSerializedFile() close(fd); } -void FieldPathUpdateTestCase::array_element_update_for_invalid_index_is_ignored() { +TEST_F(FieldPathUpdateTestCase, array_element_update_for_invalid_index_is_ignored) +{ auto doc = std::make_unique(_foobar_type, DocumentId("id::foobar::1")); doc->setRepo(*_repo); auto& field = doc->getType().getField("strarray"); @@ -1242,7 +1121,7 @@ void FieldPathUpdateTestCase::array_element_update_for_invalid_index_is_ignored( // Doc is unmodified. auto new_arr = doc->getAs(field); - CPPUNIT_ASSERT_EQUAL(str_array, *new_arr); + EXPECT_EQ(str_array, *new_arr); } } diff --git a/document/src/tests/fieldsettest.cpp b/document/src/tests/fieldsettest.cpp index f3bc2a03bc5..0297e7bdda4 100644 --- a/document/src/tests/fieldsettest.cpp +++ b/document/src/tests/fieldsettest.cpp @@ -3,13 +3,12 @@ #include #include #include -#include - #include #include #include #include #include +#include using vespalib::nbostream; @@ -17,23 +16,9 @@ using namespace document::config_builder; namespace document { -struct FieldSetTest : public CppUnit::TestFixture { - void testParsing(); - void testContains(); - void testCopyDocumentFields(); - void testDocumentSubsetCopy(); - void testStripFields(); - void testSerialize(); - - CPPUNIT_TEST_SUITE(FieldSetTest); - CPPUNIT_TEST(testParsing); - CPPUNIT_TEST(testSerialize); - CPPUNIT_TEST(testContains); - CPPUNIT_TEST(testCopyDocumentFields); - CPPUNIT_TEST(testDocumentSubsetCopy); - CPPUNIT_TEST(testStripFields); - CPPUNIT_TEST_SUITE_END(); +class FieldSetTest : public ::testing::Test { +protected: std::string stringifyFields(const Document& doc) const; std::string doCopyFields(const Document& src, const DocumentTypeRepo& docRepo, @@ -48,9 +33,7 @@ struct FieldSetTest : public CppUnit::TestFixture { Document::UP createTestDocument(const TestDocMan& testDocMan) const; }; -CPPUNIT_TEST_SUITE_REGISTRATION(FieldSetTest); - -void FieldSetTest::testParsing() +TEST_F(FieldSetTest, testParsing) { TestDocMan testDocMan; const DocumentTypeRepo& docRepo = testDocMan.getTypeRepo(); @@ -73,7 +56,7 @@ void FieldSetTest::testParsing() ost << (*iter)->getName() << " "; } - CPPUNIT_ASSERT_EQUAL(std::string("content headerval "), ost.str()); + EXPECT_EQ(std::string("content headerval "), ost.str()); } namespace { @@ -98,7 +81,7 @@ bool checkError(FieldSetRepo& r, const DocumentTypeRepo& repo, } -void FieldSetTest::testContains() +TEST_F(FieldSetTest, testContains) { TestDocMan testDocMan; const DocumentTypeRepo& repo = testDocMan.getTypeRepo(); @@ -113,45 +96,44 @@ void FieldSetTest::testContains() HeaderFields h; BodyFields b; - CPPUNIT_ASSERT_EQUAL(false, headerField.contains( - type.getField("headerlongval"))); - CPPUNIT_ASSERT_EQUAL(true, headerField.contains(headerField)); - CPPUNIT_ASSERT_EQUAL(true, headerField.contains(id)); - CPPUNIT_ASSERT_EQUAL(false, headerField.contains(all)); - CPPUNIT_ASSERT_EQUAL(true, headerField.contains(none)); - CPPUNIT_ASSERT_EQUAL(false, none.contains(headerField)); - CPPUNIT_ASSERT_EQUAL(true, all.contains(headerField)); - CPPUNIT_ASSERT_EQUAL(true, all.contains(none)); - CPPUNIT_ASSERT_EQUAL(false, none.contains(all)); - CPPUNIT_ASSERT_EQUAL(true, all.contains(id)); - CPPUNIT_ASSERT_EQUAL(false, none.contains(id)); - CPPUNIT_ASSERT_EQUAL(true, id.contains(none)); - - CPPUNIT_ASSERT_EQUAL(true, h.contains(headerField)); - CPPUNIT_ASSERT_EQUAL(false, h.contains(bodyField)); - - CPPUNIT_ASSERT_EQUAL(false, b.contains(headerField)); - CPPUNIT_ASSERT_EQUAL(true, b.contains(bodyField)); + EXPECT_EQ(false, headerField.contains(type.getField("headerlongval"))); + EXPECT_EQ(true, headerField.contains(headerField)); + EXPECT_EQ(true, headerField.contains(id)); + EXPECT_EQ(false, headerField.contains(all)); + EXPECT_EQ(true, headerField.contains(none)); + EXPECT_EQ(false, none.contains(headerField)); + EXPECT_EQ(true, all.contains(headerField)); + EXPECT_EQ(true, all.contains(none)); + EXPECT_EQ(false, none.contains(all)); + EXPECT_EQ(true, all.contains(id)); + EXPECT_EQ(false, none.contains(id)); + EXPECT_EQ(true, id.contains(none)); + + EXPECT_EQ(true, h.contains(headerField)); + EXPECT_EQ(false, h.contains(bodyField)); + + EXPECT_EQ(false, b.contains(headerField)); + EXPECT_EQ(true, b.contains(bodyField)); FieldSetRepo r; - CPPUNIT_ASSERT_EQUAL(true, checkContains(r, repo, "[body]", + EXPECT_EQ(true, checkContains(r, repo, "[body]", "testdoctype1:content")); - CPPUNIT_ASSERT_EQUAL(false, checkContains(r, repo, "[header]", + EXPECT_EQ(false, checkContains(r, repo, "[header]", "testdoctype1:content")); - CPPUNIT_ASSERT_EQUAL(true, checkContains(r, repo, + EXPECT_EQ(true, checkContains(r, repo, "testdoctype1:content,headerval", "testdoctype1:content")); - CPPUNIT_ASSERT_EQUAL(false, checkContains(r, repo, + EXPECT_EQ(false, checkContains(r, repo, "testdoctype1:content", "testdoctype1:content,headerval")); - CPPUNIT_ASSERT_EQUAL(true, checkContains(r, repo, + EXPECT_EQ(true, checkContains(r, repo, "testdoctype1:headerval,content", "testdoctype1:content,headerval")); - CPPUNIT_ASSERT(checkError(r, repo, "nodoctype")); - CPPUNIT_ASSERT(checkError(r, repo, "unknowndoctype:foo")); - CPPUNIT_ASSERT(checkError(r, repo, "testdoctype1:unknownfield")); - CPPUNIT_ASSERT(checkError(r, repo, "[badid]")); + EXPECT_TRUE(checkError(r, repo, "nodoctype")); + EXPECT_TRUE(checkError(r, repo, "unknowndoctype:foo")); + EXPECT_TRUE(checkError(r, repo, "testdoctype1:unknownfield")); + EXPECT_TRUE(checkError(r, repo, "[badid]")); } std::string @@ -221,33 +203,32 @@ FieldSetTest::createTestDocument(const TestDocMan& testDocMan) const return doc; } -void -FieldSetTest::testCopyDocumentFields() +TEST_F(FieldSetTest, testCopyDocumentFields) { TestDocMan testDocMan; const DocumentTypeRepo& repo = testDocMan.getTypeRepo(); Document::UP src(createTestDocument(testDocMan)); - CPPUNIT_ASSERT_EQUAL(std::string("content: megafoo megabar\n"), - doCopyFields(*src, repo, "[body]")); - CPPUNIT_ASSERT_EQUAL(std::string(""), - doCopyFields(*src, repo, "[none]")); - CPPUNIT_ASSERT_EQUAL(std::string("headerval: 5678\n" - "hstringval: hello fantastic world\n"), - doCopyFields(*src, repo, "[header]")); - CPPUNIT_ASSERT_EQUAL(std::string("content: megafoo megabar\n" - "headerval: 5678\n" - "hstringval: hello fantastic world\n"), - doCopyFields(*src, repo, "[all]")); - CPPUNIT_ASSERT_EQUAL(std::string("content: megafoo megabar\n" - "hstringval: hello fantastic world\n"), - doCopyFields(*src, repo, "testdoctype1:hstringval,content")); + EXPECT_EQ(std::string("content: megafoo megabar\n"), + doCopyFields(*src, repo, "[body]")); + EXPECT_EQ(std::string(""), + doCopyFields(*src, repo, "[none]")); + EXPECT_EQ(std::string("headerval: 5678\n" + "hstringval: hello fantastic world\n"), + doCopyFields(*src, repo, "[header]")); + EXPECT_EQ(std::string("content: megafoo megabar\n" + "headerval: 5678\n" + "hstringval: hello fantastic world\n"), + doCopyFields(*src, repo, "[all]")); + EXPECT_EQ(std::string("content: megafoo megabar\n" + "hstringval: hello fantastic world\n"), + doCopyFields(*src, repo, "testdoctype1:hstringval,content")); // Test that we overwrite already set fields in destination document { Document dest(src->getType(), DocumentId("doc:foo:bar")); dest.setValue(dest.getField("content"), StringFieldValue("overwriteme")); - CPPUNIT_ASSERT_EQUAL(std::string("content: megafoo megabar\n"), - doCopyFields(*src, repo, "[body]", &dest)); + EXPECT_EQ(std::string("content: megafoo megabar\n"), + doCopyFields(*src, repo, "[body]", &dest)); } } @@ -263,8 +244,7 @@ FieldSetTest::doCopyDocument(const Document& src, } -void -FieldSetTest::testDocumentSubsetCopy() +TEST_F(FieldSetTest, testDocumentSubsetCopy) { TestDocMan testDocMan; const DocumentTypeRepo& repo = testDocMan.getTypeRepo(); @@ -273,11 +253,11 @@ FieldSetTest::testDocumentSubsetCopy() { Document::UP doc(FieldSet::createDocumentSubsetCopy(*src, AllFields())); // Test that document id and type are copied correctly. - CPPUNIT_ASSERT(doc.get()); - CPPUNIT_ASSERT_EQUAL(src->getId(), doc->getId()); - CPPUNIT_ASSERT_EQUAL(src->getType(), doc->getType()); - CPPUNIT_ASSERT_EQUAL(doCopyFields(*src, repo, "[all]"), - stringifyFields(*doc)); + EXPECT_TRUE(doc.get()); + EXPECT_EQ(src->getId(), doc->getId()); + EXPECT_EQ(src->getType(), doc->getType()); + EXPECT_EQ(doCopyFields(*src, repo, "[all]"), + stringifyFields(*doc)); } const char* fieldSets[] = { @@ -288,13 +268,12 @@ FieldSetTest::testDocumentSubsetCopy() "testdoctype1:hstringval,content" }; for (size_t i = 0; i < sizeof(fieldSets) / sizeof(fieldSets[0]); ++i) { - CPPUNIT_ASSERT_EQUAL(doCopyFields(*src, repo, fieldSets[i]), - doCopyDocument(*src, repo, fieldSets[i])); + EXPECT_EQ(doCopyFields(*src, repo, fieldSets[i]), + doCopyDocument(*src, repo, fieldSets[i])); } } -void -FieldSetTest::testSerialize() +TEST_F(FieldSetTest, testSerialize) { TestDocMan testDocMan; const DocumentTypeRepo& docRepo = testDocMan.getTypeRepo(); @@ -312,33 +291,32 @@ FieldSetTest::testSerialize() FieldSetRepo repo; for (size_t i = 0; i < sizeof(fieldSets) / sizeof(fieldSets[0]); ++i) { FieldSet::UP fs = repo.parse(docRepo, fieldSets[i]); - CPPUNIT_ASSERT_EQUAL(vespalib::string(fieldSets[i]), repo.serialize(*fs)); + EXPECT_EQ(vespalib::string(fieldSets[i]), repo.serialize(*fs)); } } -void -FieldSetTest::testStripFields() +TEST_F(FieldSetTest, testStripFields) { TestDocMan testDocMan; const DocumentTypeRepo& repo = testDocMan.getTypeRepo(); Document::UP src(createTestDocument(testDocMan)); - CPPUNIT_ASSERT_EQUAL(std::string("content: megafoo megabar\n"), - doStripFields(*src, repo, "[body]")); - CPPUNIT_ASSERT_EQUAL(std::string(""), - doStripFields(*src, repo, "[none]")); - CPPUNIT_ASSERT_EQUAL(std::string(""), - doStripFields(*src, repo, "[id]")); - CPPUNIT_ASSERT_EQUAL(std::string("headerval: 5678\n" - "hstringval: hello fantastic world\n"), - doStripFields(*src, repo, "[header]")); - CPPUNIT_ASSERT_EQUAL(std::string("content: megafoo megabar\n" - "headerval: 5678\n" - "hstringval: hello fantastic world\n"), - doStripFields(*src, repo, "[all]")); - CPPUNIT_ASSERT_EQUAL(std::string("content: megafoo megabar\n" - "hstringval: hello fantastic world\n"), - doStripFields(*src, repo, "testdoctype1:hstringval,content")); + EXPECT_EQ(std::string("content: megafoo megabar\n"), + doStripFields(*src, repo, "[body]")); + EXPECT_EQ(std::string(""), + doStripFields(*src, repo, "[none]")); + EXPECT_EQ(std::string(""), + doStripFields(*src, repo, "[id]")); + EXPECT_EQ(std::string("headerval: 5678\n" + "hstringval: hello fantastic world\n"), + doStripFields(*src, repo, "[header]")); + EXPECT_EQ(std::string("content: megafoo megabar\n" + "headerval: 5678\n" + "hstringval: hello fantastic world\n"), + doStripFields(*src, repo, "[all]")); + EXPECT_EQ(std::string("content: megafoo megabar\n" + "hstringval: hello fantastic world\n"), + doStripFields(*src, repo, "testdoctype1:hstringval,content")); } } // document diff --git a/document/src/tests/fixed_bucket_spaces_test.cpp b/document/src/tests/fixed_bucket_spaces_test.cpp index 12c248adf37..87903281c46 100644 --- a/document/src/tests/fixed_bucket_spaces_test.cpp +++ b/document/src/tests/fixed_bucket_spaces_test.cpp @@ -1,62 +1,48 @@ // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include -#include +#include namespace document { -struct FixedBucketSpacesTest : CppUnit::TestFixture { - CPPUNIT_TEST_SUITE(FixedBucketSpacesTest); - CPPUNIT_TEST(bucket_space_from_name_is_defined_for_default_space); - CPPUNIT_TEST(bucket_space_from_name_is_defined_for_global_space); - CPPUNIT_TEST(bucket_space_from_name_throws_exception_for_unknown_space); - CPPUNIT_TEST(name_from_bucket_space_is_defined_for_default_space); - CPPUNIT_TEST(name_from_bucket_space_is_defined_for_global_space); - CPPUNIT_TEST(name_from_bucket_space_throws_exception_for_unknown_space); - CPPUNIT_TEST_SUITE_END(); - - void bucket_space_from_name_is_defined_for_default_space(); - void bucket_space_from_name_is_defined_for_global_space(); - void bucket_space_from_name_throws_exception_for_unknown_space(); - void name_from_bucket_space_is_defined_for_default_space(); - void name_from_bucket_space_is_defined_for_global_space(); - void name_from_bucket_space_throws_exception_for_unknown_space(); -}; - -CPPUNIT_TEST_SUITE_REGISTRATION(FixedBucketSpacesTest); - -void FixedBucketSpacesTest::bucket_space_from_name_is_defined_for_default_space() { - CPPUNIT_ASSERT_EQUAL(FixedBucketSpaces::default_space(), FixedBucketSpaces::from_string("default")); +TEST(FixedBucketSpacesTest, bucket_space_from_name_is_defined_for_default_space) +{ + EXPECT_EQ(FixedBucketSpaces::default_space(), FixedBucketSpaces::from_string("default")); } -void FixedBucketSpacesTest::bucket_space_from_name_is_defined_for_global_space() { - CPPUNIT_ASSERT_EQUAL(FixedBucketSpaces::global_space(), FixedBucketSpaces::from_string("global")); +TEST(FixedBucketSpacesTest, bucket_space_from_name_is_defined_for_global_space) +{ + EXPECT_EQ(FixedBucketSpaces::global_space(), FixedBucketSpaces::from_string("global")); } -void FixedBucketSpacesTest::bucket_space_from_name_throws_exception_for_unknown_space() { +TEST(FixedBucketSpacesTest, bucket_space_from_name_throws_exception_for_unknown_space) +{ try { FixedBucketSpaces::from_string("banana"); - CPPUNIT_FAIL("Expected exception on unknown bucket space name"); + FAIL() << "Expected exception on unknown bucket space name"; } catch (document::UnknownBucketSpaceException& e) { } } -void FixedBucketSpacesTest::name_from_bucket_space_is_defined_for_default_space() { - CPPUNIT_ASSERT_EQUAL(vespalib::stringref("default"), +TEST(FixedBucketSpacesTest, name_from_bucket_space_is_defined_for_default_space) +{ + EXPECT_EQ(vespalib::stringref("default"), FixedBucketSpaces::to_string(FixedBucketSpaces::default_space())); - CPPUNIT_ASSERT_EQUAL(vespalib::stringref("default"), FixedBucketSpaces::default_space_name()); + EXPECT_EQ(vespalib::stringref("default"), FixedBucketSpaces::default_space_name()); } -void FixedBucketSpacesTest::name_from_bucket_space_is_defined_for_global_space() { - CPPUNIT_ASSERT_EQUAL(vespalib::stringref("global"), +TEST(FixedBucketSpacesTest, name_from_bucket_space_is_defined_for_global_space) +{ + EXPECT_EQ(vespalib::stringref("global"), FixedBucketSpaces::to_string(FixedBucketSpaces::global_space())); - CPPUNIT_ASSERT_EQUAL(vespalib::stringref("global"), FixedBucketSpaces::global_space_name()); + EXPECT_EQ(vespalib::stringref("global"), FixedBucketSpaces::global_space_name()); } -void FixedBucketSpacesTest::name_from_bucket_space_throws_exception_for_unknown_space() { +TEST(FixedBucketSpacesTest, name_from_bucket_space_throws_exception_for_unknown_space) +{ try { FixedBucketSpaces::to_string(BucketSpace(4567)); - CPPUNIT_FAIL("Expected exception on unknown bucket space value"); + FAIL() << "Expected exception on unknown bucket space value"; } catch (document::UnknownBucketSpaceException& e) { } } diff --git a/document/src/tests/forcelinktest.cpp b/document/src/tests/forcelinktest.cpp index 6839843c7aa..421138f34cf 100644 --- a/document/src/tests/forcelinktest.cpp +++ b/document/src/tests/forcelinktest.cpp @@ -1,22 +1,11 @@ // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include -#include +#include namespace document { -struct ForceLinkTest : public CppUnit::TestFixture { - void testUsage(); - - CPPUNIT_TEST_SUITE(ForceLinkTest); - CPPUNIT_TEST(testUsage); - CPPUNIT_TEST_SUITE_END(); - -}; - -CPPUNIT_TEST_SUITE_REGISTRATION(ForceLinkTest); - -void ForceLinkTest::testUsage() +TEST(ForceLinkTest, testUsage) { ForceLink link; } diff --git a/document/src/tests/gid_filter_test.cpp b/document/src/tests/gid_filter_test.cpp index 7519c8f29dd..dcfafb56b99 100644 --- a/document/src/tests/gid_filter_test.cpp +++ b/document/src/tests/gid_filter_test.cpp @@ -1,16 +1,16 @@ // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include -#include #include #include #include #include +#include -namespace document { -namespace select { +namespace document::select { -class GidFilterTest : public CppUnit::TestFixture { +class GidFilterTest : public ::testing::Test { + +protected: struct Fixture { TestDocRepo _repo; BucketIdFactory _id_factory; @@ -38,48 +38,6 @@ class GidFilterTest : public CppUnit::TestFixture { auto filter = GidFilter::for_selection_root_node(*f._root); return filter.gid_might_match_selection(id_to_gid(id_string)); } - - CPPUNIT_TEST_SUITE(GidFilterTest); - CPPUNIT_TEST(same_user_for_selection_and_gid_returns_match); - CPPUNIT_TEST(differing_user_for_selection_and_gid_returns_mismatch); - CPPUNIT_TEST(user_location_constraint_is_order_invariant); - CPPUNIT_TEST(non_location_selection_always_matches); - CPPUNIT_TEST(location_selection_does_not_match_non_location_id); - CPPUNIT_TEST(simple_conjunctive_location_expressions_are_filtered); - CPPUNIT_TEST(complex_conjunctive_location_expressions_are_filtered); - CPPUNIT_TEST(simple_disjunctive_location_expressions_are_not_filtered); - CPPUNIT_TEST(complex_disjunctive_location_expressions_are_not_filtered); - CPPUNIT_TEST(non_location_id_comparisons_are_not_filtered); - CPPUNIT_TEST(unsupported_location_comparison_operands_not_filtered); - CPPUNIT_TEST(default_constructed_filter_always_matches); - CPPUNIT_TEST(most_significant_32_bits_are_ignored); - CPPUNIT_TEST(gid_filters_may_be_copy_constructed); - CPPUNIT_TEST(gid_filters_may_be_copy_assigned); - CPPUNIT_TEST(same_group_for_selection_and_gid_returns_match); - CPPUNIT_TEST(differing_group_for_selection_and_gid_returns_mismatch); - CPPUNIT_TEST(composite_user_comparison_sub_expressions_not_supported); - CPPUNIT_TEST(composite_group_comparison_sub_expressions_not_supported); - CPPUNIT_TEST_SUITE_END(); -public: - void same_user_for_selection_and_gid_returns_match(); - void differing_user_for_selection_and_gid_returns_mismatch(); - void user_location_constraint_is_order_invariant(); - void non_location_selection_always_matches(); - void location_selection_does_not_match_non_location_id(); - void simple_conjunctive_location_expressions_are_filtered(); - void complex_conjunctive_location_expressions_are_filtered(); - void simple_disjunctive_location_expressions_are_not_filtered(); - void complex_disjunctive_location_expressions_are_not_filtered(); - void non_location_id_comparisons_are_not_filtered(); - void unsupported_location_comparison_operands_not_filtered(); - void default_constructed_filter_always_matches(); - void most_significant_32_bits_are_ignored(); - void gid_filters_may_be_copy_constructed(); - void gid_filters_may_be_copy_assigned(); - void same_group_for_selection_and_gid_returns_match(); - void differing_group_for_selection_and_gid_returns_mismatch(); - void composite_user_comparison_sub_expressions_not_supported(); - void composite_group_comparison_sub_expressions_not_supported(); }; GidFilterTest::Fixture::Fixture(vespalib::stringref selection) @@ -89,157 +47,142 @@ GidFilterTest::Fixture::Fixture(vespalib::stringref selection) { } GidFilterTest::Fixture::~Fixture() { } -CPPUNIT_TEST_SUITE_REGISTRATION(GidFilterTest); - -void -GidFilterTest::same_user_for_selection_and_gid_returns_match() +TEST_F(GidFilterTest, same_user_for_selection_and_gid_returns_match) { - CPPUNIT_ASSERT(might_match("id.user == 12345", - "id::testdoctype1:n=12345:foo")); + EXPECT_TRUE(might_match("id.user == 12345", + "id::testdoctype1:n=12345:foo")); // User locations are defined over [0, 2**63-1] - CPPUNIT_ASSERT(might_match("id.user == 0", - "id::testdoctype1:n=0:foo")); - CPPUNIT_ASSERT(might_match("id.user == 9223372036854775807" , - "id::testdoctype1:n=9223372036854775807:foo")); + EXPECT_TRUE(might_match("id.user == 0", + "id::testdoctype1:n=0:foo")); + EXPECT_TRUE(might_match("id.user == 9223372036854775807" , + "id::testdoctype1:n=9223372036854775807:foo")); } -void -GidFilterTest::differing_user_for_selection_and_gid_returns_mismatch() +TEST_F(GidFilterTest, differing_user_for_selection_and_gid_returns_mismatch) { - CPPUNIT_ASSERT(!might_match("id.user == 1", "id::testdoctype1:n=2000:foo")); + EXPECT_TRUE(!might_match("id.user == 1", "id::testdoctype1:n=2000:foo")); // Similar, but non-identical, bit patterns - CPPUNIT_ASSERT(!might_match("id.user == 12345", - "id::testdoctype1:n=12346:foo")); - CPPUNIT_ASSERT(!might_match("id.user == 12345", - "id::testdoctype1:n=12344:foo")); + EXPECT_TRUE(!might_match("id.user == 12345", + "id::testdoctype1:n=12346:foo")); + EXPECT_TRUE(!might_match("id.user == 12345", + "id::testdoctype1:n=12344:foo")); } -void -GidFilterTest::user_location_constraint_is_order_invariant() +TEST_F(GidFilterTest, user_location_constraint_is_order_invariant) { - CPPUNIT_ASSERT(might_match("12345 == id.user", - "id::testdoctype1:n=12345:foo")); - CPPUNIT_ASSERT(!might_match("12345 == id.user", - "id::testdoctype1:n=12346:foo")); + EXPECT_TRUE(might_match("12345 == id.user", + "id::testdoctype1:n=12345:foo")); + EXPECT_TRUE(!might_match("12345 == id.user", + "id::testdoctype1:n=12346:foo")); } -void -GidFilterTest::non_location_selection_always_matches() +TEST_F(GidFilterTest, non_location_selection_always_matches) { - CPPUNIT_ASSERT(might_match("testdoctype1.headerval == 67890", - "id::testdoctype1:n=12345:foo")); + EXPECT_TRUE(might_match("testdoctype1.headerval == 67890", + "id::testdoctype1:n=12345:foo")); } -void -GidFilterTest::location_selection_does_not_match_non_location_id() +TEST_F(GidFilterTest, location_selection_does_not_match_non_location_id) { // Test name is a half-truth; the MD5-derived ID _will_ give a false // positive every 2**32 or so document ID when the stars and their bit // patterns align :) - CPPUNIT_ASSERT(!might_match("id.user == 987654321", - "id::testdoctype1::foo")); + EXPECT_TRUE(!might_match("id.user == 987654321", + "id::testdoctype1::foo")); - CPPUNIT_ASSERT(!might_match("id.group == 'snusmumrikk'", - "id::testdoctype1::foo")); + EXPECT_TRUE(!might_match("id.group == 'snusmumrikk'", + "id::testdoctype1::foo")); } -void -GidFilterTest::simple_conjunctive_location_expressions_are_filtered() +TEST_F(GidFilterTest, simple_conjunctive_location_expressions_are_filtered) { // A conjunctive expression in this context is one where there exist a // location predicate and the result of the entire expression can only // be true iff the location predicate matches. - CPPUNIT_ASSERT(might_match("id.user == 12345 and true", - "id::testdoctype1:n=12345:bar")); - CPPUNIT_ASSERT(might_match("true and id.user == 12345", - "id::testdoctype1:n=12345:bar")); + EXPECT_TRUE(might_match("id.user == 12345 and true", + "id::testdoctype1:n=12345:bar")); + EXPECT_TRUE(might_match("true and id.user == 12345", + "id::testdoctype1:n=12345:bar")); - CPPUNIT_ASSERT(!might_match("id.user == 123456 and true", - "id::testdoctype1:n=12345:bar")); - CPPUNIT_ASSERT(!might_match("true and id.user == 123456", - "id::testdoctype1:n=12345:bar")); + EXPECT_TRUE(!might_match("id.user == 123456 and true", + "id::testdoctype1:n=12345:bar")); + EXPECT_TRUE(!might_match("true and id.user == 123456", + "id::testdoctype1:n=12345:bar")); } -void -GidFilterTest::complex_conjunctive_location_expressions_are_filtered() +TEST_F(GidFilterTest, complex_conjunctive_location_expressions_are_filtered) { - CPPUNIT_ASSERT(might_match("(((testdoctype1.headerval < 5) and (1 != 2)) " - "and id.user == 12345)", + EXPECT_TRUE(might_match("(((testdoctype1.headerval < 5) and (1 != 2)) " + "and id.user == 12345)", "id::testdoctype1:n=12345:bar")); - CPPUNIT_ASSERT(!might_match("(((1 != 2) and (id.user==12345)) and " - "(2 != 3)) and (testdoctype1.headerval < 5)", - "id::testdoctype1:n=23456:bar")); + EXPECT_TRUE(!might_match("(((1 != 2) and (id.user==12345)) and " + "(2 != 3)) and (testdoctype1.headerval < 5)", + "id::testdoctype1:n=23456:bar")); // In this case the expression contains a disjunction but the outcome // of evaluating it still strongly depends on the location predicate. - CPPUNIT_ASSERT(might_match("((id.user == 12345 and true) and " - "(true or false))", - "id::testdoctype1:n=12345:bar")); - CPPUNIT_ASSERT(!might_match("((id.user == 12345 and true) and " - "(true or false))", - "id::testdoctype1:n=23456:bar")); + EXPECT_TRUE(might_match("((id.user == 12345 and true) and " + "(true or false))", + "id::testdoctype1:n=12345:bar")); + EXPECT_TRUE(!might_match("((id.user == 12345 and true) and " + "(true or false))", + "id::testdoctype1:n=23456:bar")); } -void -GidFilterTest::simple_disjunctive_location_expressions_are_not_filtered() +TEST_F(GidFilterTest, simple_disjunctive_location_expressions_are_not_filtered) { // Documents mismatch location but match selection as a whole. - CPPUNIT_ASSERT(might_match("id.user == 12345 or true", - "id::testdoctype1:n=12345678:bar")); - CPPUNIT_ASSERT(might_match("true or id.user == 12345", - "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("id.user == 12345 or true", + "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("true or id.user == 12345", + "id::testdoctype1:n=12345678:bar")); } -void -GidFilterTest::complex_disjunctive_location_expressions_are_not_filtered() +TEST_F(GidFilterTest, complex_disjunctive_location_expressions_are_not_filtered) { - CPPUNIT_ASSERT(might_match("((id.user == 12345) and true) or false", - "id::testdoctype1:n=12345678:bar")); - CPPUNIT_ASSERT(might_match("((id.user == 12345) or false) and true", - "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("((id.user == 12345) and true) or false", + "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("((id.user == 12345) or false) and true", + "id::testdoctype1:n=12345678:bar")); } -void -GidFilterTest::non_location_id_comparisons_are_not_filtered() +TEST_F(GidFilterTest, non_location_id_comparisons_are_not_filtered) { // Note: these selections are syntactically valid but semantically // invalid (comparing strings to integers), but are used to catch any // logic holes where an id node is indiscriminately treated as something // from which we should derive a GID-related integer. - CPPUNIT_ASSERT(might_match("id.namespace == 123456", - "id::testdoctype1:n=12345678:bar")); - CPPUNIT_ASSERT(might_match("id.type == 1234", - "id::testdoctype1:n=12345678:bar")); - CPPUNIT_ASSERT(might_match("id.scheme == 555", - "id::testdoctype1:n=12345678:bar")); - CPPUNIT_ASSERT(might_match("id.specific == 7654", - "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("id.namespace == 123456", + "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("id.type == 1234", + "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("id.scheme == 555", + "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("id.specific == 7654", + "id::testdoctype1:n=12345678:bar")); } -void -GidFilterTest::unsupported_location_comparison_operands_not_filtered() +TEST_F(GidFilterTest, unsupported_location_comparison_operands_not_filtered) { - CPPUNIT_ASSERT(might_match("id.user == 'rick & morty'", - "id::testdoctype1:n=12345678:bar")); - CPPUNIT_ASSERT(might_match("id.group == 56789", - "id::testdoctype1:n=12345678:bar")); - CPPUNIT_ASSERT(might_match("id.user == testdoctype1.headervalue", - "id::testdoctype1:n=12345678:bar")); - CPPUNIT_ASSERT(might_match("id.group == testdoctype1.headervalue", - "id::testdoctype1:g=helloworld:bar")); + EXPECT_TRUE(might_match("id.user == 'rick & morty'", + "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("id.group == 56789", + "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("id.user == testdoctype1.headervalue", + "id::testdoctype1:n=12345678:bar")); + EXPECT_TRUE(might_match("id.group == testdoctype1.headervalue", + "id::testdoctype1:g=helloworld:bar")); } -void -GidFilterTest::default_constructed_filter_always_matches() +TEST_F(GidFilterTest, default_constructed_filter_always_matches) { GidFilter filter; - CPPUNIT_ASSERT(filter.gid_might_match_selection( + EXPECT_TRUE(filter.gid_might_match_selection( DocumentId("id::testdoctype1:n=12345678:bar").getGlobalId())); - CPPUNIT_ASSERT(filter.gid_might_match_selection( + EXPECT_TRUE(filter.gid_might_match_selection( DocumentId("id::testdoctype1::foo").getGlobalId())); } -void -GidFilterTest::most_significant_32_bits_are_ignored() +TEST_F(GidFilterTest, most_significant_32_bits_are_ignored) { // The fact that the 32 MSB are effectively ignored is an artifact of // how the GID location extraction is historically performed and is not @@ -248,26 +191,24 @@ GidFilterTest::most_significant_32_bits_are_ignored() // behavior currently is and should thus be tested. // The following locations have the same 32 LSB: - CPPUNIT_ASSERT(might_match("id.user == 12345678901", - "id::testdoctype1:n=29525548085:bar")); + EXPECT_TRUE(might_match("id.user == 12345678901", + "id::testdoctype1:n=29525548085:bar")); } -void -GidFilterTest::gid_filters_may_be_copy_constructed() +TEST_F(GidFilterTest, gid_filters_may_be_copy_constructed) { Fixture f("id.user == 1337"); GidFilter filter = GidFilter::for_selection_root_node(*f._root); GidFilter copy_constructed(filter); - CPPUNIT_ASSERT(copy_constructed.gid_might_match_selection( + EXPECT_TRUE(copy_constructed.gid_might_match_selection( id_to_gid("id::testdoctype1:n=1337:zoid"))); - CPPUNIT_ASSERT(!copy_constructed.gid_might_match_selection( + EXPECT_TRUE(!copy_constructed.gid_might_match_selection( id_to_gid("id::testdoctype1:n=555:zoid"))); } -void -GidFilterTest::gid_filters_may_be_copy_assigned() +TEST_F(GidFilterTest, gid_filters_may_be_copy_assigned) { Fixture f("id.user == 1337"); GidFilter filter = GidFilter::for_selection_root_node(*f._root); @@ -275,45 +216,40 @@ GidFilterTest::gid_filters_may_be_copy_assigned() GidFilter copy_assigned; copy_assigned = filter; - CPPUNIT_ASSERT(copy_assigned.gid_might_match_selection( + EXPECT_TRUE(copy_assigned.gid_might_match_selection( id_to_gid("id::testdoctype1:n=1337:zoid"))); - CPPUNIT_ASSERT(!copy_assigned.gid_might_match_selection( + EXPECT_TRUE(!copy_assigned.gid_might_match_selection( id_to_gid("id::testdoctype1:n=555:zoid"))); } -void -GidFilterTest::same_group_for_selection_and_gid_returns_match() +TEST_F(GidFilterTest, same_group_for_selection_and_gid_returns_match) { - CPPUNIT_ASSERT(might_match("id.group == 'bjarne'", - "id::testdoctype1:g=bjarne:foo")); - CPPUNIT_ASSERT(might_match("id.group == 'andrei'", - "id::testdoctype1:g=andrei:bar")); + EXPECT_TRUE(might_match("id.group == 'bjarne'", + "id::testdoctype1:g=bjarne:foo")); + EXPECT_TRUE(might_match("id.group == 'andrei'", + "id::testdoctype1:g=andrei:bar")); } -void -GidFilterTest::differing_group_for_selection_and_gid_returns_mismatch() +TEST_F(GidFilterTest, differing_group_for_selection_and_gid_returns_mismatch) { - CPPUNIT_ASSERT(!might_match("id.group == 'cult of bjarne'", - "id::testdoctype1:g=stl:foo")); - CPPUNIT_ASSERT(!might_match("id.group == 'sutters mill'", - "id::testdoctype1:g=andrei:bar")); + EXPECT_TRUE(!might_match("id.group == 'cult of bjarne'", + "id::testdoctype1:g=stl:foo")); + EXPECT_TRUE(!might_match("id.group == 'sutters mill'", + "id::testdoctype1:g=andrei:bar")); } -void -GidFilterTest::composite_user_comparison_sub_expressions_not_supported() +TEST_F(GidFilterTest, composite_user_comparison_sub_expressions_not_supported) { // Technically this is a mismatch, but we currently only want to support // the simple, obvious cases since this is not an expected use case. - CPPUNIT_ASSERT(might_match("id.user == (1 + 2)", - "id::testdoctype1:n=20:foo")); + EXPECT_TRUE(might_match("id.user == (1 + 2)", + "id::testdoctype1:n=20:foo")); } -void -GidFilterTest::composite_group_comparison_sub_expressions_not_supported() +TEST_F(GidFilterTest, composite_group_comparison_sub_expressions_not_supported) { - CPPUNIT_ASSERT(might_match("id.group == 'foo'+'bar'", - "id::testdoctype1:g=sputnik_hits:foo")); + EXPECT_TRUE(might_match("id.group == 'foo'+'bar'", + "id::testdoctype1:g=sputnik_hits:foo")); } -} // select -} // document +} diff --git a/document/src/tests/globalidtest.cpp b/document/src/tests/globalidtest.cpp index c72ede2f20e..c6c974011ce 100644 --- a/document/src/tests/globalidtest.cpp +++ b/document/src/tests/globalidtest.cpp @@ -1,80 +1,66 @@ // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include #include #include #include #include #include +#include namespace document { -struct GlobalIdTest : public CppUnit::TestFixture { - void testNormalUsage(); - void testBucketIdConversion(); - void testGidRangeConversion(); - void testBucketOrderCmp(); +class GlobalIdTest : public ::testing::Test { +protected: void verifyGlobalIdRange(const std::vector& ids, uint32_t countBits); - - CPPUNIT_TEST_SUITE(GlobalIdTest); - CPPUNIT_TEST(testNormalUsage); - CPPUNIT_TEST(testBucketIdConversion); - CPPUNIT_TEST(testGidRangeConversion); - CPPUNIT_TEST(testBucketOrderCmp); - CPPUNIT_TEST_SUITE_END(); }; -CPPUNIT_TEST_SUITE_REGISTRATION(GlobalIdTest); - -void -GlobalIdTest::testNormalUsage() +TEST_F(GlobalIdTest, testNormalUsage) { const char* emptystring = "\0\0\0\0\0\0\0\0\0\0\0\0"; const char* teststring = "1234567890ABCDEF"; - CPPUNIT_ASSERT(strlen(teststring) > GlobalId::LENGTH); + EXPECT_TRUE(strlen(teststring) > GlobalId::LENGTH); { // Test empty global id GlobalId id; for (uint32_t i=0; i& ids, << " should be in the range " << first.convertToBucketId().toKey() << " - " << last.convertToBucketId().toKey() << "\n"; - CPPUNIT_ASSERT_MESSAGE(msg.str(), - gid.convertToBucketId().toKey() >= - first.convertToBucketId().toKey()); - CPPUNIT_ASSERT_MESSAGE(msg.str(), - gid.convertToBucketId().toKey() <= - last.convertToBucketId().toKey()); + EXPECT_TRUE(gid.convertToBucketId().toKey() >= first.convertToBucketId().toKey()) << msg.str(); + EXPECT_TRUE(gid.convertToBucketId().toKey() <= last.convertToBucketId().toKey()) << msg.str(); } } else { if ((gidKey >= first.convertToBucketId().toKey()) && (gidKey <= last.convertToBucketId().toKey())) { std::ostringstream msg; msg << gid << " should not be in the range " << first << " - " << last; - CPPUNIT_ASSERT_MESSAGE(msg.str(), - (gid.convertToBucketId().toKey() < - first.convertToBucketId().toKey()) - || - (gid.convertToBucketId().toKey() > - last.convertToBucketId().toKey())); + EXPECT_TRUE((gid.convertToBucketId().toKey() < first.convertToBucketId().toKey()) || + (gid.convertToBucketId().toKey() > last.convertToBucketId().toKey())) << msg.str(); } } } } } -void -GlobalIdTest::testGidRangeConversion() +TEST_F(GlobalIdTest, testGidRangeConversion) { // Generate a lot of random document ids used for test std::vector docIds; @@ -194,7 +168,7 @@ GlobalIdTest::testGidRangeConversion() } ost << ":"; break; - default: CPPUNIT_ASSERT(false); + default: EXPECT_TRUE(false); } ost << "http://"; for (uint32_t i=0, n=randomizer.nextUint32(1, 20); ifirst == bar); - CPPUNIT_ASSERT(it->second == 777); + EXPECT_TRUE(it->first == bar); + EXPECT_TRUE(it->second == 777); ++it; - CPPUNIT_ASSERT(it->first == baz); - CPPUNIT_ASSERT(it->second == 888); + EXPECT_TRUE(it->first == baz); + EXPECT_TRUE(it->second == 888); ++it; - CPPUNIT_ASSERT(it->first == foo); - CPPUNIT_ASSERT(it->second == 666); + EXPECT_TRUE(it->first == foo); + EXPECT_TRUE(it->second == 666); } } -} // document +} -- cgit v1.2.3