based

0 #define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE

1

2 #include "based/algorithms/max.hpp"

3

4 #include <catch2/catch_test_macros.hpp>

5

6 #include "based/concepts/is/same.hpp"

7 #include "based/utility/move.hpp"

8

9 // NOLINTBEGIN(*const-arg*,*const-correctness*,*after-move, *access-moved)

10

11 TEST_CASE("max(literal, literal) = right", "[algorithm/max]")

12 {

13 using res_t = decltype(based::max(3, 4));

14

15 STATIC_REQUIRE(based::SameAs<int&&, res_t>);

16 REQUIRE(based::max(3, 4) == 4);

17 }

18

19 TEST_CASE("max(literal, literal) = left", "[algorithm/max]")

20 {

21 using res_t = decltype(based::max(4, 3));

22

23 STATIC_REQUIRE(based::SameAs<int&&, res_t>);

24 REQUIRE(based::max(4, 3) == 4);

25 }

26

27 TEST_CASE("max(value, literal) = right", "[algorithm/max]")

28 {

29 int a = 3;

30

31 using res_t = decltype(based::max(a, 4));

32

33 STATIC_REQUIRE(based::SameAs<int, res_t>);

34 REQUIRE(based::max(a, 4) == 4);

35 }

36

37 TEST_CASE("max(value, literal) = left", "[algorithm/max]")

38 {

39 int a = 4;

40

41 using res_t = decltype(based::max(a, 3));

42

43 STATIC_REQUIRE(based::SameAs<int, res_t>);

44 REQUIRE(based::max(a, 3) == 4);

45 }

46

47 TEST_CASE("max(literal, value) = right", "[algorithm/max]")

48 {

49 int b = 4;

50

51 using res_t = decltype(based::max(3, b));

52

53 STATIC_REQUIRE(based::SameAs<int, res_t>);

54 REQUIRE(based::max(3, b) == 4);

55 }

56

57 TEST_CASE("max(literal, value) = left", "[algorithm/max]")

58 {

59 int b = 3;

60

61 using res_t = decltype(based::max(4, b));

62

63 STATIC_REQUIRE(based::SameAs<int, res_t>);

64 REQUIRE(based::max(4, b) == 4);

65 }

66

67 TEST_CASE("max(value, value) = right", "[algorithm/max]")

68 {

69 int a = 3;

70 int b = 4;

71

72 using res_t = decltype(based::max(a, b));

73

74 STATIC_REQUIRE(based::SameAs<int&, res_t>);

75 REQUIRE(based::max(a, b) == 4);

76 }

77

78 TEST_CASE("max(value, value) = left", "[algorithm/max]")

79 {

80 int a = 4;

81 int b = 3;

82

83 using res_t = decltype(based::max(a, b));

84

85 STATIC_REQUIRE(based::SameAs<int&, res_t>);

86 REQUIRE(based::max(a, b) == 4);

87 }

88

89 TEST_CASE("max(const value, literal) = right", "[algorithm/max]")

90 {

91 const int a = 3;

92

93 using res_t = decltype(based::max(a, 4));

94

95 STATIC_REQUIRE(based::SameAs<int, res_t>);

96 REQUIRE(based::max(a, 4) == 4);

97 }

98

99 TEST_CASE("max(const value, literal) = left", "[algorithm/max]")

100 {

101 const int a = 4;

102

103 using res_t = decltype(based::max(a, 3));

104

105 STATIC_REQUIRE(based::SameAs<int, res_t>);

106 REQUIRE(based::max(a, 3) == 4);

107 }

108

109 TEST_CASE("max(literal, const value) = right", "[algorithm/max]")

110 {

111 const int b = 4;

112

113 using res_t = decltype(based::max(3, b));

114

115 STATIC_REQUIRE(based::SameAs<int, res_t>);

116 REQUIRE(based::max(3, b) == 4);

117 }

118

119 TEST_CASE("max(literal, const value) = left", "[algorithm/max]")

