Mcucpp

1

2
#include <fixedpoint.h>
3
#include <gtest/gtest.h>
4

5
using namespace Mcucpp;
6

7
	typedef FixedPoint<int32_t, 17> fixed16_t;
8
	typedef FixedPoint<int16_t, 8> fixed8_t;
9
	const double threshold = 0.01;
10

11
TEST(FixedPoint, Init)
12
{
13
	fixed16_t p0;
14
	EXPECT_EQ(0, p0.IntegerPart());
15
	EXPECT_EQ(0u, p0.FractionalPart());
16

17
	fixed16_t p1(100u);
18
	EXPECT_EQ(100, p1.IntegerPart());
19
	EXPECT_EQ(0u, p1.FractionalPart());
20

21
	fixed16_t p2(100);
22
	EXPECT_EQ(100, p2.IntegerPart());
23
	EXPECT_EQ(0, p2.FractionalPart());
24

25
	fixed8_t p3(0);
26
	EXPECT_EQ(0, p3.IntegerPart());
27
	EXPECT_EQ(0u, p3.FractionalPart());
28

29
	fixed8_t p4(100);
30
	EXPECT_EQ(100, p4.IntegerPart());
31

32
	fixed16_t p5(-100);
33
	EXPECT_EQ(-100, p5.IntegerPart());
34

35
}
36

37
TEST(FixedPoint, Plus)
38
{
39
	fixed16_t p1(50.4), p2(-100.5), p3;
40
	p3 = p1 + p2;
41
	EXPECT_NEAR(-50.1f, p3.ToFloat(), threshold);
42

43
	p3 += 10;
44
	EXPECT_NEAR(-40.1f, p3.ToFloat(), threshold);
45

46
	p3 += fixed16_t(-100.2f);
47
	EXPECT_NEAR(-140.3f, p3.ToFloat(), threshold);
48

49
	p3 = p1 + 10;
50
	EXPECT_NEAR(60.4f, p3.ToFloat(), threshold);
51

52
	p3 = 10 + p2;
53
	EXPECT_NEAR(-90.5f, p3.ToFloat(), threshold);
54
}
55

56
TEST(FixedPoint, Minus)
57
{
58
	fixed16_t p1(50.4), p2(-100.5), p3;
59
	p3 = p1 - p2;
60
	EXPECT_NEAR(150.9, p3.ToDouble(), threshold);
61

62
	p3 -= 10;
63
	EXPECT_NEAR(140.9, p3.ToDouble(), threshold);
64

65
	p3 -= fixed16_t(-100.2);
66
	EXPECT_NEAR(241.1, p3.ToDouble(), threshold);
67

68
	p3 = p1 - 10;
69
	EXPECT_NEAR(40.4, p3.ToDouble(), threshold);
70

71
	p3 = 10 - p2;
72
	EXPECT_NEAR(110.5, p3.ToDouble(), threshold);
73
}
74

75
TEST(FixedPoint, Multiply)
76
{
77
	fixed16_t p1(50.4), p2(-100.5), p3;
78
	p3 = p1 * p2;
79
	EXPECT_NEAR(-5065.2, p3.ToDouble(), threshold);
80

81
	p3 *= 2;
82
	EXPECT_NEAR(-10130.4, p3.ToDouble(), threshold);
83

84
	p3 *= fixed16_t(0.1);
85
	EXPECT_NEAR(-1013, p3.ToDouble(), 0.25);
86

87
	p3 = p1 * 10;
88
	EXPECT_NEAR(504.0, p3.ToDouble(), threshold);
89

90
	p3 = 10 * p2;
91
	EXPECT_NEAR(-1005.0, p3.ToDouble(), threshold);
92

93
	p3 = fixed16_t(0.1) * fixed16_t(0.1);
94
	EXPECT_NEAR(0.01, p3.ToDouble(), threshold);
95
}
96

97
TEST(FixedPoint, Divide)
98
{
99
	EXPECT_NEAR(1.0, (fixed16_t(0.1) / fixed16_t(0.1)).ToDouble(), threshold);
100

101
	fixed16_t p1(100), p2(12), p3;
102
	p3 = p1 / p2;
103
	EXPECT_NEAR(8.33333, p3.ToDouble(), threshold);
104

105
	p3 /= -2;
106
	EXPECT_NEAR(-4.16666, p3.ToDouble(), threshold);
107

108
	p3 /= fixed16_t(0.1);
109
	EXPECT_NEAR(-41.6666, p3.ToDouble(), threshold*2);
110

111
	p3 = p1 / 10;
112
	EXPECT_NEAR(10, p3.ToDouble(), threshold);
113

114
	p3 = 10 / p2;
115
	EXPECT_NEAR(10.0 / 12.0, p3.ToDouble(), threshold);
116

117
}
118