Chromium Code Reviews Chromium Code Reviews
Issue 13986011:
SyncFS: Introduce RemoteSyncOperationResolver for directory operation support (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src| OLD | NEW |
|---|---|
| (Empty) | |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <vector> | |
| 6 | |
| 7 #include "chrome/browser/sync_file_system/remote_sync_operation_resolver.h" | |
| 8 #include "testing/gtest/include/gtest/gtest.h" | |
| 9 #include "webkit/fileapi/syncable/file_change.h" | |
| 10 #include "webkit/fileapi/syncable/sync_file_type.h" | |
| 11 | |
| 12 namespace sync_file_system { | |
| 13 | |
| 14 namespace { | |
| 15 | |
| 16 struct Input { | |
| 17 SyncFileType local_file_type; | |
| 18 FileChangeList local_changes; | |
| 19 }; | |
| 20 | |
| 21 template <typename type, size_t array_size> | |
| 22 std::vector<type> CreateList(const type (&inputs)[array_size]) { | |
| 23 return std::vector<type>(inputs, inputs + array_size); | |
| 24 } | |
| 25 | |
| 26 FileChangeList CreateNoneChange() { | |
|
kinuko
2013/04/24 14:54:50
nit: None -> Empty?
nhiroki
2013/04/25 06:54:43
Done.
| |
| 27 return FileChangeList(); | |
| 28 } | |
| 29 | |
| 30 FileChangeList CreateAddOrUpdateFileChange() { | |
| 31 FileChangeList list; | |
| 32 list.Update(FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE, | |
| 33 SYNC_FILE_TYPE_FILE)); | |
| 34 return list; | |
| 35 } | |
| 36 | |
| 37 FileChangeList CreateAddDirectoryChange() { | |
| 38 FileChangeList list; | |
| 39 list.Update(FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE, | |
| 40 SYNC_FILE_TYPE_DIRECTORY)); | |
| 41 return list; | |
| 42 } | |
| 43 | |
| 44 FileChangeList CreateDeleteFileChange() { | |
| 45 FileChangeList list; | |
| 46 list.Update(FileChange(FileChange::FILE_CHANGE_DELETE, | |
| 47 SYNC_FILE_TYPE_FILE)); | |
| 48 return list; | |
| 49 } | |
| 50 | |
| 51 FileChangeList CreateDeleteDirectoryChange() { | |
| 52 FileChangeList list; | |
| 53 list.Update(FileChange(FileChange::FILE_CHANGE_DELETE, | |
| 54 SYNC_FILE_TYPE_DIRECTORY)); | |
| 55 return list; | |
| 56 } | |
| 57 | |
| 58 std::vector<Input> CreateInput() { | |
| 59 const Input inputs[] = { | |
| 60 { SYNC_FILE_TYPE_UNKNOWN, CreateNoneChange() }, | |
| 61 { SYNC_FILE_TYPE_UNKNOWN, CreateAddOrUpdateFileChange() }, | |
| 62 { SYNC_FILE_TYPE_UNKNOWN, CreateAddDirectoryChange() }, | |
| 63 { SYNC_FILE_TYPE_UNKNOWN, CreateDeleteFileChange() }, | |
| 64 { SYNC_FILE_TYPE_UNKNOWN, CreateDeleteDirectoryChange() }, | |
| 65 | |
| 66 { SYNC_FILE_TYPE_FILE, CreateNoneChange() }, | |
| 67 { SYNC_FILE_TYPE_FILE, CreateAddOrUpdateFileChange() }, | |
| 68 { SYNC_FILE_TYPE_FILE, CreateAddDirectoryChange() }, | |
| 69 { SYNC_FILE_TYPE_FILE, CreateDeleteFileChange() }, | |
| 70 { SYNC_FILE_TYPE_FILE, CreateDeleteDirectoryChange() }, | |
| 71 | |
| 72 { SYNC_FILE_TYPE_DIRECTORY, CreateNoneChange() }, | |
| 73 { SYNC_FILE_TYPE_DIRECTORY, CreateAddOrUpdateFileChange() }, | |
| 74 { SYNC_FILE_TYPE_DIRECTORY, CreateAddDirectoryChange() }, | |
| 75 { SYNC_FILE_TYPE_DIRECTORY, CreateDeleteFileChange() }, | |
| 76 { SYNC_FILE_TYPE_DIRECTORY, CreateDeleteDirectoryChange() }, | |
| 77 }; | |
| 78 return CreateList(inputs); | |
| 79 } | |
| 80 | |
| 81 } // namespace | |
| 82 | |
| 83 class RemoteSyncOperationResolverTest : public testing::Test { | |
| 84 public: | |
| 85 RemoteSyncOperationResolverTest() {} | |
| 86 | |
| 87 protected: | |
| 88 typedef RemoteSyncOperationResolver Resolver; | |
| 89 typedef std::vector<Resolver::RemoteSyncOperationType> ExpectedTypes; | |
| 90 | |
| 91 void VerifyResolveForAddOrUpdateFile( | |
|
kinuko
2013/04/24 14:54:50
Are these Verify* helper methods in order to acces
nhiroki
2013/04/25 06:54:43
Done.
| |
| 92 Resolver::RemoteSyncOperationType expected_type, | |
| 93 const Input& input) { | |
| 94 EXPECT_EQ(expected_type, | |
| 95 Resolver::ResolveForAddOrUpdateFile( | |
| 96 input.local_changes, input.local_file_type)); | |
| 97 } | |
| 98 | |
| 99 void VerifyResolveForAddOrUpdateFileInConflict( | |
| 100 Resolver::RemoteSyncOperationType expected_type, | |
| 101 const Input& input) { | |
| 102 EXPECT_EQ(expected_type, | |
| 103 Resolver::ResolveForAddOrUpdateFileInConflict( | |
| 104 input.local_changes, input.local_file_type)); | |
| 105 } | |
| 106 | |
| 107 void VerifyResolveForAddDirectory( | |
| 108 Resolver::RemoteSyncOperationType expected_type, | |
| 109 const Input& input) { | |
| 110 EXPECT_EQ(expected_type, | |
| 111 Resolver::ResolveForAddDirectory( | |
| 112 input.local_changes, input.local_file_type)); | |
| 113 } | |
| 114 | |
| 115 void VerifyResolveForAddDirectoryInConflict( | |
| 116 Resolver::RemoteSyncOperationType expected_type, | |
| 117 const Input& input) { | |
| 118 EXPECT_EQ(expected_type, | |
| 119 Resolver::ResolveForAddDirectoryInConflict( | |
| 120 input.local_changes, input.local_file_type)); | |
| 121 } | |
| 122 | |
| 123 void VerifyResolveForDeleteFile( | |
| 124 Resolver::RemoteSyncOperationType expected_type, | |
| 125 const Input& input) { | |
| 126 EXPECT_EQ(expected_type, | |
| 127 Resolver::ResolveForDeleteFile( | |
| 128 input.local_changes, input.local_file_type)); | |
| 129 } | |
| 130 | |
| 131 void VerifyResolveForDeleteFileInConflict( | |
| 132 Resolver::RemoteSyncOperationType expected_type, | |
| 133 const Input& input) { | |
| 134 EXPECT_EQ(expected_type, | |
| 135 Resolver::ResolveForDeleteFileInConflict( | |
| 136 input.local_changes, input.local_file_type)); | |
| 137 } | |
| 138 | |
| 139 void VerifyResolveForDeleteDirectory( | |
| 140 Resolver::RemoteSyncOperationType expected_type, | |
| 141 const Input& input) { | |
| 142 EXPECT_EQ(expected_type, | |
| 143 Resolver::ResolveForDeleteDirectory( | |
| 144 input.local_changes, input.local_file_type)); | |
| 145 } | |
| 146 | |
| 147 void VerifyResolveForDeleteDirectoryInConflict( | |
| 148 Resolver::RemoteSyncOperationType expected_type, | |
| 149 const Input& input) { | |
| 150 EXPECT_EQ(expected_type, | |
| 151 Resolver::ResolveForDeleteDirectoryInConflict( | |
| 152 input.local_changes, input.local_file_type)); | |
| 153 } | |
| 154 | |
| 155 DISALLOW_COPY_AND_ASSIGN(RemoteSyncOperationResolverTest); | |
| 156 }; | |
| 157 | |
| 158 TEST_F(RemoteSyncOperationResolverTest, ResolveForAddOrUpdateFile) { | |
| 159 const Resolver::RemoteSyncOperationType kExpectedTypes[] = { | |
| 160 Resolver::REMOTE_SYNC_OPERATION_ADD_FILE, | |
| 161 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 162 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 163 Resolver::REMOTE_SYNC_OPERATION_ADD_FILE, | |
| 164 Resolver::REMOTE_SYNC_OPERATION_ADD_FILE, | |
| 165 | |
| 166 Resolver::REMOTE_SYNC_OPERATION_UPDATE_FILE, | |
| 167 Resolver::REMOTE_SYNC_OPERATION_CONFLICT, | |
| 168 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 169 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 170 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 171 | |
| 172 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 173 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 174 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 175 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 176 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 177 }; | |
| 178 | |
| 179 ExpectedTypes expected_types = CreateList(kExpectedTypes); | |
| 180 std::vector<Input> inputs = CreateInput(); | |
| 181 | |
| 182 ASSERT_EQ(expected_types.size(), inputs.size()); | |
| 183 for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i) | |
| 184 VerifyResolveForAddOrUpdateFile(expected_types[i], inputs[i]); | |
| 185 } | |
| 186 | |
| 187 TEST_F(RemoteSyncOperationResolverTest, ResolveForAddOrUpdateFileInConflict) { | |
| 188 const Resolver::RemoteSyncOperationType kExpectedTypes[] = { | |
| 189 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 190 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 191 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 192 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE, | |
| 193 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE, | |
| 194 | |
| 195 Resolver::REMOTE_SYNC_OPERATION_CONFLICT, | |
| 196 Resolver::REMOTE_SYNC_OPERATION_CONFLICT, | |
| 197 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 198 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 199 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 200 | |
| 201 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 202 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 203 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 204 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 205 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 206 }; | |
| 207 | |
| 208 ExpectedTypes expected_types = CreateList(kExpectedTypes); | |
| 209 std::vector<Input> inputs = CreateInput(); | |
| 210 | |
| 211 ASSERT_EQ(expected_types.size(), inputs.size()); | |
| 212 for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i) | |
| 213 VerifyResolveForAddOrUpdateFileInConflict(expected_types[i], inputs[i]); | |
| 214 } | |
| 215 | |
| 216 TEST_F(RemoteSyncOperationResolverTest, ResolveForAddDirectory) { | |
| 217 const Resolver::RemoteSyncOperationType kExpectedTypes[] = { | |
| 218 Resolver::REMOTE_SYNC_OPERATION_ADD_DIRECTORY, | |
| 219 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 220 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 221 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE, | |
| 222 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE, | |
| 223 | |
| 224 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE, | |
| 225 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE, | |
| 226 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 227 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 228 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 229 | |
| 230 Resolver::REMOTE_SYNC_OPERATION_NONE, | |
| 231 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 232 Resolver::REMOTE_SYNC_OPERATION_NONE, | |
| 233 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 234 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 235 }; | |
| 236 | |
| 237 ExpectedTypes expected_types = CreateList(kExpectedTypes); | |
| 238 std::vector<Input> inputs = CreateInput(); | |
| 239 | |
| 240 ASSERT_EQ(expected_types.size(), inputs.size()); | |
| 241 for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i) | |
| 242 VerifyResolveForAddDirectory(expected_types[i], inputs[i]); | |
| 243 } | |
| 244 | |
| 245 TEST_F(RemoteSyncOperationResolverTest, ResolveForAddDirectoryInConflict) { | |
| 246 const Resolver::RemoteSyncOperationType kExpectedTypes[] = { | |
| 247 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 248 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 249 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 250 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE, | |
| 251 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE, | |
| 252 | |
| 253 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE, | |
| 254 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_REMOTE, | |
| 255 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 256 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 257 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 258 | |
| 259 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 260 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 261 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 262 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 263 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 264 }; | |
| 265 | |
| 266 ExpectedTypes expected_types = CreateList(kExpectedTypes); | |
| 267 std::vector<Input> inputs = CreateInput(); | |
| 268 | |
| 269 ASSERT_EQ(expected_types.size(), inputs.size()); | |
| 270 for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i) | |
| 271 VerifyResolveForAddDirectoryInConflict(expected_types[i], inputs[i]); | |
| 272 } | |
| 273 | |
| 274 TEST_F(RemoteSyncOperationResolverTest, ResolveForDeleteFile) { | |
| 275 const Resolver::RemoteSyncOperationType kExpectedTypes[] = { | |
| 276 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 277 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 278 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 279 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 280 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 281 | |
| 282 Resolver::REMOTE_SYNC_OPERATION_DELETE_FILE, | |
| 283 Resolver::REMOTE_SYNC_OPERATION_NONE, | |
| 284 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 285 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 286 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 287 | |
| 288 Resolver::REMOTE_SYNC_OPERATION_NONE, | |
| 289 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 290 Resolver::REMOTE_SYNC_OPERATION_NONE, | |
| 291 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 292 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 293 }; | |
| 294 | |
| 295 ExpectedTypes expected_types = CreateList(kExpectedTypes); | |
| 296 std::vector<Input> inputs = CreateInput(); | |
| 297 | |
| 298 ASSERT_EQ(expected_types.size(), inputs.size()); | |
| 299 for (ExpectedTypes::size_type i = 0; i < inputs.size(); ++i) | |
| 300 VerifyResolveForDeleteFile(expected_types[i], inputs[i]); | |
| 301 } | |
| 302 | |
| 303 TEST_F(RemoteSyncOperationResolverTest, ResolveForDeleteFileInConflict) { | |
| 304 const Resolver::RemoteSyncOperationType kExpectedTypes[] = { | |
| 305 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 306 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 307 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 308 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 309 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 310 | |
| 311 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 312 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 313 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 314 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 315 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 316 | |
| 317 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 318 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 319 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 320 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 321 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 322 }; | |
| 323 | |
| 324 ExpectedTypes expected_types = CreateList(kExpectedTypes); | |
| 325 std::vector<Input> inputs = CreateInput(); | |
| 326 | |
| 327 ASSERT_EQ(expected_types.size(), inputs.size()); | |
| 328 for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i) | |
| 329 VerifyResolveForDeleteFileInConflict(expected_types[i], inputs[i]); | |
| 330 } | |
| 331 | |
| 332 TEST_F(RemoteSyncOperationResolverTest, ResolveForDeleteDirectory) { | |
| 333 const Resolver::RemoteSyncOperationType kExpectedTypes[] = { | |
| 334 Resolver::REMOTE_SYNC_OPERATION_NONE, | |
| 335 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 336 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 337 Resolver::REMOTE_SYNC_OPERATION_NONE, | |
| 338 Resolver::REMOTE_SYNC_OPERATION_NONE, | |
| 339 | |
| 340 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 341 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 342 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 343 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 344 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 345 | |
| 346 Resolver::REMOTE_SYNC_OPERATION_DELETE_DIRECTORY, | |
| 347 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 348 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 349 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 350 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 351 }; | |
| 352 | |
| 353 ExpectedTypes expected_types = CreateList(kExpectedTypes); | |
| 354 std::vector<Input> inputs = CreateInput(); | |
| 355 | |
| 356 ASSERT_EQ(expected_types.size(), inputs.size()); | |
| 357 for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i) | |
| 358 VerifyResolveForDeleteDirectory(expected_types[i], inputs[i]); | |
| 359 } | |
| 360 | |
| 361 TEST_F(RemoteSyncOperationResolverTest, ResolveForDeleteDirectoryInConflict) { | |
| 362 const Resolver::RemoteSyncOperationType kExpectedTypes[] = { | |
| 363 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 364 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 365 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 366 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 367 Resolver::REMOTE_SYNC_OPERATION_DELETE_METADATA, | |
| 368 | |
| 369 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 370 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 371 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 372 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 373 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 374 | |
| 375 Resolver::REMOTE_SYNC_OPERATION_DELETE_DIRECTORY, | |
| 376 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 377 Resolver::REMOTE_SYNC_OPERATION_RESOLVE_TO_LOCAL, | |
| 378 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 379 Resolver::REMOTE_SYNC_OPERATION_FAIL, | |
| 380 }; | |
| 381 | |
| 382 ExpectedTypes expected_types = CreateList(kExpectedTypes); | |
| 383 std::vector<Input> inputs = CreateInput(); | |
| 384 | |
| 385 ASSERT_EQ(expected_types.size(), inputs.size()); | |
| 386 for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i) | |
| 387 VerifyResolveForDeleteDirectoryInConflict(expected_types[i], inputs[i]); | |
| 388 } | |
| 389 | |
| 390 } // namespace sync_file_system | |
| OLD | NEW |
