based

0 #define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE

1

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

3

4 #include <catch2/catch_test_macros.hpp>

5

6 #include "based/concept/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 ResT = decltype(based::max(3, 4));

14

15 STATIC_REQUIRE(based::trait::IsSame<int&&, ResT>);

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

17 }

18

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

20 {

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

22

23 STATIC_REQUIRE(based::trait::IsSame<int&&, ResT>);

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 ResT = decltype(based::max(a, 4));

32

33 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(a, 3));

42

43 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(3, b));

52

53 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(4, b));

62

63 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(a, b));

73

74 STATIC_REQUIRE(based::trait::IsSame<int&, ResT>);

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 ResT = decltype(based::max(a, b));

84

85 STATIC_REQUIRE(based::trait::IsSame<int&, ResT>);

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 ResT = decltype(based::max(a, 4));

94

95 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(a, 3));

104

105 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(3, b));

114

115 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(4, b));

124

125 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(a, b));

135

136 STATIC_REQUIRE(based::trait::IsSame<const int&, ResT>);

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 ResT = decltype(based::max(a, b));

146

147 STATIC_REQUIRE(based::trait::IsSame<const int&, ResT>);

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 ResT = decltype(based::max(a, b));

157

158 STATIC_REQUIRE(based::trait::IsSame<const int&, ResT>);

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 ResT = decltype(based::max(a, b));

168

169 STATIC_REQUIRE(based::trait::IsSame<const int&, ResT>);

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 ResT = decltype(based::max(a, b));

179

180 STATIC_REQUIRE(based::trait::IsSame<const int&, ResT>);

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 ResT = decltype(based::max(a, b));

190

191 STATIC_REQUIRE(based::trait::IsSame<const int&, ResT>);

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 ResT = decltype(based::max(based::move(a), 4));

200

201 STATIC_REQUIRE(based::trait::IsSame<int&&, ResT>);

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 ResT = decltype(based::max(based::move(a), 3));

210

211 STATIC_REQUIRE(based::trait::IsSame<int&&, ResT>);

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 ResT = decltype(based::max(based::move(a), b));

221

222 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(based::move(a), b));

232

233 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(based::move(a), b));

243

244 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(based::move(a), b));

254

255 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(3, based::move(b)));

264

265 STATIC_REQUIRE(based::trait::IsSame<int&&, ResT>);

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 ResT = decltype(based::max(4, based::move(b)));

274

275 STATIC_REQUIRE(based::trait::IsSame<int&&, ResT>);

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 ResT = decltype(based::max(a, based::move(b)));

285

286 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(a, based::move(b)));

296

297 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(a, based::move(b)));

307

308 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(a, based::move(b)));

318

319 STATIC_REQUIRE(based::trait::IsSame<int, ResT>);

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 ResT = decltype(based::max(based::move(a), based::move(b)));

329

330 STATIC_REQUIRE(based::trait::IsSame<int&&, ResT>);

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 ResT = decltype(based::max(based::move(a), based::move(b)));

340

341 STATIC_REQUIRE(based::trait::IsSame<int&&, ResT>);

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 TypeT = std::pair<int, int>;

350

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

352 {

353 return x.first < y.first;

354 };

355

356 const TypeT a = {3, 4};

357 const TypeT b = {3, 5};

358

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

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

361 }