Mcucpp

1

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

5
class BufferReader
6
{
7
	uint8_t buffer[16];
8
	size_t pos;
9
public:
10
	BufferReader()
11
	{
12
		Reset();
13
		for(int i = 0; i < sizeof(buffer); i++)
14
			buffer[i] = i+1;
15
	}
16

17
	uint8_t Read()
18
	{
19
		if(pos < sizeof(buffer))
20
			return buffer[pos++];
21
		return 0;
22
	}
23

24
	void Write(uint8_t value)
25
	{
26
		if(pos < sizeof(buffer))
27
			buffer[pos++] = value;
28
	}
29

30
	void Reset()
31
	{
32
		pos = 0;
33
	}
34

35
	uint8_t* Str(){return buffer;}
36
};
37
using namespace Mcucpp;
38
typedef BinaryStream<BufferReader> Stream;
39

40
TEST(Binary, Read)
41
{
42
	Stream stream;
43
	uint32_t val32 = stream.ReadU32Be();
44
	EXPECT_EQ(0x01020304u, val32);
45
	stream.Reset();
46
	val32 = stream.ReadU32Le();
47
	EXPECT_EQ(0x04030201u, val32);
48
	stream.Reset();
49
	uint16_t val16 = stream.ReadU16Be();
50
	EXPECT_EQ(0x0102u, val16);
51
	stream.Reset();
52
	val16 = stream.ReadU16Le();
53
	EXPECT_EQ(0x0201u, val16);
54
	stream.Reset();
55
	char buf[10] = {0};
56
	stream.Read(buf, 8);
57
	EXPECT_STREQ("\x1\x2\x3\x4\x5\x6\x7\x8", buf);
58
}
59

60
TEST(Binary, Write)
61
{
62
	Stream stream;
63

64
	uint32_t val32;
65
	uint16_t val16;
66
	stream.Reset();
67
	stream.WriteU32Be(0x01020304);
68
	stream.Reset();
69
	val32 = stream.ReadU32Be();
70
	EXPECT_EQ(0x01020304u, val32);
71

72
	stream.Reset();
73
	stream.WriteU32Le(0x01020304);
74
	stream.Reset();
75
	val32 = stream.ReadU32Le();
76
	EXPECT_EQ(0x01020304u, val32);
77

78
	stream.Reset();
79
	stream.WriteU16Be(0x0102);
80
	stream.Reset();
81
	val16 = stream.ReadU16Be();
82
	EXPECT_EQ(0x0102u, val16);
83

84
	stream.Reset();
85
	stream.WriteU16Le(0x0102);
86
	stream.Reset();
87
	val16 = stream.ReadU16Le();
88
	EXPECT_EQ(0x0102u, val16);
89

90
	stream.Reset();
91
	stream.Write("Hello world", sizeof("Hello world"));
92
	EXPECT_STREQ("Hello world", (char*)stream.Str());
93
}
94

95
TEST(Binary, Ignore)
96
{
97
	Stream stream;
98
	uint8_t byte;
99
	stream.Reset();
100
	stream.Write("\x1\x2\x3\x4\x5\x6\x7\x8", 8);
101
	stream.Reset();
102
	byte = stream.Ignore(5);
103
	EXPECT_EQ(0x05u, byte);
104
	stream.Reset();
105
	byte = stream.Ignore(8, 6);
106
	EXPECT_EQ(0x06u, byte);
107
	stream.Reset();
108
	stream.Write("\xff\xff\xff\xff\xff\xff\x7\x8", 8);
109
	stream.Reset();
110
	byte = stream.IgnoreWhile(8, '\xff');
111
	EXPECT_EQ(0x07u, byte);
112
}
113

114