blob: b0f97a73c2fa903c9b0d3f0f3593373c0e8f525b [file] [log] [blame]
/*
* Copyright 2019 The Chromium Authors. All rights reserved.
* Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "net/dcsctp/public/strong_alias.h"
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include "rtc_base/gunit.h"
#include "test/gmock.h"
// This is a copy of
// https://source.chromium.org/chromium/chromium/src/+/master:base/types/strong_alias_unittest.cc
// but adapted to use WebRTC's includes, remove unit tests that test the ostream
// operator (it's removed in this port) and other adaptations to pass lint.
namespace dcsctp {
namespace {
// For test correctnenss, it's important that these getters return lexically
// incrementing values as |index| grows.
template <typename T>
T GetExampleValue(int index);
template <>
int GetExampleValue<int>(int index) {
return 5 + index;
}
template <>
uint64_t GetExampleValue<uint64_t>(int index) {
return 500U + index;
}
template <>
std::string GetExampleValue<std::string>(int index) {
return std::string('a', index);
}
} // namespace
template <typename T>
class StrongAliasTest : public ::testing::Test {};
using TestedTypes = ::testing::Types<int, uint64_t, std::string>;
TYPED_TEST_SUITE(StrongAliasTest, TestedTypes);
TYPED_TEST(StrongAliasTest, ValueAccessesUnderlyingValue) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
// Const value getter.
const FooAlias const_alias(GetExampleValue<TypeParam>(1));
EXPECT_EQ(GetExampleValue<TypeParam>(1), const_alias.value());
static_assert(std::is_const<typename std::remove_reference<decltype(
const_alias.value())>::type>::value,
"Reference returned by const value getter should be const.");
}
TYPED_TEST(StrongAliasTest, ExplicitConversionToUnderlyingValue) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
const FooAlias const_alias(GetExampleValue<TypeParam>(1));
EXPECT_EQ(GetExampleValue<TypeParam>(1), static_cast<TypeParam>(const_alias));
}
TYPED_TEST(StrongAliasTest, CanBeCopyConstructed) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
FooAlias alias(GetExampleValue<TypeParam>(0));
FooAlias copy_constructed = alias;
EXPECT_EQ(copy_constructed, alias);
FooAlias copy_assigned;
copy_assigned = alias;
EXPECT_EQ(copy_assigned, alias);
}
TYPED_TEST(StrongAliasTest, CanBeMoveConstructed) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
FooAlias alias(GetExampleValue<TypeParam>(0));
FooAlias move_constructed = std::move(alias);
EXPECT_EQ(move_constructed, FooAlias(GetExampleValue<TypeParam>(0)));
FooAlias alias2(GetExampleValue<TypeParam>(2));
FooAlias move_assigned;
move_assigned = std::move(alias2);
EXPECT_EQ(move_assigned, FooAlias(GetExampleValue<TypeParam>(2)));
// Check that FooAlias is nothrow move constructible. This matters for
// performance when used in std::vectors.
static_assert(std::is_nothrow_move_constructible<FooAlias>::value,
"Error: Alias is not nothow move constructible");
}
TYPED_TEST(StrongAliasTest, CanBeConstructedFromMoveOnlyType) {
// Note, using a move-only unique_ptr to T:
using FooAlias = StrongAlias<class FooTag, std::unique_ptr<TypeParam>>;
FooAlias a(std::make_unique<TypeParam>(GetExampleValue<TypeParam>(0)));
EXPECT_EQ(*a.value(), GetExampleValue<TypeParam>(0));
auto bare_value = std::make_unique<TypeParam>(GetExampleValue<TypeParam>(1));
FooAlias b(std::move(bare_value));
EXPECT_EQ(*b.value(), GetExampleValue<TypeParam>(1));
}
TYPED_TEST(StrongAliasTest, MutableOperatorArrow) {
// Note, using a move-only unique_ptr to T:
using Ptr = std::unique_ptr<TypeParam>;
using FooAlias = StrongAlias<class FooTag, Ptr>;
FooAlias a(std::make_unique<TypeParam>());
EXPECT_TRUE(a.value());
// Check that `a` can be modified through the use of operator->.
a->reset();
EXPECT_FALSE(a.value());
}
TYPED_TEST(StrongAliasTest, MutableOperatorStar) {
// Note, using a move-only unique_ptr to T:
using Ptr = std::unique_ptr<TypeParam>;
using FooAlias = StrongAlias<class FooTag, Ptr>;
FooAlias a(std::make_unique<TypeParam>());
FooAlias b(std::make_unique<TypeParam>());
EXPECT_TRUE(*a);
EXPECT_TRUE(*b);
// Check that both the mutable l-value and r-value overloads work and we can
// move out of the aliases.
{ Ptr ignore(*std::move(a)); }
{ Ptr ignore(std::move(*b)); }
EXPECT_FALSE(a.value());
EXPECT_FALSE(b.value());
}
TYPED_TEST(StrongAliasTest, MutableValue) {
// Note, using a move-only unique_ptr to T:
using Ptr = std::unique_ptr<TypeParam>;
using FooAlias = StrongAlias<class FooTag, Ptr>;
FooAlias a(std::make_unique<TypeParam>());
FooAlias b(std::make_unique<TypeParam>());
EXPECT_TRUE(a.value());
EXPECT_TRUE(b.value());
// Check that both the mutable l-value and r-value overloads work and we can
// move out of the aliases.
{ Ptr ignore(std::move(a).value()); }
{ Ptr ignore(std::move(b.value())); }
EXPECT_FALSE(a.value());
EXPECT_FALSE(b.value());
}
TYPED_TEST(StrongAliasTest, SizeSameAsUnderlyingType) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
static_assert(sizeof(FooAlias) == sizeof(TypeParam),
"StrongAlias should be as large as the underlying type.");
}
TYPED_TEST(StrongAliasTest, IsDefaultConstructible) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
static_assert(std::is_default_constructible<FooAlias>::value,
"Should be possible to default-construct a StrongAlias.");
static_assert(
std::is_trivially_default_constructible<FooAlias>::value ==
std::is_trivially_default_constructible<TypeParam>::value,
"Should be possible to trivially default-construct a StrongAlias iff the "
"underlying type is trivially default constructible.");
}
TEST(StrongAliasTest, TrivialTypeAliasIsStandardLayout) {
using FooAlias = StrongAlias<class FooTag, int>;
static_assert(std::is_standard_layout<FooAlias>::value,
"int-based alias should have standard layout. ");
static_assert(std::is_trivially_copyable<FooAlias>::value,
"int-based alias should be trivially copyable. ");
}
TYPED_TEST(StrongAliasTest, CannotBeCreatedFromDifferentAlias) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
using BarAlias = StrongAlias<class BarTag, TypeParam>;
static_assert(!std::is_constructible<FooAlias, BarAlias>::value,
"Should be impossible to construct FooAlias from a BarAlias.");
static_assert(!std::is_convertible<BarAlias, FooAlias>::value,
"Should be impossible to convert a BarAlias into FooAlias.");
}
TYPED_TEST(StrongAliasTest, CannotBeImplicitlyConverterToUnderlyingValue) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
static_assert(!std::is_convertible<FooAlias, TypeParam>::value,
"Should be impossible to implicitly convert a StrongAlias into "
"an underlying type.");
}
TYPED_TEST(StrongAliasTest, ComparesEqualToSameValue) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
// Comparison to self:
const FooAlias a = FooAlias(GetExampleValue<TypeParam>(0));
EXPECT_EQ(a, a);
EXPECT_FALSE(a != a);
EXPECT_TRUE(a >= a);
EXPECT_TRUE(a <= a);
EXPECT_FALSE(a > a);
EXPECT_FALSE(a < a);
// Comparison to other equal object:
const FooAlias b = FooAlias(GetExampleValue<TypeParam>(0));
EXPECT_EQ(a, b);
EXPECT_FALSE(a != b);
EXPECT_TRUE(a >= b);
EXPECT_TRUE(a <= b);
EXPECT_FALSE(a > b);
EXPECT_FALSE(a < b);
}
TYPED_TEST(StrongAliasTest, ComparesCorrectlyToDifferentValue) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
const FooAlias a = FooAlias(GetExampleValue<TypeParam>(0));
const FooAlias b = FooAlias(GetExampleValue<TypeParam>(1));
EXPECT_NE(a, b);
EXPECT_FALSE(a == b);
EXPECT_TRUE(b >= a);
EXPECT_TRUE(a <= b);
EXPECT_TRUE(b > a);
EXPECT_TRUE(a < b);
}
TEST(StrongAliasTest, CanBeDerivedFrom) {
// Aliases can be enriched by custom operations or validations if needed.
// Ideally, one could go from a 'using' declaration to a derived class to add
// those methods without the need to change any other code.
class CountryCode : public StrongAlias<CountryCode, std::string> {
public:
explicit CountryCode(const std::string& value)
: StrongAlias<CountryCode, std::string>::StrongAlias(value) {
if (value_.length() != 2) {
// Country code invalid!
value_.clear(); // is_null() will return true.
}
}
bool is_null() const { return value_.empty(); }
};
CountryCode valid("US");
EXPECT_FALSE(valid.is_null());
CountryCode invalid("United States");
EXPECT_TRUE(invalid.is_null());
}
TEST(StrongAliasTest, CanWrapComplexStructures) {
// A pair of strings implements odering and can, in principle, be used as
// a base of StrongAlias.
using PairOfStrings = std::pair<std::string, std::string>;
using ComplexAlias = StrongAlias<class FooTag, PairOfStrings>;
ComplexAlias a1{std::make_pair("aaa", "bbb")};
ComplexAlias a2{std::make_pair("ccc", "ddd")};
EXPECT_TRUE(a1 < a2);
EXPECT_TRUE(a1.value() == PairOfStrings("aaa", "bbb"));
// Note a caveat, an std::pair doesn't have an overload of operator<<, and it
// cannot be easily added since ADL rules would require it to be in the std
// namespace. So we can't print ComplexAlias.
}
TYPED_TEST(StrongAliasTest, CanBeKeysInStdUnorderedMap) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
std::unordered_map<FooAlias, std::string, typename FooAlias::Hasher> map;
FooAlias k1(GetExampleValue<TypeParam>(0));
FooAlias k2(GetExampleValue<TypeParam>(1));
map[k1] = "value1";
map[k2] = "value2";
EXPECT_EQ(map[k1], "value1");
EXPECT_EQ(map[k2], "value2");
}
TYPED_TEST(StrongAliasTest, CanBeKeysInStdMap) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
std::map<FooAlias, std::string> map;
FooAlias k1(GetExampleValue<TypeParam>(0));
FooAlias k2(GetExampleValue<TypeParam>(1));
map[k1] = "value1";
map[k2] = "value2";
EXPECT_EQ(map[k1], "value1");
EXPECT_EQ(map[k2], "value2");
}
TYPED_TEST(StrongAliasTest, CanDifferentiateOverloads) {
using FooAlias = StrongAlias<class FooTag, TypeParam>;
using BarAlias = StrongAlias<class BarTag, TypeParam>;
class Scope {
public:
static std::string Overload(FooAlias) { return "FooAlias"; }
static std::string Overload(BarAlias) { return "BarAlias"; }
};
EXPECT_EQ("FooAlias", Scope::Overload(FooAlias()));
EXPECT_EQ("BarAlias", Scope::Overload(BarAlias()));
}
TEST(StrongAliasTest, EnsureConstexpr) {
using FooAlias = StrongAlias<class FooTag, int>;
// Check constructors.
static constexpr FooAlias kZero{};
static constexpr FooAlias kOne(1);
// Check operator*.
static_assert(*kZero == 0, "");
static_assert(*kOne == 1, "");
// Check value().
static_assert(kZero.value() == 0, "");
static_assert(kOne.value() == 1, "");
// Check explicit conversions to underlying type.
static_assert(static_cast<int>(kZero) == 0, "");
static_assert(static_cast<int>(kOne) == 1, "");
// Check comparison operations.
static_assert(kZero == kZero, "");
static_assert(kZero != kOne, "");
static_assert(kZero < kOne, "");
static_assert(kZero <= kOne, "");
static_assert(kOne > kZero, "");
static_assert(kOne >= kZero, "");
}
} // namespace dcsctp