based

0 #include <numeric>

1

2 #include "based/list.hpp"

3

4 #include <catch2/catch_test_macros.hpp>

5

6 #include "based/types/types.hpp"

7

8 template class based::list_pool<based::u8, based::u8>;

9

10 TEST_CASE("list_pool", "[list/list_pool]")

11 {

12 using namespace based::literals; // NOLINT

13 using list_pool = based::list_pool<based::u8, based::u8>;

14

15 auto pool = list_pool();

16 auto head = pool.node_empty();

17

18 SECTION("node_empty is empty")

19 {

20 REQUIRE(pool.is_empty(head) == true);

21 REQUIRE(pool.node_empty() == head);

22 }

23

24 SECTION("add one node")

25 {

26 head = pool.allocate(1_u8, head);

27

28 REQUIRE(pool.is_empty(head) == false);

29 REQUIRE(pool.value(head) == 1_u8);

30

31 REQUIRE(pool.next(head) == pool.node_empty());

32

33 SECTION("add two nodes")

34 {

35 head = pool.allocate(2_u8, head);

36

37 REQUIRE(pool.is_empty(head) == false);

38 REQUIRE(pool.value(head) == 2_u8);

39

40 REQUIRE(pool.value(pool.next(head)) == 1_u8);

41 REQUIRE(pool.next(pool.next(head)) == pool.node_empty());

42

43 head = pool.free(head);

44 }

45

46 SECTION("alloc after free")

47 {

48 head = pool.allocate(2_u8, head);

49 head = pool.free(head);

50 head = pool.allocate(3_u8, head);

51

52 REQUIRE(pool.is_empty(head) == false);

53 REQUIRE(pool.value(head) == 3_u8);

54

55 head = pool.free(head);

56 }

57

58 head = pool.free(head);

59 }

60

61 REQUIRE(pool.is_empty(head) == true);

62 REQUIRE(pool.node_empty() == head);

63 }

64

65 TEST_CASE("list_pool iterator", "[list/list_pool]")

66 {

67 using namespace based::literals; // NOLINT

68 using list_pool = based::list_pool<based::u8, based::u8>;

69

70 auto pool = list_pool();

71 auto head = pool.node_empty();

72

73 static constexpr auto iter_count = 0xFF_u8;

74 for (auto i = 0_u8; i < iter_count; i++) {

75 head = pool.allocate(i, head);

76 }

77

78 SECTION("for-loop")

79 {

80 using iter = list_pool::iterator;

81

82 auto sum = 0_u32;

83 for (auto it = iter(pool, head); it != iter(pool); it++) {

84 sum += *it.operator->();

85 sum += *it;

86 }

87

88 REQUIRE(sum == 0xFF_u32 * 0xFE_u32);

89 }

90

91 SECTION("accumulate")

92 {

93 using iter = list_pool::iterator;

94

95 const auto sum = std::accumulate(

96 iter(pool, head),

97 iter(pool),

98 based::u32 {0},

99 [](auto a, auto b)

100 {

101 return a + b;

102 }

103 );

104

105 REQUIRE(sum == 0xFF_u32 * 0xFE_u32 / 2_u32);

106 }

107

108 based::free_list(pool, head);

109 }

110

111 TEST_CASE("list_pool const iterator", "[list/list_pool]")

112 {

113 using namespace based::literals; // NOLINT

114 using list_pool = based::list_pool<based::u8, based::u8>;

115

116 auto pool = list_pool();

117 auto head = pool.node_empty();

118

119 static constexpr auto iter_count = 0xFF_u8;

120 for (auto i = 0_u8; i < iter_count; i++) {

121 head = pool.allocate(i, head);

122 }

123

124 SECTION("const for-loop")

125 {

126 using iter = list_pool::const_iterator;

127

128 auto sum = 0_u32;

129 for (auto it = iter(pool, head); it != iter(pool); it++) {

130 sum += *it.operator->();

131 sum += *it;

132 }

133

134 REQUIRE(sum == 0xFF_u32 * 0xFE_u32);

135 }

136

137 SECTION("const accumulate")

138 {

139 using iter = list_pool::const_iterator;

140

141 static const auto sum =

142 [](const list_pool& lpool, const list_pool::list_type& lhead)

143 {

144 return std::accumulate(

145 iter(lpool, lhead),

146 iter(lpool),

147 based::u32 {0},

148 [](auto a, auto b)

149 {

150 return a + b;

151 }

152 );

153 };

154

155 REQUIRE(sum(pool, head) == 0xFF_u32 * 0xFE_u32 / 2_u32);

156 }

157

158 based::free_list(pool, head);

159 }

160

161 TEST_CASE("list_pool queue", "[list/list_pool/queue]")

162 {

163 using list_pool = based::list_pool<based::u8, based::u8>;

164 using iter = list_pool::iterator;

165

166 auto pool = list_pool();

167 auto queue = pool.queue_empty();

168

169 SECTION("free(empty, empty)")

170 {

171 REQUIRE(pool.free(queue.first, queue.second) == pool.node_empty());

172 }

173

174 SECTION("pop_front(empty)")

175 {

176 REQUIRE(pool.pop_front(queue) == queue);

177 }

178

179 using namespace based::literals; // NOLINT

180 static constexpr auto iter_count = 0xFF_u8;

181 for (auto i = 0_u8; i < iter_count; i++) {

182 if (i % 2_u8 == 0_u8) {

183 queue = pool.push_front(queue, i);

184 } else {

185 queue = pool.push_back(queue, i);

186 }

187

188 if (i % 3_u8 == 0_u8) {

189 queue = pool.pop_front(queue);

190 }

191 }

192

193 auto sum = 0_u64;

194 for (auto it = iter(pool, queue.first); it != iter(pool); ++it) {

195 sum += *it;

196 }

197

198 pool.free(queue);

199

200 REQUIRE(sum == 21717_u64);

201 }