Protocol Buffers - Google's data interchange format (grpc依赖) https://developers.google.com/protocol-buffers/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

191 lines
7.4 KiB

// Protocol Buffers - Google's data interchange format
// Copyright 2023 Google LLC. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
//! Tests covering enum type generation.
use enums_rust_proto::*;
use googletest::prelude::*;
use protobuf::Enum;
use unittest_rust_proto::*;
#[test]
fn test_nested_enum_values() {
assert_that!(i32::from(test_all_types::NestedEnum::Foo), eq(1));
assert_that!(i32::from(test_all_types::NestedEnum::Bar), eq(2));
assert_that!(i32::from(test_all_types::NestedEnum::Baz), eq(3));
assert_that!(i32::from(test_all_types::NestedEnum::Neg), eq(-1));
}
#[test]
fn test_isolated_nested_enum() {
// Ensure that the enum is generated even when it's the only nested type for the
// message.
assert_that!(i32::from(test_required_enum_no_mask::NestedEnum::Foo), eq(2));
}
#[test]
fn test_enum_value_name_same_as_enum() {
assert_that!(i32::from(TestEnumValueNameSameAsEnum::TestEnumValueNameSameAsEnum), eq(1));
}
#[test]
fn test_enum_defaults() {
assert_that!(TestSparseEnum::default(), eq(TestSparseEnum::SparseA));
assert_that!(TestEnumWithDupValue::default(), eq(TestEnumWithDupValue::Foo1));
assert_that!(TestEnumWithDupValue::default(), eq(TestEnumWithDupValue::Foo2));
assert_that!(
TestEnumWithDuplicateStrippedPrefixNames::default(),
eq(TestEnumWithDuplicateStrippedPrefixNames::Unknown)
);
assert_that!(test_all_types::NestedEnum::default(), eq(test_all_types::NestedEnum::Foo));
}
#[test]
#[deny(unreachable_patterns)]
#[allow(clippy::let_unit_value)]
fn test_closed_enum_is_nonexhaustive() {
let val = ForeignEnum::ForeignFoo;
let _it_compiles: () = match val {
ForeignEnum::ForeignFoo => (),
ForeignEnum::ForeignBar => (),
ForeignEnum::ForeignBaz => (),
ForeignEnum::ForeignBax => (),
_ => unreachable!(),
};
}
#[test]
fn test_closed_enum_conversion() {
assert_that!(i32::from(TestSparseEnum::SparseA), eq(123));
assert_that!(TestSparseEnum::try_from(123), ok(eq(&TestSparseEnum::SparseA)));
assert_that!(i32::from(TestSparseEnum::SparseD), eq(-15));
assert_that!(TestSparseEnum::try_from(-15), ok(eq(&TestSparseEnum::SparseD)));
assert_that!(TestSparseEnum::try_from(0), ok(eq(&TestSparseEnum::SparseF)));
assert_that!(TestSparseEnum::try_from(1), err(anything()));
}
#[test]
fn test_closed_aliased_enum_conversion() {
assert_that!(i32::from(TestEnumWithDupValue::Foo1), eq(1));
assert_that!(i32::from(TestEnumWithDupValue::Foo2), eq(1));
assert_that!(i32::from(TestEnumWithDupValue::Bar1), eq(2));
assert_that!(i32::from(TestEnumWithDupValue::Bar2), eq(2));
assert_that!(i32::from(TestEnumWithDupValue::Baz), eq(3));
assert_that!(TestEnumWithDupValue::try_from(1), ok(eq(&TestEnumWithDupValue::Foo1)));
assert_that!(TestEnumWithDupValue::try_from(2), ok(eq(&TestEnumWithDupValue::Bar1)));
assert_that!(TestEnumWithDupValue::try_from(3), ok(eq(&TestEnumWithDupValue::Baz)));
assert_that!(TestEnumWithDupValue::try_from(0), err(anything()));
assert_that!(TestEnumWithDupValue::try_from(4), err(anything()));
assert_that!(TestEnumWithDupValue::Foo1, eq(TestEnumWithDupValue::Foo2));
assert_that!(TestEnumWithDupValue::Bar1, eq(TestEnumWithDupValue::Bar2));
}
#[test]
#[deny(unreachable_patterns)]
#[allow(clippy::let_unit_value)]
fn test_open_enum_is_nonexhaustive() {
let val = TestEnumValueNameSameAsEnum::Unknown;
let _it_compiles: () = match val {
TestEnumValueNameSameAsEnum::Unknown => (),
TestEnumValueNameSameAsEnum::TestEnumValueNameSameAsEnum => (),
_ => unreachable!(),
};
}
#[test]
fn test_open_enum_conversion() {
assert_that!(i32::from(TestEnumWithNumericNames::Unknown), eq(0));
assert_that!(i32::from(TestEnumWithNumericNames::_2020), eq(1));
assert_that!(i32::from(TestEnumWithNumericNames::_2021), eq(2));
assert_that!(i32::from(TestEnumWithNumericNames::_2022), eq(3));
assert_that!(TestEnumWithNumericNames::from(0), eq(TestEnumWithNumericNames::Unknown));
assert_that!(TestEnumWithNumericNames::from(1), eq(TestEnumWithNumericNames::_2020));
assert_that!(TestEnumWithNumericNames::from(2), eq(TestEnumWithNumericNames::_2021));
assert_that!(TestEnumWithNumericNames::from(3), eq(TestEnumWithNumericNames::_2022));
assert_that!(
TestEnumWithNumericNames::from(4),
not(any![
eq(TestEnumWithNumericNames::Unknown),
eq(TestEnumWithNumericNames::_2020),
eq(TestEnumWithNumericNames::_2021),
eq(TestEnumWithNumericNames::_2022),
])
);
assert_that!(i32::from(TestEnumWithNumericNames::from(-1)), eq(-1));
}
#[test]
fn test_open_aliased_enum_conversion() {
assert_that!(i32::from(TestEnumWithDuplicateStrippedPrefixNames::Unknown), eq(0));
assert_that!(i32::from(TestEnumWithDuplicateStrippedPrefixNames::Foo), eq(1));
assert_that!(i32::from(TestEnumWithDuplicateStrippedPrefixNames::Bar), eq(2));
assert_that!(i32::from(TestEnumWithDuplicateStrippedPrefixNames::DifferentNameAlias), eq(2));
assert_that!(
TestEnumWithDuplicateStrippedPrefixNames::from(0),
eq(TestEnumWithDuplicateStrippedPrefixNames::Unknown)
);
assert_that!(
TestEnumWithDuplicateStrippedPrefixNames::from(1),
eq(TestEnumWithDuplicateStrippedPrefixNames::Foo)
);
assert_that!(
TestEnumWithDuplicateStrippedPrefixNames::from(2),
eq(TestEnumWithDuplicateStrippedPrefixNames::Bar)
);
assert_that!(
TestEnumWithDuplicateStrippedPrefixNames::from(2),
eq(TestEnumWithDuplicateStrippedPrefixNames::DifferentNameAlias)
);
assert_that!(
TestEnumWithDuplicateStrippedPrefixNames::from(3),
not(any![
eq(TestEnumWithDuplicateStrippedPrefixNames::Unknown),
eq(TestEnumWithDuplicateStrippedPrefixNames::Foo),
eq(TestEnumWithDuplicateStrippedPrefixNames::Bar),
])
);
assert_that!(i32::from(TestEnumWithDuplicateStrippedPrefixNames::from(5)), eq(5));
}
#[test]
fn test_enum_conversion_failure_display() {
let err = TestSparseEnum::try_from(1).unwrap_err();
assert_that!(format!("{err}"), eq("1 is not a known value for TestSparseEnum"));
}
#[test]
fn test_enum_conversion_failure_impls_std_error() {
let err = TestSparseEnum::try_from(1).unwrap_err();
let _test_compiles: &dyn std::error::Error = &err;
}
#[test]
fn test_is_known_for_closed_enum() {
assert_that!(test_all_types::NestedEnum::is_known(-2), eq(false));
assert_that!(test_all_types::NestedEnum::is_known(-1), eq(true));
assert_that!(test_all_types::NestedEnum::is_known(0), eq(false));
assert_that!(test_all_types::NestedEnum::is_known(1), eq(true));
assert_that!(test_all_types::NestedEnum::is_known(2), eq(true));
assert_that!(test_all_types::NestedEnum::is_known(3), eq(true));
assert_that!(test_all_types::NestedEnum::is_known(4), eq(false));
}
#[test]
fn test_is_known_for_open_enum() {
assert_that!(TestEnumWithNumericNames::is_known(-1), eq(false));
assert_that!(TestEnumWithNumericNames::is_known(0), eq(true));
assert_that!(TestEnumWithNumericNames::is_known(1), eq(true));
assert_that!(TestEnumWithNumericNames::is_known(2), eq(true));
assert_that!(TestEnumWithNumericNames::is_known(3), eq(true));
assert_that!(TestEnumWithNumericNames::is_known(4), eq(false));
}