based

0 #define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE

1

2 #include "based/trait/signature.hpp"

3

4 #include <catch2/catch_test_macros.hpp>

5

6 #include "based/concept/is_same.hpp"

7 // NOLINTBEGIN(*cognitive-complexity*)

8

9 namespace

10 {

11

12 // NOLINTNEXTLINE (*needed*)

13 int free_func(const double& a, int&& b) noexcept(false)

14 {

15 return static_cast<int>(a + b);

16 }

17

18 // NOLINTNEXTLINE (*needed*)

19 int free_func_noexcept(const double& a, int&& b) noexcept(true)

20 {

21 return static_cast<int>(a + b);

22 }

23

24 } // namespace

25

26 using based::trait::IsSame;

27

28 TEST_CASE("free function", "[trait/Signature]")

29 {

30 using Sig = based::Signature<decltype(free_func)>;

31 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

32 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

33 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

34 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

35 }

36

37 TEST_CASE("free function noexcept", "[trait/Signature]")

38 {

39 using Sig = based::Signature<decltype(free_func_noexcept)>;

40 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

41 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

42 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

43 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

44 }

45

46 TEST_CASE("empty", "[trait/Signature]")

47 {

48 struct Test

49 {

50 int func(const double& a, int&& b) noexcept(false);

51 };

52

53 using Sig = based::Signature<decltype(&Test::func)>;

54 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

55 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

56 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

57 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

58 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

59 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

60 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

61 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

62 }

63

64 TEST_CASE("const", "[trait/Signature]")

65 {

66 struct Test

67 {

68 int func(const double& a, int&& b) const noexcept(false);

69 };

70

71 using Sig = based::Signature<decltype(&Test::func)>;

72 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

73 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

74 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

75 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

76 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

77 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

78 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

79 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

80 }

81

82 TEST_CASE("volatile", "[trait/Signature]")

83 {

84 struct Test

85 {

86 int func(const double& a, int&& b) volatile noexcept(false);

87 };

88

89 using Sig = based::Signature<decltype(&Test::func)>;

90 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

91 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

92 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

93 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

94 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

95 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

96 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

97 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

98 }

99

100 TEST_CASE("const volatile", "[trait/Signature]")

101 {

102 struct Test

103 {

104 int func(const double& a, int&& b) const volatile noexcept(false);

105 };

106

107 using Sig = based::Signature<decltype(&Test::func)>;

108 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

109 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

110 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

111 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

112 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

113 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

114 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

115 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

116 }

117

118 TEST_CASE("noexcept", "[trait/Signature]")

119 {

120 struct Test

121 {

122 int func(const double& a, int&& b) noexcept(true);

123 };

124

125 using Sig = based::Signature<decltype(&Test::func)>;

126 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

127 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

128 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

129 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

130 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

131 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

132 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

133 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

134 }

135

136 TEST_CASE("const noexcept", "[trait/Signature]")

137 {

138 struct Test

139 {

140 int func(const double& a, int&& b) const noexcept(true);

141 };

142

143 using Sig = based::Signature<decltype(&Test::func)>;

144 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

145 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

146 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

147 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

148 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

149 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

150 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

151 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

152 }

153

154 TEST_CASE("volatile noexcept", "[trait/Signature]")

155 {

156 struct Test

157 {

158 int func(const double& a, int&& b) volatile noexcept(true);

159 };

160

161 using Sig = based::Signature<decltype(&Test::func)>;

162 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

163 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

164 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

165 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

166 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

167 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

168 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

169 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

170 }

171

172 TEST_CASE("const volatile noexcept", "[trait/Signature]")

173 {

174 struct Test

175 {

176 int func(const double& a, int&& b) const volatile noexcept(true);

177 };

178

179 using Sig = based::Signature<decltype(&Test::func)>;

180 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

181 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

182 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

183 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

184 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

185 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

186 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

187 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

188 }

189

190 TEST_CASE("lvalref", "[trait/Signature]")

