based

0 #define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE

1

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

3

4 #include <catch2/catch_test_macros.hpp>

5

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

7

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

9

10 TEST_CASE("min(literal, literal) = left", "[algorithm/min]")

11 {

12 using ResT = decltype(based::min(3, 4));

13

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

15 REQUIRE(based::min(3, 4) == 3);

16 }

17

18 TEST_CASE("min(literal, literal) = right", "[algorithm/min]")

19 {

20 using ResT = decltype(based::min(4, 3));

21

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

23 REQUIRE(based::min(4, 3) == 3);

24 }

25

26 TEST_CASE("min(value, literal) = left", "[algorithm/min]")

27 {

28 int a = 3;

29

30 using ResT = decltype(based::min(a, 4));

31

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

33 REQUIRE(based::min(a, 4) == 3);

34 }

35

36 TEST_CASE("min(value, literal) = right", "[algorithm/min]")

37 {

38 int a = 4;

39

40 using ResT = decltype(based::min(a, 3));

41

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

43 REQUIRE(based::min(a, 3) == 3);

44 }

45

46 TEST_CASE("min(literal, value) = left", "[algorithm/min]")

47 {

48 int b = 4;

49

50 using ResT = decltype(based::min(3, b));

51

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

53 REQUIRE(based::min(3, b) == 3);

54 }

55

56 TEST_CASE("min(literal, value) = right", "[algorithm/min]")

57 {

58 int b = 3;

59

60 using ResT = decltype(based::min(4, b));

61

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

63 REQUIRE(based::min(4, b) == 3);

64 }

65

66 TEST_CASE("min(value, value) = left", "[algorithm/min]")

67 {

68 int a = 3;

69 int b = 4;

70

71 using ResT = decltype(based::min(a, b));

72

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

74 REQUIRE(based::min(a, b) == 3);

75 }

76

77 TEST_CASE("min(value, value) = right", "[algorithm/min]")

78 {

79 int a = 4;

80 int b = 3;

81

82 using ResT = decltype(based::min(a, b));

83

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

85 REQUIRE(based::min(a, b) == 3);

86 }

87

88 TEST_CASE("min(const value, literal) = left", "[algorithm/min]")

89 {

90 const int a = 3;

91

92 using ResT = decltype(based::min(a, 4));

93

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

95 REQUIRE(based::min(a, 4) == 3);

96 }

97

98 TEST_CASE("min(const value, literal) = right", "[algorithm/min]")

99 {

100 const int a = 4;

101

102 using ResT = decltype(based::min(a, 3));

103

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

105 REQUIRE(based::min(a, 3) == 3);

106 }

107

108 TEST_CASE("min(literal, const value) = left", "[algorithm/min]")

109 {

110 const int b = 4;

111

112 using ResT = decltype(based::min(3, b));

113

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

115 REQUIRE(based::min(3, b) == 3);

116 }

117

118 TEST_CASE("min(literal, const value) = right", "[algorithm/min]")

119 {

120 const int b = 3;

121

122 using ResT = decltype(based::min(4, b));

123

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

125 REQUIRE(based::min(4, b) == 3);

126 }

127

128 TEST_CASE("min(const value, const value) = left", "[algorithm/min]")

129 {

130 const int a = 3;

131 const int b = 4;

132

133 using ResT = decltype(based::min(a, b));

134

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

136 REQUIRE(based::min(a, b) == 3);

137 }

138

139 TEST_CASE("min(const value, const value) = right", "[algorithm/min]")

140 {

141 const int a = 4;

142 const int b = 3;

143

144 using ResT = decltype(based::min(a, b));

145

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

147 REQUIRE(based::min(a, b) == 3);

148 }

149

150 TEST_CASE("min(value, const value) = left", "[algorithm/min]")

151 {

152 int a = 3;

153 const int b = 4;

154

155 using ResT = decltype(based::min(a, b));

156

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

158 REQUIRE(based::min(a, b) == 3);

159 }

160

161 TEST_CASE("min(value, const value) = right", "[algorithm/min]")

162 {

163 int a = 4;

164 const int b = 3;

165

166 using ResT = decltype(based::min(a, b));

167

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

169 REQUIRE(based::min(a, b) == 3);

170 }

171

172 TEST_CASE("min(const value, value) = left", "[algorithm/min]")

173 {

174 const int a = 3;

175 int b = 4;

176

177 using ResT = decltype(based::min(a, b));

178

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

180 REQUIRE(based::min(a, b) == 3);

181 }

182

183 TEST_CASE("min(const value, value) = right", "[algorithm/min]")