120 {

121 const int b = 3;

122

123 using res_t = decltype(based::max(4, b));

124

125 STATIC_REQUIRE(based::SameAs<int, res_t>);

126 REQUIRE(based::max(4, b) == 4);

127 }

128

129 TEST_CASE("max(const value, const value) = right", "[algorithm/max]")

130 {

131 const int a = 3;

132 const int b = 4;

133

134 using res_t = decltype(based::max(a, b));

135

136 STATIC_REQUIRE(based::SameAs<const int&, res_t>);

137 REQUIRE(based::max(a, b) == 4);

138 }

139

140 TEST_CASE("max(const value, const value) = left", "[algorithm/max]")

141 {

142 const int a = 4;

143 const int b = 3;

144

145 using res_t = decltype(based::max(a, b));

146

147 STATIC_REQUIRE(based::SameAs<const int&, res_t>);

148 REQUIRE(based::max(a, b) == 4);

149 }

150

151 TEST_CASE("max(value, const value) = right", "[algorithm/max]")

152 {

153 int a = 3;

154 const int b = 4;

155

156 using res_t = decltype(based::max(a, b));

157

158 STATIC_REQUIRE(based::SameAs<const int&, res_t>);

159 REQUIRE(based::max(a, b) == 4);

160 }

161

162 TEST_CASE("max(value, const value) = left", "[algorithm/max]")

163 {

164 int a = 4;

165 const int b = 3;

166

167 using res_t = decltype(based::max(a, b));

168

169 STATIC_REQUIRE(based::SameAs<const int&, res_t>);

170 REQUIRE(based::max(a, b) == 4);

171 }

172

173 TEST_CASE("max(const value, value) = right", "[algorithm/max]")

174 {

175 const int a = 3;

176 int b = 4;

177

178 using res_t = decltype(based::max(a, b));

179

180 STATIC_REQUIRE(based::SameAs<const int&, res_t>);

181 REQUIRE(based::max(a, b) == 4);

182 }

183

184 TEST_CASE("max(const value, value) = left", "[algorithm/max]")

185 {

186 const int a = 4;

187 int b = 3;

188

189 using res_t = decltype(based::max(a, b));

190

191 STATIC_REQUIRE(based::SameAs<const int&, res_t>);

192 REQUIRE(based::max(a, b) == 4);

193 }

194

195 TEST_CASE("max(move, literal) = right", "[algorithm/max]")

196 {

197 int a = 3;

198

199 using res_t = decltype(based::max(based::move(a), 4));

200

201 STATIC_REQUIRE(based::SameAs<int&&, res_t>);

202 REQUIRE(based::max(based::move(a), 4) == 4);

203 }

204

205 TEST_CASE("max(move, literal) = left", "[algorithm/max]")

206 {

207 int a = 4;

208

209 using res_t = decltype(based::max(based::move(a), 3));

210

211 STATIC_REQUIRE(based::SameAs<int&&, res_t>);

212 REQUIRE(based::max(based::move(a), 3) == 4);

213 }

214

215 TEST_CASE("max(move, value) = right", "[algorithm/max]")

216 {

217 int a = 3;

218 int b = 4;

219

220 using res_t = decltype(based::max(based::move(a), b));

221

222 STATIC_REQUIRE(based::SameAs<int, res_t>);

223 REQUIRE(based::max(based::move(a), b) == 4);

224 }

225

226 TEST_CASE("max(move, value) = left", "[algorithm/max]")

227 {

228 int a = 4;

229 int b = 3;

230

231 using res_t = decltype(based::max(based::move(a), b));

232

233 STATIC_REQUIRE(based::SameAs<int, res_t>);

234 REQUIRE(based::max(based::move(a), b) == 4);

235 }

236

237 TEST_CASE("max(move, const value) = right", "[algorithm/max]")

238 {

239 int a = 3;

240 const int b = 4;

241

242 using res_t = decltype(based::max(based::move(a), b));

243

244 STATIC_REQUIRE(based::SameAs<int, res_t>);

245 REQUIRE(based::max(based::move(a), b) == 4);

246 }