191 {

192 struct Test

193 {

194 int func(const double& a, int&& b) & noexcept(false);

195 };

196

197 using Sig = based::Signature<decltype(&Test::func)>;

198 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

199 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

200 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

201 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

202 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

203 STATIC_REQUIRE(IsSame<based::TrueType, Sig::LvalrefVal>);

204 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

205 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

206 }

207

208 TEST_CASE("const lvalref", "[trait/Signature]")

209 {

210 struct Test

211 {

212 int func(const double& a, int&& b) const& noexcept(false);

213 };

214

215 using Sig = based::Signature<decltype(&Test::func)>;

216 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

217 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

218 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

219 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

220 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

221 STATIC_REQUIRE(IsSame<based::TrueType, Sig::LvalrefVal>);

222 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

223 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

224 }

225

226 TEST_CASE("volatile lvalref", "[trait/Signature]")

227 {

228 struct Test

229 {

230 int func(const double& a, int&& b) volatile& noexcept(false);

231 };

232

233 using Sig = based::Signature<decltype(&Test::func)>;

234 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

235 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

236 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

237 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

238 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

239 STATIC_REQUIRE(IsSame<based::TrueType, Sig::LvalrefVal>);

240 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

241 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

242 }

243

244 TEST_CASE("const volatile lvalref", "[trait/Signature]")

245 {

246 struct Test

247 {

248 int func(const double& a, int&& b) const volatile& noexcept(false);

249 };

250

251 using Sig = based::Signature<decltype(&Test::func)>;

252 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

253 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

254 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

255 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

256 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

257 STATIC_REQUIRE(IsSame<based::TrueType, Sig::LvalrefVal>);

258 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

259 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

260 }

261

262 TEST_CASE("noexcept lvalref", "[trait/Signature]")

263 {

264 struct Test

265 {

266 int func(const double& a, int&& b) & noexcept(true);

267 };

268

269 using Sig = based::Signature<decltype(&Test::func)>;

270 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

271 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

272 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

273 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

274 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

275 STATIC_REQUIRE(IsSame<based::TrueType, Sig::LvalrefVal>);

276 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

277 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

278 }

279

280 TEST_CASE("const noexcept lvalref", "[trait/Signature]")

281 {

282 struct Test

283 {

284 int func(const double& a, int&& b) const& noexcept(true);

285 };

286

287 using Sig = based::Signature<decltype(&Test::func)>;

288 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

289 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

290 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

291 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

292 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

293 STATIC_REQUIRE(IsSame<based::TrueType, Sig::LvalrefVal>);

294 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

295 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

296 }

297

298 TEST_CASE("volatile noexcept lvalref", "[trait/Signature]")

299 {

300 struct Test

301 {

302 int func(const double& a, int&& b) volatile& noexcept(true);

303 };

304

305 using Sig = based::Signature<decltype(&Test::func)>;

306 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

307 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

308 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

309 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

310 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

311 STATIC_REQUIRE(IsSame<based::TrueType, Sig::LvalrefVal>);

312 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

313 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

314 }

315

316 TEST_CASE("const volatile noexcept lvalref", "[trait/Signature]")

317 {

318 struct Test

319 {

320 int func(const double& a, int&& b) const volatile& noexcept(true);

321 };

322

323 using Sig = based::Signature<decltype(&Test::func)>;

324 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

325 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

326 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

327 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

328 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

329 STATIC_REQUIRE(IsSame<based::TrueType, Sig::LvalrefVal>);

330 STATIC_REQUIRE(IsSame<based::FalseType, Sig::RvalrefVal>);

331 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

332 }

333

334 TEST_CASE("rvalref", "[trait/Signature]")

335 {

336 struct Test

337 {

338 int func(const double& a, int&& b) && noexcept(false);

339 };

340

341 using Sig = based::Signature<decltype(&Test::func)>;

342 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

343 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

344 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

345 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

346 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

347 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

348 STATIC_REQUIRE(IsSame<based::TrueType, Sig::RvalrefVal>);

349 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

350 }

351

352 TEST_CASE("const rvalref", "[trait/Signature]")

