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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include "enum_flags.hpp"
#include <cassert>
#include <iostream>

// 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);
  assert(widget.has_all_states());

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

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