1 // Copyright 2016 The PDFium Authors
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 <iterator>
8 #include <limits>
9 #include <memory>
10
11 #include "core/fxcodec/basic/basicmodule.h"
12 #include "core/fxcrt/data_vector.h"
13 #include "testing/gtest/include/gtest/gtest.h"
14
TEST(fxcodec,A85EmptyInput)15 TEST(fxcodec, A85EmptyInput) {
16 EXPECT_TRUE(BasicModule::A85Encode({}).empty());
17 }
18
19 // No leftover bytes, just translate 2 sets of symbols.
TEST(fxcodec,A85Basic)20 TEST(fxcodec, A85Basic) {
21 // Make sure really big values don't break.
22 const uint8_t src_buf[] = {1, 2, 3, 4, 255, 255, 255, 255};
23 DataVector<uint8_t> dest_buf = BasicModule::A85Encode(src_buf);
24
25 // Should have 5 chars for each set of 4 and 2 terminators.
26 const uint8_t expected_out[] = {33, 60, 78, 63, 43, 115,
27 56, 87, 45, 33, 126, 62};
28 ASSERT_EQ(std::size(expected_out), dest_buf.size());
29
30 // Check the output
31 for (uint32_t i = 0; i < dest_buf.size(); i++)
32 EXPECT_EQ(expected_out[i], dest_buf[i]) << " at " << i;
33 }
34
35 // Leftover bytes.
TEST(fxcodec,A85LeftoverBytes)36 TEST(fxcodec, A85LeftoverBytes) {
37 {
38 // 1 Leftover Byte:
39 const uint8_t src_buf_1leftover[] = {1, 2, 3, 4, 255};
40 DataVector<uint8_t> dest_buf = BasicModule::A85Encode(src_buf_1leftover);
41
42 // 5 chars for first symbol + 2 + 2 terminators.
43 uint8_t expected_out_1leftover[] = {33, 60, 78, 63, 43, 114, 114, 126, 62};
44 ASSERT_EQ(std::size(expected_out_1leftover), dest_buf.size());
45
46 // Check the output
47 for (uint32_t i = 0; i < dest_buf.size(); i++)
48 EXPECT_EQ(expected_out_1leftover[i], dest_buf[i]) << " at " << i;
49 }
50
51 {
52 // 2 Leftover bytes:
53 const uint8_t src_buf_2leftover[] = {1, 2, 3, 4, 255, 254};
54 DataVector<uint8_t> dest_buf = BasicModule::A85Encode(src_buf_2leftover);
55 // 5 chars for first symbol + 3 + 2 terminators.
56 const uint8_t expected_out_2leftover[] = {33, 60, 78, 63, 43,
57 115, 56, 68, 126, 62};
58 ASSERT_EQ(std::size(expected_out_2leftover), dest_buf.size());
59
60 // Check the output
61 for (uint32_t i = 0; i < dest_buf.size(); i++)
62 EXPECT_EQ(expected_out_2leftover[i], dest_buf[i]) << " at " << i;
63 }
64
65 {
66 // 3 Leftover bytes:
67 const uint8_t src_buf_3leftover[] = {1, 2, 3, 4, 255, 254, 253};
68 DataVector<uint8_t> dest_buf = BasicModule::A85Encode(src_buf_3leftover);
69 // 5 chars for first symbol + 4 + 2 terminators.
70 const uint8_t expected_out_3leftover[] = {33, 60, 78, 63, 43, 115,
71 56, 77, 114, 126, 62};
72 ASSERT_EQ(std::size(expected_out_3leftover), dest_buf.size());
73
74 // Check the output
75 for (uint32_t i = 0; i < dest_buf.size(); i++)
76 EXPECT_EQ(expected_out_3leftover[i], dest_buf[i]) << " at " << i;
77 }
78 }
79
80 // Test all zeros comes through as "z".
TEST(fxcodec,A85Zeros)81 TEST(fxcodec, A85Zeros) {
82 {
83 // Make sure really big values don't break.
84 const uint8_t src_buf[] = {1, 2, 3, 4, 0, 0, 0, 0};
85 DataVector<uint8_t> dest_buf = BasicModule::A85Encode(src_buf);
86
87 // Should have 5 chars for first set of 4 + 1 for z + 2 terminators.
88 const uint8_t expected_out[] = {33, 60, 78, 63, 43, 122, 126, 62};
89 ASSERT_EQ(std::size(expected_out), dest_buf.size());
90
91 // Check the output
92 for (uint32_t i = 0; i < dest_buf.size(); i++)
93 EXPECT_EQ(expected_out[i], dest_buf[i]) << " at " << i;
94 }
95
96 {
97 // Should also work if it is at the start:
98 const uint8_t src_buf_2[] = {0, 0, 0, 0, 1, 2, 3, 4};
99 DataVector<uint8_t> dest_buf = BasicModule::A85Encode(src_buf_2);
100
101 // Should have 5 chars for set of 4 + 1 for z + 2 terminators.
102 const uint8_t expected_out_2[] = {122, 33, 60, 78, 63, 43, 126, 62};
103 ASSERT_EQ(std::size(expected_out_2), dest_buf.size());
104
105 // Check the output
106 for (uint32_t i = 0; i < dest_buf.size(); i++)
107 EXPECT_EQ(expected_out_2[i], dest_buf[i]) << " at " << i;
108 }
109
110 {
111 // Try with 2 leftover zero bytes. Make sure we don't get a "z".
112 const uint8_t src_buf_3[] = {1, 2, 3, 4, 0, 0};
113 DataVector<uint8_t> dest_buf = BasicModule::A85Encode(src_buf_3);
114
115 // Should have 5 chars for set of 4 + 3 for last 2 + 2 terminators.
116 const uint8_t expected_out_leftover[] = {33, 60, 78, 63, 43,
117 33, 33, 33, 126, 62};
118 ASSERT_EQ(std::size(expected_out_leftover), dest_buf.size());
119
120 // Check the output
121 for (uint32_t i = 0; i < dest_buf.size(); i++)
122 EXPECT_EQ(expected_out_leftover[i], dest_buf[i]) << " at " << i;
123 }
124 }
125
126 // Make sure we get returns in the expected locations.
TEST(fxcodec,A85LineBreaks)127 TEST(fxcodec, A85LineBreaks) {
128 // Make sure really big values don't break.
129 uint8_t src_buf[131] = {0};
130 // 1 full line + most of a line of normal symbols.
131 for (int k = 0; k < 116; k += 4) {
132 src_buf[k] = 1;
133 src_buf[k + 1] = 2;
134 src_buf[k + 2] = 3;
135 src_buf[k + 3] = 4;
136 }
137 // Fill in the end, leaving an all zero gap + 3 extra zeros at the end.
138 for (int k = 120; k < 128; k++) {
139 src_buf[k] = 1;
140 src_buf[k + 1] = 2;
141 src_buf[k + 2] = 3;
142 src_buf[k + 3] = 4;
143 }
144
145 // Should succeed.
146 DataVector<uint8_t> dest_buf = BasicModule::A85Encode(src_buf);
147
148 // Should have 75 chars in the first row plus 2 char return,
149 // 76 chars in the second row plus 2 char return,
150 // and 9 chars in the last row with 2 terminators.
151 ASSERT_EQ(166u, dest_buf.size());
152
153 // Check for the returns.
154 EXPECT_EQ(13, dest_buf[75]);
155 EXPECT_EQ(10, dest_buf[76]);
156 EXPECT_EQ(13, dest_buf[153]);
157 EXPECT_EQ(10, dest_buf[154]);
158 }
159