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/fpdfapi/parser/fpdf_parser_decode.h" | |
10 #include "core/fxcodec/codec/ccodec_basicmodule.h" | |
11 #include "core/fxcodec/fx_codec.h" | |
12 #include "testing/fx_string_testhelpers.h" | |
13 #include "testing/gtest/include/gtest/gtest.h" | |
14 | |
15 TEST(fxcodec, RLETestBadInputs) { | |
16 uint8_t src_buf[1] = {1}; | |
17 uint8_t* dest_buf = nullptr; | |
18 uint32_t src_size = 4; | |
19 uint32_t dest_size = 0; | |
20 | |
21 CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule(); | |
22 EXPECT_TRUE(pEncoders); | |
23 | |
24 // Error codes, not segvs, should callers pass us a nullptr pointer. | |
25 EXPECT_FALSE( | |
26 pEncoders->RunLengthEncode(src_buf, src_size, &dest_buf, nullptr)); | |
27 EXPECT_FALSE( | |
28 pEncoders->RunLengthEncode(src_buf, src_size, nullptr, &dest_size)); | |
29 EXPECT_FALSE(pEncoders->RunLengthEncode(src_buf, 0, &dest_buf, &dest_size)); | |
30 EXPECT_FALSE( | |
31 pEncoders->RunLengthEncode(nullptr, src_size, &dest_buf, &dest_size)); | |
32 } | |
33 | |
34 // Check length 1 input works. Check terminating character is applied. | |
35 TEST(fxcodec, RLETestShortInput) { | |
36 uint8_t src_buf[1] = {1}; | |
37 uint8_t* dest_buf = nullptr; | |
38 uint32_t src_size = 1; | |
39 uint32_t dest_size = 0; | |
40 | |
41 CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule(); | |
42 EXPECT_TRUE(pEncoders); | |
43 | |
44 EXPECT_TRUE( | |
45 pEncoders->RunLengthEncode(src_buf, src_size, &dest_buf, &dest_size)); | |
46 EXPECT_EQ(dest_size, 3); | |
47 EXPECT_EQ(dest_buf[0], 0); | |
48 EXPECT_EQ(dest_buf[1], 1); | |
49 EXPECT_EQ(dest_buf[2], 128); | |
50 } | |
51 | |
52 // Check a few basic cases (2 matching runs in a row, matching run followed | |
53 // by a nonmatching run, and nonmatching run followed by a matching run). | |
54 TEST(fxcodec, RLETestNormalInputs) { | |
55 // Match, match | |
56 uint8_t src_buf_1[10] = {2, 2, 2, 2, 4, 4, 4, 4, 4, 4}; | |
57 | |
58 // Match, nonmatch | |
59 uint8_t src_buf_2[10] = {2, 2, 2, 2, 1, 2, 3, 4, 5, 6}; | |
60 | |
61 // Nonmatch, match | |
62 uint8_t src_buf_3[10] = {1, 2, 3, 4, 5, 3, 3, 3, 3, 3}; | |
63 | |
64 uint32_t src_size = 10; | |
65 uint32_t dest_size = 0; | |
66 uint8_t* dest_buf = nullptr; | |
67 | |
68 CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule(); | |
69 EXPECT_TRUE(pEncoders); | |
70 | |
71 // Case 1: | |
72 EXPECT_TRUE( | |
73 pEncoders->RunLengthEncode(src_buf_1, src_size, &dest_buf, &dest_size)); | |
74 uint8_t* decoded_buf = nullptr; | |
75 uint32_t decoded_size = 0; | |
76 RunLengthDecode(dest_buf, dest_size, decoded_buf, decoded_size); | |
77 EXPECT_EQ(decoded_size, src_size); | |
78 for (uint32_t i = 0; i < src_size; i++) | |
79 EXPECT_EQ(decoded_buf[i], src_buf_1[i]); | |
80 delete (dest_buf); | |
Tom Sepez
2017/01/10 21:08:41
FX_Free() here too and throughout.
rbpotter
2017/01/11 20:34:49
Done.
| |
81 delete (decoded_buf); | |
82 | |
83 // Case 2: | |
84 dest_buf = nullptr; | |
85 dest_size = 0; | |
86 EXPECT_TRUE( | |
87 pEncoders->RunLengthEncode(src_buf_2, src_size, &dest_buf, &dest_size)); | |
88 decoded_buf = nullptr; | |
89 decoded_size = 0; | |
90 RunLengthDecode(dest_buf, dest_size, decoded_buf, decoded_size); | |
91 EXPECT_EQ(decoded_size, src_size); | |
92 for (uint32_t i = 0; i < src_size; i++) | |
93 EXPECT_EQ(decoded_buf[i], src_buf_2[i]); | |
94 delete (dest_buf); | |
95 delete (decoded_buf); | |
96 | |
97 // Case 3: | |
98 dest_buf = nullptr; | |
99 dest_size = 0; | |
100 EXPECT_TRUE( | |
101 pEncoders->RunLengthEncode(src_buf_3, src_size, &dest_buf, &dest_size)); | |
102 decoded_buf = nullptr; | |
103 decoded_size = 0; | |
104 RunLengthDecode(dest_buf, dest_size, decoded_buf, decoded_size); | |
105 EXPECT_EQ(decoded_size, src_size); | |
106 for (uint32_t i = 0; i < src_size; i++) | |
107 EXPECT_EQ(decoded_buf[i], src_buf_3[i]); | |
108 delete (dest_buf); | |
109 delete (decoded_buf); | |
110 } | |
111 | |
112 // Check that runs longer than 128 are broken up properly, both matched and | |
113 // nonmatched. | |
114 TEST(fxcodec, RLETestFullLengthInputs) { | |
115 // Match, match | |
116 uint8_t src_buf_1[260] = {1}; | |
117 | |
118 // Match, nonmatch | |
119 uint8_t src_buf_2[260] = {2}; | |
120 for (uint16_t i = 128; i < 260; i++) | |
121 src_buf_2[i] = (uint8_t)(i - 125); | |
122 | |
123 // Nonmatch, match | |
124 uint8_t src_buf_3[260] = {3}; | |
125 for (uint8_t i = 0; i < 128; i++) | |
126 src_buf_3[i] = i; | |
127 | |
128 // Nonmatch, nonmatch | |
129 uint8_t src_buf_4[260]; | |
130 for (uint16_t i = 0; i < 260; i++) | |
131 src_buf_4[i] = (uint8_t)(i); | |
132 | |
133 uint32_t src_size = 260; | |
134 uint32_t dest_size = 0; | |
135 uint8_t* dest_buf = nullptr; | |
136 | |
137 CCodec_BasicModule* pEncoders = CCodec_ModuleMgr().GetBasicModule(); | |
138 EXPECT_TRUE(pEncoders); | |
139 | |
140 // Case 1: | |
141 EXPECT_TRUE( | |
142 pEncoders->RunLengthEncode(src_buf_1, src_size, &dest_buf, &dest_size)); | |
143 uint8_t* decoded_buf = nullptr; | |
144 uint32_t decoded_size = 0; | |
145 RunLengthDecode(dest_buf, dest_size, decoded_buf, decoded_size); | |
146 EXPECT_EQ(decoded_size, src_size); | |
147 for (uint32_t i = 0; i < src_size; i++) | |
148 EXPECT_EQ(decoded_buf[i], src_buf_1[i]); | |
149 delete (dest_buf); | |
150 delete (decoded_buf); | |
151 | |
152 // Case 2: | |
153 dest_buf = nullptr; | |
154 dest_size = 0; | |
155 EXPECT_TRUE( | |
156 pEncoders->RunLengthEncode(src_buf_2, src_size, &dest_buf, &dest_size)); | |
157 decoded_buf = nullptr; | |
158 decoded_size = 0; | |
159 RunLengthDecode(dest_buf, dest_size, decoded_buf, decoded_size); | |
160 EXPECT_EQ(decoded_size, src_size); | |
161 for (uint32_t i = 0; i < src_size; i++) | |
162 EXPECT_EQ(decoded_buf[i], src_buf_2[i]); | |
163 delete (dest_buf); | |
164 delete (decoded_buf); | |
165 | |
166 // Case 3: | |
167 dest_buf = nullptr; | |
168 dest_size = 0; | |
169 EXPECT_TRUE( | |
170 pEncoders->RunLengthEncode(src_buf_3, src_size, &dest_buf, &dest_size)); | |
171 decoded_buf = nullptr; | |
172 decoded_size = 0; | |
173 RunLengthDecode(dest_buf, dest_size, decoded_buf, decoded_size); | |
174 EXPECT_EQ(decoded_size, src_size); | |
175 for (uint32_t i = 0; i < src_size; i++) | |
176 EXPECT_EQ(decoded_buf[i], src_buf_3[i]); | |
177 delete (dest_buf); | |
178 delete (decoded_buf); | |
179 | |
180 // Case 4: | |
181 dest_buf = nullptr; | |
182 dest_size = 0; | |
183 EXPECT_TRUE( | |
184 pEncoders->RunLengthEncode(src_buf_4, src_size, &dest_buf, &dest_size)); | |
185 decoded_buf = nullptr; | |
186 decoded_size = 0; | |
187 RunLengthDecode(dest_buf, dest_size, decoded_buf, decoded_size); | |
188 EXPECT_EQ(decoded_size, src_size); | |
189 for (uint32_t i = 0; i < src_size; i++) | |
190 EXPECT_EQ(decoded_buf[i], src_buf_4[i]); | |
191 delete (dest_buf); | |
192 delete (decoded_buf); | |
193 } | |
OLD | NEW |