184 {

185 const int a = 4;

186 int b = 3;

187

188 using ResT = decltype(based::min(a, b));

189

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

191 REQUIRE(based::min(a, b) == 3);

192 }

193

194 TEST_CASE("min(move, literal) = left", "[algorithm/min]")

195 {

196 int a = 3;

197

198 using ResT = decltype(based::min(based::move(a), 4));

199

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

201 REQUIRE(based::min(based::move(a), 4) == 3);

202 }

203

204 TEST_CASE("min(move, literal) = right", "[algorithm/min]")

205 {

206 int a = 4;

207

208 using ResT = decltype(based::min(based::move(a), 3));

209

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

211 REQUIRE(based::min(based::move(a), 3) == 3);

212 }

213

214 TEST_CASE("min(move, value) = left", "[algorithm/min]")

215 {

216 int a = 3;

217 int b = 4;

218

219 using ResT = decltype(based::min(based::move(a), b));

220

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

222 REQUIRE(based::min(based::move(a), b) == 3);

223 }

224

225 TEST_CASE("min(move, value) = right", "[algorithm/min]")

226 {

227 int a = 4;

228 int b = 3;

229

230 using ResT = decltype(based::min(based::move(a), b));

231

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

233 REQUIRE(based::min(based::move(a), b) == 3);

234 }

235

236 TEST_CASE("min(move, const value) = left", "[algorithm/min]")

237 {

238 int a = 3;

239 const int b = 4;

240

241 using ResT = decltype(based::min(based::move(a), b));

242

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

244 REQUIRE(based::min(based::move(a), b) == 3);

245 }

246

247 TEST_CASE("min(move, const value) = right", "[algorithm/min]")

248 {

249 int a = 4;

250 const int b = 3;

251

252 using ResT = decltype(based::min(based::move(a), b));

253

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

255 REQUIRE(based::min(based::move(a), b) == 3);

256 }

257

258 TEST_CASE("min(literal, move) = left", "[algorithm/min]")

259 {

260 int b = 4;

261

262 using ResT = decltype(based::min(3, based::move(b)));

263

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

265 REQUIRE(based::min(3, based::move(b)) == 3);

266 }

267

268 TEST_CASE("min(literal, move) = right", "[algorithm/min]")

269 {

270 int b = 3;

271

272 using ResT = decltype(based::min(4, based::move(b)));

273

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

275 REQUIRE(based::min(4, based::move(b)) == 3);

276 }

277

278 TEST_CASE("min(value, move) = left", "[algorithm/min]")

279 {

280 int a = 3;

281 int b = 4;

282

283 using ResT = decltype(based::min(a, based::move(b)));

284

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

286 REQUIRE(based::min(a, based::move(b)) == 3);

287 }

288

289 TEST_CASE("min(value, move) = right", "[algorithm/min]")

290 {

291 int a = 4;

292 int b = 3;

293

294 using ResT = decltype(based::min(a, based::move(b)));

295

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

297 REQUIRE(based::min(a, based::move(b)) == 3);

298 }

299

300 TEST_CASE("min(const value, move) = left", "[algorithm/min]")

301 {

302 const int a = 3;

303 int b = 4;

304

305 using ResT = decltype(based::min(a, based::move(b)));

306

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

308 REQUIRE(based::min(a, based::move(b)) == 3);

309 }

310

311 TEST_CASE("min(const value, move) = right", "[algorithm/min]")

312 {

313 const int a = 4;

314 int b = 3;

315

316 using ResT = decltype(based::min(a, based::move(b)));

317

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

319 REQUIRE(based::min(a, based::move(b)) == 3);

320 }

321

322 TEST_CASE("min(move, move) = left", "[algorithm/min]")

323 {

324 int a = 3;

325 int b = 4;

326

327 using ResT = decltype(based::min(based::move(a), based::move(b)));

328

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

330 REQUIRE(based::min(based::move(a), based::move(b)) == 3);

331 }

332

333 TEST_CASE("min(move, move) = right", "[algorithm/min]")

334 {

335 int a = 4;

336 int b = 3;

337

338 using ResT = decltype(based::min(based::move(a), based::move(b)));

339

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

341 REQUIRE(based::min(based::move(a), based::move(b)) == 3);

342 }

343

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

345

346 TEST_CASE("min-stability", "[algorithm/min]")

347 {

348 using TypeT = std::pair<int, int>;

349

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

351 {

352 return x.first < y.first;

353 };

354

355 const TypeT a = {3, 4};

356 const TypeT b = {3, 5};

357

358 REQUIRE(based::min(a, b, cmp).second == 4);

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

360 }