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