353 {

354 struct Test

355 {

356 int func(const double& a, int&& b) const&& noexcept(false);

357 };

358

359 using Sig = based::Signature<decltype(&Test::func)>;

360 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

361 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

362 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

363 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

364 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

365 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

366 STATIC_REQUIRE(IsSame<based::TrueType, Sig::RvalrefVal>);

367 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

368 }

369

370 TEST_CASE("volatile rvalref", "[trait/Signature]")

371 {

372 struct Test

373 {

374 int func(const double& a, int&& b) volatile&& noexcept(false);

375 };

376

377 using Sig = based::Signature<decltype(&Test::func)>;

378 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

379 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

380 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

381 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

382 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

383 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

384 STATIC_REQUIRE(IsSame<based::TrueType, Sig::RvalrefVal>);

385 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

386 }

387

388 TEST_CASE("const volatile rvalref", "[trait/Signature]")

389 {

390 struct Test

391 {

392 int func(const double& a, int&& b) const volatile&& noexcept(false);

393 };

394

395 using Sig = based::Signature<decltype(&Test::func)>;

396 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

397 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

398 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

399 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

400 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

401 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

402 STATIC_REQUIRE(IsSame<based::TrueType, Sig::RvalrefVal>);

403 STATIC_REQUIRE(IsSame<based::FalseType, Sig::NoexceptVal>);

404 }

405

406 TEST_CASE("noexcept rvalref", "[trait/Signature]")

407 {

408 struct Test

409 {

410 int func(const double& a, int&& b) && noexcept(true);

411 };

412

413 using Sig = based::Signature<decltype(&Test::func)>;

414 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

415 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

416 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

417 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

418 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

419 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

420 STATIC_REQUIRE(IsSame<based::TrueType, Sig::RvalrefVal>);

421 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

422 }

423

424 TEST_CASE("const noexcept rvalref", "[trait/Signature]")

425 {

426 struct Test

427 {

428 int func(const double& a, int&& b) const&& noexcept(true);

429 };

430

431 using Sig = based::Signature<decltype(&Test::func)>;

432 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

433 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

434 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

435 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

436 STATIC_REQUIRE(IsSame<based::FalseType, Sig::VolatileVal>);

437 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

438 STATIC_REQUIRE(IsSame<based::TrueType, Sig::RvalrefVal>);

439 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

440 }

441

442 TEST_CASE("volatile noexcept rvalref", "[trait/Signature]")

443 {

444 struct Test

445 {

446 int func(const double& a, int&& b) volatile&& noexcept(true);

447 };

448

449 using Sig = based::Signature<decltype(&Test::func)>;

450 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

451 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

452 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

453 STATIC_REQUIRE(IsSame<based::FalseType, Sig::ConstVal>);

454 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

455 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

456 STATIC_REQUIRE(IsSame<based::TrueType, Sig::RvalrefVal>);

457 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

458 }

459

460 TEST_CASE("const volatile noexcept rvalref", "[trait/Signature]")

461 {

462 struct Test

463 {

464 int func(const double& a, int&& b) const volatile&& noexcept(true);

465 };

466

467 using Sig = based::Signature<decltype(&Test::func)>;

468 STATIC_REQUIRE(IsSame<int(const double&, int&&), Sig::SigType>);

469 STATIC_REQUIRE(IsSame<std::tuple<const double&, int&&>, Sig::ArgType>);

470 STATIC_REQUIRE(IsSame<int, Sig::RetType>);

471 STATIC_REQUIRE(IsSame<based::TrueType, Sig::ConstVal>);

472 STATIC_REQUIRE(IsSame<based::TrueType, Sig::VolatileVal>);

473 STATIC_REQUIRE(IsSame<based::FalseType, Sig::LvalrefVal>);

474 STATIC_REQUIRE(IsSame<based::TrueType, Sig::RvalrefVal>);

475 STATIC_REQUIRE(IsSame<based::TrueType, Sig::NoexceptVal>);

476 }

477

478 // NOLINTEND(*cognitive-complexity*)