[LLDB] Add multi value test for const static enum

[DavidSpickett]

Summary

1438639a2f7eb9e9cba01454d3a9b1b16d179c9a removed a test
that was using undefined behaviour setting a non-typed enum
to a value outside its known range.

That test also checked if we formatted the value properly
when it could contain >1 valid enum value.

I don't think there's anything special about how we format
typed vs non-typed enums so I'm adding a test for ScopedEnum
that will expect to see 2 enum values plus extra.

[DavidSpickett]

clang-format

[labath]

Good catch. Lldb should try to be useful even if the debugged program invokes undefined behavior.

[shafik]

In D131472#3709684, @labath wrote:

Good catch. Lldb should try to be useful even if the debugged program invokes undefined behavior.

Totally agree, for the purposes here there should be no difference for these purposes between a scoped enum and an enum without a fixed underlying type.

lldb/test/API/lang/cpp/const_static_integral_member/main.cpp

52

I am just going to super nitpick here and say that these are not invalid values. When we have a fixed underlying type we are allowed to use the full range of the underlying type. The values may be outside the range of the enumerators but they are valid values.

[shafik]

LGTM. Thank you for the quick follow-up.

[DavidSpickett]

invalid -> not_enumerator

lldb/test/API/lang/cpp/const_static_integral_member/TestConstStaticIntegralMember.py

def test(self):
         self.expect_expr("A::longlong_min == longlong_min", result_value="true")
         self.expect_expr("A::ulonglong_min == ulonglong_min", result_value="true")
 
         # Test an unscoped enum.
         self.expect_expr("A::enum_val", result_value="enum_case2")
 
         # Test a scoped enum.
         self.expect_expr("A::scoped_enum_val", result_value="scoped_enum_case2")
-        # Test an scoped enum with an invalid enum case.
-        self.expect_expr("A::invalid_scoped_enum_val", result_value="scoped_enum_case1 | 0x4")
+        # Test an scoped enum with a value that isn't an enumerator.
+        self.expect_expr("A::not_enumerator_scoped_enum_val", result_value="scoped_enum_case1 | 0x4")
+        # This time with more than one enum value plus the extra.
+        self.expect_expr("A::not_enumerator_scoped_enum_val_2",
+                         result_value="scoped_enum_case1 | scoped_enum_case2 | 0x4")
 
         # Test an enum with fixed underlying type.
         self.expect_expr("A::scoped_char_enum_val", result_value="case2")
         self.expect_expr("A::scoped_ll_enum_val_neg", result_value="case0")
         self.expect_expr("A::scoped_ll_enum_val", result_value="case2")
 
         # Test an aliased enum with fixed underlying type.
         self.expect_expr("ClassWithEnumAlias::enum_alias",

lldb/test/API/lang/cpp/const_static_integral_member/main.cpp

 #include <limits>
 
 enum Enum {
   enum_case1 = 1,
   enum_case2 = 2,
 };
 
 enum class ScopedEnum {
struct A {
   const static auto long_min = std::numeric_limits<long>::min();
   const static auto ulong_min = std::numeric_limits<unsigned long>::min();
   const static auto longlong_min = std::numeric_limits<long long>::min();
   const static auto ulonglong_min =
       std::numeric_limits<unsigned long long>::min();
 
   const static Enum enum_val = enum_case2;
   const static ScopedEnum scoped_enum_val = ScopedEnum::scoped_enum_case2;
-  const static ScopedEnum invalid_scoped_enum_val = static_cast<ScopedEnum>(5);
+  const static ScopedEnum not_enumerator_scoped_enum_val = static_cast<ScopedEnum>(5);
+  const static ScopedEnum not_enumerator_scoped_enum_val_2 =
+      static_cast<ScopedEnum>(7);
   const static ScopedCharEnum scoped_char_enum_val = ScopedCharEnum::case2;
   const static ScopedLongLongEnum scoped_ll_enum_val_neg =
       ScopedLongLongEnum::case0;
   const static ScopedLongLongEnum scoped_ll_enum_val =
       ScopedLongLongEnum::case2;
 };
 
 const int A::int_val_with_address;
int main() {
   auto ulong_min = A::ulong_min;
   auto longlong_min = A::longlong_min;
   auto ulonglong_min = A::ulonglong_min;
 
   int member_copy = ClassWithOnlyConstStatic::member;
 
   Enum e = A::enum_val;
   ScopedEnum se = A::scoped_enum_val;
-  se = A::invalid_scoped_enum_val;
+  se = A::not_enumerator_scoped_enum_val;
   ScopedCharEnum sce = A::scoped_char_enum_val;
   ScopedLongLongEnum sle = A::scoped_ll_enum_val;
 
   auto enum_alias_val = ClassWithEnumAlias::enum_alias;
   auto enum_alias_alias_val = ClassWithEnumAlias::enum_alias_alias;
 
   return 0; // break here
 }