Skip to content

Commit b602a84

Browse files
FrozenLemonTeeFrozenLemonTee
committed
test: Add unit tests for comparison operators in operations module
Signed-off-by: FrozenlemonTee <1115306170@qq.com>
1 parent fff80c3 commit b602a84

File tree

1 file changed

+191
-0
lines changed

1 file changed

+191
-0
lines changed

‎tests/basic/operations/operators/test_framework_and_compound.cpp‎

Lines changed: 191 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -380,3 +380,194 @@ TEST(OperationsTest,
380380
EXPECT_EQ(add_result.error(), policy::error::kind::overflow);
381381
EXPECT_EQ(value.load(), static_cast<std::int16_t>(32000));
382382
}
383+
384+
TEST(OperationsTest, LessThanReturnsCorrectResultForIntegers) {
385+
using namespace mcpplibs::primitives::operators;
386+
using value_t =
387+
primitive<int, policy::value::checked, policy::error::expected>;
388+
389+
auto const less_result = operations::less_than(value_t{3}, value_t{7});
390+
auto const greater_result = operations::less_than(value_t{9}, value_t{1});
391+
auto const equal_result = operations::less_than(value_t{5}, value_t{5});
392+
393+
ASSERT_TRUE(less_result.has_value());
394+
ASSERT_TRUE(greater_result.has_value());
395+
ASSERT_TRUE(equal_result.has_value());
396+
EXPECT_EQ(less_result->value(), 1);
397+
EXPECT_EQ(greater_result->value(), 0);
398+
EXPECT_EQ(equal_result->value(), 0);
399+
}
400+
401+
TEST(OperationsTest, GreaterThanReturnsCorrectResultForIntegers) {
402+
using namespace mcpplibs::primitives::operators;
403+
using value_t =
404+
primitive<int, policy::value::checked, policy::error::expected>;
405+
406+
auto const less_result = operations::greater_than(value_t{3}, value_t{7});
407+
auto const greater_result = operations::greater_than(value_t{9}, value_t{1});
408+
auto const equal_result = operations::greater_than(value_t{5}, value_t{5});
409+
410+
ASSERT_TRUE(less_result.has_value());
411+
ASSERT_TRUE(greater_result.has_value());
412+
ASSERT_TRUE(equal_result.has_value());
413+
EXPECT_EQ(less_result->value(), 0);
414+
EXPECT_EQ(greater_result->value(), 1);
415+
EXPECT_EQ(equal_result->value(), 0);
416+
}
417+
418+
TEST(OperationsTest, LessThanOrEqualReturnsCorrectResultForIntegers) {
419+
using namespace mcpplibs::primitives::operators;
420+
using value_t =
421+
primitive<int, policy::value::checked, policy::error::expected>;
422+
423+
auto const less_result = operations::less_than_or_equal(value_t{3}, value_t{7});
424+
auto const greater_result = operations::less_than_or_equal(value_t{9}, value_t{1});
425+
auto const equal_result = operations::less_than_or_equal(value_t{5}, value_t{5});
426+
427+
ASSERT_TRUE(less_result.has_value());
428+
ASSERT_TRUE(greater_result.has_value());
429+
ASSERT_TRUE(equal_result.has_value());
430+
EXPECT_EQ(less_result->value(), 1);
431+
EXPECT_EQ(greater_result->value(), 0);
432+
EXPECT_EQ(equal_result->value(), 1);
433+
}
434+
435+
TEST(OperationsTest, GreaterThanOrEqualReturnsCorrectResultForIntegers) {
436+
using namespace mcpplibs::primitives::operators;
437+
using value_t =
438+
primitive<int, policy::value::checked, policy::error::expected>;
439+
440+
auto const less_result = operations::greater_than_or_equal(value_t{3}, value_t{7});
441+
auto const greater_result = operations::greater_than_or_equal(value_t{9}, value_t{1});
442+
auto const equal_result = operations::greater_than_or_equal(value_t{5}, value_t{5});
443+
444+
ASSERT_TRUE(less_result.has_value());
445+
ASSERT_TRUE(greater_result.has_value());
446+
ASSERT_TRUE(equal_result.has_value());
447+
EXPECT_EQ(less_result->value(), 0);
448+
EXPECT_EQ(greater_result->value(), 1);
449+
EXPECT_EQ(equal_result->value(), 1);
450+
}
451+
452+
TEST(OperationsTest, OperatorLessThanDelegatesToDispatcher) {
453+
using namespace mcpplibs::primitives::operators;
454+
using value_t =
455+
primitive<int, policy::value::checked, policy::error::expected>;
456+
457+
auto const result = (value_t{3} < value_t{7});
458+
459+
ASSERT_TRUE(result.has_value());
460+
EXPECT_EQ(result->value(), 1);
461+
}
462+
463+
TEST(OperationsTest, OperatorGreaterThanDelegatesToDispatcher) {
464+
using namespace mcpplibs::primitives::operators;
465+
using value_t =
466+
primitive<int, policy::value::checked, policy::error::expected>;
467+
468+
auto const result = (value_t{9} > value_t{1});
469+
470+
ASSERT_TRUE(result.has_value());
471+
EXPECT_EQ(result->value(), 1);
472+
}
473+
474+
TEST(OperationsTest, OperatorLessThanOrEqualDelegatesToDispatcher) {
475+
using namespace mcpplibs::primitives::operators;
476+
using value_t =
477+
primitive<int, policy::value::checked, policy::error::expected>;
478+
479+
auto const less_result = (value_t{3} <= value_t{7});
480+
auto const equal_result = (value_t{5} <= value_t{5});
481+
482+
ASSERT_TRUE(less_result.has_value());
483+
ASSERT_TRUE(equal_result.has_value());
484+
EXPECT_EQ(less_result->value(), 1);
485+
EXPECT_EQ(equal_result->value(), 1);
486+
}
487+
488+
TEST(OperationsTest, OperatorGreaterThanOrEqualDelegatesToDispatcher) {
489+
using namespace mcpplibs::primitives::operators;
490+
using value_t =
491+
primitive<int, policy::value::checked, policy::error::expected>;
492+
493+
auto const greater_result = (value_t{9} >= value_t{1});
494+
auto const equal_result = (value_t{5} >= value_t{5});
495+
496+
ASSERT_TRUE(greater_result.has_value());
497+
ASSERT_TRUE(equal_result.has_value());
498+
EXPECT_EQ(greater_result->value(), 1);
499+
EXPECT_EQ(equal_result->value(), 1);
500+
}
501+
502+
TEST(OperationsTest, FourWayComparisonOperatorsWorkTogether) {
503+
using namespace mcpplibs::primitives::operators;
504+
using value_t =
505+
primitive<int, policy::value::checked, policy::error::expected>;
506+
507+
auto const a = value_t{10};
508+
auto const b = value_t{20};
509+
auto const c = value_t{10};
510+
511+
auto const a_lt_b = (a < b);
512+
auto const a_gt_b = (a > b);
513+
auto const a_le_b = (a <= b);
514+
auto const a_ge_b = (a >= b);
515+
auto const a_lt_c = (a < c);
516+
auto const a_le_c = (a <= c);
517+
auto const a_ge_c = (a >= c);
518+
auto const a_gt_c = (a > c);
519+
520+
ASSERT_TRUE(a_lt_b.has_value());
521+
ASSERT_TRUE(a_gt_b.has_value());
522+
ASSERT_TRUE(a_le_b.has_value());
523+
ASSERT_TRUE(a_ge_b.has_value());
524+
ASSERT_TRUE(a_lt_c.has_value());
525+
ASSERT_TRUE(a_le_c.has_value());
526+
ASSERT_TRUE(a_ge_c.has_value());
527+
ASSERT_TRUE(a_gt_c.has_value());
528+
529+
EXPECT_EQ(a_lt_b->value(), 1);
530+
EXPECT_EQ(a_gt_b->value(), 0);
531+
EXPECT_EQ(a_le_b->value(), 1);
532+
EXPECT_EQ(a_ge_b->value(), 0);
533+
EXPECT_EQ(a_lt_c->value(), 0);
534+
EXPECT_EQ(a_le_c->value(), 1);
535+
EXPECT_EQ(a_ge_c->value(), 1);
536+
EXPECT_EQ(a_gt_c->value(), 0);
537+
}
538+
539+
TEST(OperationsTest, ComparisonOperatorsWorkWithMixedTypes) {
540+
using namespace mcpplibs::primitives::operators;
541+
using value_t = primitive<int, policy::value::checked, policy::error::expected,
542+
policy::type::compatible>;
543+
544+
auto const lhs = value_t{10};
545+
short const rhs = 20;
546+
547+
auto const lt_lr = lhs < rhs;
548+
auto const lt_rl = rhs < lhs;
549+
auto const gt_lr = lhs > rhs;
550+
auto const gt_rl = rhs > lhs;
551+
auto const le_lr = lhs <= rhs;
552+
auto const le_rl = rhs <= lhs;
553+
auto const ge_lr = lhs >= rhs;
554+
auto const ge_rl = rhs >= lhs;
555+
556+
ASSERT_TRUE(lt_lr.has_value());
557+
ASSERT_TRUE(lt_rl.has_value());
558+
ASSERT_TRUE(gt_lr.has_value());
559+
ASSERT_TRUE(gt_rl.has_value());
560+
ASSERT_TRUE(le_lr.has_value());
561+
ASSERT_TRUE(le_rl.has_value());
562+
ASSERT_TRUE(ge_lr.has_value());
563+
ASSERT_TRUE(ge_rl.has_value());
564+
565+
EXPECT_EQ(lt_lr->value(), 1);
566+
EXPECT_EQ(lt_rl->value(), 0);
567+
EXPECT_EQ(gt_lr->value(), 0);
568+
EXPECT_EQ(gt_rl->value(), 1);
569+
EXPECT_EQ(le_lr->value(), 1);
570+
EXPECT_EQ(le_rl->value(), 0);
571+
EXPECT_EQ(ge_lr->value(), 0);
572+
EXPECT_EQ(ge_rl->value(), 1);
573+
}

0 commit comments

Comments
 (0)