chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,298 @@
|
||||
// Licensed to the Apache Software Foundation (ASF) under one
|
||||
// or more contributor license agreements. See the NOTICE file
|
||||
// distributed with this work for additional information
|
||||
// regarding copyright ownership. The ASF licenses this file
|
||||
// to you under the Apache License, Version 2.0 (the
|
||||
// "License"); you may not use this file except in compliance
|
||||
// with the License. You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing,
|
||||
// software distributed under the License is distributed on an
|
||||
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
// KIND, either express or implied. See the License for the
|
||||
// specific language governing permissions and limitations
|
||||
// under the License.
|
||||
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include "butil/containers/optional.h"
|
||||
|
||||
namespace {
|
||||
|
||||
butil::optional<int> empty_optional() {
|
||||
return {};
|
||||
}
|
||||
|
||||
TEST(OptionalTest, sanity) {
|
||||
{
|
||||
butil::optional<int> empty;
|
||||
ASSERT_FALSE(empty);
|
||||
}
|
||||
|
||||
{
|
||||
butil::optional<int> empty{};
|
||||
ASSERT_FALSE(empty);
|
||||
}
|
||||
|
||||
{
|
||||
butil::optional<int> empty = empty_optional();
|
||||
ASSERT_FALSE(empty);
|
||||
}
|
||||
|
||||
{
|
||||
butil::optional<int> non_empty(42);
|
||||
ASSERT_TRUE(non_empty);
|
||||
ASSERT_TRUE(non_empty.has_value());
|
||||
ASSERT_EQ(*non_empty, 42);
|
||||
}
|
||||
|
||||
butil::optional<std::string> opt_string = "abc";
|
||||
ASSERT_TRUE(opt_string);
|
||||
ASSERT_EQ(*opt_string, "abc");
|
||||
}
|
||||
|
||||
TEST(OptionalTest, nullopt) {
|
||||
butil::optional<int> empty(butil::nullopt);
|
||||
ASSERT_FALSE(empty);
|
||||
|
||||
empty = 1;
|
||||
ASSERT_TRUE(empty);
|
||||
ASSERT_EQ(1, empty);
|
||||
|
||||
empty = butil::nullopt;
|
||||
ASSERT_FALSE(empty);
|
||||
}
|
||||
|
||||
TEST(OptionalTest, copy) {
|
||||
butil::optional<int> op(1);
|
||||
ASSERT_TRUE(op);
|
||||
ASSERT_EQ(1, op);
|
||||
|
||||
butil::optional<int> non_empty(op);
|
||||
ASSERT_TRUE(non_empty);
|
||||
|
||||
op = butil::nullopt;
|
||||
ASSERT_FALSE(op);
|
||||
|
||||
butil::optional<int> empty(op);
|
||||
ASSERT_FALSE(empty);
|
||||
|
||||
non_empty = empty;
|
||||
ASSERT_FALSE(non_empty);
|
||||
|
||||
op = 10;
|
||||
non_empty = op;
|
||||
ASSERT_TRUE(non_empty);
|
||||
ASSERT_EQ(10, non_empty);
|
||||
}
|
||||
|
||||
TEST(OptionalTest, move) {
|
||||
butil::optional<int> empty;
|
||||
ASSERT_FALSE(empty);
|
||||
butil::optional<int> non_empty = 1;
|
||||
ASSERT_TRUE(non_empty);
|
||||
ASSERT_EQ(1, non_empty);
|
||||
|
||||
butil::optional<int> empty_move(std::move(empty));
|
||||
ASSERT_FALSE(empty_move);
|
||||
|
||||
butil::optional<int> non_empty_move(std::move(non_empty));
|
||||
ASSERT_TRUE(non_empty_move);
|
||||
ASSERT_EQ(1, non_empty_move);
|
||||
|
||||
butil::optional<int> empty_move_assign;
|
||||
empty_move_assign = std::move(empty);
|
||||
ASSERT_FALSE(empty_move_assign);
|
||||
}
|
||||
|
||||
struct Obj {};
|
||||
|
||||
struct Convert {
|
||||
Convert()
|
||||
:default_ctor(false), move_ctor(false) { }
|
||||
explicit Convert(const Obj&)
|
||||
:default_ctor(true), move_ctor(false) { }
|
||||
explicit Convert(Obj&&)
|
||||
:default_ctor(true), move_ctor(true) { }
|
||||
|
||||
bool default_ctor;
|
||||
bool move_ctor;
|
||||
};
|
||||
|
||||
struct ConvertFromOptional {
|
||||
ConvertFromOptional()
|
||||
:default_ctor(false), move_ctor(false), from_optional(false) { }
|
||||
ConvertFromOptional(const Obj&)
|
||||
:default_ctor(true), move_ctor(false), from_optional(false) { }
|
||||
ConvertFromOptional(Obj&&)
|
||||
:default_ctor(true), move_ctor(true), from_optional(false) { }
|
||||
ConvertFromOptional(
|
||||
const butil::optional<Obj>&)
|
||||
:default_ctor(true), move_ctor(false), from_optional(true) { }
|
||||
ConvertFromOptional(butil::optional<Obj>&&)
|
||||
:default_ctor(true), move_ctor(true), from_optional(true) { }
|
||||
|
||||
bool default_ctor;
|
||||
bool move_ctor;
|
||||
bool from_optional;
|
||||
};
|
||||
|
||||
TEST(OptionalTest, convert) {
|
||||
butil::optional<Obj> i_empty;
|
||||
ASSERT_FALSE(i_empty);
|
||||
butil::optional<Obj> i(butil::in_place);
|
||||
ASSERT_TRUE(i);
|
||||
{
|
||||
butil::optional<Convert> empty(i_empty);
|
||||
ASSERT_FALSE(empty);
|
||||
butil::optional<Convert> opt_copy(i);
|
||||
ASSERT_TRUE(opt_copy);
|
||||
ASSERT_TRUE(opt_copy->default_ctor);
|
||||
ASSERT_FALSE(opt_copy->move_ctor);
|
||||
|
||||
butil::optional<Convert> opt_move(butil::optional<Obj>{ butil::in_place });
|
||||
ASSERT_TRUE(opt_move);
|
||||
ASSERT_TRUE(opt_move->default_ctor);
|
||||
ASSERT_TRUE(opt_move->move_ctor);
|
||||
}
|
||||
|
||||
{
|
||||
static_assert(
|
||||
std::is_convertible<butil::optional<Obj>,
|
||||
butil::optional<ConvertFromOptional>>::value,
|
||||
"");
|
||||
butil::optional<ConvertFromOptional> opt0 = i_empty;
|
||||
ASSERT_TRUE(opt0);
|
||||
ASSERT_TRUE(opt0->default_ctor);
|
||||
ASSERT_FALSE(opt0->move_ctor);
|
||||
ASSERT_TRUE(opt0->from_optional);
|
||||
butil::optional<ConvertFromOptional> opt1 = butil::optional<Obj>();
|
||||
ASSERT_TRUE(opt1);
|
||||
ASSERT_TRUE(opt1->default_ctor);
|
||||
ASSERT_TRUE(opt1->move_ctor);
|
||||
ASSERT_TRUE(opt1->from_optional);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(OptionalTest, value) {
|
||||
butil::optional<double> opt_empty;
|
||||
butil::optional<double> opt_double = 1.0;
|
||||
ASSERT_THROW(opt_empty.value(), butil::bad_optional_access);
|
||||
ASSERT_EQ(10.0, opt_empty.value_or(10));
|
||||
ASSERT_EQ(1.0, opt_double.value());
|
||||
ASSERT_EQ(1.0, opt_double.value_or(42));
|
||||
ASSERT_EQ(10.0, butil::optional<double>().value_or(10));
|
||||
ASSERT_EQ(1.0, butil::optional<double>(1).value_or(10));
|
||||
}
|
||||
|
||||
TEST(OptionalTest, emplace) {
|
||||
butil::optional<std::string> opt_string;
|
||||
ASSERT_TRUE((std::is_same<std::string&, decltype(opt_string.emplace("abc"))>::value));
|
||||
std::string& str = opt_string.emplace("abc");
|
||||
ASSERT_EQ(&str, &opt_string.value());
|
||||
}
|
||||
|
||||
TEST(OptionalTest, swap) {
|
||||
butil::optional<int> opt_empty, opt1 = 1, opt2 = 2;
|
||||
ASSERT_FALSE(opt_empty);
|
||||
ASSERT_TRUE(opt1);
|
||||
ASSERT_EQ(1, opt1.value());
|
||||
ASSERT_TRUE(opt2);
|
||||
ASSERT_EQ(2, opt2.value());
|
||||
swap(opt_empty, opt1);
|
||||
ASSERT_FALSE(opt1);
|
||||
ASSERT_TRUE(opt_empty);
|
||||
ASSERT_EQ(1, opt_empty.value());
|
||||
ASSERT_TRUE(opt2);
|
||||
ASSERT_EQ(2, opt2.value());
|
||||
swap(opt_empty, opt1);
|
||||
ASSERT_FALSE(opt_empty);
|
||||
ASSERT_TRUE(opt1);
|
||||
ASSERT_EQ(1, opt1.value());
|
||||
ASSERT_TRUE(opt2);
|
||||
ASSERT_EQ(2, opt2.value());
|
||||
swap(opt1, opt2);
|
||||
ASSERT_FALSE(opt_empty);
|
||||
ASSERT_TRUE(opt1);
|
||||
ASSERT_EQ(2, opt1.value());
|
||||
ASSERT_TRUE(opt2);
|
||||
ASSERT_EQ(1, opt2.value());
|
||||
|
||||
ASSERT_TRUE(noexcept(opt1.swap(opt2)));
|
||||
ASSERT_TRUE(noexcept(swap(opt1, opt2)));
|
||||
}
|
||||
|
||||
TEST(OptionalTest, make_optional) {
|
||||
auto opt_int = butil::make_optional(1);
|
||||
ASSERT_TRUE((std::is_same<decltype(opt_int), butil::optional<int>>::value));
|
||||
ASSERT_EQ(1, opt_int);
|
||||
}
|
||||
|
||||
TEST(OptionalTest, comparison) {
|
||||
butil::optional<int> empty;
|
||||
butil::optional<int> one = 1;
|
||||
butil::optional<int> two = 2;
|
||||
ASSERT_TRUE(empty == empty);
|
||||
ASSERT_FALSE(empty == one);
|
||||
ASSERT_FALSE(empty == two);
|
||||
ASSERT_TRUE(empty == butil::nullopt);
|
||||
ASSERT_TRUE(one == one);
|
||||
ASSERT_FALSE(one == two);
|
||||
ASSERT_FALSE(one == butil::nullopt);
|
||||
ASSERT_TRUE(two == two);
|
||||
ASSERT_FALSE(two == butil::nullopt);
|
||||
|
||||
ASSERT_FALSE(empty != empty);
|
||||
ASSERT_TRUE(empty != one);
|
||||
ASSERT_TRUE(empty != two);
|
||||
ASSERT_FALSE(empty != butil::nullopt);
|
||||
ASSERT_FALSE(one != one);
|
||||
ASSERT_TRUE(one != two);
|
||||
ASSERT_TRUE(one != butil::nullopt);
|
||||
ASSERT_FALSE(two != two);
|
||||
ASSERT_TRUE(two != butil::nullopt);
|
||||
|
||||
ASSERT_FALSE(empty < empty);
|
||||
ASSERT_TRUE(empty < one);
|
||||
ASSERT_TRUE(empty < two);
|
||||
ASSERT_FALSE(empty < butil::nullopt);
|
||||
ASSERT_FALSE(one < one);
|
||||
ASSERT_TRUE(one < two);
|
||||
ASSERT_FALSE(one < butil::nullopt);
|
||||
ASSERT_FALSE(two < two);
|
||||
ASSERT_FALSE(two < butil::nullopt);
|
||||
|
||||
ASSERT_TRUE(empty <= empty);
|
||||
ASSERT_TRUE(empty <= one);
|
||||
ASSERT_TRUE(empty <= two);
|
||||
ASSERT_TRUE(empty <= butil::nullopt);
|
||||
ASSERT_TRUE(one <= one);
|
||||
ASSERT_TRUE(one <= two);
|
||||
ASSERT_FALSE(one <= butil::nullopt);
|
||||
ASSERT_TRUE(two <= two);
|
||||
ASSERT_FALSE(two <= butil::nullopt);
|
||||
|
||||
ASSERT_FALSE(empty > empty);
|
||||
ASSERT_FALSE(empty > one);
|
||||
ASSERT_FALSE(empty > two);
|
||||
ASSERT_FALSE(empty > butil::nullopt);
|
||||
ASSERT_FALSE(one > one);
|
||||
ASSERT_FALSE(one > two);
|
||||
ASSERT_TRUE(one > butil::nullopt);
|
||||
ASSERT_FALSE(two > two);
|
||||
ASSERT_TRUE(two > butil::nullopt);
|
||||
|
||||
ASSERT_TRUE(empty >= empty);
|
||||
ASSERT_FALSE(empty >= one);
|
||||
ASSERT_FALSE(empty >= two);
|
||||
ASSERT_TRUE(empty >= butil::nullopt);
|
||||
ASSERT_TRUE(one >= one);
|
||||
ASSERT_FALSE(one >= two);
|
||||
ASSERT_TRUE(one >= butil::nullopt);
|
||||
ASSERT_TRUE(two >= two);
|
||||
ASSERT_TRUE(two >= butil::nullopt);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
Reference in New Issue
Block a user