display

0 #include <limits>

1

2 #include "display/utility.hpp"

3

4 #include <based/types/types.hpp>

5

6 int main()

7 {

8 using namespace display; // NOLINT

9

10 using sz_t = based::bu16;

11 using lim = std::numeric_limits<sz_t>;

12

13 static constexpr const sz_t zero = 0;

14 static constexpr const sz_t one = 1;

15

16 // is_overflow

17 static_assert(!is_overflow(lim::max(), zero));

18 static_assert(is_overflow(lim::max(), one));

19 static_assert(!is_overflow(lim::min(), zero));

20 static_assert(!is_overflow(lim::min(), one));

21

22 // is_underflow

23 static_assert(!is_underflow(lim::max(), zero));

24 static_assert(!is_underflow(lim::max(), one));

25 static_assert(!is_underflow(lim::min(), zero));

26 static_assert(is_underflow(lim::min(), one));

27

28 // is_overflow_lim

29 static_assert(!is_overflow_lim(1U, 0U, 2U));

30 static_assert(is_overflow_lim(1U, 2U, 2U));

31 static_assert(is_overflow_lim(3U, 1U, 2U));

32 static_assert(is_overflow_lim(1U, 3U, 2U));

33

34 // is_underflow_lim

35 static_assert(!is_underflow_lim(2U, 1U, 1U));

36 static_assert(is_underflow_lim(1U, 2U, 1U));

37 static_assert(is_underflow_lim(0U, 1U, 1U));

38 static_assert(is_underflow_lim(1U, 0U, 1U));

39

40 // add_lim

41 static_assert(add_lim(1U, 0U, 2U) == 1);

42 static_assert(add_lim(1U, 2U, 2U) == 2);

43 static_assert(add_lim(3U, 1U, 2U) == 2);

44 static_assert(add_lim(1U, 3U, 2U) == 2);

45

46 // sub_lim

47 static_assert(sub_lim(3U, 1U, 1U) == 2);

48 static_assert(sub_lim(1U, 2U, 1U) == 1);

49 static_assert(sub_lim(0U, 1U, 1U) == 1);

50 static_assert(sub_lim(1U, 0U, 1U) == 1);

51

52 return 0;

53 }