Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 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 | |
Dan Sinclair | bcd1e70 | 2017-08-31 13:19:18 -0400 | [diff] [blame] | 5 | #include <memory> |
| 6 | #include <string> |
| 7 | #include <utility> |
| 8 | #include <vector> |
| 9 | |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 10 | #include "constants/stream_dict_common.h" |
dsinclair | 488b7ad | 2016-10-04 11:55:50 -0700 | [diff] [blame] | 11 | #include "core/fpdfapi/parser/cpdf_array.h" |
| 12 | #include "core/fpdfapi/parser/cpdf_boolean.h" |
| 13 | #include "core/fpdfapi/parser/cpdf_dictionary.h" |
Dan Sinclair | bcd1e70 | 2017-08-31 13:19:18 -0400 | [diff] [blame] | 14 | #include "core/fpdfapi/parser/cpdf_indirect_object_holder.h" |
dsinclair | 488b7ad | 2016-10-04 11:55:50 -0700 | [diff] [blame] | 15 | #include "core/fpdfapi/parser/cpdf_name.h" |
| 16 | #include "core/fpdfapi/parser/cpdf_null.h" |
| 17 | #include "core/fpdfapi/parser/cpdf_number.h" |
| 18 | #include "core/fpdfapi/parser/cpdf_reference.h" |
| 19 | #include "core/fpdfapi/parser/cpdf_stream.h" |
| 20 | #include "core/fpdfapi/parser/cpdf_string.h" |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 21 | #include "testing/gtest/include/gtest/gtest.h" |
| 22 | |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 23 | namespace { |
| 24 | |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 25 | void TestArrayAccessors(const CPDF_Array* arr, |
| 26 | size_t index, |
| 27 | const char* str_val, |
| 28 | const char* const_str_val, |
| 29 | int int_val, |
| 30 | float float_val, |
| 31 | CPDF_Array* arr_val, |
| 32 | CPDF_Dictionary* dict_val, |
| 33 | CPDF_Stream* stream_val) { |
| 34 | EXPECT_STREQ(str_val, arr->GetStringAt(index).c_str()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 35 | EXPECT_EQ(int_val, arr->GetIntegerAt(index)); |
| 36 | EXPECT_EQ(float_val, arr->GetNumberAt(index)); |
| 37 | EXPECT_EQ(float_val, arr->GetFloatAt(index)); |
| 38 | EXPECT_EQ(arr_val, arr->GetArrayAt(index)); |
| 39 | EXPECT_EQ(dict_val, arr->GetDictAt(index)); |
| 40 | EXPECT_EQ(stream_val, arr->GetStreamAt(index)); |
| 41 | } |
| 42 | |
| 43 | } // namespace |
| 44 | |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 45 | class PDFObjectsTest : public testing::Test { |
| 46 | public: |
| 47 | void SetUp() override { |
| 48 | // Initialize different kinds of objects. |
| 49 | // Boolean objects. |
| 50 | CPDF_Boolean* boolean_false_obj = new CPDF_Boolean(false); |
| 51 | CPDF_Boolean* boolean_true_obj = new CPDF_Boolean(true); |
| 52 | // Number objects. |
| 53 | CPDF_Number* number_int_obj = new CPDF_Number(1245); |
| 54 | CPDF_Number* number_float_obj = new CPDF_Number(9.00345f); |
| 55 | // String objects. |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 56 | CPDF_String* str_reg_obj = new CPDF_String(nullptr, L"A simple test"); |
| 57 | CPDF_String* str_spec_obj = new CPDF_String(nullptr, L"\t\n"); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 58 | // Name object. |
tsepez | 5913a6c | 2016-11-16 17:31:18 -0800 | [diff] [blame] | 59 | CPDF_Name* name_obj = new CPDF_Name(nullptr, "space"); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 60 | // Array object. |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 61 | m_ArrayObj = new CPDF_Array; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 62 | m_ArrayObj->InsertNewAt<CPDF_Number>(0, 8902); |
| 63 | m_ArrayObj->InsertNewAt<CPDF_Name>(1, "address"); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 64 | // Dictionary object. |
tsepez | cd5bca4 | 2016-09-30 10:45:06 -0700 | [diff] [blame] | 65 | m_DictObj = new CPDF_Dictionary(); |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 66 | m_DictObj->SetNewFor<CPDF_Boolean>("bool", false); |
| 67 | m_DictObj->SetNewFor<CPDF_Number>("num", 0.23f); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 68 | // Stream object. |
| 69 | const char content[] = "abcdefghijklmnopqrstuvwxyz"; |
| 70 | size_t buf_len = FX_ArraySize(content); |
tsepez | 47fb8c0 | 2016-12-15 13:51:34 -0800 | [diff] [blame] | 71 | std::unique_ptr<uint8_t, FxFreeDeleter> buf(FX_Alloc(uint8_t, buf_len)); |
| 72 | memcpy(buf.get(), content, buf_len); |
tsepez | 9e05ee1 | 2016-11-21 13:19:10 -0800 | [diff] [blame] | 73 | auto pNewDict = pdfium::MakeUnique<CPDF_Dictionary>(); |
| 74 | m_StreamDictObj = pNewDict.get(); |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 75 | m_StreamDictObj->SetNewFor<CPDF_String>("key1", L" test dict"); |
| 76 | m_StreamDictObj->SetNewFor<CPDF_Number>("key2", -1); |
tsepez | 9e05ee1 | 2016-11-21 13:19:10 -0800 | [diff] [blame] | 77 | CPDF_Stream* stream_obj = |
tsepez | 47fb8c0 | 2016-12-15 13:51:34 -0800 | [diff] [blame] | 78 | new CPDF_Stream(std::move(buf), buf_len, std::move(pNewDict)); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 79 | // Null Object. |
| 80 | CPDF_Null* null_obj = new CPDF_Null; |
| 81 | // All direct objects. |
| 82 | CPDF_Object* objs[] = {boolean_false_obj, boolean_true_obj, number_int_obj, |
| 83 | number_float_obj, str_reg_obj, str_spec_obj, |
Tom Sepez | d0409af | 2017-05-25 15:53:57 -0700 | [diff] [blame] | 84 | name_obj, m_ArrayObj.Get(), m_DictObj.Get(), |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 85 | stream_obj, null_obj}; |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 86 | m_DirectObjTypes = { |
| 87 | CPDF_Object::BOOLEAN, CPDF_Object::BOOLEAN, CPDF_Object::NUMBER, |
| 88 | CPDF_Object::NUMBER, CPDF_Object::STRING, CPDF_Object::STRING, |
| 89 | CPDF_Object::NAME, CPDF_Object::ARRAY, CPDF_Object::DICTIONARY, |
| 90 | CPDF_Object::STREAM, CPDF_Object::NULLOBJ}; |
| 91 | for (size_t i = 0; i < FX_ArraySize(objs); ++i) |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 92 | m_DirectObjs.emplace_back(objs[i]); |
| 93 | |
| 94 | // Indirect references to indirect objects. |
tsepez | 70c4afd | 2016-11-15 11:33:44 -0800 | [diff] [blame] | 95 | m_ObjHolder = pdfium::MakeUnique<CPDF_IndirectObjectHolder>(); |
| 96 | m_IndirectObjs = {m_ObjHolder->AddIndirectObject(boolean_true_obj->Clone()), |
| 97 | m_ObjHolder->AddIndirectObject(number_int_obj->Clone()), |
| 98 | m_ObjHolder->AddIndirectObject(str_spec_obj->Clone()), |
| 99 | m_ObjHolder->AddIndirectObject(name_obj->Clone()), |
| 100 | m_ObjHolder->AddIndirectObject(m_ArrayObj->Clone()), |
| 101 | m_ObjHolder->AddIndirectObject(m_DictObj->Clone()), |
| 102 | m_ObjHolder->AddIndirectObject(stream_obj->Clone())}; |
| 103 | for (CPDF_Object* pObj : m_IndirectObjs) { |
| 104 | m_RefObjs.emplace_back( |
| 105 | new CPDF_Reference(m_ObjHolder.get(), pObj->GetObjNum())); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 106 | } |
| 107 | } |
| 108 | |
tsepez | 836f7d5 | 2016-10-10 14:31:05 -0700 | [diff] [blame] | 109 | bool Equal(const CPDF_Object* obj1, const CPDF_Object* obj2) { |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 110 | if (obj1 == obj2) |
| 111 | return true; |
| 112 | if (!obj1 || !obj2 || obj1->GetType() != obj2->GetType()) |
| 113 | return false; |
| 114 | switch (obj1->GetType()) { |
| 115 | case CPDF_Object::BOOLEAN: |
| 116 | return obj1->GetInteger() == obj2->GetInteger(); |
| 117 | case CPDF_Object::NUMBER: |
| 118 | return obj1->AsNumber()->IsInteger() == obj2->AsNumber()->IsInteger() && |
| 119 | obj1->GetInteger() == obj2->GetInteger(); |
| 120 | case CPDF_Object::STRING: |
| 121 | case CPDF_Object::NAME: |
| 122 | return obj1->GetString() == obj2->GetString(); |
| 123 | case CPDF_Object::ARRAY: { |
| 124 | const CPDF_Array* array1 = obj1->AsArray(); |
| 125 | const CPDF_Array* array2 = obj2->AsArray(); |
| 126 | if (array1->GetCount() != array2->GetCount()) |
| 127 | return false; |
| 128 | for (size_t i = 0; i < array1->GetCount(); ++i) { |
tsepez | bd56755 | 2016-03-29 14:51:50 -0700 | [diff] [blame] | 129 | if (!Equal(array1->GetObjectAt(i), array2->GetObjectAt(i))) |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 130 | return false; |
| 131 | } |
| 132 | return true; |
| 133 | } |
| 134 | case CPDF_Object::DICTIONARY: { |
| 135 | const CPDF_Dictionary* dict1 = obj1->AsDictionary(); |
| 136 | const CPDF_Dictionary* dict2 = obj2->AsDictionary(); |
| 137 | if (dict1->GetCount() != dict2->GetCount()) |
| 138 | return false; |
| 139 | for (CPDF_Dictionary::const_iterator it = dict1->begin(); |
| 140 | it != dict1->end(); ++it) { |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 141 | if (!Equal(it->second.get(), dict2->GetObjectFor(it->first))) |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 142 | return false; |
| 143 | } |
| 144 | return true; |
| 145 | } |
| 146 | case CPDF_Object::NULLOBJ: |
| 147 | return true; |
| 148 | case CPDF_Object::STREAM: { |
| 149 | const CPDF_Stream* stream1 = obj1->AsStream(); |
| 150 | const CPDF_Stream* stream2 = obj2->AsStream(); |
| 151 | if (!stream1->GetDict() && !stream2->GetDict()) |
| 152 | return true; |
| 153 | // Compare dictionaries. |
| 154 | if (!Equal(stream1->GetDict(), stream2->GetDict())) |
| 155 | return false; |
| 156 | // Compare sizes. |
| 157 | if (stream1->GetRawSize() != stream2->GetRawSize()) |
| 158 | return false; |
| 159 | // Compare contents. |
| 160 | // Since this function is used for testing Clone(), only memory based |
| 161 | // streams need to be handled. |
| 162 | if (!stream1->IsMemoryBased() || !stream2->IsMemoryBased()) |
| 163 | return false; |
Dan Sinclair | 1c5d0b4 | 2017-04-03 15:05:11 -0400 | [diff] [blame] | 164 | return memcmp(stream1->GetRawData(), stream2->GetRawData(), |
| 165 | stream1->GetRawSize()) == 0; |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 166 | } |
| 167 | case CPDF_Object::REFERENCE: |
| 168 | return obj1->AsReference()->GetRefObjNum() == |
| 169 | obj2->AsReference()->GetRefObjNum(); |
| 170 | } |
| 171 | return false; |
| 172 | } |
| 173 | |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 174 | protected: |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 175 | // m_ObjHolder needs to be declared first and destructed last since it also |
| 176 | // refers to some objects in m_DirectObjs. |
| 177 | std::unique_ptr<CPDF_IndirectObjectHolder> m_ObjHolder; |
tsepez | 33fdebc | 2016-11-04 11:38:40 -0700 | [diff] [blame] | 178 | std::vector<std::unique_ptr<CPDF_Object>> m_DirectObjs; |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 179 | std::vector<int> m_DirectObjTypes; |
tsepez | 33fdebc | 2016-11-04 11:38:40 -0700 | [diff] [blame] | 180 | std::vector<std::unique_ptr<CPDF_Object>> m_RefObjs; |
Dan Sinclair | aee0db0 | 2017-09-21 16:53:58 -0400 | [diff] [blame] | 181 | UnownedPtr<CPDF_Dictionary> m_DictObj; |
| 182 | UnownedPtr<CPDF_Dictionary> m_StreamDictObj; |
| 183 | UnownedPtr<CPDF_Array> m_ArrayObj; |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 184 | std::vector<CPDF_Object*> m_IndirectObjs; |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 185 | }; |
| 186 | |
| 187 | TEST_F(PDFObjectsTest, GetString) { |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 188 | const char* const direct_obj_results[] = { |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 189 | "false", "true", "1245", "9.00345", "A simple test", "\t\n", "space", |
| 190 | "", "", "", ""}; |
| 191 | // Check for direct objects. |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 192 | for (size_t i = 0; i < m_DirectObjs.size(); ++i) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 193 | EXPECT_STREQ(direct_obj_results[i], m_DirectObjs[i]->GetString().c_str()); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 194 | |
| 195 | // Check indirect references. |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 196 | const char* const indirect_obj_results[] = {"true", "1245", "\t\n", "space", |
| 197 | "", "", ""}; |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 198 | for (size_t i = 0; i < m_RefObjs.size(); ++i) { |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 199 | EXPECT_STREQ(indirect_obj_results[i], m_RefObjs[i]->GetString().c_str()); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 200 | } |
| 201 | } |
| 202 | |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 203 | TEST_F(PDFObjectsTest, GetUnicodeText) { |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 204 | const wchar_t* const direct_obj_results[] = { |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 205 | L"", L"", L"", L"", L"A simple test", |
| 206 | L"\t\n", L"space", L"", L"", L"abcdefghijklmnopqrstuvwxyz", |
| 207 | L""}; |
| 208 | // Check for direct objects. |
dsinclair | 685bb88 | 2016-04-20 07:32:39 -0700 | [diff] [blame] | 209 | for (size_t i = 0; i < m_DirectObjs.size(); ++i) { |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 210 | EXPECT_STREQ(direct_obj_results[i], |
| 211 | m_DirectObjs[i]->GetUnicodeText().c_str()); |
dsinclair | 685bb88 | 2016-04-20 07:32:39 -0700 | [diff] [blame] | 212 | } |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 213 | |
| 214 | // Check indirect references. |
| 215 | for (const auto& it : m_RefObjs) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 216 | EXPECT_STREQ(L"", it->GetUnicodeText().c_str()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 217 | } |
| 218 | |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 219 | TEST_F(PDFObjectsTest, GetNumber) { |
Dan Sinclair | 05df075 | 2017-03-14 14:43:42 -0400 | [diff] [blame] | 220 | const float direct_obj_results[] = {0, 0, 1245, 9.00345f, 0, 0, |
| 221 | 0, 0, 0, 0, 0}; |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 222 | // Check for direct objects. |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 223 | for (size_t i = 0; i < m_DirectObjs.size(); ++i) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 224 | EXPECT_EQ(direct_obj_results[i], m_DirectObjs[i]->GetNumber()); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 225 | |
| 226 | // Check indirect references. |
Dan Sinclair | 05df075 | 2017-03-14 14:43:42 -0400 | [diff] [blame] | 227 | const float indirect_obj_results[] = {0, 1245, 0, 0, 0, 0, 0}; |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 228 | for (size_t i = 0; i < m_RefObjs.size(); ++i) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 229 | EXPECT_EQ(indirect_obj_results[i], m_RefObjs[i]->GetNumber()); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 230 | } |
| 231 | |
| 232 | TEST_F(PDFObjectsTest, GetInteger) { |
| 233 | const int direct_obj_results[] = {0, 1, 1245, 9, 0, 0, 0, 0, 0, 0, 0}; |
| 234 | // Check for direct objects. |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 235 | for (size_t i = 0; i < m_DirectObjs.size(); ++i) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 236 | EXPECT_EQ(direct_obj_results[i], m_DirectObjs[i]->GetInteger()); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 237 | |
| 238 | // Check indirect references. |
| 239 | const int indirect_obj_results[] = {1, 1245, 0, 0, 0, 0, 0}; |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 240 | for (size_t i = 0; i < m_RefObjs.size(); ++i) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 241 | EXPECT_EQ(indirect_obj_results[i], m_RefObjs[i]->GetInteger()); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | TEST_F(PDFObjectsTest, GetDict) { |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 245 | const CPDF_Dictionary* const direct_obj_results[] = { |
Tom Sepez | d0409af | 2017-05-25 15:53:57 -0700 | [diff] [blame] | 246 | nullptr, nullptr, nullptr, nullptr, nullptr, |
| 247 | nullptr, nullptr, nullptr, m_DictObj.Get(), m_StreamDictObj.Get(), |
| 248 | nullptr}; |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 249 | // Check for direct objects. |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 250 | for (size_t i = 0; i < m_DirectObjs.size(); ++i) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 251 | EXPECT_EQ(direct_obj_results[i], m_DirectObjs[i]->GetDict()); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 252 | |
| 253 | // Check indirect references. |
Tom Sepez | d0409af | 2017-05-25 15:53:57 -0700 | [diff] [blame] | 254 | const CPDF_Dictionary* const indirect_obj_results[] = {nullptr, |
| 255 | nullptr, |
| 256 | nullptr, |
| 257 | nullptr, |
| 258 | nullptr, |
| 259 | m_DictObj.Get(), |
| 260 | m_StreamDictObj.Get()}; |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 261 | for (size_t i = 0; i < m_RefObjs.size(); ++i) |
tsepez | 836f7d5 | 2016-10-10 14:31:05 -0700 | [diff] [blame] | 262 | EXPECT_TRUE(Equal(indirect_obj_results[i], m_RefObjs[i]->GetDict())); |
Lei Zhang | 9429368 | 2016-01-27 18:27:56 -0800 | [diff] [blame] | 263 | } |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 264 | |
| 265 | TEST_F(PDFObjectsTest, GetArray) { |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 266 | const CPDF_Array* const direct_obj_results[] = { |
Tom Sepez | d0409af | 2017-05-25 15:53:57 -0700 | [diff] [blame] | 267 | nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, |
| 268 | nullptr, m_ArrayObj.Get(), nullptr, nullptr, nullptr}; |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 269 | // Check for direct objects. |
| 270 | for (size_t i = 0; i < m_DirectObjs.size(); ++i) |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 271 | EXPECT_EQ(direct_obj_results[i], m_DirectObjs[i]->AsArray()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 272 | |
| 273 | // Check indirect references. |
| 274 | for (const auto& it : m_RefObjs) |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 275 | EXPECT_EQ(nullptr, it->AsArray()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 276 | } |
| 277 | |
| 278 | TEST_F(PDFObjectsTest, Clone) { |
| 279 | // Check for direct objects. |
| 280 | for (size_t i = 0; i < m_DirectObjs.size(); ++i) { |
tsepez | 335cf09 | 2016-11-09 13:28:26 -0800 | [diff] [blame] | 281 | std::unique_ptr<CPDF_Object> obj = m_DirectObjs[i]->Clone(); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 282 | EXPECT_TRUE(Equal(m_DirectObjs[i].get(), obj.get())); |
| 283 | } |
| 284 | |
| 285 | // Check indirect references. |
| 286 | for (const auto& it : m_RefObjs) { |
tsepez | 335cf09 | 2016-11-09 13:28:26 -0800 | [diff] [blame] | 287 | std::unique_ptr<CPDF_Object> obj = it->Clone(); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 288 | EXPECT_TRUE(Equal(it.get(), obj.get())); |
| 289 | } |
| 290 | } |
| 291 | |
| 292 | TEST_F(PDFObjectsTest, GetType) { |
| 293 | // Check for direct objects. |
| 294 | for (size_t i = 0; i < m_DirectObjs.size(); ++i) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 295 | EXPECT_EQ(m_DirectObjTypes[i], m_DirectObjs[i]->GetType()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 296 | |
| 297 | // Check indirect references. |
| 298 | for (const auto& it : m_RefObjs) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 299 | EXPECT_EQ(CPDF_Object::REFERENCE, it->GetType()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 300 | } |
| 301 | |
| 302 | TEST_F(PDFObjectsTest, GetDirect) { |
| 303 | // Check for direct objects. |
| 304 | for (size_t i = 0; i < m_DirectObjs.size(); ++i) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 305 | EXPECT_EQ(m_DirectObjs[i].get(), m_DirectObjs[i]->GetDirect()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 306 | |
| 307 | // Check indirect references. |
| 308 | for (size_t i = 0; i < m_RefObjs.size(); ++i) |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 309 | EXPECT_EQ(m_IndirectObjs[i], m_RefObjs[i]->GetDirect()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 310 | } |
| 311 | |
| 312 | TEST_F(PDFObjectsTest, SetString) { |
| 313 | // Check for direct objects. |
| 314 | const char* const set_values[] = {"true", "fake", "3.125f", "097", |
| 315 | "changed", "", "NewName"}; |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 316 | const char* const expected[] = {"true", "false", "3.125", "97", |
| 317 | "changed", "", "NewName"}; |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 318 | for (size_t i = 0; i < FX_ArraySize(set_values); ++i) { |
| 319 | m_DirectObjs[i]->SetString(set_values[i]); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 320 | EXPECT_STREQ(expected[i], m_DirectObjs[i]->GetString().c_str()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 321 | } |
| 322 | } |
| 323 | |
| 324 | TEST_F(PDFObjectsTest, IsTypeAndAsType) { |
| 325 | // Check for direct objects. |
| 326 | for (size_t i = 0; i < m_DirectObjs.size(); ++i) { |
| 327 | if (m_DirectObjTypes[i] == CPDF_Object::ARRAY) { |
| 328 | EXPECT_TRUE(m_DirectObjs[i]->IsArray()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 329 | EXPECT_EQ(m_DirectObjs[i].get(), m_DirectObjs[i]->AsArray()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 330 | } else { |
| 331 | EXPECT_FALSE(m_DirectObjs[i]->IsArray()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 332 | EXPECT_EQ(nullptr, m_DirectObjs[i]->AsArray()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 333 | } |
| 334 | |
| 335 | if (m_DirectObjTypes[i] == CPDF_Object::BOOLEAN) { |
| 336 | EXPECT_TRUE(m_DirectObjs[i]->IsBoolean()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 337 | EXPECT_EQ(m_DirectObjs[i].get(), m_DirectObjs[i]->AsBoolean()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 338 | } else { |
| 339 | EXPECT_FALSE(m_DirectObjs[i]->IsBoolean()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 340 | EXPECT_EQ(nullptr, m_DirectObjs[i]->AsBoolean()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 341 | } |
| 342 | |
| 343 | if (m_DirectObjTypes[i] == CPDF_Object::NAME) { |
| 344 | EXPECT_TRUE(m_DirectObjs[i]->IsName()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 345 | EXPECT_EQ(m_DirectObjs[i].get(), m_DirectObjs[i]->AsName()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 346 | } else { |
| 347 | EXPECT_FALSE(m_DirectObjs[i]->IsName()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 348 | EXPECT_EQ(nullptr, m_DirectObjs[i]->AsName()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 349 | } |
| 350 | |
| 351 | if (m_DirectObjTypes[i] == CPDF_Object::NUMBER) { |
| 352 | EXPECT_TRUE(m_DirectObjs[i]->IsNumber()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 353 | EXPECT_EQ(m_DirectObjs[i].get(), m_DirectObjs[i]->AsNumber()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 354 | } else { |
| 355 | EXPECT_FALSE(m_DirectObjs[i]->IsNumber()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 356 | EXPECT_EQ(nullptr, m_DirectObjs[i]->AsNumber()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 357 | } |
| 358 | |
| 359 | if (m_DirectObjTypes[i] == CPDF_Object::STRING) { |
| 360 | EXPECT_TRUE(m_DirectObjs[i]->IsString()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 361 | EXPECT_EQ(m_DirectObjs[i].get(), m_DirectObjs[i]->AsString()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 362 | } else { |
| 363 | EXPECT_FALSE(m_DirectObjs[i]->IsString()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 364 | EXPECT_EQ(nullptr, m_DirectObjs[i]->AsString()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 365 | } |
| 366 | |
| 367 | if (m_DirectObjTypes[i] == CPDF_Object::DICTIONARY) { |
| 368 | EXPECT_TRUE(m_DirectObjs[i]->IsDictionary()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 369 | EXPECT_EQ(m_DirectObjs[i].get(), m_DirectObjs[i]->AsDictionary()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 370 | } else { |
| 371 | EXPECT_FALSE(m_DirectObjs[i]->IsDictionary()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 372 | EXPECT_EQ(nullptr, m_DirectObjs[i]->AsDictionary()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 373 | } |
| 374 | |
| 375 | if (m_DirectObjTypes[i] == CPDF_Object::STREAM) { |
| 376 | EXPECT_TRUE(m_DirectObjs[i]->IsStream()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 377 | EXPECT_EQ(m_DirectObjs[i].get(), m_DirectObjs[i]->AsStream()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 378 | } else { |
| 379 | EXPECT_FALSE(m_DirectObjs[i]->IsStream()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 380 | EXPECT_EQ(nullptr, m_DirectObjs[i]->AsStream()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 381 | } |
| 382 | |
| 383 | EXPECT_FALSE(m_DirectObjs[i]->IsReference()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 384 | EXPECT_EQ(nullptr, m_DirectObjs[i]->AsReference()); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 385 | } |
| 386 | // Check indirect references. |
| 387 | for (size_t i = 0; i < m_RefObjs.size(); ++i) { |
| 388 | EXPECT_TRUE(m_RefObjs[i]->IsReference()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 389 | EXPECT_EQ(m_RefObjs[i].get(), m_RefObjs[i]->AsReference()); |
| 390 | } |
| 391 | } |
| 392 | |
| 393 | TEST(PDFArrayTest, GetMatrix) { |
| 394 | float elems[][6] = {{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}, |
| 395 | {1, 2, 3, 4, 5, 6}, |
| 396 | {2.3f, 4.05f, 3, -2, -3, 0.0f}, |
| 397 | {0.05f, 0.1f, 0.56f, 0.67f, 1.34f, 99.9f}}; |
| 398 | for (size_t i = 0; i < FX_ArraySize(elems); ++i) { |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 399 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 400 | CFX_Matrix matrix(elems[i][0], elems[i][1], elems[i][2], elems[i][3], |
| 401 | elems[i][4], elems[i][5]); |
| 402 | for (size_t j = 0; j < 6; ++j) |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 403 | arr->AddNew<CPDF_Number>(elems[i][j]); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 404 | CFX_Matrix arr_matrix = arr->GetMatrix(); |
Dan Sinclair | 687a79c | 2017-02-09 14:08:53 -0500 | [diff] [blame] | 405 | EXPECT_EQ(matrix.a, arr_matrix.a); |
| 406 | EXPECT_EQ(matrix.b, arr_matrix.b); |
| 407 | EXPECT_EQ(matrix.c, arr_matrix.c); |
| 408 | EXPECT_EQ(matrix.d, arr_matrix.d); |
| 409 | EXPECT_EQ(matrix.e, arr_matrix.e); |
| 410 | EXPECT_EQ(matrix.f, arr_matrix.f); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 411 | } |
| 412 | } |
| 413 | |
| 414 | TEST(PDFArrayTest, GetRect) { |
| 415 | float elems[][4] = {{0.0f, 0.0f, 0.0f, 0.0f}, |
| 416 | {1, 2, 5, 6}, |
| 417 | {2.3f, 4.05f, -3, 0.0f}, |
| 418 | {0.05f, 0.1f, 1.34f, 99.9f}}; |
| 419 | for (size_t i = 0; i < FX_ArraySize(elems); ++i) { |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 420 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 421 | CFX_FloatRect rect(elems[i]); |
| 422 | for (size_t j = 0; j < 4; ++j) |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 423 | arr->AddNew<CPDF_Number>(elems[i][j]); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 424 | CFX_FloatRect arr_rect = arr->GetRect(); |
| 425 | EXPECT_EQ(rect.left, arr_rect.left); |
| 426 | EXPECT_EQ(rect.right, arr_rect.right); |
| 427 | EXPECT_EQ(rect.bottom, arr_rect.bottom); |
| 428 | EXPECT_EQ(rect.top, arr_rect.top); |
| 429 | } |
| 430 | } |
| 431 | |
| 432 | TEST(PDFArrayTest, GetTypeAt) { |
| 433 | { |
| 434 | // Boolean array. |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 435 | const bool vals[] = {true, false, false, true, true}; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 436 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 437 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 438 | arr->InsertNewAt<CPDF_Boolean>(i, vals[i]); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 439 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) { |
| 440 | TestArrayAccessors(arr.get(), i, // Array and index. |
| 441 | vals[i] ? "true" : "false", // String value. |
| 442 | nullptr, // Const string value. |
| 443 | vals[i] ? 1 : 0, // Integer value. |
| 444 | 0, // Float value. |
| 445 | nullptr, // Array value. |
| 446 | nullptr, // Dictionary value. |
| 447 | nullptr); // Stream value. |
| 448 | } |
| 449 | } |
| 450 | { |
| 451 | // Integer array. |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 452 | const int vals[] = {10, 0, -345, 2089345456, -1000000000, 567, 93658767}; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 453 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 454 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 455 | arr->InsertNewAt<CPDF_Number>(i, vals[i]); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 456 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) { |
| 457 | char buf[33]; |
| 458 | TestArrayAccessors(arr.get(), i, // Array and index. |
| 459 | FXSYS_itoa(vals[i], buf, 10), // String value. |
| 460 | nullptr, // Const string value. |
| 461 | vals[i], // Integer value. |
| 462 | vals[i], // Float value. |
| 463 | nullptr, // Array value. |
| 464 | nullptr, // Dictionary value. |
| 465 | nullptr); // Stream value. |
| 466 | } |
| 467 | } |
| 468 | { |
| 469 | // Float array. |
thestig | b8bf55f | 2016-05-21 21:08:05 -0700 | [diff] [blame] | 470 | const float vals[] = {0.0f, 0, 10, 10.0f, 0.0345f, |
| 471 | 897.34f, -2.5f, -1.0f, -345.0f, -0.0f}; |
| 472 | const char* const expected_str[] = { |
| 473 | "0", "0", "10", "10", "0.0345", "897.34", "-2.5", "-1", "-345", "0"}; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 474 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
| 475 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) |
| 476 | arr->InsertNewAt<CPDF_Number>(i, vals[i]); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 477 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) { |
| 478 | TestArrayAccessors(arr.get(), i, // Array and index. |
| 479 | expected_str[i], // String value. |
| 480 | nullptr, // Const string value. |
| 481 | vals[i], // Integer value. |
| 482 | vals[i], // Float value. |
| 483 | nullptr, // Array value. |
| 484 | nullptr, // Dictionary value. |
| 485 | nullptr); // Stream value. |
| 486 | } |
| 487 | } |
| 488 | { |
| 489 | // String and name array |
| 490 | const char* const vals[] = {"this", "adsde$%^", "\r\t", "\"012", |
| 491 | ".", "EYREW", "It is a joke :)"}; |
Dan Sinclair | 0bb1333 | 2017-03-30 16:12:02 -0400 | [diff] [blame] | 492 | auto string_array = pdfium::MakeUnique<CPDF_Array>(); |
| 493 | auto name_array = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 494 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) { |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 495 | string_array->InsertNewAt<CPDF_String>(i, vals[i], false); |
| 496 | name_array->InsertNewAt<CPDF_Name>(i, vals[i]); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 497 | } |
| 498 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) { |
| 499 | TestArrayAccessors(string_array.get(), i, // Array and index. |
| 500 | vals[i], // String value. |
| 501 | vals[i], // Const string value. |
| 502 | 0, // Integer value. |
| 503 | 0, // Float value. |
| 504 | nullptr, // Array value. |
| 505 | nullptr, // Dictionary value. |
| 506 | nullptr); // Stream value. |
| 507 | TestArrayAccessors(name_array.get(), i, // Array and index. |
| 508 | vals[i], // String value. |
| 509 | vals[i], // Const string value. |
| 510 | 0, // Integer value. |
| 511 | 0, // Float value. |
| 512 | nullptr, // Array value. |
| 513 | nullptr, // Dictionary value. |
| 514 | nullptr); // Stream value. |
| 515 | } |
| 516 | } |
| 517 | { |
| 518 | // Null element array. |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 519 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 520 | for (size_t i = 0; i < 3; ++i) |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 521 | arr->InsertNewAt<CPDF_Null>(i); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 522 | for (size_t i = 0; i < 3; ++i) { |
| 523 | TestArrayAccessors(arr.get(), i, // Array and index. |
| 524 | "", // String value. |
| 525 | nullptr, // Const string value. |
| 526 | 0, // Integer value. |
| 527 | 0, // Float value. |
| 528 | nullptr, // Array value. |
| 529 | nullptr, // Dictionary value. |
| 530 | nullptr); // Stream value. |
| 531 | } |
| 532 | } |
| 533 | { |
| 534 | // Array of array. |
| 535 | CPDF_Array* vals[3]; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 536 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 537 | for (size_t i = 0; i < 3; ++i) { |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 538 | vals[i] = arr->AddNew<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 539 | for (size_t j = 0; j < 3; ++j) { |
| 540 | int value = j + 100; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 541 | vals[i]->InsertNewAt<CPDF_Number>(i, value); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 542 | } |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 543 | } |
| 544 | for (size_t i = 0; i < 3; ++i) { |
| 545 | TestArrayAccessors(arr.get(), i, // Array and index. |
| 546 | "", // String value. |
| 547 | nullptr, // Const string value. |
| 548 | 0, // Integer value. |
| 549 | 0, // Float value. |
| 550 | vals[i], // Array value. |
| 551 | nullptr, // Dictionary value. |
| 552 | nullptr); // Stream value. |
| 553 | } |
| 554 | } |
| 555 | { |
| 556 | // Dictionary array. |
| 557 | CPDF_Dictionary* vals[3]; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 558 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 559 | for (size_t i = 0; i < 3; ++i) { |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 560 | vals[i] = arr->AddNew<CPDF_Dictionary>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 561 | for (size_t j = 0; j < 3; ++j) { |
| 562 | std::string key("key"); |
| 563 | char buf[33]; |
| 564 | key.append(FXSYS_itoa(j, buf, 10)); |
| 565 | int value = j + 200; |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 566 | vals[i]->SetNewFor<CPDF_Number>(key.c_str(), value); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 567 | } |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 568 | } |
| 569 | for (size_t i = 0; i < 3; ++i) { |
| 570 | TestArrayAccessors(arr.get(), i, // Array and index. |
| 571 | "", // String value. |
| 572 | nullptr, // Const string value. |
| 573 | 0, // Integer value. |
| 574 | 0, // Float value. |
| 575 | nullptr, // Array value. |
| 576 | vals[i], // Dictionary value. |
| 577 | nullptr); // Stream value. |
| 578 | } |
| 579 | } |
| 580 | { |
| 581 | // Stream array. |
| 582 | CPDF_Dictionary* vals[3]; |
| 583 | CPDF_Stream* stream_vals[3]; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 584 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 585 | for (size_t i = 0; i < 3; ++i) { |
tsepez | cd5bca4 | 2016-09-30 10:45:06 -0700 | [diff] [blame] | 586 | vals[i] = new CPDF_Dictionary(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 587 | for (size_t j = 0; j < 3; ++j) { |
| 588 | std::string key("key"); |
| 589 | char buf[33]; |
| 590 | key.append(FXSYS_itoa(j, buf, 10)); |
| 591 | int value = j + 200; |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 592 | vals[i]->SetNewFor<CPDF_Number>(key.c_str(), value); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 593 | } |
| 594 | uint8_t content[] = "content: this is a stream"; |
| 595 | size_t data_size = FX_ArraySize(content); |
tsepez | 47fb8c0 | 2016-12-15 13:51:34 -0800 | [diff] [blame] | 596 | std::unique_ptr<uint8_t, FxFreeDeleter> data( |
| 597 | FX_Alloc(uint8_t, data_size)); |
| 598 | memcpy(data.get(), content, data_size); |
| 599 | stream_vals[i] = arr->AddNew<CPDF_Stream>(std::move(data), data_size, |
tsepez | 9e05ee1 | 2016-11-21 13:19:10 -0800 | [diff] [blame] | 600 | pdfium::WrapUnique(vals[i])); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 601 | } |
| 602 | for (size_t i = 0; i < 3; ++i) { |
| 603 | TestArrayAccessors(arr.get(), i, // Array and index. |
| 604 | "", // String value. |
| 605 | nullptr, // Const string value. |
| 606 | 0, // Integer value. |
| 607 | 0, // Float value. |
| 608 | nullptr, // Array value. |
| 609 | vals[i], // Dictionary value. |
| 610 | stream_vals[i]); // Stream value. |
| 611 | } |
| 612 | } |
| 613 | { |
| 614 | // Mixed array. |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 615 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
| 616 | arr->InsertNewAt<CPDF_Boolean>(0, true); |
| 617 | arr->InsertNewAt<CPDF_Boolean>(1, false); |
| 618 | arr->InsertNewAt<CPDF_Number>(2, 0); |
| 619 | arr->InsertNewAt<CPDF_Number>(3, -1234); |
| 620 | arr->InsertNewAt<CPDF_Number>(4, 2345.0f); |
| 621 | arr->InsertNewAt<CPDF_Number>(5, 0.05f); |
| 622 | arr->InsertNewAt<CPDF_String>(6, "", false); |
| 623 | arr->InsertNewAt<CPDF_String>(7, "It is a test!", false); |
| 624 | arr->InsertNewAt<CPDF_Name>(8, "NAME"); |
| 625 | arr->InsertNewAt<CPDF_Name>(9, "test"); |
| 626 | arr->InsertNewAt<CPDF_Null>(10); |
| 627 | |
| 628 | CPDF_Array* arr_val = arr->InsertNewAt<CPDF_Array>(11); |
| 629 | arr_val->AddNew<CPDF_Number>(1); |
| 630 | arr_val->AddNew<CPDF_Number>(2); |
| 631 | |
| 632 | CPDF_Dictionary* dict_val = arr->InsertNewAt<CPDF_Dictionary>(12); |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 633 | dict_val->SetNewFor<CPDF_String>("key1", "Linda", false); |
| 634 | dict_val->SetNewFor<CPDF_String>("key2", "Zoe", false); |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 635 | |
tsepez | cd5bca4 | 2016-09-30 10:45:06 -0700 | [diff] [blame] | 636 | CPDF_Dictionary* stream_dict = new CPDF_Dictionary(); |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 637 | stream_dict->SetNewFor<CPDF_String>("key1", "John", false); |
| 638 | stream_dict->SetNewFor<CPDF_String>("key2", "King", false); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 639 | uint8_t data[] = "A stream for test"; |
| 640 | // The data buffer will be owned by stream object, so it needs to be |
| 641 | // dynamically allocated. |
| 642 | size_t buf_size = sizeof(data); |
tsepez | 47fb8c0 | 2016-12-15 13:51:34 -0800 | [diff] [blame] | 643 | std::unique_ptr<uint8_t, FxFreeDeleter> buf(FX_Alloc(uint8_t, buf_size)); |
| 644 | memcpy(buf.get(), data, buf_size); |
tsepez | 9e05ee1 | 2016-11-21 13:19:10 -0800 | [diff] [blame] | 645 | CPDF_Stream* stream_val = arr->InsertNewAt<CPDF_Stream>( |
tsepez | 47fb8c0 | 2016-12-15 13:51:34 -0800 | [diff] [blame] | 646 | 13, std::move(buf), buf_size, pdfium::WrapUnique(stream_dict)); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 647 | const char* const expected_str[] = { |
| 648 | "true", "false", "0", "-1234", "2345", "0.05", "", |
| 649 | "It is a test!", "NAME", "test", "", "", "", ""}; |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 650 | const int expected_int[] = {1, 0, 0, -1234, 2345, 0, 0, |
| 651 | 0, 0, 0, 0, 0, 0, 0}; |
| 652 | const float expected_float[] = {0, 0, 0, -1234, 2345, 0.05f, 0, |
| 653 | 0, 0, 0, 0, 0, 0, 0}; |
| 654 | for (size_t i = 0; i < arr->GetCount(); ++i) { |
| 655 | EXPECT_STREQ(expected_str[i], arr->GetStringAt(i).c_str()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 656 | EXPECT_EQ(expected_int[i], arr->GetIntegerAt(i)); |
| 657 | EXPECT_EQ(expected_float[i], arr->GetNumberAt(i)); |
| 658 | EXPECT_EQ(expected_float[i], arr->GetFloatAt(i)); |
| 659 | if (i == 11) |
| 660 | EXPECT_EQ(arr_val, arr->GetArrayAt(i)); |
| 661 | else |
| 662 | EXPECT_EQ(nullptr, arr->GetArrayAt(i)); |
| 663 | if (i == 13) { |
| 664 | EXPECT_EQ(stream_dict, arr->GetDictAt(i)); |
| 665 | EXPECT_EQ(stream_val, arr->GetStreamAt(i)); |
| 666 | } else { |
| 667 | EXPECT_EQ(nullptr, arr->GetStreamAt(i)); |
| 668 | if (i == 12) |
| 669 | EXPECT_EQ(dict_val, arr->GetDictAt(i)); |
| 670 | else |
| 671 | EXPECT_EQ(nullptr, arr->GetDictAt(i)); |
| 672 | } |
| 673 | } |
| 674 | } |
| 675 | } |
| 676 | |
| 677 | TEST(PDFArrayTest, AddNumber) { |
| 678 | float vals[] = {1.0f, -1.0f, 0, 0.456734f, |
| 679 | 12345.54321f, 0.5f, 1000, 0.000045f}; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 680 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 681 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 682 | arr->AddNew<CPDF_Number>(vals[i]); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 683 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) { |
tsepez | bd56755 | 2016-03-29 14:51:50 -0700 | [diff] [blame] | 684 | EXPECT_EQ(CPDF_Object::NUMBER, arr->GetObjectAt(i)->GetType()); |
| 685 | EXPECT_EQ(vals[i], arr->GetObjectAt(i)->GetNumber()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 686 | } |
| 687 | } |
| 688 | |
| 689 | TEST(PDFArrayTest, AddInteger) { |
| 690 | int vals[] = {0, 1, 934435456, 876, 10000, -1, -24354656, -100}; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 691 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 692 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 693 | arr->AddNew<CPDF_Number>(vals[i]); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 694 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) { |
tsepez | bd56755 | 2016-03-29 14:51:50 -0700 | [diff] [blame] | 695 | EXPECT_EQ(CPDF_Object::NUMBER, arr->GetObjectAt(i)->GetType()); |
| 696 | EXPECT_EQ(vals[i], arr->GetObjectAt(i)->GetNumber()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 697 | } |
| 698 | } |
| 699 | |
| 700 | TEST(PDFArrayTest, AddStringAndName) { |
Lei Zhang | 69fe711 | 2017-09-14 18:26:26 -0700 | [diff] [blame] | 701 | static constexpr const char* vals[] = { |
| 702 | "", "a", "ehjhRIOYTTFdfcdnv", "122323", |
| 703 | "$#%^&**", " ", "This is a test.\r\n"}; |
Dan Sinclair | 0bb1333 | 2017-03-30 16:12:02 -0400 | [diff] [blame] | 704 | auto string_array = pdfium::MakeUnique<CPDF_Array>(); |
| 705 | auto name_array = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 706 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) { |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 707 | string_array->AddNew<CPDF_String>(vals[i], false); |
| 708 | name_array->AddNew<CPDF_Name>(vals[i]); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 709 | } |
| 710 | for (size_t i = 0; i < FX_ArraySize(vals); ++i) { |
tsepez | bd56755 | 2016-03-29 14:51:50 -0700 | [diff] [blame] | 711 | EXPECT_EQ(CPDF_Object::STRING, string_array->GetObjectAt(i)->GetType()); |
| 712 | EXPECT_STREQ(vals[i], string_array->GetObjectAt(i)->GetString().c_str()); |
| 713 | EXPECT_EQ(CPDF_Object::NAME, name_array->GetObjectAt(i)->GetType()); |
| 714 | EXPECT_STREQ(vals[i], name_array->GetObjectAt(i)->GetString().c_str()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 715 | } |
| 716 | } |
| 717 | |
tsepez | bd56755 | 2016-03-29 14:51:50 -0700 | [diff] [blame] | 718 | TEST(PDFArrayTest, AddReferenceAndGetObjectAt) { |
Dan Sinclair | 0bb1333 | 2017-03-30 16:12:02 -0400 | [diff] [blame] | 719 | auto holder = pdfium::MakeUnique<CPDF_IndirectObjectHolder>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 720 | CPDF_Boolean* boolean_obj = new CPDF_Boolean(true); |
| 721 | CPDF_Number* int_obj = new CPDF_Number(-1234); |
| 722 | CPDF_Number* float_obj = new CPDF_Number(2345.089f); |
tsepez | 5913a6c | 2016-11-16 17:31:18 -0800 | [diff] [blame] | 723 | CPDF_String* str_obj = |
| 724 | new CPDF_String(nullptr, "Adsfdsf 343434 %&&*\n", false); |
| 725 | CPDF_Name* name_obj = new CPDF_Name(nullptr, "Title:"); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 726 | CPDF_Null* null_obj = new CPDF_Null(); |
| 727 | CPDF_Object* indirect_objs[] = {boolean_obj, int_obj, float_obj, |
| 728 | str_obj, name_obj, null_obj}; |
| 729 | unsigned int obj_nums[] = {2, 4, 7, 2345, 799887, 1}; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 730 | auto arr = pdfium::MakeUnique<CPDF_Array>(); |
Dan Sinclair | 0bb1333 | 2017-03-30 16:12:02 -0400 | [diff] [blame] | 731 | auto arr1 = pdfium::MakeUnique<CPDF_Array>(); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 732 | // Create two arrays of references by different AddReference() APIs. |
| 733 | for (size_t i = 0; i < FX_ArraySize(indirect_objs); ++i) { |
tsepez | 931d087 | 2016-11-04 16:00:03 -0700 | [diff] [blame] | 734 | holder->ReplaceIndirectObjectIfHigherGeneration( |
| 735 | obj_nums[i], pdfium::WrapUnique<CPDF_Object>(indirect_objs[i])); |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 736 | arr->AddNew<CPDF_Reference>(holder.get(), obj_nums[i]); |
| 737 | arr1->AddNew<CPDF_Reference>(holder.get(), indirect_objs[i]->GetObjNum()); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 738 | } |
| 739 | // Check indirect objects. |
| 740 | for (size_t i = 0; i < FX_ArraySize(obj_nums); ++i) |
dsinclair | 03bd7c7 | 2016-08-23 20:13:41 -0700 | [diff] [blame] | 741 | EXPECT_EQ(indirect_objs[i], holder->GetOrParseIndirectObject(obj_nums[i])); |
Wei Li | bb53a5d | 2016-02-03 10:04:19 -0800 | [diff] [blame] | 742 | // Check arrays. |
| 743 | EXPECT_EQ(arr->GetCount(), arr1->GetCount()); |
| 744 | for (size_t i = 0; i < arr->GetCount(); ++i) { |
tsepez | bd56755 | 2016-03-29 14:51:50 -0700 | [diff] [blame] | 745 | EXPECT_EQ(CPDF_Object::REFERENCE, arr->GetObjectAt(i)->GetType()); |
| 746 | EXPECT_EQ(indirect_objs[i], arr->GetObjectAt(i)->GetDirect()); |
| 747 | EXPECT_EQ(indirect_objs[i], arr->GetDirectObjectAt(i)); |
| 748 | EXPECT_EQ(CPDF_Object::REFERENCE, arr1->GetObjectAt(i)->GetType()); |
| 749 | EXPECT_EQ(indirect_objs[i], arr1->GetObjectAt(i)->GetDirect()); |
| 750 | EXPECT_EQ(indirect_objs[i], arr1->GetDirectObjectAt(i)); |
Wei Li | 8f95227 | 2016-01-29 18:04:42 -0800 | [diff] [blame] | 751 | } |
| 752 | } |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 753 | |
thestig | 22b176d | 2016-08-25 11:14:21 -0700 | [diff] [blame] | 754 | TEST(PDFArrayTest, CloneDirectObject) { |
| 755 | CPDF_IndirectObjectHolder objects_holder; |
Dan Sinclair | 0bb1333 | 2017-03-30 16:12:02 -0400 | [diff] [blame] | 756 | auto array = pdfium::MakeUnique<CPDF_Array>(); |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 757 | array->AddNew<CPDF_Reference>(&objects_holder, 1234); |
thestig | 22b176d | 2016-08-25 11:14:21 -0700 | [diff] [blame] | 758 | ASSERT_EQ(1U, array->GetCount()); |
| 759 | CPDF_Object* obj = array->GetObjectAt(0); |
| 760 | ASSERT_TRUE(obj); |
| 761 | EXPECT_TRUE(obj->IsReference()); |
| 762 | |
tsepez | 335cf09 | 2016-11-09 13:28:26 -0800 | [diff] [blame] | 763 | std::unique_ptr<CPDF_Object> cloned_array_object = array->CloneDirectObject(); |
thestig | 22b176d | 2016-08-25 11:14:21 -0700 | [diff] [blame] | 764 | ASSERT_TRUE(cloned_array_object); |
| 765 | ASSERT_TRUE(cloned_array_object->IsArray()); |
| 766 | |
tsepez | 335cf09 | 2016-11-09 13:28:26 -0800 | [diff] [blame] | 767 | std::unique_ptr<CPDF_Array> cloned_array = |
| 768 | ToArray(std::move(cloned_array_object)); |
Wei Li | 6bdd824 | 2017-03-23 09:45:04 -0700 | [diff] [blame] | 769 | ASSERT_EQ(0U, cloned_array->GetCount()); |
thestig | 22b176d | 2016-08-25 11:14:21 -0700 | [diff] [blame] | 770 | CPDF_Object* cloned_obj = cloned_array->GetObjectAt(0); |
| 771 | EXPECT_FALSE(cloned_obj); |
| 772 | } |
| 773 | |
tsepez | 381fc83 | 2016-10-10 14:06:44 -0700 | [diff] [blame] | 774 | TEST(PDFArrayTest, ConvertIndirect) { |
| 775 | CPDF_IndirectObjectHolder objects_holder; |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 776 | auto array = pdfium::MakeUnique<CPDF_Array>(); |
| 777 | CPDF_Object* pObj = array->AddNew<CPDF_Number>(42); |
tsepez | 381fc83 | 2016-10-10 14:06:44 -0700 | [diff] [blame] | 778 | array->ConvertToIndirectObjectAt(0, &objects_holder); |
| 779 | CPDF_Object* pRef = array->GetObjectAt(0); |
| 780 | CPDF_Object* pNum = array->GetDirectObjectAt(0); |
| 781 | EXPECT_TRUE(pRef->IsReference()); |
| 782 | EXPECT_TRUE(pNum->IsNumber()); |
| 783 | EXPECT_NE(pObj, pRef); |
| 784 | EXPECT_EQ(pObj, pNum); |
| 785 | EXPECT_EQ(42, array->GetIntegerAt(0)); |
| 786 | } |
| 787 | |
Artem Strygin | 90555e0 | 2017-07-28 19:41:59 +0300 | [diff] [blame] | 788 | TEST(PDFStreamTest, SetData) { |
| 789 | std::vector<uint8_t> data(100); |
| 790 | auto stream = pdfium::MakeUnique<CPDF_Stream>(); |
| 791 | stream->InitStream(data.data(), data.size(), |
| 792 | pdfium::MakeUnique<CPDF_Dictionary>()); |
| 793 | EXPECT_EQ(static_cast<int>(data.size()), |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 794 | stream->GetDict()->GetIntegerFor(pdfium::stream::kLength)); |
Artem Strygin | 90555e0 | 2017-07-28 19:41:59 +0300 | [diff] [blame] | 795 | |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 796 | stream->GetDict()->SetNewFor<CPDF_String>(pdfium::stream::kFilter, |
| 797 | L"SomeFilter"); |
| 798 | stream->GetDict()->SetNewFor<CPDF_String>(pdfium::stream::kDecodeParms, |
| 799 | L"SomeParams"); |
Artem Strygin | 90555e0 | 2017-07-28 19:41:59 +0300 | [diff] [blame] | 800 | |
| 801 | std::vector<uint8_t> new_data(data.size() * 2); |
| 802 | stream->SetData(new_data.data(), new_data.size()); |
| 803 | |
| 804 | // The "Length" field should be updated for new data size. |
| 805 | EXPECT_EQ(static_cast<int>(new_data.size()), |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 806 | stream->GetDict()->GetIntegerFor(pdfium::stream::kLength)); |
Artem Strygin | 90555e0 | 2017-07-28 19:41:59 +0300 | [diff] [blame] | 807 | |
| 808 | // The "Filter" and "DecodeParms" fields should not be changed. |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 809 | EXPECT_EQ(stream->GetDict()->GetUnicodeTextFor(pdfium::stream::kFilter), |
| 810 | L"SomeFilter"); |
| 811 | EXPECT_EQ(stream->GetDict()->GetUnicodeTextFor(pdfium::stream::kDecodeParms), |
| 812 | L"SomeParams"); |
Artem Strygin | 90555e0 | 2017-07-28 19:41:59 +0300 | [diff] [blame] | 813 | } |
| 814 | |
| 815 | TEST(PDFStreamTest, SetDataAndRemoveFilter) { |
| 816 | std::vector<uint8_t> data(100); |
| 817 | auto stream = pdfium::MakeUnique<CPDF_Stream>(); |
| 818 | stream->InitStream(data.data(), data.size(), |
| 819 | pdfium::MakeUnique<CPDF_Dictionary>()); |
| 820 | EXPECT_EQ(static_cast<int>(data.size()), |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 821 | stream->GetDict()->GetIntegerFor(pdfium::stream::kLength)); |
Artem Strygin | 90555e0 | 2017-07-28 19:41:59 +0300 | [diff] [blame] | 822 | |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 823 | stream->GetDict()->SetNewFor<CPDF_String>(pdfium::stream::kFilter, |
| 824 | L"SomeFilter"); |
| 825 | stream->GetDict()->SetNewFor<CPDF_String>(pdfium::stream::kDecodeParms, |
| 826 | L"SomeParams"); |
Artem Strygin | 90555e0 | 2017-07-28 19:41:59 +0300 | [diff] [blame] | 827 | |
| 828 | std::vector<uint8_t> new_data(data.size() * 2); |
| 829 | stream->SetDataAndRemoveFilter(new_data.data(), new_data.size()); |
| 830 | // The "Length" field should be updated for new data size. |
| 831 | EXPECT_EQ(static_cast<int>(new_data.size()), |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 832 | stream->GetDict()->GetIntegerFor(pdfium::stream::kLength)); |
Artem Strygin | 90555e0 | 2017-07-28 19:41:59 +0300 | [diff] [blame] | 833 | |
| 834 | // The "Filter" and "DecodeParms" should be removed. |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 835 | EXPECT_FALSE(stream->GetDict()->KeyExist(pdfium::stream::kFilter)); |
| 836 | EXPECT_FALSE(stream->GetDict()->KeyExist(pdfium::stream::kDecodeParms)); |
Artem Strygin | 90555e0 | 2017-07-28 19:41:59 +0300 | [diff] [blame] | 837 | } |
| 838 | |
Artem Strygin | 4fde70e | 2017-09-04 17:01:41 +0300 | [diff] [blame] | 839 | TEST(PDFStreamTest, LengthInDictionaryOnCreate) { |
| 840 | static constexpr uint32_t kBufSize = 100; |
| 841 | // The length field should be created on stream create. |
| 842 | { |
| 843 | std::unique_ptr<uint8_t, FxFreeDeleter> data; |
| 844 | data.reset(FX_Alloc(uint8_t, kBufSize)); |
| 845 | auto stream = pdfium::MakeUnique<CPDF_Stream>( |
| 846 | std::move(data), kBufSize, pdfium::MakeUnique<CPDF_Dictionary>()); |
| 847 | EXPECT_EQ(static_cast<int>(kBufSize), |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 848 | stream->GetDict()->GetIntegerFor(pdfium::stream::kLength)); |
Artem Strygin | 4fde70e | 2017-09-04 17:01:41 +0300 | [diff] [blame] | 849 | } |
| 850 | // The length field should be corrected on stream create. |
| 851 | { |
| 852 | std::unique_ptr<uint8_t, FxFreeDeleter> data; |
| 853 | data.reset(FX_Alloc(uint8_t, kBufSize)); |
| 854 | auto dict = pdfium::MakeUnique<CPDF_Dictionary>(); |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 855 | dict->SetNewFor<CPDF_Number>(pdfium::stream::kLength, 30000); |
Artem Strygin | 4fde70e | 2017-09-04 17:01:41 +0300 | [diff] [blame] | 856 | auto stream = pdfium::MakeUnique<CPDF_Stream>(std::move(data), kBufSize, |
| 857 | std::move(dict)); |
| 858 | EXPECT_EQ(static_cast<int>(kBufSize), |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame^] | 859 | stream->GetDict()->GetIntegerFor(pdfium::stream::kLength)); |
Artem Strygin | 4fde70e | 2017-09-04 17:01:41 +0300 | [diff] [blame] | 860 | } |
| 861 | } |
| 862 | |
thestig | 22b176d | 2016-08-25 11:14:21 -0700 | [diff] [blame] | 863 | TEST(PDFDictionaryTest, CloneDirectObject) { |
| 864 | CPDF_IndirectObjectHolder objects_holder; |
Dan Sinclair | 0bb1333 | 2017-03-30 16:12:02 -0400 | [diff] [blame] | 865 | auto dict = pdfium::MakeUnique<CPDF_Dictionary>(); |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 866 | dict->SetNewFor<CPDF_Reference>("foo", &objects_holder, 1234); |
thestig | 22b176d | 2016-08-25 11:14:21 -0700 | [diff] [blame] | 867 | ASSERT_EQ(1U, dict->GetCount()); |
dsinclair | 38fd844 | 2016-09-15 10:15:32 -0700 | [diff] [blame] | 868 | CPDF_Object* obj = dict->GetObjectFor("foo"); |
thestig | 22b176d | 2016-08-25 11:14:21 -0700 | [diff] [blame] | 869 | ASSERT_TRUE(obj); |
| 870 | EXPECT_TRUE(obj->IsReference()); |
| 871 | |
tsepez | 335cf09 | 2016-11-09 13:28:26 -0800 | [diff] [blame] | 872 | std::unique_ptr<CPDF_Object> cloned_dict_object = dict->CloneDirectObject(); |
thestig | 22b176d | 2016-08-25 11:14:21 -0700 | [diff] [blame] | 873 | ASSERT_TRUE(cloned_dict_object); |
| 874 | ASSERT_TRUE(cloned_dict_object->IsDictionary()); |
| 875 | |
tsepez | 335cf09 | 2016-11-09 13:28:26 -0800 | [diff] [blame] | 876 | std::unique_ptr<CPDF_Dictionary> cloned_dict = |
| 877 | ToDictionary(std::move(cloned_dict_object)); |
Wei Li | 6bdd824 | 2017-03-23 09:45:04 -0700 | [diff] [blame] | 878 | ASSERT_EQ(0U, cloned_dict->GetCount()); |
dsinclair | 38fd844 | 2016-09-15 10:15:32 -0700 | [diff] [blame] | 879 | CPDF_Object* cloned_obj = cloned_dict->GetObjectFor("foo"); |
thestig | 22b176d | 2016-08-25 11:14:21 -0700 | [diff] [blame] | 880 | EXPECT_FALSE(cloned_obj); |
| 881 | } |
| 882 | |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 883 | TEST(PDFObjectTest, CloneCheckLoop) { |
| 884 | { |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 885 | // Create a dictionary/array pair with a reference loop. It takes |
| 886 | // some work to do this nowadays, in particular we need the |
| 887 | // anti-pattern pdfium::WrapUnique(arr.get()). |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 888 | auto arr_obj = pdfium::MakeUnique<CPDF_Array>(); |
| 889 | CPDF_Dictionary* dict_obj = arr_obj->InsertNewAt<CPDF_Dictionary>(0); |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 890 | dict_obj->SetFor("arr", pdfium::WrapUnique(arr_obj.get())); |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 891 | // Clone this object to see whether stack overflow will be triggered. |
tsepez | 335cf09 | 2016-11-09 13:28:26 -0800 | [diff] [blame] | 892 | std::unique_ptr<CPDF_Array> cloned_array = ToArray(arr_obj->Clone()); |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 893 | // Cloned object should be the same as the original. |
| 894 | ASSERT_TRUE(cloned_array); |
| 895 | EXPECT_EQ(1u, cloned_array->GetCount()); |
| 896 | CPDF_Object* cloned_dict = cloned_array->GetObjectAt(0); |
| 897 | ASSERT_TRUE(cloned_dict); |
| 898 | ASSERT_TRUE(cloned_dict->IsDictionary()); |
| 899 | // Recursively referenced object is not cloned. |
dsinclair | 38fd844 | 2016-09-15 10:15:32 -0700 | [diff] [blame] | 900 | EXPECT_EQ(nullptr, cloned_dict->AsDictionary()->GetObjectFor("arr")); |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 901 | } |
| 902 | { |
tsepez | 9e05ee1 | 2016-11-21 13:19:10 -0800 | [diff] [blame] | 903 | // Create a dictionary/stream pair with a reference loop. It takes |
| 904 | // some work to do this nowadays, in particular we need the |
| 905 | // anti-pattern pdfium::WrapUnique(dict.get()). |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 906 | auto dict_obj = pdfium::MakeUnique<CPDF_Dictionary>(); |
tsepez | 9e05ee1 | 2016-11-21 13:19:10 -0800 | [diff] [blame] | 907 | CPDF_Stream* stream_obj = dict_obj->SetNewFor<CPDF_Stream>( |
| 908 | "stream", nullptr, 0, pdfium::WrapUnique(dict_obj.get())); |
tsepez | 836f7d5 | 2016-10-10 14:31:05 -0700 | [diff] [blame] | 909 | // Clone this object to see whether stack overflow will be triggered. |
tsepez | 335cf09 | 2016-11-09 13:28:26 -0800 | [diff] [blame] | 910 | std::unique_ptr<CPDF_Stream> cloned_stream = ToStream(stream_obj->Clone()); |
tsepez | 836f7d5 | 2016-10-10 14:31:05 -0700 | [diff] [blame] | 911 | // Cloned object should be the same as the original. |
| 912 | ASSERT_TRUE(cloned_stream); |
| 913 | CPDF_Object* cloned_dict = cloned_stream->GetDict(); |
| 914 | ASSERT_TRUE(cloned_dict); |
| 915 | ASSERT_TRUE(cloned_dict->IsDictionary()); |
| 916 | // Recursively referenced object is not cloned. |
| 917 | EXPECT_EQ(nullptr, cloned_dict->AsDictionary()->GetObjectFor("stream")); |
| 918 | } |
| 919 | { |
thestig | 22b176d | 2016-08-25 11:14:21 -0700 | [diff] [blame] | 920 | CPDF_IndirectObjectHolder objects_holder; |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 921 | // Create an object with a reference loop. |
tsepez | 70c4afd | 2016-11-15 11:33:44 -0800 | [diff] [blame] | 922 | CPDF_Dictionary* dict_obj = objects_holder.NewIndirect<CPDF_Dictionary>(); |
| 923 | std::unique_ptr<CPDF_Array> arr_obj = pdfium::MakeUnique<CPDF_Array>(); |
tsepez | 8a3aa45 | 2016-11-16 12:26:06 -0800 | [diff] [blame] | 924 | arr_obj->InsertNewAt<CPDF_Reference>(0, &objects_holder, |
| 925 | dict_obj->GetObjNum()); |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 926 | CPDF_Object* elem0 = arr_obj->GetObjectAt(0); |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 927 | dict_obj->SetFor("arr", std::move(arr_obj)); |
tsepez | 70c4afd | 2016-11-15 11:33:44 -0800 | [diff] [blame] | 928 | EXPECT_EQ(1u, dict_obj->GetObjNum()); |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 929 | ASSERT_TRUE(elem0); |
| 930 | ASSERT_TRUE(elem0->IsReference()); |
| 931 | EXPECT_EQ(1u, elem0->AsReference()->GetRefObjNum()); |
| 932 | EXPECT_EQ(dict_obj, elem0->AsReference()->GetDirect()); |
| 933 | |
| 934 | // Clone this object to see whether stack overflow will be triggered. |
tsepez | 335cf09 | 2016-11-09 13:28:26 -0800 | [diff] [blame] | 935 | std::unique_ptr<CPDF_Dictionary> cloned_dict = |
| 936 | ToDictionary(dict_obj->CloneDirectObject()); |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 937 | // Cloned object should be the same as the original. |
| 938 | ASSERT_TRUE(cloned_dict); |
dsinclair | 38fd844 | 2016-09-15 10:15:32 -0700 | [diff] [blame] | 939 | CPDF_Object* cloned_arr = cloned_dict->GetObjectFor("arr"); |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 940 | ASSERT_TRUE(cloned_arr); |
| 941 | ASSERT_TRUE(cloned_arr->IsArray()); |
Wei Li | 6bdd824 | 2017-03-23 09:45:04 -0700 | [diff] [blame] | 942 | EXPECT_EQ(0U, cloned_arr->AsArray()->GetCount()); |
weili | a470b5e | 2016-08-23 22:08:37 -0700 | [diff] [blame] | 943 | // Recursively referenced object is not cloned. |
| 944 | EXPECT_EQ(nullptr, cloned_arr->AsArray()->GetObjectAt(0)); |
| 945 | } |
| 946 | } |
tsepez | 381fc83 | 2016-10-10 14:06:44 -0700 | [diff] [blame] | 947 | |
| 948 | TEST(PDFDictionaryTest, ConvertIndirect) { |
| 949 | CPDF_IndirectObjectHolder objects_holder; |
Dan Sinclair | 0bb1333 | 2017-03-30 16:12:02 -0400 | [diff] [blame] | 950 | auto dict = pdfium::MakeUnique<CPDF_Dictionary>(); |
tsepez | 0e606b5 | 2016-11-18 16:22:41 -0800 | [diff] [blame] | 951 | CPDF_Object* pObj = dict->SetNewFor<CPDF_Number>("clams", 42); |
tsepez | 381fc83 | 2016-10-10 14:06:44 -0700 | [diff] [blame] | 952 | dict->ConvertToIndirectObjectFor("clams", &objects_holder); |
| 953 | CPDF_Object* pRef = dict->GetObjectFor("clams"); |
| 954 | CPDF_Object* pNum = dict->GetDirectObjectFor("clams"); |
| 955 | EXPECT_TRUE(pRef->IsReference()); |
| 956 | EXPECT_TRUE(pNum->IsNumber()); |
| 957 | EXPECT_NE(pObj, pRef); |
| 958 | EXPECT_EQ(pObj, pNum); |
| 959 | EXPECT_EQ(42, dict->GetIntegerFor("clams")); |
| 960 | } |
Artem Strygin | 106eecd | 2017-07-28 14:34:37 +0300 | [diff] [blame] | 961 | |
| 962 | TEST(PDFDictionaryTest, ExtractObjectOnRemove) { |
| 963 | auto dict = pdfium::MakeUnique<CPDF_Dictionary>(); |
| 964 | CPDF_Object* pObj = dict->SetNewFor<CPDF_Number>("child", 42); |
| 965 | auto extracted_object = dict->RemoveFor("child"); |
| 966 | EXPECT_EQ(pObj, extracted_object.get()); |
| 967 | |
| 968 | extracted_object = dict->RemoveFor("non_exists_object"); |
| 969 | EXPECT_FALSE(extracted_object); |
| 970 | } |