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 #include "core/fpdfapi/fpdf_parser/include/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(11, 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(nullptr)); |
| 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->InsertIndirectObject(obj_num, obj); |
| 120 arr_elem->InsertAt(j, new CPDF_Reference(obj_holder.get(), obj_num), |
| 121 obj_holder.get()); |
| 122 } |
| 123 arr->InsertAt(i, arr_elem); |
| 124 } |
| 125 ASSERT_EQ(kNumOfRows, arr->GetCount()); |
| 126 // Not dereferencing reference objects means just creating new references |
| 127 // instead of new copies of direct objects. |
| 128 ScopedArray arr1(arr->Clone(FALSE)->AsArray()); |
| 129 EXPECT_EQ(arr->GetCount(), arr1->GetCount()); |
| 130 // Dereferencing reference objects creates new copies of direct objects. |
| 131 ScopedArray arr2(arr->Clone(TRUE)->AsArray()); |
| 132 EXPECT_EQ(arr->GetCount(), arr2->GetCount()); |
| 133 for (size_t i = 0; i < kNumOfRows; ++i) { |
| 134 CPDF_Array* arr_elem = arr->GetObjectAt(i)->AsArray(); |
| 135 CPDF_Array* arr1_elem = arr1->GetObjectAt(i)->AsArray(); |
| 136 CPDF_Array* arr2_elem = arr2->GetObjectAt(i)->AsArray(); |
| 137 EXPECT_NE(arr_elem, arr1_elem); |
| 138 EXPECT_NE(arr_elem, arr2_elem); |
| 139 for (size_t j = 0; j < kNumOfRowElems; ++j) { |
| 140 auto elem_obj = arr_elem->GetObjectAt(j); |
| 141 auto elem_obj1 = arr1_elem->GetObjectAt(j); |
| 142 auto elem_obj2 = arr2_elem->GetObjectAt(j); |
| 143 // Results from not deferencing reference objects. |
| 144 EXPECT_NE(elem_obj, elem_obj1); |
| 145 EXPECT_TRUE(elem_obj1->IsReference()); |
| 146 EXPECT_EQ(elem_obj->GetDirect(), elem_obj1->GetDirect()); |
| 147 EXPECT_EQ(elem_obj->GetInteger(), elem_obj1->GetInteger()); |
| 148 // Results from deferencing reference objects. |
| 149 EXPECT_NE(elem_obj, elem_obj2); |
| 150 EXPECT_TRUE(elem_obj2->IsNumber()); |
| 151 EXPECT_NE(elem_obj->GetDirect(), elem_obj2); |
| 152 EXPECT_EQ(elem_obj->GetObjNum(), elem_obj2->GetObjNum()); |
| 153 EXPECT_EQ(elem_obj->GetInteger(), elem_obj2->GetInteger()); |
| 154 } |
| 155 } |
| 156 arr.reset(); |
| 157 ASSERT_EQ(kNumOfRows, arr1->GetCount()); |
| 158 for (size_t i = 0; i < kNumOfRows; ++i) { |
| 159 for (size_t j = 0; j < kNumOfRowElems; ++j) { |
| 160 // Results from not deferencing reference objects. |
| 161 auto elem_obj1 = arr1->GetObjectAt(i)->AsArray()->GetObjectAt(j); |
| 162 EXPECT_TRUE(elem_obj1->IsReference()); |
| 163 EXPECT_EQ(elems[i][j], elem_obj1->GetInteger()); |
| 164 // Results from deferencing reference objects. |
| 165 EXPECT_EQ(elems[i][j], |
| 166 arr2->GetObjectAt(i)->AsArray()->GetIntegerAt(j)); |
| 167 } |
| 168 } |
| 169 } |
| 170 } |
| 171 |
| 172 TEST(cpdf_array, Iterator) { |
| 173 int elems[] = {-23, -11, 3, 455, 2345877, |
| 174 0, 7895330, -12564334, 10000, -100000}; |
| 175 ScopedArray arr(new CPDF_Array); |
| 176 for (size_t i = 0; i < FX_ArraySize(elems); ++i) |
| 177 arr->InsertAt(i, new CPDF_Number(elems[i])); |
| 178 size_t index = 0; |
| 179 for (const auto& it : *arr) |
| 180 EXPECT_EQ(elems[index++], it->AsNumber()->GetInteger()); |
| 181 } |
OLD | NEW |