OLD | NEW |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2013 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/browser/chromeos/drive/search_metadata.h" | 5 #include "chrome/browser/chromeos/drive/search_metadata.h" |
6 | 6 |
7 #include "base/files/file_util.h" | 7 #include "base/files/file_util.h" |
8 #include "base/files/scoped_temp_dir.h" | 8 #include "base/files/scoped_temp_dir.h" |
9 #include "base/i18n/string_search.h" | 9 #include "base/i18n/string_search.h" |
10 #include "base/message_loop/message_loop_proxy.h" | |
11 #include "base/run_loop.h" | 10 #include "base/run_loop.h" |
| 11 #include "base/single_thread_task_runner.h" |
12 #include "base/strings/utf_string_conversions.h" | 12 #include "base/strings/utf_string_conversions.h" |
| 13 #include "base/thread_task_runner_handle.h" |
13 #include "chrome/browser/chromeos/drive/fake_free_disk_space_getter.h" | 14 #include "chrome/browser/chromeos/drive/fake_free_disk_space_getter.h" |
14 #include "chrome/browser/chromeos/drive/file_cache.h" | 15 #include "chrome/browser/chromeos/drive/file_cache.h" |
15 #include "chrome/browser/chromeos/drive/file_system_util.h" | 16 #include "chrome/browser/chromeos/drive/file_system_util.h" |
16 #include "chrome/browser/chromeos/drive/test_util.h" | 17 #include "chrome/browser/chromeos/drive/test_util.h" |
17 #include "chrome/browser/drive/drive_api_util.h" | 18 #include "chrome/browser/drive/drive_api_util.h" |
18 #include "content/public/test/test_browser_thread_bundle.h" | 19 #include "content/public/test/test_browser_thread_bundle.h" |
19 #include "testing/gtest/include/gtest/gtest.h" | 20 #include "testing/gtest/include/gtest/gtest.h" |
20 | 21 |
21 namespace drive { | 22 namespace drive { |
22 namespace internal { | 23 namespace internal { |
(...skipping 15 matching lines...) Expand all Loading... |
38 | 39 |
39 } // namespace | 40 } // namespace |
40 | 41 |
41 class SearchMetadataTest : public testing::Test { | 42 class SearchMetadataTest : public testing::Test { |
42 protected: | 43 protected: |
43 void SetUp() override { | 44 void SetUp() override { |
44 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); | 45 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
45 fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter); | 46 fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter); |
46 | 47 |
47 metadata_storage_.reset(new ResourceMetadataStorage( | 48 metadata_storage_.reset(new ResourceMetadataStorage( |
48 temp_dir_.path(), base::MessageLoopProxy::current().get())); | 49 temp_dir_.path(), base::ThreadTaskRunnerHandle::Get().get())); |
49 ASSERT_TRUE(metadata_storage_->Initialize()); | 50 ASSERT_TRUE(metadata_storage_->Initialize()); |
50 | 51 |
51 cache_.reset(new FileCache(metadata_storage_.get(), | 52 cache_.reset(new FileCache(metadata_storage_.get(), |
52 temp_dir_.path(), | 53 temp_dir_.path(), |
53 base::MessageLoopProxy::current().get(), | 54 base::ThreadTaskRunnerHandle::Get().get(), |
54 fake_free_disk_space_getter_.get())); | 55 fake_free_disk_space_getter_.get())); |
55 ASSERT_TRUE(cache_->Initialize()); | 56 ASSERT_TRUE(cache_->Initialize()); |
56 | 57 |
57 resource_metadata_.reset( | 58 resource_metadata_.reset( |
58 new ResourceMetadata(metadata_storage_.get(), | 59 new ResourceMetadata(metadata_storage_.get(), |
59 cache_.get(), | 60 cache_.get(), |
60 base::MessageLoopProxy::current())); | 61 base::ThreadTaskRunnerHandle::Get().get())); |
61 ASSERT_EQ(FILE_ERROR_OK, resource_metadata_->Initialize()); | 62 ASSERT_EQ(FILE_ERROR_OK, resource_metadata_->Initialize()); |
62 | 63 |
63 AddEntriesToMetadata(); | 64 AddEntriesToMetadata(); |
64 } | 65 } |
65 | 66 |
66 void AddEntriesToMetadata() { | 67 void AddEntriesToMetadata() { |
67 base::FilePath temp_file; | 68 base::FilePath temp_file; |
68 EXPECT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file)); | 69 EXPECT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &temp_file)); |
69 const std::string temp_file_md5 = "md5"; | 70 const std::string temp_file_md5 = "md5"; |
70 | 71 |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
156 scoped_ptr<ResourceMetadata, test_util::DestroyHelperForTests> | 157 scoped_ptr<ResourceMetadata, test_util::DestroyHelperForTests> |
157 resource_metadata_; | 158 resource_metadata_; |
158 scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache_; | 159 scoped_ptr<FileCache, test_util::DestroyHelperForTests> cache_; |
159 }; | 160 }; |
160 | 161 |
161 TEST_F(SearchMetadataTest, SearchMetadata_ZeroMatches) { | 162 TEST_F(SearchMetadataTest, SearchMetadata_ZeroMatches) { |
162 FileError error = FILE_ERROR_FAILED; | 163 FileError error = FILE_ERROR_FAILED; |
163 scoped_ptr<MetadataSearchResultVector> result; | 164 scoped_ptr<MetadataSearchResultVector> result; |
164 | 165 |
165 SearchMetadata( | 166 SearchMetadata( |
166 base::MessageLoopProxy::current(), resource_metadata_.get(), | 167 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), |
167 "NonExistent", base::Bind(&MatchesType, SEARCH_METADATA_ALL), | 168 "NonExistent", base::Bind(&MatchesType, SEARCH_METADATA_ALL), |
168 kDefaultAtMostNumMatches, | 169 kDefaultAtMostNumMatches, |
169 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 170 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
170 base::RunLoop().RunUntilIdle(); | 171 base::RunLoop().RunUntilIdle(); |
171 EXPECT_EQ(FILE_ERROR_OK, error); | 172 EXPECT_EQ(FILE_ERROR_OK, error); |
172 ASSERT_TRUE(result); | 173 ASSERT_TRUE(result); |
173 ASSERT_EQ(0U, result->size()); | 174 ASSERT_EQ(0U, result->size()); |
174 } | 175 } |
175 | 176 |
176 TEST_F(SearchMetadataTest, SearchMetadata_RegularFile) { | 177 TEST_F(SearchMetadataTest, SearchMetadata_RegularFile) { |
177 FileError error = FILE_ERROR_FAILED; | 178 FileError error = FILE_ERROR_FAILED; |
178 scoped_ptr<MetadataSearchResultVector> result; | 179 scoped_ptr<MetadataSearchResultVector> result; |
179 | 180 |
180 SearchMetadata( | 181 SearchMetadata( |
181 base::MessageLoopProxy::current(), resource_metadata_.get(), | 182 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), |
182 "SubDirectory File 1.txt", base::Bind(&MatchesType, SEARCH_METADATA_ALL), | 183 "SubDirectory File 1.txt", base::Bind(&MatchesType, SEARCH_METADATA_ALL), |
183 kDefaultAtMostNumMatches, | 184 kDefaultAtMostNumMatches, |
184 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 185 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
185 base::RunLoop().RunUntilIdle(); | 186 base::RunLoop().RunUntilIdle(); |
186 EXPECT_EQ(FILE_ERROR_OK, error); | 187 EXPECT_EQ(FILE_ERROR_OK, error); |
187 ASSERT_TRUE(result); | 188 ASSERT_TRUE(result); |
188 ASSERT_EQ(1U, result->size()); | 189 ASSERT_EQ(1U, result->size()); |
189 EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt", | 190 EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt", |
190 result->at(0).path.AsUTF8Unsafe()); | 191 result->at(0).path.AsUTF8Unsafe()); |
191 } | 192 } |
192 | 193 |
193 // This test checks if |FindAndHighlightWrapper| does case-insensitive search. | 194 // This test checks if |FindAndHighlightWrapper| does case-insensitive search. |
194 // Tricker test cases for |FindAndHighlightWrapper| can be found below. | 195 // Tricker test cases for |FindAndHighlightWrapper| can be found below. |
195 TEST_F(SearchMetadataTest, SearchMetadata_CaseInsensitiveSearch) { | 196 TEST_F(SearchMetadataTest, SearchMetadata_CaseInsensitiveSearch) { |
196 FileError error = FILE_ERROR_FAILED; | 197 FileError error = FILE_ERROR_FAILED; |
197 scoped_ptr<MetadataSearchResultVector> result; | 198 scoped_ptr<MetadataSearchResultVector> result; |
198 | 199 |
199 // The query is all in lower case. | 200 // The query is all in lower case. |
200 SearchMetadata( | 201 SearchMetadata( |
201 base::MessageLoopProxy::current(), resource_metadata_.get(), | 202 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), |
202 "subdirectory file 1.txt", base::Bind(&MatchesType, SEARCH_METADATA_ALL), | 203 "subdirectory file 1.txt", base::Bind(&MatchesType, SEARCH_METADATA_ALL), |
203 kDefaultAtMostNumMatches, | 204 kDefaultAtMostNumMatches, |
204 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 205 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
205 base::RunLoop().RunUntilIdle(); | 206 base::RunLoop().RunUntilIdle(); |
206 EXPECT_EQ(FILE_ERROR_OK, error); | 207 EXPECT_EQ(FILE_ERROR_OK, error); |
207 ASSERT_TRUE(result); | 208 ASSERT_TRUE(result); |
208 ASSERT_EQ(1U, result->size()); | 209 ASSERT_EQ(1U, result->size()); |
209 EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt", | 210 EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt", |
210 result->at(0).path.AsUTF8Unsafe()); | 211 result->at(0).path.AsUTF8Unsafe()); |
211 } | 212 } |
212 | 213 |
213 TEST_F(SearchMetadataTest, SearchMetadata_RegularFiles) { | 214 TEST_F(SearchMetadataTest, SearchMetadata_RegularFiles) { |
214 FileError error = FILE_ERROR_FAILED; | 215 FileError error = FILE_ERROR_FAILED; |
215 scoped_ptr<MetadataSearchResultVector> result; | 216 scoped_ptr<MetadataSearchResultVector> result; |
216 | 217 |
217 SearchMetadata( | 218 SearchMetadata( |
218 base::MessageLoopProxy::current(), resource_metadata_.get(), "SubDir", | 219 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "SubDir", |
219 base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches, | 220 base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches, |
220 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 221 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
221 base::RunLoop().RunUntilIdle(); | 222 base::RunLoop().RunUntilIdle(); |
222 EXPECT_EQ(FILE_ERROR_OK, error); | 223 EXPECT_EQ(FILE_ERROR_OK, error); |
223 ASSERT_TRUE(result); | 224 ASSERT_TRUE(result); |
224 ASSERT_EQ(2U, result->size()); | 225 ASSERT_EQ(2U, result->size()); |
225 | 226 |
226 // All base names should contain "File". The results should be sorted by the | 227 // All base names should contain "File". The results should be sorted by the |
227 // last accessed time in descending order. | 228 // last accessed time in descending order. |
228 EXPECT_EQ("drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt", | 229 EXPECT_EQ("drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt", |
229 result->at(0).path.AsUTF8Unsafe()); | 230 result->at(0).path.AsUTF8Unsafe()); |
230 EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt", | 231 EXPECT_EQ("drive/root/Directory 1/SubDirectory File 1.txt", |
231 result->at(1).path.AsUTF8Unsafe()); | 232 result->at(1).path.AsUTF8Unsafe()); |
232 } | 233 } |
233 | 234 |
234 TEST_F(SearchMetadataTest, SearchMetadata_AtMostOneFile) { | 235 TEST_F(SearchMetadataTest, SearchMetadata_AtMostOneFile) { |
235 FileError error = FILE_ERROR_FAILED; | 236 FileError error = FILE_ERROR_FAILED; |
236 scoped_ptr<MetadataSearchResultVector> result; | 237 scoped_ptr<MetadataSearchResultVector> result; |
237 | 238 |
238 // There are two files matching "SubDir" but only one file should be | 239 // There are two files matching "SubDir" but only one file should be |
239 // returned. | 240 // returned. |
240 SearchMetadata( | 241 SearchMetadata( |
241 base::MessageLoopProxy::current(), resource_metadata_.get(), "SubDir", | 242 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "SubDir", |
242 base::Bind(&MatchesType, SEARCH_METADATA_ALL), | 243 base::Bind(&MatchesType, SEARCH_METADATA_ALL), |
243 1, // at_most_num_matches | 244 1, // at_most_num_matches |
244 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 245 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
245 base::RunLoop().RunUntilIdle(); | 246 base::RunLoop().RunUntilIdle(); |
246 EXPECT_EQ(FILE_ERROR_OK, error); | 247 EXPECT_EQ(FILE_ERROR_OK, error); |
247 ASSERT_TRUE(result); | 248 ASSERT_TRUE(result); |
248 ASSERT_EQ(1U, result->size()); | 249 ASSERT_EQ(1U, result->size()); |
249 EXPECT_EQ("drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt", | 250 EXPECT_EQ("drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt", |
250 result->at(0).path.AsUTF8Unsafe()); | 251 result->at(0).path.AsUTF8Unsafe()); |
251 } | 252 } |
252 | 253 |
253 TEST_F(SearchMetadataTest, SearchMetadata_Directory) { | 254 TEST_F(SearchMetadataTest, SearchMetadata_Directory) { |
254 FileError error = FILE_ERROR_FAILED; | 255 FileError error = FILE_ERROR_FAILED; |
255 scoped_ptr<MetadataSearchResultVector> result; | 256 scoped_ptr<MetadataSearchResultVector> result; |
256 | 257 |
257 SearchMetadata( | 258 SearchMetadata( |
258 base::MessageLoopProxy::current(), resource_metadata_.get(), | 259 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), |
259 "Directory 1", base::Bind(&MatchesType, SEARCH_METADATA_ALL), | 260 "Directory 1", base::Bind(&MatchesType, SEARCH_METADATA_ALL), |
260 kDefaultAtMostNumMatches, | 261 kDefaultAtMostNumMatches, |
261 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 262 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
262 base::RunLoop().RunUntilIdle(); | 263 base::RunLoop().RunUntilIdle(); |
263 EXPECT_EQ(FILE_ERROR_OK, error); | 264 EXPECT_EQ(FILE_ERROR_OK, error); |
264 ASSERT_TRUE(result); | 265 ASSERT_TRUE(result); |
265 ASSERT_EQ(1U, result->size()); | 266 ASSERT_EQ(1U, result->size()); |
266 EXPECT_EQ("drive/root/Directory 1", result->at(0).path.AsUTF8Unsafe()); | 267 EXPECT_EQ("drive/root/Directory 1", result->at(0).path.AsUTF8Unsafe()); |
267 } | 268 } |
268 | 269 |
269 TEST_F(SearchMetadataTest, SearchMetadata_HostedDocument) { | 270 TEST_F(SearchMetadataTest, SearchMetadata_HostedDocument) { |
270 FileError error = FILE_ERROR_FAILED; | 271 FileError error = FILE_ERROR_FAILED; |
271 scoped_ptr<MetadataSearchResultVector> result; | 272 scoped_ptr<MetadataSearchResultVector> result; |
272 | 273 |
273 SearchMetadata( | 274 SearchMetadata( |
274 base::MessageLoopProxy::current(), resource_metadata_.get(), "Document", | 275 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "Document", |
275 base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches, | 276 base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches, |
276 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 277 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
277 base::RunLoop().RunUntilIdle(); | 278 base::RunLoop().RunUntilIdle(); |
278 EXPECT_EQ(FILE_ERROR_OK, error); | 279 EXPECT_EQ(FILE_ERROR_OK, error); |
279 ASSERT_TRUE(result); | 280 ASSERT_TRUE(result); |
280 ASSERT_EQ(1U, result->size()); | 281 ASSERT_EQ(1U, result->size()); |
281 | 282 |
282 EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc", | 283 EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc", |
283 result->at(0).path.AsUTF8Unsafe()); | 284 result->at(0).path.AsUTF8Unsafe()); |
284 } | 285 } |
285 | 286 |
286 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeHostedDocument) { | 287 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeHostedDocument) { |
287 FileError error = FILE_ERROR_FAILED; | 288 FileError error = FILE_ERROR_FAILED; |
288 scoped_ptr<MetadataSearchResultVector> result; | 289 scoped_ptr<MetadataSearchResultVector> result; |
289 | 290 |
290 SearchMetadata( | 291 SearchMetadata( |
291 base::MessageLoopProxy::current(), resource_metadata_.get(), "Document", | 292 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "Document", |
292 base::Bind(&MatchesType, SEARCH_METADATA_EXCLUDE_HOSTED_DOCUMENTS), | 293 base::Bind(&MatchesType, SEARCH_METADATA_EXCLUDE_HOSTED_DOCUMENTS), |
293 kDefaultAtMostNumMatches, | 294 kDefaultAtMostNumMatches, |
294 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 295 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
295 base::RunLoop().RunUntilIdle(); | 296 base::RunLoop().RunUntilIdle(); |
296 EXPECT_EQ(FILE_ERROR_OK, error); | 297 EXPECT_EQ(FILE_ERROR_OK, error); |
297 ASSERT_TRUE(result); | 298 ASSERT_TRUE(result); |
298 ASSERT_EQ(0U, result->size()); | 299 ASSERT_EQ(0U, result->size()); |
299 } | 300 } |
300 | 301 |
301 TEST_F(SearchMetadataTest, SearchMetadata_SharedWithMe) { | 302 TEST_F(SearchMetadataTest, SearchMetadata_SharedWithMe) { |
302 FileError error = FILE_ERROR_FAILED; | 303 FileError error = FILE_ERROR_FAILED; |
303 scoped_ptr<MetadataSearchResultVector> result; | 304 scoped_ptr<MetadataSearchResultVector> result; |
304 | 305 |
305 SearchMetadata( | 306 SearchMetadata( |
306 base::MessageLoopProxy::current(), resource_metadata_.get(), "", | 307 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "", |
307 base::Bind(&MatchesType, SEARCH_METADATA_SHARED_WITH_ME), | 308 base::Bind(&MatchesType, SEARCH_METADATA_SHARED_WITH_ME), |
308 kDefaultAtMostNumMatches, | 309 kDefaultAtMostNumMatches, |
309 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 310 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
310 base::RunLoop().RunUntilIdle(); | 311 base::RunLoop().RunUntilIdle(); |
311 EXPECT_EQ(FILE_ERROR_OK, error); | 312 EXPECT_EQ(FILE_ERROR_OK, error); |
312 ASSERT_TRUE(result); | 313 ASSERT_TRUE(result); |
313 ASSERT_EQ(1U, result->size()); | 314 ASSERT_EQ(1U, result->size()); |
314 EXPECT_EQ("drive/root/Directory 1/Shared To The Account Owner.txt", | 315 EXPECT_EQ("drive/root/Directory 1/Shared To The Account Owner.txt", |
315 result->at(0).path.AsUTF8Unsafe()); | 316 result->at(0).path.AsUTF8Unsafe()); |
316 } | 317 } |
317 | 318 |
318 TEST_F(SearchMetadataTest, SearchMetadata_FileAndDirectory) { | 319 TEST_F(SearchMetadataTest, SearchMetadata_FileAndDirectory) { |
319 FileError error = FILE_ERROR_FAILED; | 320 FileError error = FILE_ERROR_FAILED; |
320 scoped_ptr<MetadataSearchResultVector> result; | 321 scoped_ptr<MetadataSearchResultVector> result; |
321 | 322 |
322 SearchMetadata( | 323 SearchMetadata( |
323 base::MessageLoopProxy::current(), resource_metadata_.get(), | 324 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), |
324 "excludeDir-test", base::Bind(&MatchesType, SEARCH_METADATA_ALL), | 325 "excludeDir-test", base::Bind(&MatchesType, SEARCH_METADATA_ALL), |
325 kDefaultAtMostNumMatches, | 326 kDefaultAtMostNumMatches, |
326 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 327 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
327 | 328 |
328 base::RunLoop().RunUntilIdle(); | 329 base::RunLoop().RunUntilIdle(); |
329 EXPECT_EQ(FILE_ERROR_OK, error); | 330 EXPECT_EQ(FILE_ERROR_OK, error); |
330 ASSERT_TRUE(result); | 331 ASSERT_TRUE(result); |
331 ASSERT_EQ(2U, result->size()); | 332 ASSERT_EQ(2U, result->size()); |
332 | 333 |
333 EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc", | 334 EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc", |
334 result->at(0).path.AsUTF8Unsafe()); | 335 result->at(0).path.AsUTF8Unsafe()); |
335 EXPECT_EQ("drive/root/Directory 2 excludeDir-test", | 336 EXPECT_EQ("drive/root/Directory 2 excludeDir-test", |
336 result->at(1).path.AsUTF8Unsafe()); | 337 result->at(1).path.AsUTF8Unsafe()); |
337 } | 338 } |
338 | 339 |
339 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeDirectory) { | 340 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeDirectory) { |
340 FileError error = FILE_ERROR_FAILED; | 341 FileError error = FILE_ERROR_FAILED; |
341 scoped_ptr<MetadataSearchResultVector> result; | 342 scoped_ptr<MetadataSearchResultVector> result; |
342 | 343 |
343 SearchMetadata( | 344 SearchMetadata( |
344 base::MessageLoopProxy::current(), resource_metadata_.get(), | 345 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), |
345 "excludeDir-test", | 346 "excludeDir-test", |
346 base::Bind(&MatchesType, SEARCH_METADATA_EXCLUDE_DIRECTORIES), | 347 base::Bind(&MatchesType, SEARCH_METADATA_EXCLUDE_DIRECTORIES), |
347 kDefaultAtMostNumMatches, | 348 kDefaultAtMostNumMatches, |
348 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 349 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
349 | 350 |
350 base::RunLoop().RunUntilIdle(); | 351 base::RunLoop().RunUntilIdle(); |
351 EXPECT_EQ(FILE_ERROR_OK, error); | 352 EXPECT_EQ(FILE_ERROR_OK, error); |
352 ASSERT_TRUE(result); | 353 ASSERT_TRUE(result); |
353 ASSERT_EQ(1U, result->size()); | 354 ASSERT_EQ(1U, result->size()); |
354 | 355 |
355 EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc", | 356 EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc", |
356 result->at(0).path.AsUTF8Unsafe()); | 357 result->at(0).path.AsUTF8Unsafe()); |
357 } | 358 } |
358 | 359 |
359 // "drive", "drive/root", "drive/other" should be excluded. | 360 // "drive", "drive/root", "drive/other" should be excluded. |
360 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeSpecialDirectories) { | 361 TEST_F(SearchMetadataTest, SearchMetadata_ExcludeSpecialDirectories) { |
361 const char* const kQueries[] = { "drive", "root", "other" }; | 362 const char* const kQueries[] = { "drive", "root", "other" }; |
362 for (size_t i = 0; i < arraysize(kQueries); ++i) { | 363 for (size_t i = 0; i < arraysize(kQueries); ++i) { |
363 FileError error = FILE_ERROR_FAILED; | 364 FileError error = FILE_ERROR_FAILED; |
364 scoped_ptr<MetadataSearchResultVector> result; | 365 scoped_ptr<MetadataSearchResultVector> result; |
365 | 366 |
366 const std::string query = kQueries[i]; | 367 const std::string query = kQueries[i]; |
367 SearchMetadata( | 368 SearchMetadata( |
368 base::MessageLoopProxy::current(), resource_metadata_.get(), query, | 369 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), query, |
369 base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches, | 370 base::Bind(&MatchesType, SEARCH_METADATA_ALL), kDefaultAtMostNumMatches, |
370 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 371 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
371 | 372 |
372 base::RunLoop().RunUntilIdle(); | 373 base::RunLoop().RunUntilIdle(); |
373 EXPECT_EQ(FILE_ERROR_OK, error); | 374 EXPECT_EQ(FILE_ERROR_OK, error); |
374 ASSERT_TRUE(result); | 375 ASSERT_TRUE(result); |
375 ASSERT_TRUE(result->empty()) << ": " << query << " should not match"; | 376 ASSERT_TRUE(result->empty()) << ": " << query << " should not match"; |
376 } | 377 } |
377 } | 378 } |
378 | 379 |
379 TEST_F(SearchMetadataTest, SearchMetadata_Offline) { | 380 TEST_F(SearchMetadataTest, SearchMetadata_Offline) { |
380 FileError error = FILE_ERROR_FAILED; | 381 FileError error = FILE_ERROR_FAILED; |
381 scoped_ptr<MetadataSearchResultVector> result; | 382 scoped_ptr<MetadataSearchResultVector> result; |
382 | 383 |
383 SearchMetadata( | 384 SearchMetadata( |
384 base::MessageLoopProxy::current(), resource_metadata_.get(), "", | 385 base::ThreadTaskRunnerHandle::Get(), resource_metadata_.get(), "", |
385 base::Bind(&MatchesType, SEARCH_METADATA_OFFLINE), | 386 base::Bind(&MatchesType, SEARCH_METADATA_OFFLINE), |
386 kDefaultAtMostNumMatches, | 387 kDefaultAtMostNumMatches, |
387 google_apis::test_util::CreateCopyResultCallback(&error, &result)); | 388 google_apis::test_util::CreateCopyResultCallback(&error, &result)); |
388 base::RunLoop().RunUntilIdle(); | 389 base::RunLoop().RunUntilIdle(); |
389 EXPECT_EQ(FILE_ERROR_OK, error); | 390 EXPECT_EQ(FILE_ERROR_OK, error); |
390 ASSERT_EQ(3U, result->size()); | 391 ASSERT_EQ(3U, result->size()); |
391 | 392 |
392 // This is not included in the cache but is a hosted document. | 393 // This is not included in the cache but is a hosted document. |
393 EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc", | 394 EXPECT_EQ("drive/root/Document 1 excludeDir-test.gdoc", |
394 result->at(0).path.AsUTF8Unsafe()); | 395 result->at(0).path.AsUTF8Unsafe()); |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
490 } | 491 } |
491 | 492 |
492 TEST(SearchMetadataSimpleTest, FindAndHighlight_MoreMetaChars) { | 493 TEST(SearchMetadataSimpleTest, FindAndHighlight_MoreMetaChars) { |
493 std::string highlighted_text; | 494 std::string highlighted_text; |
494 EXPECT_TRUE(FindAndHighlightWrapper("a&b&c&d", "b&c", &highlighted_text)); | 495 EXPECT_TRUE(FindAndHighlightWrapper("a&b&c&d", "b&c", &highlighted_text)); |
495 EXPECT_EQ("a&<b>b&c</b>&d", highlighted_text); | 496 EXPECT_EQ("a&<b>b&c</b>&d", highlighted_text); |
496 } | 497 } |
497 | 498 |
498 } // namespace internal | 499 } // namespace internal |
499 } // namespace drive | 500 } // namespace drive |
OLD | NEW |