enum_flags/test_nested_namespace.cpp at main · merlotqi/enum_flags · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include <cassert>
#include <iostream>

#include "enum_flags.hpp"

// Test: Enum inside nested namespaces (the problematic case)
namespace Outer {
namespace Inner {
enum NestedFlags {
  None = 0,
  Flag1 = 1 << 0,
  Flag2 = 1 << 1,
  Flag3 = 1 << 2
};
}  // namespace Inner
}  // namespace Outer

// Enable flag operations for NestedFlags
enum_flags::enable_flag_ops flag_enable(Outer::Inner::NestedFlags);

// Another namespace to test cross-namespace usage
namespace AnotherNamespace {
void test_cross_namespace() {
  using Outer::Inner::NestedFlags;

  // These should work now with the fix
  auto flags = NestedFlags::Flag1 | NestedFlags::Flag2;
  assert(enum_flags::test(flags, NestedFlags::Flag1));
  assert(enum_flags::test(flags, NestedFlags::Flag2));

  // Bitwise AND
  auto masked = flags & NestedFlags::Flag1;
  assert(enum_flags::test(masked, NestedFlags::Flag1));
  assert(!enum_flags::test(masked, NestedFlags::Flag2));

  // Bitwise OR assignment
  flags |= NestedFlags::Flag3;
  assert(enum_flags::test(flags, NestedFlags::Flag3));

  // Bitwise NOT
  auto inverted = ~NestedFlags::Flag1;
  assert(!enum_flags::test(inverted, NestedFlags::Flag1));

  std::cout << "Cross-namespace test passed!" << std::endl;
}
}  // namespace AnotherNamespace

void test_nested_namespace() {
  std::cout << "Testing nested namespace enum..." << std::endl;

  using Outer::Inner::NestedFlags;

  // Test bitwise operations - these should work with ADL
  auto flags = NestedFlags::Flag1 | NestedFlags::Flag2;
  assert(enum_flags::test(flags, NestedFlags::Flag1));
  assert(enum_flags::test(flags, NestedFlags::Flag2));
  assert(!enum_flags::test(flags, NestedFlags::Flag3));

  // Test bitwise AND
  auto masked = flags & NestedFlags::Flag1;
  assert(enum_flags::test(masked, NestedFlags::Flag1));
  assert(!enum_flags::test(masked, NestedFlags::Flag2));

  // Test bitwise XOR
  auto xored = flags ^ NestedFlags::Flag1;
  assert(!enum_flags::test(xored, NestedFlags::Flag1));
  assert(enum_flags::test(xored, NestedFlags::Flag2));

  // Test bitwise NOT
  auto inverted = ~NestedFlags::Flag1;
  assert(!enum_flags::test(inverted, NestedFlags::Flag1));

  // Test compound assignments
  flags |= NestedFlags::Flag3;
  assert(enum_flags::test(flags, NestedFlags::Flag3));

  flags &= NestedFlags::Flag1;
  assert(enum_flags::test(flags, NestedFlags::Flag1));
  assert(!enum_flags::test(flags, NestedFlags::Flag2));

  flags ^= NestedFlags::Flag1;
  assert(!enum_flags::test(flags, NestedFlags::Flag1));

  std::cout << "Nested namespace enum tests passed!" << std::endl;
}

int main() {
  test_nested_namespace();
  AnotherNamespace::test_cross_namespace();
  return 0;
}