247

248 TEST_CASE("max(move, const value) = left", "[algorithm/max]")

249 {

250 int a = 4;

251 const int b = 3;

252

253 using res_t = decltype(based::max(based::move(a), b));

254

255 STATIC_REQUIRE(based::SameAs<int, res_t>);

256 REQUIRE(based::max(based::move(a), b) == 4);

257 }

258

259 TEST_CASE("max(literal, move) = right", "[algorithm/max]")

260 {

261 int b = 4;

262

263 using res_t = decltype(based::max(3, based::move(b)));

264

265 STATIC_REQUIRE(based::SameAs<int&&, res_t>);

266 REQUIRE(based::max(3, based::move(b)) == 4);

267 }

268

269 TEST_CASE("max(literal, move) = left", "[algorithm/max]")

270 {

271 int b = 3;

272

273 using res_t = decltype(based::max(4, based::move(b)));

274

275 STATIC_REQUIRE(based::SameAs<int&&, res_t>);

276 REQUIRE(based::max(4, based::move(b)) == 4);

277 }

278

279 TEST_CASE("max(value, move) = right", "[algorithm/max]")

280 {

281 int a = 3;

282 int b = 4;

283

284 using res_t = decltype(based::max(a, based::move(b)));

285

286 STATIC_REQUIRE(based::SameAs<int, res_t>);

287 REQUIRE(based::max(a, based::move(b)) == 4);

288 }

289

290 TEST_CASE("max(value, move) = left", "[algorithm/max]")

291 {

292 int a = 4;

293 int b = 3;

294

295 using res_t = decltype(based::max(a, based::move(b)));

296

297 STATIC_REQUIRE(based::SameAs<int, res_t>);

298 REQUIRE(based::max(a, based::move(b)) == 4);

299 }

300

301 TEST_CASE("max(const value, move) = right", "[algorithm/max]")

302 {

303 const int a = 3;

304 int b = 4;

305

306 using res_t = decltype(based::max(a, based::move(b)));

307

308 STATIC_REQUIRE(based::SameAs<int, res_t>);

309 REQUIRE(based::max(a, based::move(b)) == 4);

310 }

311

312 TEST_CASE("max(const value, move) = left", "[algorithm/max]")

313 {

314 const int a = 4;

315 int b = 3;

316

317 using res_t = decltype(based::max(a, based::move(b)));

318

319 STATIC_REQUIRE(based::SameAs<int, res_t>);

320 REQUIRE(based::max(a, based::move(b)) == 4);

321 }

322

323 TEST_CASE("max(move, move) = right", "[algorithm/max]")

324 {

325 int a = 3;

326 int b = 4;

327

328 using res_t = decltype(based::max(based::move(a), based::move(b)));

329

330 STATIC_REQUIRE(based::SameAs<int&&, res_t>);

331 REQUIRE(based::max(based::move(a), based::move(b)) == 4);

332 }

333

334 TEST_CASE("max(move, move) = left", "[algorithm/max]")

335 {

336 int a = 4;

337 int b = 3;

338

339 using res_t = decltype(based::max(based::move(a), based::move(b)));

340

341 STATIC_REQUIRE(based::SameAs<int&&, res_t>);

342 REQUIRE(based::max(based::move(a), based::move(b)) == 4);

343 }

344

345 // NOLINTEND(*const-arg*,*const-correctness*,*after-move, *access-moved)

346

347 TEST_CASE("max-stability", "[algorithm/max]")

348 {

349 using type_t = std::pair<int, int>;

350

351 static const auto cmp = [](const type_t& x, const type_t& y)

352 {

353 return x.first < y.first;

354 };

355

356 const type_t a = {3, 4};

357 const type_t b = {3, 5};

358

359 REQUIRE(based::max(a, b, cmp).second == 5);

360 REQUIRE(based::max(b, a, cmp).second == 4);

361 }