Mercurial > code

comparison C++/Tests/Pack/main.cpp @ 268:b5d795389387

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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)