Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Ardupilot
GitHub Repository: Ardupilot/ardupilot
 Path: blob/master/libraries/AP_Common/tests/test_bitmask.cpp
9420 views
1
#include <AP_gtest.h>

2
#include <AP_HAL/AP_HAL.h>

3


4
#include <AP_Common/Bitmask.h>

5


6
const AP_HAL::HAL& hal = AP_HAL::get_HAL();

7


8
template<int N>

9
void bitmask_tests(void)

10
{

11
    Bitmask<N> x;

12
    EXPECT_EQ(0, x.count());

13
    EXPECT_EQ(-1, x.first_set());

14
    x.set(5);

15
    EXPECT_EQ(1, x.count());

16
    EXPECT_EQ(5, x.first_set());

17
    x.clear(5);

18
    EXPECT_EQ(0, x.count());

19
    EXPECT_EQ(-1, x.first_set());

20


21
    EXPECT_EQ(-1, x.first_set());

22
    x.set(N-7);

23
    EXPECT_EQ(N-7, x.first_set());

24
    x.clear(N-7);

25
    EXPECT_EQ(-1, x.first_set());

26


27
    EXPECT_EQ(-1, x.first_set());

28
    x.set(0);

29
    x.set(5);

30
    x.set(6);

31
    x.set(N-1);

32
    EXPECT_EQ(4, x.count());

33
    EXPECT_EQ(0, x.first_set());

34
    EXPECT_EQ(0, x.first_set());

35
    x.clear(0);

36
    EXPECT_EQ(5, x.first_set());

37
    EXPECT_EQ(5, x.first_set());

38
    x.clear(5);

39
    EXPECT_EQ(6, x.first_set());

40
    EXPECT_EQ(6, x.first_set());

41
    x.clear(6);

42
    EXPECT_EQ(N-1, x.first_set());

43
    EXPECT_EQ(N-1, x.first_set());

44
    x.clear(N-1);

45
    EXPECT_EQ(-1, x.first_set());

46


47
    Bitmask<N> x2;

48
    x2 = x;

49


50
#if CONFIG_HAL_BOARD == HAL_BOARD_LINUX

51
    x.clear(N+1);

52
#elif CONFIG_HAL_BOARD == HAL_BOARD_SITL

53
    EXPECT_EXIT(x.clear(N+1), testing::KilledBySignal(SIGABRT), "AP_InternalError::error_t::bitmask_range");

54
#endif

55


56
#if CONFIG_HAL_BOARD == HAL_BOARD_LINUX

57
    x.set(N+1);

58
#elif CONFIG_HAL_BOARD == HAL_BOARD_SITL

59
    EXPECT_EXIT(x.set(N+1), testing::KilledBySignal(SIGABRT), "AP_InternalError::error_t::bitmask_range");

60
#endif

61


62
    for (uint8_t i=0; i<N; i++) {

63
        EXPECT_EQ(x2.get(i), x.get(i));

64
    }

65


66
#if CONFIG_HAL_BOARD == HAL_BOARD_LINUX

67
    EXPECT_EQ(false, x.get(N+1));

68
    EXPECT_EQ(false, x2.get(N+1));

69
#elif CONFIG_HAL_BOARD == HAL_BOARD_SITL

70
    EXPECT_EXIT(x2.get(N+1), testing::KilledBySignal(SIGABRT), "AP_InternalError::error_t::bitmask_range");

71
#endif

72
}

73


74
// bitmasks are composed of 32 bit words, so test those boundaries

75
TEST(Bitmask, Tests31) { bitmask_tests<31>(); }

76
TEST(Bitmask, Tests32) { bitmask_tests<32>(); }

77
TEST(Bitmask, Tests33) { bitmask_tests<33>(); }

78
TEST(Bitmask, Tests47) { bitmask_tests<47>(); }

79
TEST(Bitmask, Tests48) { bitmask_tests<48>(); }

80
TEST(Bitmask, Tests49) { bitmask_tests<49>(); }

81
TEST(Bitmask, Tests63) { bitmask_tests<63>(); }

82
TEST(Bitmask, Tests64) { bitmask_tests<64>(); }

83
TEST(Bitmask, Tests65) { bitmask_tests<65>(); }

84


85
template<int N>

86
void bitmask_setall(void)

87
{

88
    Bitmask<N> x;

89
    EXPECT_EQ(-1, x.first_set());

90
    EXPECT_EQ(false, x.get(N-4));

91
    EXPECT_EQ(0, x.count());

92
    x.setall();

93
    EXPECT_EQ(0, x.first_set());

94
    EXPECT_EQ(N, x.count());

95
    x.clear(0);

96
    EXPECT_EQ(1, x.first_set());

97
    x.clear(1);

98
    EXPECT_EQ(2, x.first_set());

99
    EXPECT_EQ(true, x.get(N-4));

100
    EXPECT_EQ(false, x.empty());

101
    x.clearall();

102
    EXPECT_EQ(-1, x.first_set());

103
    EXPECT_EQ(false, x.get(N-4));

104
    EXPECT_EQ(true, x.empty());

105
    EXPECT_EQ(0, x.count());

106
}

107


108
TEST(Bitmask, SetAll31) { bitmask_setall<31>(); }

109
TEST(Bitmask, SetAll32) { bitmask_setall<32>(); }

110
TEST(Bitmask, SetAll33) { bitmask_setall<33>(); }

111
TEST(Bitmask, SetAll47) { bitmask_setall<47>(); }

112
TEST(Bitmask, SetAll48) { bitmask_setall<48>(); }

113
TEST(Bitmask, SetAll49) { bitmask_setall<49>(); }

114
TEST(Bitmask, SetAll63) { bitmask_setall<63>(); }

115
TEST(Bitmask, SetAll64) { bitmask_setall<64>(); }

116
TEST(Bitmask, SetAll65) { bitmask_setall<65>(); }

117


118
template<int N>

119
void bitmask_assignment(void)

120
{

121
    Bitmask<N> x;

122
    x.set(0);

123
    x.set(5);

124
    x.set(6);

125
    x.set(N-1);

126


127
    Bitmask<N> y;

128
    y = x;

129
    EXPECT_EQ(true, x == y);

130
    x.clear(0);

131
    EXPECT_EQ(true, y.get(0));

132
    EXPECT_EQ(true, y.get(5));

133
    EXPECT_EQ(true, y.get(6));

134
    EXPECT_EQ(true, y.get(N-1));

135
}

136


137
TEST(Bitmask, Assignment31) { bitmask_assignment<31>(); }

138
TEST(Bitmask, Assignment32) { bitmask_assignment<32>(); }

139
TEST(Bitmask, Assignment33) { bitmask_assignment<33>(); }

140
TEST(Bitmask, Assignment47) { bitmask_assignment<47>(); }

141
TEST(Bitmask, Assignment48) { bitmask_assignment<48>(); }

142
TEST(Bitmask, Assignment49) { bitmask_assignment<49>(); }

143
TEST(Bitmask, Assignment63) { bitmask_assignment<63>(); }

144
TEST(Bitmask, Assignment64) { bitmask_assignment<64>(); }

145
TEST(Bitmask, Assignment65) { bitmask_assignment<65>(); }

146


147
AP_GTEST_PANIC()

148
AP_GTEST_MAIN()

149


150