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/include/cpdf_array.h" | |
6 #include "core/fpdfapi/fpdf_parser/include/cpdf_number.h" | |
7 | |
8 #include <memory> | |
9 | |
10 #include "testing/gtest/include/gtest/gtest.h" | |
11 | |
12 namespace { | |
13 | |
14 using ScopedArray = std::unique_ptr<CPDF_Array, ReleaseDeleter<CPDF_Array>>; | |
15 | |
16 } // namespace | |
17 | |
18 TEST(cpdf_array, RemoveAt) { | |
19 { | |
20 int elems[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; | |
21 ScopedArray arr(new CPDF_Array); | |
22 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
23 arr->AddInteger(elems[i]); | |
24 arr->RemoveAt(3, 3); | |
25 int expected[] = {1, 2, 3, 7, 8, 9, 10}; | |
26 EXPECT_EQ(FX_ArraySize(expected), arr->GetCount()); | |
27 for (size_t i = 0; i < FX_ArraySize(expected); ++i) | |
28 EXPECT_EQ(expected[i], arr->GetIntegerAt(i)); | |
29 arr->RemoveAt(4, 2); | |
30 int expected2[] = {1, 2, 3, 7, 10}; | |
31 EXPECT_EQ(FX_ArraySize(expected2), arr->GetCount()); | |
32 for (size_t i = 0; i < FX_ArraySize(expected2); ++i) | |
33 EXPECT_EQ(expected2[i], arr->GetIntegerAt(i)); | |
34 } | |
35 { | |
36 // When the range is out of bound, RemoveAt has no effect. | |
37 int elems[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; | |
38 ScopedArray arr(new CPDF_Array); | |
39 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
40 arr->AddInteger(elems[i]); | |
41 arr->RemoveAt(8, 5); | |
42 EXPECT_EQ(FX_ArraySize(elems), arr->GetCount()); | |
43 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
44 EXPECT_EQ(elems[i], arr->GetIntegerAt(i)); | |
45 arr->RemoveAt(0, 12); | |
46 EXPECT_EQ(FX_ArraySize(elems), arr->GetCount()); | |
47 arr->RemoveAt(11, 1); | |
48 EXPECT_EQ(FX_ArraySize(elems), arr->GetCount()); | |
49 } | |
50 } | |
51 | |
52 TEST(cpdf_array, InsertAt) { | |
53 { | |
54 int elems[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; | |
55 ScopedArray arr(new CPDF_Array); | |
56 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
57 arr->InsertAt(i, new CPDF_Number(elems[i])); | |
58 EXPECT_EQ(FX_ArraySize(elems), arr->GetCount()); | |
59 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
60 EXPECT_EQ(elems[i], arr->GetIntegerAt(i)); | |
61 arr->InsertAt(3, new CPDF_Number(33)); | |
62 arr->InsertAt(6, new CPDF_Number(55)); | |
63 arr->InsertAt(12, new CPDF_Number(12)); | |
64 int expected[] = {1, 2, 3, 33, 4, 5, 55, 6, 7, 8, 9, 10, 12}; | |
65 EXPECT_EQ(FX_ArraySize(expected), arr->GetCount()); | |
66 for (size_t i = 0; i < FX_ArraySize(expected); ++i) | |
67 EXPECT_EQ(expected[i], arr->GetIntegerAt(i)); | |
68 } | |
69 { | |
70 // When the position to insert is beyond the upper bound, | |
71 // an element is inserted at that position while other unfilled | |
72 // positions have nullptr. | |
73 int elems[] = {1, 2}; | |
74 ScopedArray arr(new CPDF_Array); | |
75 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
76 arr->InsertAt(i, new CPDF_Number(elems[i])); | |
77 arr->InsertAt(10, new CPDF_Number(10)); | |
78 EXPECT_EQ(11, arr->GetCount()); | |
79 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
80 EXPECT_EQ(elems[i], arr->GetIntegerAt(i)); | |
81 for (size_t i = FX_ArraySize(elems); i < 10; ++i) | |
82 EXPECT_EQ(nullptr, arr->GetObjectAt(i)); | |
83 EXPECT_EQ(10, arr->GetIntegerAt(10)); | |
84 } | |
85 } | |
86 | |
87 TEST(cpdf_array, Clone) { | |
88 { | |
89 int elems[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; | |
90 ScopedArray arr(new CPDF_Array); | |
91 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
92 arr->InsertAt(i, new CPDF_Number(elems[i])); | |
93 ScopedArray arr2(arr->Clone()->AsArray()); | |
94 EXPECT_EQ(arr->GetCount(), arr2->GetCount()); | |
95 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
96 EXPECT_EQ(arr->GetIntegerAt(i), arr2->GetIntegerAt(i)); | |
Tom Sepez
2016/04/12 00:29:17
can we also EXPECT that no new objects got created
Wei Li
2016/04/12 02:56:20
Turns out it is a bit more complicated :)
| |
97 } | |
98 { | |
99 // Clone with deep copy option. | |
100 static const size_t kNumOfRows = 3; | |
101 static const size_t kNumOfRowElems = 5; | |
102 int elems[kNumOfRows][kNumOfRowElems] = { | |
103 {1, 2, 3, 4, 5}, {10, 9, 8, 7, 6}, {11, 12, 13, 14, 15}}; | |
104 ScopedArray arr(new CPDF_Array); | |
105 for (size_t i = 0; i < kNumOfRows; ++i) { | |
106 CPDF_Array* arr_elem = new CPDF_Array; | |
107 for (size_t j = 0; j < kNumOfRowElems; ++j) | |
108 arr_elem->InsertAt(j, new CPDF_Number(elems[i][j])); | |
109 arr->InsertAt(i, arr_elem); | |
110 } | |
111 ASSERT_EQ(kNumOfRows, arr->GetCount()); | |
112 ScopedArray arr2(arr->Clone(TRUE)->AsArray()); | |
113 EXPECT_EQ(arr->GetCount(), arr2->GetCount()); | |
114 // Verify the deep copy results. | |
115 for (size_t i = 0; i < kNumOfRows; ++i) { | |
116 CPDF_Array* arr_elem = arr->GetObjectAt(i)->AsArray(); | |
117 CPDF_Array* arr2_elem = arr2->GetObjectAt(i)->AsArray(); | |
118 EXPECT_NE(arr_elem, arr2_elem); | |
119 for (size_t j = 0; j < kNumOfRowElems; ++j) | |
120 EXPECT_EQ(arr_elem->GetIntegerAt(j), arr2_elem->GetIntegerAt(j)); | |
121 } | |
122 arr.reset(); | |
123 ASSERT_EQ(kNumOfRows, arr2->GetCount()); | |
124 for (size_t i = 0; i < kNumOfRows; ++i) { | |
125 for (size_t j = 0; j < kNumOfRowElems; ++j) { | |
126 EXPECT_EQ(elems[i][j], | |
127 arr2->GetObjectAt(i)->AsArray()->GetIntegerAt(j)); | |
128 } | |
129 } | |
130 } | |
131 } | |
132 | |
133 TEST(cpdf_array, Iterator) { | |
134 int elems[] = {-23, -11, 3, 455, 2345877, | |
135 0, 7895330, -12564334, 10000, -100000}; | |
136 ScopedArray arr(new CPDF_Array); | |
137 for (size_t i = 0; i < FX_ArraySize(elems); ++i) | |
138 arr->InsertAt(i, new CPDF_Number(elems[i])); | |
139 size_t index = 0; | |
140 for (const auto& it : *arr) | |
141 EXPECT_EQ(elems[index++], it->AsNumber()->GetInteger()); | |
142 } | |
OLD | NEW |