Adding upstream version 2.4.1.upstream/2.4.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 162 insertions, 0 deletions

diff --git a/src/lib/util/tests/optional_unittest.cc b/src/lib/util/tests/optional_unittest.cc
new file mode 100644
index 0000000..71830ab
--- /dev/null
+++ b/src/lib/util/tests/optional_unittest.cc
@@ -0,0 +1,162 @@
+// Copyright (C) 2015-2022 Internet Systems Consortium, Inc. ("ISC")
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include <config.h>
+#include <util/optional.h>
+#include <gtest/gtest.h>
+
+namespace {
+
+using namespace isc::util;
+
+// This test checks that the constructors work correctly.
+TEST(OptionalTest, constructor) {
+    // Explicitly set a value via constructor. The value becomes
+    // specified.
+    Optional<int> value1(10);
+    EXPECT_EQ(10, value1.get());
+    EXPECT_FALSE(value1.unspecified());
+
+    // Do not set a value in a constructor. The value should be
+    // unspecified.
+    Optional<int> value2;
+    EXPECT_EQ(0, value2.get());
+    EXPECT_TRUE(value2.unspecified());
+
+    // Use the non-default value for second parameter.
+    Optional<bool> value3(true, true);
+    EXPECT_TRUE(value3.get());
+    EXPECT_TRUE(value3.unspecified());
+}
+
+// This test checks if the constructors for a string value
+// work correctly.
+TEST(OptionalTest, constructorString) {
+    Optional<std::string> value1("foo");
+    EXPECT_EQ("foo", value1.get());
+    EXPECT_FALSE(value1.unspecified());
+
+    Optional<std::string> value2;
+    EXPECT_TRUE(value2.get().empty());
+    EXPECT_TRUE(value2.unspecified());
+}
+
+// This test checks if the assignment operator assigning an actual
+// value to the optional value works as expected.
+TEST(OptionalTest, assignValue) {
+    Optional<int> value(10, true);
+    EXPECT_EQ(10, value.get());
+    EXPECT_TRUE(value.unspecified());
+
+    // Assign a new value.
+    value = 111;
+    EXPECT_EQ(111, value.get());
+    EXPECT_FALSE(value.unspecified());
+
+    // Assign another value.
+    value = 1000;
+    EXPECT_EQ(1000, value.get());
+    EXPECT_FALSE(value.unspecified());
+}
+
+// This test checks if the assignment operator assigning an actual
+// string value to the optional value works as expected.
+TEST(OptionalTest, assignStringValue) {
+    Optional<std::string> value("foo");
+    EXPECT_EQ("foo", value.get());
+    EXPECT_FALSE(value.unspecified());
+
+    value = "bar";
+    EXPECT_EQ("bar", value.get());
+    EXPECT_FALSE(value.unspecified());
+
+    value = "foobar";
+    EXPECT_EQ("foobar", value.get());
+    EXPECT_FALSE(value.unspecified());
+}
+
+// This test checks that it is possible to modify the flag that indicates
+// if the value is specified or unspecified.
+TEST(OptionalTest, modifyUnspecified) {
+    Optional<int> value;
+    EXPECT_TRUE(value.unspecified());
+
+    value.unspecified(false);
+    EXPECT_FALSE(value.unspecified());
+
+    value.unspecified(true);
+    EXPECT_TRUE(value.unspecified());
+}
+
+// This test checks if the type case operator returns correct value.
+TEST(OptionalTest, typeCastOperator) {
+    Optional<int> value(-10);
+    EXPECT_EQ(-10, value.get());
+    EXPECT_FALSE(value.unspecified());
+
+    int actual = value;
+    EXPECT_EQ(-10, actual);
+}
+
+// This test checks if the type case operator returns correct string
+// value.
+TEST(OptionalTest, stringCastOperator) {
+    Optional<std::string> value("xyz");
+    EXPECT_EQ("xyz", value.get());
+    EXPECT_FALSE(value.unspecified());
+
+    std::string actual = value;
+    EXPECT_EQ("xyz", actual);
+}
+
+// This test checks that the equality operators work as expected.
+TEST(OptionalTest, equality) {
+    int exp_value = 1234;
+    Optional<int> value(1234);
+    EXPECT_TRUE(value == exp_value);
+    EXPECT_FALSE(value != exp_value);
+}
+
+// This test checks that the equality operators for strings work as
+// expected.
+TEST(OptionalTest, stringEquality) {
+    const char* exp_value = "foo";
+    Optional<std::string> value("foo");
+    EXPECT_TRUE(value == exp_value);
+    EXPECT_FALSE(value != exp_value);
+}
+
+// This test checks that an exception is thrown when calling an empty()
+// method on non-string optional value.
+TEST(OptionalTest, empty) {
+    Optional<int> value(10);
+    EXPECT_THROW(value.empty(), isc::InvalidOperation);
+}
+
+// This test checks that no exception is thrown when calling an empty()
+// method on string optional value and that it returns an expected
+// boolean value.
+TEST(OptionalTest, stringEmpty) {
+    Optional<std::string> value("foo");
+    bool is_empty = true;
+    ASSERT_NO_THROW(is_empty = value.empty());
+    EXPECT_FALSE(is_empty);
+
+    value = "";
+    ASSERT_NO_THROW(is_empty = value.empty());
+    EXPECT_TRUE(is_empty);
+}
+
+// Checks that the valueOr function works correctly.
+TEST(OptionalTest, valueOr) {
+    Optional<std::string> optional("foo");
+    EXPECT_EQ(optional.valueOr("bar"), "foo");
+
+    Optional<std::string> unspecified_optional;
+    EXPECT_EQ(unspecified_optional.valueOr("bar"), "bar");
+}
+
+} // end of anonymous namespace