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 "core/fpdfapi/fpdf_parser/cpdf_array.h" | |
6 #include "core/fpdfapi/fpdf_parser/cpdf_number.h" | |
7 #include "core/fpdfapi/fpdf_parser/cpdf_reference.h" | |
8 | |
9 #include <memory> | |
10 | |
11 #include "testing/gtest/include/gtest/gtest.h" | |
12 | |
13 namespace { | |
14 | |
15 using ScopedArray = std::unique_ptr<CPDF_Array, ReleaseDeleter<CPDF_Array>>; | |
16 | |
17 } // namespace | |
18 | |
19 TEST(cpdf_array, RemoveAt) { | |
20 { | |
21 int elems[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; | |
22 ScopedArray arr(new CPDF_Array); | |
23 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
24 arr->AddInteger(elems[i]); | |
25 arr->RemoveAt(3, 3); | |
26 int expected[] = {1, 2, 3, 7, 8, 9, 10}; | |
27 EXPECT_EQ(FX_ArraySize(expected), arr->GetCount()); | |
28 for (size_t i = 0; i < FX_ArraySize(expected); ++i) | |
29 EXPECT_EQ(expected[i], arr->GetIntegerAt(i)); | |
30 arr->RemoveAt(4, 2); | |
31 int expected2[] = {1, 2, 3, 7, 10}; | |
32 EXPECT_EQ(FX_ArraySize(expected2), arr->GetCount()); | |
33 for (size_t i = 0; i < FX_ArraySize(expected2); ++i) | |
34 EXPECT_EQ(expected2[i], arr->GetIntegerAt(i)); | |
35 } | |
36 { | |
37 // When the range is out of bound, RemoveAt has no effect. | |
38 int elems[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; | |
39 ScopedArray arr(new CPDF_Array); | |
40 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
41 arr->AddInteger(elems[i]); | |
42 arr->RemoveAt(8, 5); | |
43 EXPECT_EQ(FX_ArraySize(elems), arr->GetCount()); | |
44 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
45 EXPECT_EQ(elems[i], arr->GetIntegerAt(i)); | |
46 arr->RemoveAt(0, 12); | |
47 EXPECT_EQ(FX_ArraySize(elems), arr->GetCount()); | |
48 arr->RemoveAt(11, 1); | |
49 EXPECT_EQ(FX_ArraySize(elems), arr->GetCount()); | |
50 } | |
51 } | |
52 | |
53 TEST(cpdf_array, InsertAt) { | |
54 { | |
55 int elems[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; | |
56 ScopedArray arr(new CPDF_Array); | |
57 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
58 arr->InsertAt(i, new CPDF_Number(elems[i])); | |
59 EXPECT_EQ(FX_ArraySize(elems), arr->GetCount()); | |
60 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
61 EXPECT_EQ(elems[i], arr->GetIntegerAt(i)); | |
62 arr->InsertAt(3, new CPDF_Number(33)); | |
63 arr->InsertAt(6, new CPDF_Number(55)); | |
64 arr->InsertAt(12, new CPDF_Number(12)); | |
65 int expected[] = {1, 2, 3, 33, 4, 5, 55, 6, 7, 8, 9, 10, 12}; | |
66 EXPECT_EQ(FX_ArraySize(expected), arr->GetCount()); | |
67 for (size_t i = 0; i < FX_ArraySize(expected); ++i) | |
68 EXPECT_EQ(expected[i], arr->GetIntegerAt(i)); | |
69 } | |
70 { | |
71 // When the position to insert is beyond the upper bound, | |
72 // an element is inserted at that position while other unfilled | |
73 // positions have nullptr. | |
74 int elems[] = {1, 2}; | |
75 ScopedArray arr(new CPDF_Array); | |
76 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
77 arr->InsertAt(i, new CPDF_Number(elems[i])); | |
78 arr->InsertAt(10, new CPDF_Number(10)); | |
79 EXPECT_EQ(11u, arr->GetCount()); | |
80 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
81 EXPECT_EQ(elems[i], arr->GetIntegerAt(i)); | |
82 for (size_t i = FX_ArraySize(elems); i < 10; ++i) | |
83 EXPECT_EQ(nullptr, arr->GetObjectAt(i)); | |
84 EXPECT_EQ(10, arr->GetIntegerAt(10)); | |
85 } | |
86 } | |
87 | |
88 TEST(cpdf_array, Clone) { | |
89 { | |
90 // Basic case. | |
91 int elems[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; | |
92 ScopedArray arr(new CPDF_Array); | |
93 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
94 arr->InsertAt(i, new CPDF_Number(elems[i])); | |
95 ScopedArray arr2(arr->Clone()->AsArray()); | |
96 EXPECT_EQ(arr->GetCount(), arr2->GetCount()); | |
97 for (size_t i = 0; i < FX_ArraySize(elems); ++i) { | |
98 // Clone() always create new objects. | |
99 EXPECT_NE(arr->GetObjectAt(i), arr2->GetObjectAt(i)); | |
100 EXPECT_EQ(arr->GetIntegerAt(i), arr2->GetIntegerAt(i)); | |
101 } | |
102 } | |
103 { | |
104 // Clone() with and without dereferencing reference objects. | |
105 static const size_t kNumOfRows = 3; | |
106 static const size_t kNumOfRowElems = 5; | |
107 int elems[kNumOfRows][kNumOfRowElems] = { | |
108 {1, 2, 3, 4, 5}, {10, 9, 8, 7, 6}, {11, 12, 13, 14, 15}}; | |
109 ScopedArray arr(new CPDF_Array); | |
110 // Indirect references to indirect objects. | |
111 std::unique_ptr<CPDF_IndirectObjectHolder> obj_holder( | |
112 new CPDF_IndirectObjectHolder()); | |
113 for (size_t i = 0; i < kNumOfRows; ++i) { | |
114 CPDF_Array* arr_elem = new CPDF_Array; | |
115 for (size_t j = 0; j < kNumOfRowElems; ++j) { | |
116 CPDF_Number* obj = new CPDF_Number(elems[i][j]); | |
117 // Starts object number from 1. | |
118 int obj_num = i * kNumOfRowElems + j + 1; | |
119 obj_holder->ReplaceIndirectObjectIfHigherGeneration(obj_num, obj); | |
120 arr_elem->InsertAt(j, new CPDF_Reference(obj_holder.get(), obj_num)); | |
121 } | |
122 arr->InsertAt(i, arr_elem); | |
123 } | |
124 ASSERT_EQ(kNumOfRows, arr->GetCount()); | |
125 // Not dereferencing reference objects means just creating new references | |
126 // instead of new copies of direct objects. | |
127 ScopedArray arr1(arr->Clone()->AsArray()); | |
128 EXPECT_EQ(arr->GetCount(), arr1->GetCount()); | |
129 // Dereferencing reference objects creates new copies of direct objects. | |
130 ScopedArray arr2(arr->CloneDirectObject()->AsArray()); | |
131 EXPECT_EQ(arr->GetCount(), arr2->GetCount()); | |
132 for (size_t i = 0; i < kNumOfRows; ++i) { | |
133 CPDF_Array* arr_elem = arr->GetObjectAt(i)->AsArray(); | |
134 CPDF_Array* arr1_elem = arr1->GetObjectAt(i)->AsArray(); | |
135 CPDF_Array* arr2_elem = arr2->GetObjectAt(i)->AsArray(); | |
136 EXPECT_NE(arr_elem, arr1_elem); | |
137 EXPECT_NE(arr_elem, arr2_elem); | |
138 for (size_t j = 0; j < kNumOfRowElems; ++j) { | |
139 auto elem_obj = arr_elem->GetObjectAt(j); | |
140 auto elem_obj1 = arr1_elem->GetObjectAt(j); | |
141 auto elem_obj2 = arr2_elem->GetObjectAt(j); | |
142 // Results from not deferencing reference objects. | |
143 EXPECT_NE(elem_obj, elem_obj1); | |
144 EXPECT_TRUE(elem_obj1->IsReference()); | |
145 EXPECT_EQ(elem_obj->GetDirect(), elem_obj1->GetDirect()); | |
146 EXPECT_EQ(elem_obj->GetInteger(), elem_obj1->GetInteger()); | |
147 // Results from deferencing reference objects. | |
148 EXPECT_NE(elem_obj, elem_obj2); | |
149 EXPECT_TRUE(elem_obj2->IsNumber()); | |
150 EXPECT_NE(elem_obj->GetDirect(), elem_obj2); | |
151 EXPECT_EQ(elem_obj->GetObjNum(), elem_obj2->GetObjNum()); | |
152 EXPECT_EQ(elem_obj->GetInteger(), elem_obj2->GetInteger()); | |
153 } | |
154 } | |
155 arr.reset(); | |
156 ASSERT_EQ(kNumOfRows, arr1->GetCount()); | |
157 for (size_t i = 0; i < kNumOfRows; ++i) { | |
158 for (size_t j = 0; j < kNumOfRowElems; ++j) { | |
159 // Results from not deferencing reference objects. | |
160 auto elem_obj1 = arr1->GetObjectAt(i)->AsArray()->GetObjectAt(j); | |
161 EXPECT_TRUE(elem_obj1->IsReference()); | |
162 EXPECT_EQ(elems[i][j], elem_obj1->GetInteger()); | |
163 // Results from deferencing reference objects. | |
164 EXPECT_EQ(elems[i][j], | |
165 arr2->GetObjectAt(i)->AsArray()->GetIntegerAt(j)); | |
166 } | |
167 } | |
168 } | |
169 } | |
170 | |
171 TEST(cpdf_array, Iterator) { | |
172 int elems[] = {-23, -11, 3, 455, 2345877, | |
173 0, 7895330, -12564334, 10000, -100000}; | |
174 ScopedArray arr(new CPDF_Array); | |
175 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
176 arr->InsertAt(i, new CPDF_Number(elems[i])); | |
177 size_t index = 0; | |
178 for (const auto& it : *arr) | |
179 EXPECT_EQ(elems[index++], it->AsNumber()->GetInteger()); | |
180 } | |
OLD | NEW |