OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/utility/safe_browsing/mac/read_stream.h" | 5 #include "chrome/utility/safe_browsing/mac/read_stream.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
| 10 #include <memory> |
10 #include <vector> | 11 #include <vector> |
11 | 12 |
12 #include "base/files/file.h" | 13 #include "base/files/file.h" |
13 #include "base/files/file_path.h" | 14 #include "base/files/file_path.h" |
14 #include "base/files/scoped_temp_dir.h" | 15 #include "base/files/scoped_temp_dir.h" |
15 #include "base/memory/scoped_ptr.h" | 16 #include "base/memory/ptr_util.h" |
16 #include "base/path_service.h" | 17 #include "base/path_service.h" |
17 #include "chrome/common/chrome_paths.h" | 18 #include "chrome/common/chrome_paths.h" |
18 #include "chrome/utility/safe_browsing/mac/dmg_test_utils.h" | 19 #include "chrome/utility/safe_browsing/mac/dmg_test_utils.h" |
19 #include "testing/gtest/include/gtest/gtest.h" | 20 #include "testing/gtest/include/gtest/gtest.h" |
20 | 21 |
21 namespace safe_browsing { | 22 namespace safe_browsing { |
22 namespace dmg { | 23 namespace dmg { |
23 | 24 |
24 struct MemoryReadStreamTest { | 25 struct MemoryReadStreamTest { |
25 void SetUp() {} | 26 void SetUp() {} |
(...skipping 23 matching lines...) Expand all Loading... |
49 protected: | 50 protected: |
50 void SetUp() override { | 51 void SetUp() override { |
51 test_helper_.SetUp(); | 52 test_helper_.SetUp(); |
52 } | 53 } |
53 | 54 |
54 void TearDown() override { | 55 void TearDown() override { |
55 if (HasFailure()) | 56 if (HasFailure()) |
56 ADD_FAILURE() << "Failing type is " << test_helper_.TestName(); | 57 ADD_FAILURE() << "Failing type is " << test_helper_.TestName(); |
57 } | 58 } |
58 | 59 |
59 scoped_ptr<ReadStream> CreateStream(size_t data_size); | 60 std::unique_ptr<ReadStream> CreateStream(size_t data_size); |
60 | 61 |
61 private: | 62 private: |
62 T test_helper_; | 63 T test_helper_; |
63 }; | 64 }; |
64 | 65 |
65 template <> | 66 template <> |
66 scoped_ptr<ReadStream> | 67 std::unique_ptr<ReadStream> ReadStreamTest<MemoryReadStreamTest>::CreateStream( |
67 ReadStreamTest<MemoryReadStreamTest>::CreateStream(size_t data_size) { | 68 size_t data_size) { |
68 test_helper_.data.resize(data_size); | 69 test_helper_.data.resize(data_size); |
69 for (size_t i = 0; i < data_size; ++i) { | 70 for (size_t i = 0; i < data_size; ++i) { |
70 test_helper_.data[i] = i % 255; | 71 test_helper_.data[i] = i % 255; |
71 } | 72 } |
72 return make_scoped_ptr( | 73 return base::WrapUnique( |
73 new MemoryReadStream(&test_helper_.data[0], data_size)); | 74 new MemoryReadStream(&test_helper_.data[0], data_size)); |
74 } | 75 } |
75 | 76 |
76 template <> | 77 template <> |
77 scoped_ptr<ReadStream> | 78 std::unique_ptr<ReadStream> ReadStreamTest<FileReadStreamTest>::CreateStream( |
78 ReadStreamTest<FileReadStreamTest>::CreateStream(size_t data_size) { | 79 size_t data_size) { |
79 base::FilePath path = test_helper_.temp_dir.path().Append("stream"); | 80 base::FilePath path = test_helper_.temp_dir.path().Append("stream"); |
80 test_helper_.file.Initialize(path, | 81 test_helper_.file.Initialize(path, |
81 base::File::FLAG_CREATE | base::File::FLAG_WRITE); | 82 base::File::FLAG_CREATE | base::File::FLAG_WRITE); |
82 if (!test_helper_.file.IsValid()) { | 83 if (!test_helper_.file.IsValid()) { |
83 ADD_FAILURE() << "Failed to create temp file"; | 84 ADD_FAILURE() << "Failed to create temp file"; |
84 return nullptr; | 85 return nullptr; |
85 } | 86 } |
86 | 87 |
87 for (size_t i = 0; i < data_size; ++i) { | 88 for (size_t i = 0; i < data_size; ++i) { |
88 char value = i % 255; | 89 char value = i % 255; |
89 EXPECT_EQ(1, test_helper_.file.WriteAtCurrentPos(&value, 1)); | 90 EXPECT_EQ(1, test_helper_.file.WriteAtCurrentPos(&value, 1)); |
90 } | 91 } |
91 | 92 |
92 test_helper_.file.Close(); | 93 test_helper_.file.Close(); |
93 | 94 |
94 test_helper_.file.Initialize(path, | 95 test_helper_.file.Initialize(path, |
95 base::File::FLAG_OPEN | base::File::FLAG_READ); | 96 base::File::FLAG_OPEN | base::File::FLAG_READ); |
96 if (!test_helper_.file.IsValid()) { | 97 if (!test_helper_.file.IsValid()) { |
97 ADD_FAILURE() << "Failed to open temp file"; | 98 ADD_FAILURE() << "Failed to open temp file"; |
98 return nullptr; | 99 return nullptr; |
99 } | 100 } |
100 | 101 |
101 return make_scoped_ptr( | 102 return base::WrapUnique( |
102 new FileReadStream(test_helper_.file.GetPlatformFile())); | 103 new FileReadStream(test_helper_.file.GetPlatformFile())); |
103 } | 104 } |
104 | 105 |
105 using ReadStreamImpls = testing::Types<MemoryReadStreamTest, | 106 using ReadStreamImpls = testing::Types<MemoryReadStreamTest, |
106 FileReadStreamTest>; | 107 FileReadStreamTest>; |
107 TYPED_TEST_CASE(ReadStreamTest, ReadStreamImpls); | 108 TYPED_TEST_CASE(ReadStreamTest, ReadStreamImpls); |
108 | 109 |
109 TYPED_TEST(ReadStreamTest, Read) { | 110 TYPED_TEST(ReadStreamTest, Read) { |
110 scoped_ptr<ReadStream> stream = ReadStreamTest<TypeParam>::CreateStream(128); | 111 std::unique_ptr<ReadStream> stream = |
| 112 ReadStreamTest<TypeParam>::CreateStream(128); |
111 uint8_t buf[128] = {0}; | 113 uint8_t buf[128] = {0}; |
112 size_t bytes_read; | 114 size_t bytes_read; |
113 | 115 |
114 { | 116 { |
115 EXPECT_TRUE(stream->Read(buf, 4, &bytes_read)); | 117 EXPECT_TRUE(stream->Read(buf, 4, &bytes_read)); |
116 EXPECT_EQ(4u, bytes_read); | 118 EXPECT_EQ(4u, bytes_read); |
117 uint8_t expected[] = { 0, 1, 2, 3, 0, 0, 0 }; | 119 uint8_t expected[] = { 0, 1, 2, 3, 0, 0, 0 }; |
118 EXPECT_EQ(0, memcmp(expected, buf, sizeof(expected))); | 120 EXPECT_EQ(0, memcmp(expected, buf, sizeof(expected))); |
119 } | 121 } |
120 | 122 |
121 { | 123 { |
122 EXPECT_TRUE(stream->Read(buf, 9, &bytes_read)); | 124 EXPECT_TRUE(stream->Read(buf, 9, &bytes_read)); |
123 EXPECT_EQ(9u, bytes_read); | 125 EXPECT_EQ(9u, bytes_read); |
124 uint8_t expected[] = { 4, 5, 6, 7, 8, 9, 10, 11, 12, 0, 0 }; | 126 uint8_t expected[] = { 4, 5, 6, 7, 8, 9, 10, 11, 12, 0, 0 }; |
125 EXPECT_EQ(0, memcmp(expected, buf, sizeof(expected))); | 127 EXPECT_EQ(0, memcmp(expected, buf, sizeof(expected))); |
126 } | 128 } |
127 } | 129 } |
128 | 130 |
129 TYPED_TEST(ReadStreamTest, ReadAll) { | 131 TYPED_TEST(ReadStreamTest, ReadAll) { |
130 const size_t kStreamSize = 4242; | 132 const size_t kStreamSize = 4242; |
131 scoped_ptr<ReadStream> stream = | 133 std::unique_ptr<ReadStream> stream = |
132 ReadStreamTest<TypeParam>::CreateStream(kStreamSize); | 134 ReadStreamTest<TypeParam>::CreateStream(kStreamSize); |
133 | 135 |
134 std::vector<uint8_t> data; | 136 std::vector<uint8_t> data; |
135 EXPECT_TRUE(test::ReadEntireStream(stream.get(), &data)); | 137 EXPECT_TRUE(test::ReadEntireStream(stream.get(), &data)); |
136 EXPECT_EQ(kStreamSize, data.size()); | 138 EXPECT_EQ(kStreamSize, data.size()); |
137 } | 139 } |
138 | 140 |
139 TYPED_TEST(ReadStreamTest, SeekSet) { | 141 TYPED_TEST(ReadStreamTest, SeekSet) { |
140 scoped_ptr<ReadStream> stream = ReadStreamTest<TypeParam>::CreateStream(255); | 142 std::unique_ptr<ReadStream> stream = |
| 143 ReadStreamTest<TypeParam>::CreateStream(255); |
141 uint8_t buf[32] = {0}; | 144 uint8_t buf[32] = {0}; |
142 size_t bytes_read; | 145 size_t bytes_read; |
143 | 146 |
144 { | 147 { |
145 EXPECT_EQ(250, stream->Seek(250, SEEK_SET)); | 148 EXPECT_EQ(250, stream->Seek(250, SEEK_SET)); |
146 EXPECT_TRUE(stream->Read(buf, sizeof(buf), &bytes_read)); | 149 EXPECT_TRUE(stream->Read(buf, sizeof(buf), &bytes_read)); |
147 EXPECT_EQ(5u, bytes_read); | 150 EXPECT_EQ(5u, bytes_read); |
148 uint8_t expected[] = { 250, 251, 252, 253, 254, 0, 0 }; | 151 uint8_t expected[] = { 250, 251, 252, 253, 254, 0, 0 }; |
149 EXPECT_EQ(0, memcmp(expected, buf, sizeof(expected))); | 152 EXPECT_EQ(0, memcmp(expected, buf, sizeof(expected))); |
150 } | 153 } |
151 | 154 |
152 { | 155 { |
153 EXPECT_EQ(5, stream->Seek(5, SEEK_SET)); | 156 EXPECT_EQ(5, stream->Seek(5, SEEK_SET)); |
154 EXPECT_TRUE(stream->Read(buf, 3, &bytes_read)); | 157 EXPECT_TRUE(stream->Read(buf, 3, &bytes_read)); |
155 EXPECT_EQ(3u, bytes_read); | 158 EXPECT_EQ(3u, bytes_read); |
156 uint8_t expected[] = { 5, 6, 7, 253, 254, 0, 0 }; | 159 uint8_t expected[] = { 5, 6, 7, 253, 254, 0, 0 }; |
157 EXPECT_EQ(0, memcmp(expected, buf, sizeof(expected))); | 160 EXPECT_EQ(0, memcmp(expected, buf, sizeof(expected))); |
158 } | 161 } |
159 } | 162 } |
160 | 163 |
161 TYPED_TEST(ReadStreamTest, SeekEnd) { | 164 TYPED_TEST(ReadStreamTest, SeekEnd) { |
162 scoped_ptr<ReadStream> stream = ReadStreamTest<TypeParam>::CreateStream(32); | 165 std::unique_ptr<ReadStream> stream = |
| 166 ReadStreamTest<TypeParam>::CreateStream(32); |
163 uint8_t buf[32] = {0}; | 167 uint8_t buf[32] = {0}; |
164 size_t bytes_read; | 168 size_t bytes_read; |
165 | 169 |
166 { | 170 { |
167 EXPECT_EQ(32, stream->Seek(0, SEEK_END)); | 171 EXPECT_EQ(32, stream->Seek(0, SEEK_END)); |
168 EXPECT_TRUE(stream->Read(buf, sizeof(buf), &bytes_read)); | 172 EXPECT_TRUE(stream->Read(buf, sizeof(buf), &bytes_read)); |
169 EXPECT_EQ(0u, bytes_read); | 173 EXPECT_EQ(0u, bytes_read); |
170 } | 174 } |
171 | 175 |
172 { | 176 { |
173 EXPECT_EQ(28, stream->Seek(-4, SEEK_END)); | 177 EXPECT_EQ(28, stream->Seek(-4, SEEK_END)); |
174 EXPECT_TRUE(stream->Read(buf, sizeof(buf), &bytes_read)); | 178 EXPECT_TRUE(stream->Read(buf, sizeof(buf), &bytes_read)); |
175 EXPECT_EQ(4u, bytes_read); | 179 EXPECT_EQ(4u, bytes_read); |
176 uint8_t expected[] = { 28, 29, 30, 31, 0, 0, 0 }; | 180 uint8_t expected[] = { 28, 29, 30, 31, 0, 0, 0 }; |
177 EXPECT_EQ(0, memcmp(expected, buf, sizeof(expected))); | 181 EXPECT_EQ(0, memcmp(expected, buf, sizeof(expected))); |
178 } | 182 } |
179 } | 183 } |
180 | 184 |
181 TYPED_TEST(ReadStreamTest, SeekCur) { | 185 TYPED_TEST(ReadStreamTest, SeekCur) { |
182 scoped_ptr<ReadStream> stream = ReadStreamTest<TypeParam>::CreateStream(100); | 186 std::unique_ptr<ReadStream> stream = |
| 187 ReadStreamTest<TypeParam>::CreateStream(100); |
183 uint8_t buf[32] = {0}; | 188 uint8_t buf[32] = {0}; |
184 size_t bytes_read; | 189 size_t bytes_read; |
185 | 190 |
186 { | 191 { |
187 EXPECT_EQ(0, stream->Seek(0, SEEK_CUR)); | 192 EXPECT_EQ(0, stream->Seek(0, SEEK_CUR)); |
188 } | 193 } |
189 | 194 |
190 { | 195 { |
191 EXPECT_TRUE(stream->Read(buf, sizeof(buf), &bytes_read)); | 196 EXPECT_TRUE(stream->Read(buf, sizeof(buf), &bytes_read)); |
192 EXPECT_EQ(sizeof(buf), bytes_read); | 197 EXPECT_EQ(sizeof(buf), bytes_read); |
(...skipping 12 matching lines...) Expand all Loading... |
205 } | 210 } |
206 | 211 |
207 { | 212 { |
208 EXPECT_EQ(100, stream->Seek(0, SEEK_END)); | 213 EXPECT_EQ(100, stream->Seek(0, SEEK_END)); |
209 EXPECT_EQ(100, stream->Seek(0, SEEK_CUR)); | 214 EXPECT_EQ(100, stream->Seek(0, SEEK_CUR)); |
210 } | 215 } |
211 } | 216 } |
212 | 217 |
213 } // namespace dmg | 218 } // namespace dmg |
214 } // namespace safe_browsing | 219 } // namespace safe_browsing |
OLD | NEW |