4f381f6d07
* bump abseil to 20250814 * bump protobuf to v32.0 * cmake: add ccache auto support * backport flatzinc, math_opt and sat update
133 lines
4.3 KiB
C++
133 lines
4.3 KiB
C++
// Copyright 2010-2025 Google LLC
|
|
// Licensed 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 "ortools/math_opt/cpp/enums.h"
|
|
|
|
#include <optional>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <type_traits>
|
|
|
|
#include "absl/strings/string_view.h"
|
|
#include "absl/types/span.h"
|
|
#include "gtest/gtest.h"
|
|
#include "ortools/base/gmock.h"
|
|
#include "ortools/base/logging.h"
|
|
#include "ortools/math_opt/cpp/enums_test.pb.h"
|
|
#include "ortools/math_opt/cpp/enums_testing.h"
|
|
#include "ortools/math_opt/testing/stream.h"
|
|
|
|
namespace operations_research::math_opt {
|
|
namespace {
|
|
|
|
enum class TestEnum {
|
|
kFirstValue = TEST_ENUM_FIRST_VALUE,
|
|
kSecondValue = TEST_ENUM_SECOND_VALUE
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Template specialization must be in the same namespace. It can't be in the
|
|
// anonymous namespace.
|
|
MATH_OPT_DEFINE_ENUM(TestEnum, TEST_ENUM_UNSPECIFIED);
|
|
|
|
std::optional<absl::string_view> Enum<TestEnum>::ToOptString(TestEnum value) {
|
|
switch (value) {
|
|
case TestEnum::kFirstValue:
|
|
return "first_value";
|
|
case TestEnum::kSecondValue:
|
|
return "second_value";
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
absl::Span<const TestEnum> Enum<TestEnum>::AllValues() {
|
|
static constexpr TestEnum kTestEnumValues[] = {TestEnum::kFirstValue,
|
|
TestEnum::kSecondValue};
|
|
|
|
return absl::MakeConstSpan(kTestEnumValues);
|
|
}
|
|
|
|
namespace {
|
|
|
|
using ::testing::ElementsAre;
|
|
using ::testing::Optional;
|
|
|
|
TEST(EnumsTest, EnumToProtoWithOptional) {
|
|
std::optional<TestEnum> opt_value = TestEnum::kFirstValue;
|
|
EXPECT_EQ(EnumToProto(opt_value), TEST_ENUM_FIRST_VALUE);
|
|
EXPECT_EQ(EnumToProto<TestEnum>(std::nullopt), TEST_ENUM_UNSPECIFIED);
|
|
}
|
|
|
|
TEST(EnumsTest, EnumToProtoWithValue) {
|
|
EXPECT_EQ(EnumToProto(TestEnum::kFirstValue), TEST_ENUM_FIRST_VALUE);
|
|
EXPECT_EQ(EnumToProto(TestEnum::kSecondValue), TEST_ENUM_SECOND_VALUE);
|
|
}
|
|
|
|
TEST(EnumsTest, FromProto) {
|
|
EXPECT_THAT(EnumFromProto(TEST_ENUM_FIRST_VALUE),
|
|
Optional(TestEnum::kFirstValue));
|
|
EXPECT_THAT(EnumFromProto(TEST_ENUM_SECOND_VALUE),
|
|
Optional(TestEnum::kSecondValue));
|
|
EXPECT_EQ(EnumFromProto(TEST_ENUM_UNSPECIFIED), std::nullopt);
|
|
}
|
|
|
|
TEST(EnumsTest, EnumToOptString) {
|
|
EXPECT_THAT(EnumToOptString(TestEnum::kFirstValue),
|
|
Optional(absl::string_view("first_value")));
|
|
EXPECT_THAT(EnumToOptString(TestEnum::kSecondValue),
|
|
Optional(absl::string_view("second_value")));
|
|
EXPECT_EQ(EnumToOptString(static_cast<TestEnum>(-15)), std::nullopt);
|
|
}
|
|
|
|
TEST(EnumsTest, EnumToString) {
|
|
EXPECT_THAT(EnumToString(TestEnum::kFirstValue), "first_value");
|
|
EXPECT_THAT(EnumToString(TestEnum::kSecondValue), "second_value");
|
|
}
|
|
|
|
TEST(EnumsDeathTest, EnumToString) {
|
|
EXPECT_DEATH_IF_SUPPORTED(EnumToString(static_cast<TestEnum>(-15)),
|
|
"invalid value: -15");
|
|
}
|
|
|
|
TEST(EnumsTest, EnumFromString) {
|
|
EXPECT_THAT(EnumFromString<TestEnum>("first_value"),
|
|
Optional(TestEnum::kFirstValue));
|
|
EXPECT_THAT(EnumFromString<TestEnum>("second_value"),
|
|
Optional(TestEnum::kSecondValue));
|
|
EXPECT_EQ(EnumFromString<TestEnum>("unknown"), std::nullopt);
|
|
}
|
|
|
|
TEST(EnumsTest, AllValues) {
|
|
EXPECT_THAT(Enum<TestEnum>::AllValues(),
|
|
ElementsAre(TestEnum::kFirstValue, TestEnum::kSecondValue));
|
|
}
|
|
|
|
TEST(EnumsTest, Stream) {
|
|
EXPECT_EQ(StreamToString(TestEnum::kFirstValue), "first_value");
|
|
EXPECT_EQ(StreamToString(static_cast<TestEnum>(-15)), "<invalid enum (-15)>");
|
|
}
|
|
|
|
TEST(EnumsTest, OptStream) {
|
|
EXPECT_EQ(StreamToString(std::make_optional(TestEnum::kFirstValue)),
|
|
"first_value");
|
|
EXPECT_EQ(StreamToString(std::make_optional(static_cast<TestEnum>(-15))),
|
|
"<invalid enum (-15)>");
|
|
EXPECT_EQ(StreamToString(std::optional<TestEnum>()), "<unspecified>");
|
|
}
|
|
|
|
INSTANTIATE_TYPED_TEST_SUITE_P(TestEnum, EnumTest, TestEnum);
|
|
|
|
} // namespace
|
|
} // namespace operations_research::math_opt
|