OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 PDFium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include <stdint.h> | |
6 | |
7 #include <limits> | |
8 | |
9 #include "core/fxcodec/codec/ccodec_basicmodule.h" | |
10 #include "core/fxcodec/fx_codec.h" | |
11 #include "testing/fx_string_testhelpers.h" | |
12 #include "testing/gtest/include/gtest/gtest.h" | |
13 | |
14 TEST(fxcodec, A85TestBadInputs) { | |
15 uint8_t src_buf[4] = {1, 2, 3, 4}; | |
16 uint8_t* dest_buf = nullptr; | |
17 uint32_t src_size = 4; | |
18 uint32_t dest_size = 0; | |
19 | |
20 CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule(); | |
21 EXPECT_TRUE(pEncoders); | |
22 | |
23 // Error codes, not segvs, should callers pass us a nullptr pointer. | |
24 EXPECT_FALSE(pEncoders->A85Encode(src_buf, src_size, &dest_buf, nullptr)); | |
25 EXPECT_FALSE(pEncoders->A85Encode(src_buf, src_size, nullptr, &dest_size)); | |
26 EXPECT_FALSE(pEncoders->A85Encode(src_buf, 0, &dest_buf, &dest_size)); | |
27 EXPECT_FALSE(pEncoders->A85Encode(nullptr, src_size, &dest_buf, &dest_size)); | |
28 } | |
29 | |
30 // No leftover bytes, just translate 2 sets of symbols. | |
31 TEST(fxcodec, A85TestBasic) { | |
32 // Make sure really big values don't break. | |
33 uint8_t src_buf[8] = {1, 2, 3, 4, 255, 255, 255, 255}; | |
34 uint8_t* dest_buf = nullptr; | |
35 uint32_t src_size = 8; | |
36 uint32_t dest_size = 0; | |
37 | |
38 CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule(); | |
39 EXPECT_TRUE(pEncoders); | |
40 | |
41 // Should succeed. | |
42 EXPECT_TRUE(pEncoders->A85Encode(src_buf, src_size, &dest_buf, &dest_size)); | |
43 | |
44 // Should have 5 chars for each set of 4 and 2 terminators. | |
45 EXPECT_EQ(dest_size, 12); | |
46 uint8_t expected_out[12] = {33, 60, 78, 63, 43, 115, 56, 87, 45, 33, 126, 62}; | |
47 | |
48 // Check the output | |
49 for (int i = 0; i < 12; i++) | |
50 EXPECT_EQ(dest_buf[i], expected_out[i]); | |
Tom Sepez
2017/01/10 21:08:41
nit: I like to write
EXPECT_EQ(dest_buf[i], expect
rbpotter
2017/01/11 20:34:49
Done.
| |
51 delete (dest_buf); | |
Tom Sepez
2017/01/10 21:08:41
FX_Free() is the inverse of FX_Alloc() and needs t
rbpotter
2017/01/11 20:34:49
Done.
| |
52 } | |
53 | |
54 // Leftover bytes. | |
55 TEST(fxcodec, A85TestLeftoverBytes) { | |
56 // 1 Leftover Byte: | |
57 uint8_t src_buf_1leftover[5] = {1, 2, 3, 4, 255}; | |
58 uint8_t* dest_buf = nullptr; | |
59 uint32_t src_size = 5; | |
60 uint32_t dest_size = 0; | |
61 | |
62 CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule(); | |
63 EXPECT_TRUE(pEncoders); | |
64 | |
65 // Should succeed | |
66 EXPECT_TRUE( | |
67 pEncoders->A85Encode(src_buf_1leftover, src_size, &dest_buf, &dest_size)); | |
68 EXPECT_EQ(dest_size, 9); // 5 chars for first symbol + 2 + 2 terminators. | |
69 uint8_t expected_out_1leftover[9] = {33, 60, 78, 63, 43, 114, 114, 126, 62}; | |
70 | |
71 // Check the output | |
72 for (int i = 0; i < 9; i++) | |
73 EXPECT_EQ(dest_buf[i], expected_out_1leftover[i]); | |
74 delete (dest_buf); | |
75 | |
76 // 2 Leftover bytes: | |
77 src_size++; | |
78 dest_buf = nullptr; | |
79 dest_size = 0; | |
80 uint8_t src_buf_2leftover[6] = {1, 2, 3, 4, 255, 254}; | |
81 // Should succeed | |
82 EXPECT_TRUE( | |
83 pEncoders->A85Encode(src_buf_2leftover, src_size, &dest_buf, &dest_size)); | |
84 EXPECT_EQ(dest_size, 10); // 5 chars for first symbol + 3 + 2 terminators. | |
85 uint8_t expected_out_2leftover[10] = {33, 60, 78, 63, 43, | |
86 115, 56, 68, 126, 62}; | |
87 | |
88 // Check the output | |
89 for (int i = 0; i < 10; i++) | |
90 EXPECT_EQ(dest_buf[i], expected_out_2leftover[i]); | |
91 delete (dest_buf); | |
92 | |
93 // 3 Leftover bytes: | |
94 src_size++; | |
95 dest_buf = nullptr; | |
96 dest_size = 0; | |
97 uint8_t src_buf_3leftover[7] = {1, 2, 3, 4, 255, 254, 253}; | |
98 // Should succeed | |
99 EXPECT_TRUE( | |
100 pEncoders->A85Encode(src_buf_3leftover, src_size, &dest_buf, &dest_size)); | |
101 EXPECT_EQ(dest_size, 11); // 5 chars for first symbol + 4 + 2 terminators. | |
102 uint8_t expected_out_3leftover[11] = {33, 60, 78, 63, 43, 115, | |
103 56, 77, 114, 126, 62}; | |
104 | |
105 // Check the output | |
106 for (int i = 0; i < 11; i++) | |
107 EXPECT_EQ(dest_buf[i], expected_out_3leftover[i]); | |
108 delete (dest_buf); | |
109 } | |
110 | |
111 // Test all zeros comes through as "z". | |
112 TEST(fxcodec, A85TestZeros) { | |
113 // Make sure really big values don't break. | |
114 uint8_t src_buf[8] = {1, 2, 3, 4, 0, 0, 0, 0}; | |
115 uint8_t* dest_buf = nullptr; | |
116 uint32_t src_size = 8; | |
117 uint32_t dest_size = 0; | |
118 | |
119 CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule(); | |
120 EXPECT_TRUE(pEncoders); | |
121 | |
122 // Should succeed. | |
123 EXPECT_TRUE(pEncoders->A85Encode(src_buf, src_size, &dest_buf, &dest_size)); | |
124 | |
125 // Should have 5 chars for first set of 4 + 1 for z + 2 terminators. | |
126 EXPECT_EQ(dest_size, 8); | |
127 uint8_t expected_out[8] = {33, 60, 78, 63, 43, 122, 126, 62}; | |
128 | |
129 // Check the output | |
130 for (int i = 0; i < 8; i++) | |
131 EXPECT_EQ(dest_buf[i], expected_out[i]); | |
132 delete (dest_buf); | |
133 | |
134 // Should also work if it is at the start: | |
135 dest_buf = nullptr; | |
136 dest_size = 0; | |
137 uint8_t src_buf_2[8] = {0, 0, 0, 0, 1, 2, 3, 4}; | |
138 | |
139 // Should succeed. | |
140 EXPECT_TRUE(pEncoders->A85Encode(src_buf_2, src_size, &dest_buf, &dest_size)); | |
141 | |
142 // Should have 5 chars for set of 4 + 1 for z + 2 terminators. | |
143 EXPECT_EQ(dest_size, 8); | |
144 uint8_t expected_out_2[8] = {122, 33, 60, 78, 63, 43, 126, 62}; | |
145 | |
146 // Check the output | |
147 for (int i = 0; i < 8; i++) | |
148 EXPECT_EQ(dest_buf[i], expected_out_2[i]); | |
149 delete (dest_buf); | |
150 | |
151 // Try with 2 leftover zero bytes. Make sure we don't get a "z". | |
152 src_size = 6; // Cut off the last 2 zeros. | |
153 dest_buf = nullptr; | |
154 dest_size = 0; | |
155 | |
156 // Should succeed. | |
157 EXPECT_TRUE(pEncoders->A85Encode(src_buf, src_size, &dest_buf, &dest_size)); | |
158 | |
159 // Should have 5 chars for set of 4 + 3 for last 2 + 2 terminators. | |
160 EXPECT_EQ(dest_size, 10); | |
161 uint8_t expected_out_leftover[10] = {33, 60, 78, 63, 43, 33, 33, 33, 126, 62}; | |
162 | |
163 // Check the output | |
164 for (int i = 0; i < 10; i++) | |
165 EXPECT_EQ(dest_buf[i], expected_out_leftover[i]); | |
166 delete (dest_buf); | |
167 } | |
168 | |
169 // Make sure we get returns in the expected locations. | |
170 TEST(fxcodec, A85TestLineBreaks) { | |
171 // Make sure really big values don't break. | |
172 uint8_t src_buf[131] = {0}; | |
173 // 1 full line + most of a line of normal symbols. | |
174 for (int k = 0; k < 116; k += 4) { | |
175 src_buf[k] = 1; | |
176 src_buf[k + 1] = 2; | |
177 src_buf[k + 2] = 3; | |
178 src_buf[k + 3] = 4; | |
179 } | |
180 // Fill in the end, leaving an all zero gap + 3 extra zeros at the end. | |
181 for (int k = 120; k < 128; k++) { | |
182 src_buf[k] = 1; | |
183 src_buf[k + 1] = 2; | |
184 src_buf[k + 2] = 3; | |
185 src_buf[k + 3] = 4; | |
186 } | |
187 uint8_t* dest_buf = nullptr; | |
188 uint32_t src_size = 131; | |
189 uint32_t dest_size = 0; | |
190 | |
191 CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule(); | |
192 EXPECT_TRUE(pEncoders); | |
193 | |
194 // Should succeed. | |
195 EXPECT_TRUE(pEncoders->A85Encode(src_buf, src_size, &dest_buf, &dest_size)); | |
196 | |
197 // Should have 75 chars in the first row plus 2 char return, | |
198 // 76 chars in the second row plus 2 char return, | |
199 // and 9 chars in the last row with 2 terminators. | |
200 EXPECT_EQ(dest_size, 166); | |
201 | |
202 // Check for the returns. | |
203 EXPECT_EQ(dest_buf[75], 13); | |
204 EXPECT_EQ(dest_buf[76], 10); | |
205 EXPECT_EQ(dest_buf[153], 13); | |
206 EXPECT_EQ(dest_buf[154], 10); | |
207 } | |
OLD | NEW |