enum_flags/test_class_enum.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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <cassert>
#include <iostream>

#include "enum_flags.hpp"

// Test 3: Enum inside a class
class MyClass {
 public:
  enum ClassFlags {
    None = 0,
    Enabled = 1 << 0,
    Visible = 1 << 1,
    Focused = 1 << 2
  };
};

// Enable flag operations for ClassFlags
enum_flags::enable_flag_ops flag_enable(MyClass::ClassFlags);

class Widget {
 private:
  MyClass::ClassFlags state_ = MyClass::ClassFlags::None;

 public:
  void set_enabled(bool enabled) { enum_flags::set_assign(state_, MyClass::ClassFlags::Enabled, enabled); }

  bool is_enabled() const { return enum_flags::test(state_, MyClass::ClassFlags::Enabled); }

  void set_visible(bool visible) { enum_flags::set_assign(state_, MyClass::ClassFlags::Visible, visible); }

  bool is_visible() const { return enum_flags::test(state_, MyClass::ClassFlags::Visible); }

  void set_focused(bool focused) { enum_flags::set_assign(state_, MyClass::ClassFlags::Focused, focused); }

  bool is_focused() const { return enum_flags::test(state_, MyClass::ClassFlags::Focused); }

  void toggle_visibility() { enum_flags::toggle_assign(state_, MyClass::ClassFlags::Visible); }

  bool has_any_state() const { return enum_flags::any(state_); }

  bool has_all_states() const {
    return enum_flags::all(state_,
                           MyClass::ClassFlags::Enabled | MyClass::ClassFlags::Visible | MyClass::ClassFlags::Focused);
  }

  int state_count() const { return enum_flags::count(state_); }
};

void test_class_enum() {
  std::cout << "Testing class enum..." << std::endl;

  // Test bitwise operations
  auto state = MyClass::ClassFlags::Enabled | MyClass::ClassFlags::Visible;
  assert(enum_flags::test(state, MyClass::ClassFlags::Enabled));
  assert(enum_flags::test(state, MyClass::ClassFlags::Visible));
  assert(!enum_flags::test(state, MyClass::ClassFlags::Focused));

  // Test flag manipulation
  state = enum_flags::set_flag(state, MyClass::ClassFlags::Focused);
  assert(enum_flags::test(state, MyClass::ClassFlags::Focused));

  state = enum_flags::clear_flag(state, MyClass::ClassFlags::Enabled);
  assert(!enum_flags::test(state, MyClass::ClassFlags::Enabled));
  assert(enum_flags::test(state, MyClass::ClassFlags::Visible));
  assert(enum_flags::test(state, MyClass::ClassFlags::Focused));

  // Test assignment operations
  enum_flags::set_assign(state, MyClass::ClassFlags::Enabled, true);
  assert(enum_flags::test(state, MyClass::ClassFlags::Enabled));

  enum_flags::clear_assign(state, MyClass::ClassFlags::Visible);
  assert(!enum_flags::test(state, MyClass::ClassFlags::Visible));

  // Test query operations
  assert(enum_flags::any(state));
  assert(!enum_flags::none(state));
  assert(enum_flags::all(state, MyClass::ClassFlags::Enabled | MyClass::ClassFlags::Focused));
  assert(!enum_flags::all(state, MyClass::ClassFlags::Enabled | MyClass::ClassFlags::Visible));
  assert(enum_flags::count(state) == 2);

  // Test with Widget class
  Widget widget;
  widget.set_enabled(true);
  widget.set_visible(true);
  widget.set_focused(false);

  assert(widget.is_enabled());
  assert(widget.is_visible());
  assert(!widget.is_focused());
  assert(widget.state_count() == 2);

  widget.toggle_visibility();
  assert(!widget.is_visible());
  assert(widget.state_count() == 1);

  widget.set_focused(true);
  widget.set_visible(true);
  assert(widget.has_all_states());

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

int main() {
  test_class_enum();
  return 0;
}