Mercurial > code
comparison C++/Tests/Pack/main.cpp @ 268:b5d795389387
Pack:
* Remove read / write from path, it makes no sense because you need to read
all in one shot.
* Implement arrays via readArray / writeArray using iterators.
Task: #302
author | David Demelier <markand@malikania.fr> |
---|---|
date | Wed, 15 Oct 2014 21:29:20 +0200 |
parents | b686a09fb9c6 |
children | 7433ebe6a8b0 |
comparison
equal
deleted
inserted
replaced
267:bc9b5e7421a7 | 268:b5d795389387 |
---|---|
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
17 */ | 17 */ |
18 | 18 |
19 #include <sstream> | |
20 #include <vector> | |
21 | |
19 #include <gtest/gtest.h> | 22 #include <gtest/gtest.h> |
20 | 23 |
21 #include <Pack.h> | 24 #include <Pack.h> |
22 | 25 |
23 TEST(Simple, simpleLittleEndian) | 26 TEST(File, simpleLittleEndian) |
24 { | 27 { |
25 uint8_t u8(1), r8; | 28 uint8_t u8(1), r8; |
26 uint16_t u16(2), r16; | 29 uint16_t u16(2), r16; |
27 uint32_t u32(3), r32; | 30 uint32_t u32(3), r32; |
28 uint64_t u64(4), r64; | 31 uint64_t u64(4), r64; |
29 | 32 |
30 try { | 33 try { |
31 Pack::write("simple-little.bin", Pack::Little, u8, u16, u32, u64); | 34 std::ofstream out; |
32 Pack::read("simple-little.bin", Pack::Little, r8, r16, r32, r64); | 35 out.open("simple-little.bin", std::ostream::out); |
33 | 36 Pack::write(out, Pack::Little, u8, u16, u32, u64); |
34 ASSERT_EQ(u8, r8); | 37 out.close(); |
35 ASSERT_EQ(u16, r16); | 38 |
36 ASSERT_EQ(u32, r32); | 39 std::ifstream in; |
37 ASSERT_EQ(u64, r64); | 40 in.open("simple-little.bin", std::ostream::in); |
38 } catch (const std::runtime_error &error) { | 41 Pack::read(in, Pack::Little, r8, r16, r32, r64); |
39 FAIL() << error.what(); | 42 in.close(); |
40 } | 43 |
41 } | 44 ASSERT_EQ(u8, r8); |
42 | 45 ASSERT_EQ(u16, r16); |
43 TEST(Simple, simpleBigEndian) | 46 ASSERT_EQ(u32, r32); |
44 { | 47 ASSERT_EQ(u64, r64); |
45 uint8_t u8(1), r8; | 48 } catch (const std::exception &error) { |
46 uint16_t u16(2), r16; | 49 FAIL() << error.what(); |
47 uint32_t u32(3), r32; | 50 } |
48 uint64_t u64(4), r64; | 51 } |
49 | 52 |
50 try { | 53 TEST(File, simpleBigEndian) |
51 Pack::write("simple-big.bin", Pack::Big, u8, u16, u32, u64); | 54 { |
52 Pack::read("simple-big.bin", Pack::Big, r8, r16, r32, r64); | 55 uint8_t u8(1), r8; |
53 | 56 uint16_t u16(2), r16; |
54 ASSERT_EQ(u8, r8); | 57 uint32_t u32(3), r32; |
55 ASSERT_EQ(u16, r16); | 58 uint64_t u64(4), r64; |
56 ASSERT_EQ(u32, r32); | 59 |
57 ASSERT_EQ(u64, r64); | 60 try { |
58 } catch (const std::runtime_error &error) { | 61 std::ofstream out; |
62 out.open("simple-big.bin", std::ostream::out); | |
63 Pack::write(out, Pack::Big, u8, u16, u32, u64); | |
64 out.close(); | |
65 | |
66 std::ifstream in; | |
67 in.open("simple-big.bin", std::ostream::in); | |
68 Pack::read(in, Pack::Big, r8, r16, r32, r64); | |
69 in.close(); | |
70 | |
71 ASSERT_EQ(u8, r8); | |
72 ASSERT_EQ(u16, r16); | |
73 ASSERT_EQ(u32, r32); | |
74 ASSERT_EQ(u64, r64); | |
75 } catch (const std::exception &error) { | |
76 FAIL() << error.what(); | |
77 } | |
78 } | |
79 | |
80 TEST(String, simpleLittleEndian) | |
81 { | |
82 uint8_t u8(1), r8; | |
83 uint16_t u16(2), r16; | |
84 uint32_t u32(3), r32; | |
85 uint64_t u64(4), r64; | |
86 | |
87 try { | |
88 std::ostringstream out; | |
89 Pack::write(out, Pack::Little, u8, u16, u32, u64); | |
90 | |
91 std::istringstream in(out.str()); | |
92 Pack::read(in, Pack::Little, r8, r16, r32, r64); | |
93 | |
94 ASSERT_EQ(u8, r8); | |
95 ASSERT_EQ(u16, r16); | |
96 ASSERT_EQ(u32, r32); | |
97 ASSERT_EQ(u64, r64); | |
98 } catch (const std::exception &error) { | |
99 FAIL() << error.what(); | |
100 } | |
101 } | |
102 | |
103 TEST(String, simpleBigEndian) | |
104 { | |
105 uint8_t u8(1), r8; | |
106 uint16_t u16(2), r16; | |
107 uint32_t u32(3), r32; | |
108 uint64_t u64(4), r64; | |
109 | |
110 try { | |
111 std::ostringstream out; | |
112 Pack::write(out, Pack::Big, u8, u16, u32, u64); | |
113 | |
114 std::istringstream in(out.str()); | |
115 Pack::read(in, Pack::Big, r8, r16, r32, r64); | |
116 | |
117 ASSERT_EQ(u8, r8); | |
118 ASSERT_EQ(u16, r16); | |
119 ASSERT_EQ(u32, r32); | |
120 ASSERT_EQ(u64, r64); | |
121 } catch (const std::exception &error) { | |
122 FAIL() << error.what(); | |
123 } | |
124 } | |
125 | |
126 TEST(Array, simpleLittleEndian) | |
127 { | |
128 std::vector<uint8_t> u8 { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
129 std::vector<uint16_t> u16 { 10, 20, 30, 40, 50, 60, 70, 80 }; | |
130 std::vector<uint32_t> u32 { 100, 200, 300, 400, 500, 600, 700, 800 }; | |
131 std::vector<uint64_t> u64 { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000 }; | |
132 | |
133 std::vector<uint8_t> r8; | |
134 std::vector<uint16_t> r16; | |
135 std::vector<uint32_t> r32; | |
136 std::vector<uint64_t> r64; | |
137 | |
138 try { | |
139 std::ostringstream out; | |
140 Pack::writeArray(out, Pack::Little, u8.cbegin(), u8.size()); | |
141 Pack::writeArray(out, Pack::Little, u16.cbegin(), u16.size()); | |
142 Pack::writeArray(out, Pack::Little, u32.cbegin(), u32.size()); | |
143 Pack::writeArray(out, Pack::Little, u64.cbegin(), u64.size()); | |
144 | |
145 std::istringstream in(out.str()); | |
146 Pack::readArray(in, Pack::Little, std::back_inserter(r8), 8); | |
147 Pack::readArray(in, Pack::Little, std::back_inserter(r16), 8); | |
148 Pack::readArray(in, Pack::Little, std::back_inserter(r32), 8); | |
149 Pack::readArray(in, Pack::Little, std::back_inserter(r64), 8); | |
150 | |
151 | |
152 ASSERT_EQ(u8, r8); | |
153 ASSERT_EQ(u16, r16); | |
154 ASSERT_EQ(u32, r32); | |
155 ASSERT_EQ(u64, r64); | |
156 } catch (const std::exception &error) { | |
157 FAIL() << error.what(); | |
158 } | |
159 } | |
160 | |
161 TEST(Array, simpleBigEndian) | |
162 { | |
163 std::vector<uint8_t> u8 { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
164 std::vector<uint16_t> u16 { 10, 20, 30, 40, 50, 60, 70, 80 }; | |
165 std::vector<uint32_t> u32 { 100, 200, 300, 400, 500, 600, 700, 800 }; | |
166 std::vector<uint64_t> u64 { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000 }; | |
167 | |
168 std::vector<uint8_t> r8; | |
169 std::vector<uint16_t> r16; | |
170 std::vector<uint32_t> r32; | |
171 std::vector<uint64_t> r64; | |
172 | |
173 try { | |
174 std::ostringstream out; | |
175 Pack::writeArray(out, Pack::Big, u8.cbegin(), u8.size()); | |
176 Pack::writeArray(out, Pack::Big, u16.cbegin(), u16.size()); | |
177 Pack::writeArray(out, Pack::Big, u32.cbegin(), u32.size()); | |
178 Pack::writeArray(out, Pack::Big, u64.cbegin(), u64.size()); | |
179 | |
180 std::istringstream in(out.str()); | |
181 Pack::readArray(in, Pack::Big, std::back_inserter(r8), 8); | |
182 Pack::readArray(in, Pack::Big, std::back_inserter(r16), 8); | |
183 Pack::readArray(in, Pack::Big, std::back_inserter(r32), 8); | |
184 Pack::readArray(in, Pack::Big, std::back_inserter(r64), 8); | |
185 | |
186 | |
187 ASSERT_EQ(u8, r8); | |
188 ASSERT_EQ(u16, r16); | |
189 ASSERT_EQ(u32, r32); | |
190 ASSERT_EQ(u64, r64); | |
191 } catch (const std::exception &error) { | |
59 FAIL() << error.what(); | 192 FAIL() << error.what(); |
60 } | 193 } |
61 } | 194 } |
62 | 195 |
63 int main(int argc, char **argv) | 196 int main(int argc, char **argv) |