OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 "base/bind.h" | 5 #include "base/bind.h" |
6 #include "base/macros.h" | 6 #include "base/macros.h" |
| 7 #include "base/run_loop.h" |
7 #include "components/filesystem/public/interfaces/directory.mojom.h" | 8 #include "components/filesystem/public/interfaces/directory.mojom.h" |
8 #include "components/filesystem/public/interfaces/file_system.mojom.h" | 9 #include "components/filesystem/public/interfaces/file_system.mojom.h" |
9 #include "components/filesystem/public/interfaces/types.mojom.h" | 10 #include "components/filesystem/public/interfaces/types.mojom.h" |
10 #include "components/leveldb/public/interfaces/leveldb.mojom.h" | 11 #include "components/leveldb/public/interfaces/leveldb.mojom.h" |
11 #include "mojo/common/common_type_converters.h" | 12 #include "mojo/common/common_type_converters.h" |
12 #include "mojo/public/cpp/bindings/binding_set.h" | 13 #include "mojo/public/cpp/bindings/binding_set.h" |
13 #include "services/shell/public/cpp/shell_connection.h" | 14 #include "services/shell/public/cpp/shell_connection.h" |
14 #include "services/shell/public/cpp/shell_test.h" | 15 #include "services/shell/public/cpp/shell_test.h" |
15 | 16 |
16 using filesystem::mojom::FileError; | 17 using filesystem::mojom::FileError; |
17 | 18 |
18 namespace leveldb { | 19 namespace leveldb { |
19 namespace { | 20 namespace { |
20 | 21 |
21 template <typename... Args> void IgnoreAllArgs(Args&&...) {} | 22 template <typename... Args> void IgnoreAllArgs(Args&&...) {} |
22 | 23 |
23 template <typename... Args> | 24 template <typename... Args> |
24 void DoCaptures(Args*... out_args, Args... in_args) { | 25 void DoCaptures(Args*... out_args, |
| 26 const base::Closure& quit_closure, |
| 27 Args... in_args) { |
25 IgnoreAllArgs((*out_args = std::move(in_args))...); | 28 IgnoreAllArgs((*out_args = std::move(in_args))...); |
| 29 quit_closure.Run(); |
26 } | 30 } |
27 | 31 |
28 template <typename T1> | 32 template <typename T1> |
29 base::Callback<void(T1)> Capture(T1* t1) { | 33 base::Callback<void(T1)> Capture(T1* t1, const base::Closure& quit_closure) { |
30 return base::Bind(&DoCaptures<T1>, t1); | 34 return base::Bind(&DoCaptures<T1>, t1, quit_closure); |
31 } | 35 } |
32 | 36 |
33 template <typename T1, typename T2> | 37 template <typename T1, typename T2> |
34 base::Callback<void(T1, T2)> Capture(T1* t1, T2* t2) { | 38 base::Callback<void(T1, T2)> Capture(T1* t1, |
35 return base::Bind(&DoCaptures<T1, T2>, t1, t2); | 39 T2* t2, |
| 40 const base::Closure& quit_closure) { |
| 41 return base::Bind(&DoCaptures<T1, T2>, t1, t2, quit_closure); |
| 42 } |
| 43 |
| 44 void DatabaseSyncPut(mojom::LevelDBDatabase* database, |
| 45 mojo::Array<uint8_t> key, |
| 46 mojo::Array<uint8_t> value, |
| 47 mojom::DatabaseError* out_error) { |
| 48 base::RunLoop run_loop; |
| 49 database->Put(std::move(key), std::move(value), |
| 50 Capture(out_error, run_loop.QuitClosure())); |
| 51 run_loop.Run(); |
| 52 } |
| 53 |
| 54 void DatabaseSyncGet(mojom::LevelDBDatabase* database, |
| 55 mojo::Array<uint8_t> key, |
| 56 mojom::DatabaseError* out_error, |
| 57 mojo::Array<uint8_t>* out_value) { |
| 58 base::RunLoop run_loop; |
| 59 database->Get(std::move(key), |
| 60 Capture(out_error, out_value, run_loop.QuitClosure())); |
| 61 run_loop.Run(); |
| 62 } |
| 63 |
| 64 void DatabaseSyncGetPrefixed(mojom::LevelDBDatabase* database, |
| 65 mojo::Array<uint8_t> key_prefix, |
| 66 mojom::DatabaseError* out_error, |
| 67 mojo::Array<mojom::KeyValuePtr>* out_key_values) { |
| 68 base::RunLoop run_loop; |
| 69 database->GetPrefixed( |
| 70 std::move(key_prefix), |
| 71 Capture(out_error, out_key_values, run_loop.QuitClosure())); |
| 72 run_loop.Run(); |
| 73 } |
| 74 |
| 75 void DatabaseSyncDeletePrefixed(mojom::LevelDBDatabase* database, |
| 76 mojo::Array<uint8_t> key_prefix, |
| 77 mojom::DatabaseError* out_error) { |
| 78 base::RunLoop run_loop; |
| 79 database->DeletePrefixed(std::move(key_prefix), |
| 80 Capture(out_error, run_loop.QuitClosure())); |
| 81 run_loop.Run(); |
| 82 } |
| 83 |
| 84 void LevelDBSyncOpenInMemory(mojom::LevelDBService* leveldb, |
| 85 mojom::LevelDBDatabaseRequest database, |
| 86 mojom::DatabaseError* out_error) { |
| 87 base::RunLoop run_loop; |
| 88 leveldb->OpenInMemory(std::move(database), |
| 89 Capture(out_error, run_loop.QuitClosure())); |
| 90 run_loop.Run(); |
36 } | 91 } |
37 | 92 |
38 class LevelDBServiceTest : public shell::test::ShellTest { | 93 class LevelDBServiceTest : public shell::test::ShellTest { |
39 public: | 94 public: |
40 LevelDBServiceTest() : ShellTest("exe:leveldb_service_unittests") {} | 95 LevelDBServiceTest() : ShellTest("exe:leveldb_service_unittests") {} |
41 ~LevelDBServiceTest() override {} | 96 ~LevelDBServiceTest() override {} |
42 | 97 |
43 protected: | 98 protected: |
44 // Overridden from mojo::test::ApplicationTestBase: | 99 // Overridden from mojo::test::ApplicationTestBase: |
45 void SetUp() override { | 100 void SetUp() override { |
46 ShellTest::SetUp(); | 101 ShellTest::SetUp(); |
47 connector()->ConnectToInterface("mojo:filesystem", &files_); | 102 connector()->ConnectToInterface("mojo:filesystem", &files_); |
48 connector()->ConnectToInterface("mojo:leveldb", &leveldb_); | 103 connector()->ConnectToInterface("mojo:leveldb", &leveldb_); |
49 } | 104 } |
50 | 105 |
51 void TearDown() override { | 106 void TearDown() override { |
52 leveldb_.reset(); | 107 leveldb_.reset(); |
53 files_.reset(); | 108 files_.reset(); |
54 ShellTest::TearDown(); | 109 ShellTest::TearDown(); |
55 } | 110 } |
56 | 111 |
57 // Note: This has an out parameter rather than returning the |DirectoryPtr|, | 112 // Note: This has an out parameter rather than returning the |DirectoryPtr|, |
58 // since |ASSERT_...()| doesn't work with return values. | 113 // since |ASSERT_...()| doesn't work with return values. |
59 void GetTempDirectory(filesystem::mojom::DirectoryPtr* directory) { | 114 void GetTempDirectory(filesystem::mojom::DirectoryPtr* directory) { |
60 FileError error = FileError::FAILED; | 115 FileError error = FileError::FAILED; |
61 files()->OpenTempDirectory(GetProxy(directory), Capture(&error)); | 116 bool handled = files()->OpenTempDirectory(GetProxy(directory), &error); |
62 ASSERT_TRUE(files().WaitForIncomingResponse()); | 117 ASSERT_TRUE(handled); |
63 ASSERT_EQ(FileError::OK, error); | 118 ASSERT_EQ(FileError::OK, error); |
64 } | 119 } |
65 | 120 |
66 filesystem::mojom::FileSystemPtr& files() { return files_; } | 121 filesystem::mojom::FileSystemPtr& files() { return files_; } |
67 mojom::LevelDBServicePtr& leveldb() { return leveldb_; } | 122 mojom::LevelDBServicePtr& leveldb() { return leveldb_; } |
68 | 123 |
69 private: | 124 private: |
70 filesystem::mojom::FileSystemPtr files_; | 125 filesystem::mojom::FileSystemPtr files_; |
71 mojom::LevelDBServicePtr leveldb_; | 126 mojom::LevelDBServicePtr leveldb_; |
72 | 127 |
73 DISALLOW_COPY_AND_ASSIGN(LevelDBServiceTest); | 128 DISALLOW_COPY_AND_ASSIGN(LevelDBServiceTest); |
74 }; | 129 }; |
75 | 130 |
76 TEST_F(LevelDBServiceTest, Basic) { | 131 TEST_F(LevelDBServiceTest, Basic) { |
77 mojom::DatabaseError error; | 132 mojom::DatabaseError error; |
78 mojom::LevelDBDatabasePtr database; | 133 mojom::LevelDBDatabasePtr database; |
79 leveldb()->OpenInMemory(GetProxy(&database), Capture(&error)); | 134 LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error); |
80 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
81 EXPECT_EQ(mojom::DatabaseError::OK, error); | 135 EXPECT_EQ(mojom::DatabaseError::OK, error); |
82 | 136 |
83 // Write a key to the database. | 137 // Write a key to the database. |
84 error = mojom::DatabaseError::INVALID_ARGUMENT; | 138 error = mojom::DatabaseError::INVALID_ARGUMENT; |
85 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | 139 DatabaseSyncPut(database.get(), |
86 mojo::Array<uint8_t>::From(std::string("value")), | 140 mojo::Array<uint8_t>::From(std::string("key")), |
87 Capture(&error)); | 141 mojo::Array<uint8_t>::From(std::string("value")), &error); |
88 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
89 EXPECT_EQ(mojom::DatabaseError::OK, error); | 142 EXPECT_EQ(mojom::DatabaseError::OK, error); |
90 | 143 |
91 // Read the key back from the database. | 144 // Read the key back from the database. |
92 error = mojom::DatabaseError::INVALID_ARGUMENT; | 145 error = mojom::DatabaseError::INVALID_ARGUMENT; |
93 mojo::Array<uint8_t> value; | 146 mojo::Array<uint8_t> value; |
94 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | 147 DatabaseSyncGet(database.get(), |
95 Capture(&error, &value)); | 148 mojo::Array<uint8_t>::From(std::string("key")), &error, |
96 ASSERT_TRUE(database.WaitForIncomingResponse()); | 149 &value); |
97 EXPECT_EQ(mojom::DatabaseError::OK, error); | 150 EXPECT_EQ(mojom::DatabaseError::OK, error); |
98 EXPECT_EQ("value", value.To<std::string>()); | 151 EXPECT_EQ("value", value.To<std::string>()); |
99 | 152 |
100 // Delete the key from the database. | 153 // Delete the key from the database. |
101 error = mojom::DatabaseError::INVALID_ARGUMENT; | 154 error = mojom::DatabaseError::INVALID_ARGUMENT; |
| 155 base::RunLoop run_loop; |
102 database->Delete(mojo::Array<uint8_t>::From(std::string("key")), | 156 database->Delete(mojo::Array<uint8_t>::From(std::string("key")), |
103 Capture(&error)); | 157 Capture(&error, run_loop.QuitClosure())); |
104 ASSERT_TRUE(database.WaitForIncomingResponse()); | 158 run_loop.Run(); |
105 EXPECT_EQ(mojom::DatabaseError::OK, error); | 159 EXPECT_EQ(mojom::DatabaseError::OK, error); |
106 | 160 |
107 // Read the key back from the database. | 161 // Read the key back from the database. |
108 error = mojom::DatabaseError::INVALID_ARGUMENT; | 162 error = mojom::DatabaseError::INVALID_ARGUMENT; |
109 value.SetToEmpty(); | 163 value.SetToEmpty(); |
110 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | 164 DatabaseSyncGet(database.get(), |
111 Capture(&error, &value)); | 165 mojo::Array<uint8_t>::From(std::string("key")), &error, |
112 ASSERT_TRUE(database.WaitForIncomingResponse()); | 166 &value); |
113 EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error); | 167 EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error); |
114 EXPECT_EQ("", value.To<std::string>()); | 168 EXPECT_EQ("", value.To<std::string>()); |
115 } | 169 } |
116 | 170 |
117 TEST_F(LevelDBServiceTest, WriteBatch) { | 171 TEST_F(LevelDBServiceTest, WriteBatch) { |
118 mojom::DatabaseError error; | 172 mojom::DatabaseError error; |
119 mojom::LevelDBDatabasePtr database; | 173 mojom::LevelDBDatabasePtr database; |
120 leveldb()->OpenInMemory(GetProxy(&database), Capture(&error)); | 174 LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error); |
121 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
122 EXPECT_EQ(mojom::DatabaseError::OK, error); | 175 EXPECT_EQ(mojom::DatabaseError::OK, error); |
123 | 176 |
124 // Write a key to the database. | 177 // Write a key to the database. |
125 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | 178 DatabaseSyncPut(database.get(), |
126 mojo::Array<uint8_t>::From(std::string("value")), | 179 mojo::Array<uint8_t>::From(std::string("key")), |
127 Capture(&error)); | 180 mojo::Array<uint8_t>::From(std::string("value")), &error); |
128 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
129 EXPECT_EQ(mojom::DatabaseError::OK, error); | 181 EXPECT_EQ(mojom::DatabaseError::OK, error); |
130 | 182 |
131 // Create a batched operation which both deletes "key" and adds another write. | 183 // Create a batched operation which both deletes "key" and adds another write. |
132 mojo::Array<mojom::BatchedOperationPtr> operations; | 184 mojo::Array<mojom::BatchedOperationPtr> operations; |
133 mojom::BatchedOperationPtr item = mojom::BatchedOperation::New(); | 185 mojom::BatchedOperationPtr item = mojom::BatchedOperation::New(); |
134 item->type = mojom::BatchOperationType::DELETE_KEY; | 186 item->type = mojom::BatchOperationType::DELETE_KEY; |
135 item->key = mojo::Array<uint8_t>::From(std::string("key")); | 187 item->key = mojo::Array<uint8_t>::From(std::string("key")); |
136 operations.push_back(std::move(item)); | 188 operations.push_back(std::move(item)); |
137 | 189 |
138 item = mojom::BatchedOperation::New(); | 190 item = mojom::BatchedOperation::New(); |
139 item->type = mojom::BatchOperationType::PUT_KEY; | 191 item->type = mojom::BatchOperationType::PUT_KEY; |
140 item->key = mojo::Array<uint8_t>::From(std::string("other")); | 192 item->key = mojo::Array<uint8_t>::From(std::string("other")); |
141 item->value = mojo::Array<uint8_t>::From(std::string("more")); | 193 item->value = mojo::Array<uint8_t>::From(std::string("more")); |
142 operations.push_back(std::move(item)); | 194 operations.push_back(std::move(item)); |
143 | 195 |
144 database->Write(std::move(operations), Capture(&error)); | 196 base::RunLoop run_loop; |
145 ASSERT_TRUE(database.WaitForIncomingResponse()); | 197 database->Write(std::move(operations), |
| 198 Capture(&error, run_loop.QuitClosure())); |
| 199 run_loop.Run(); |
146 EXPECT_EQ(mojom::DatabaseError::OK, error); | 200 EXPECT_EQ(mojom::DatabaseError::OK, error); |
147 | 201 |
148 // Reading "key" should be invalid now. | 202 // Reading "key" should be invalid now. |
149 error = mojom::DatabaseError::INVALID_ARGUMENT; | 203 error = mojom::DatabaseError::INVALID_ARGUMENT; |
150 mojo::Array<uint8_t> value; | 204 mojo::Array<uint8_t> value; |
151 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | 205 DatabaseSyncGet(database.get(), |
152 Capture(&error, &value)); | 206 mojo::Array<uint8_t>::From(std::string("key")), &error, |
153 ASSERT_TRUE(database.WaitForIncomingResponse()); | 207 &value); |
154 EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error); | 208 EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error); |
155 EXPECT_EQ("", value.To<std::string>()); | 209 EXPECT_EQ("", value.To<std::string>()); |
156 | 210 |
157 // Reading "other" should return "more" | 211 // Reading "other" should return "more" |
158 error = mojom::DatabaseError::INVALID_ARGUMENT; | 212 error = mojom::DatabaseError::INVALID_ARGUMENT; |
159 database->Get(mojo::Array<uint8_t>::From(std::string("other")), | 213 DatabaseSyncGet(database.get(), |
160 Capture(&error, &value)); | 214 mojo::Array<uint8_t>::From(std::string("other")), &error, |
161 ASSERT_TRUE(database.WaitForIncomingResponse()); | 215 &value); |
162 EXPECT_EQ(mojom::DatabaseError::OK, error); | 216 EXPECT_EQ(mojom::DatabaseError::OK, error); |
163 EXPECT_EQ("more", value.To<std::string>()); | 217 EXPECT_EQ("more", value.To<std::string>()); |
164 | 218 |
165 // Write a some prefixed keys to the database. | 219 // Write a some prefixed keys to the database. |
166 database->Put(mojo::Array<uint8_t>::From(std::string("prefix-key1")), | 220 DatabaseSyncPut(database.get(), |
167 mojo::Array<uint8_t>::From(std::string("value")), | 221 mojo::Array<uint8_t>::From(std::string("prefix-key1")), |
168 Capture(&error)); | 222 mojo::Array<uint8_t>::From(std::string("value")), &error); |
169 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
170 EXPECT_EQ(mojom::DatabaseError::OK, error); | 223 EXPECT_EQ(mojom::DatabaseError::OK, error); |
171 database->Put(mojo::Array<uint8_t>::From(std::string("prefix-key2")), | 224 DatabaseSyncPut(database.get(), |
172 mojo::Array<uint8_t>::From(std::string("value")), | 225 mojo::Array<uint8_t>::From(std::string("prefix-key2")), |
173 Capture(&error)); | 226 mojo::Array<uint8_t>::From(std::string("value")), &error); |
174 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
175 EXPECT_EQ(mojom::DatabaseError::OK, error); | 227 EXPECT_EQ(mojom::DatabaseError::OK, error); |
176 | 228 |
177 // Create a batched operation to delete them. | 229 // Create a batched operation to delete them. |
178 operations.SetToEmpty(); | 230 operations.SetToEmpty(); |
179 item = mojom::BatchedOperation::New(); | 231 item = mojom::BatchedOperation::New(); |
180 item->type = mojom::BatchOperationType::DELETE_PREFIXED_KEY; | 232 item->type = mojom::BatchOperationType::DELETE_PREFIXED_KEY; |
181 item->key = mojo::Array<uint8_t>::From(std::string("prefix")); | 233 item->key = mojo::Array<uint8_t>::From(std::string("prefix")); |
182 operations.push_back(std::move(item)); | 234 operations.push_back(std::move(item)); |
183 database->Write(std::move(operations), Capture(&error)); | 235 base::RunLoop run_loop2; |
184 ASSERT_TRUE(database.WaitForIncomingResponse()); | 236 database->Write(std::move(operations), |
| 237 Capture(&error, run_loop2.QuitClosure())); |
| 238 run_loop2.Run(); |
185 EXPECT_EQ(mojom::DatabaseError::OK, error); | 239 EXPECT_EQ(mojom::DatabaseError::OK, error); |
186 | 240 |
187 // Reading all "prefix" keys should be invalid now. | 241 // Reading all "prefix" keys should be invalid now. |
188 error = mojom::DatabaseError::INVALID_ARGUMENT; | 242 error = mojom::DatabaseError::INVALID_ARGUMENT; |
189 value = nullptr; | 243 value = nullptr; |
190 database->Get(mojo::Array<uint8_t>::From(std::string("prefix-key1")), | 244 DatabaseSyncGet(database.get(), |
191 Capture(&error, &value)); | 245 mojo::Array<uint8_t>::From(std::string("prefix-key1")), |
192 ASSERT_TRUE(database.WaitForIncomingResponse()); | 246 &error, &value); |
193 EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error); | 247 EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error); |
194 EXPECT_EQ("", value.To<std::string>()); | 248 EXPECT_EQ("", value.To<std::string>()); |
195 // Reading "key" should be invalid now. | 249 // Reading "key" should be invalid now. |
196 error = mojom::DatabaseError::INVALID_ARGUMENT; | 250 error = mojom::DatabaseError::INVALID_ARGUMENT; |
197 value = nullptr; | 251 value = nullptr; |
198 database->Get(mojo::Array<uint8_t>::From(std::string("prefix-key2")), | 252 DatabaseSyncGet(database.get(), |
199 Capture(&error, &value)); | 253 mojo::Array<uint8_t>::From(std::string("prefix-key2")), |
200 ASSERT_TRUE(database.WaitForIncomingResponse()); | 254 &error, &value); |
201 EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error); | 255 EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error); |
202 EXPECT_EQ("", value.To<std::string>()); | 256 EXPECT_EQ("", value.To<std::string>()); |
203 } | 257 } |
204 | 258 |
205 TEST_F(LevelDBServiceTest, Reconnect) { | 259 TEST_F(LevelDBServiceTest, Reconnect) { |
206 mojom::DatabaseError error; | 260 mojom::DatabaseError error; |
207 | 261 |
208 filesystem::mojom::DirectoryPtr temp_directory; | 262 filesystem::mojom::DirectoryPtr temp_directory; |
209 GetTempDirectory(&temp_directory); | 263 GetTempDirectory(&temp_directory); |
210 | 264 |
211 { | 265 { |
212 filesystem::mojom::DirectoryPtr directory; | 266 filesystem::mojom::DirectoryPtr directory; |
213 temp_directory->Clone(GetProxy(&directory)); | 267 temp_directory->Clone(GetProxy(&directory)); |
214 | 268 |
215 mojom::LevelDBDatabasePtr database; | 269 mojom::LevelDBDatabasePtr database; |
216 leveldb::mojom::OpenOptionsPtr options = leveldb::mojom::OpenOptions::New(); | 270 leveldb::mojom::OpenOptionsPtr options = leveldb::mojom::OpenOptions::New(); |
217 options->error_if_exists = true; | 271 options->error_if_exists = true; |
218 options->create_if_missing = true; | 272 options->create_if_missing = true; |
219 leveldb()->OpenWithOptions(std::move(options), | 273 base::RunLoop run_loop; |
220 std::move(directory), "test", | 274 leveldb()->OpenWithOptions(std::move(options), std::move(directory), "test", |
221 GetProxy(&database), | 275 GetProxy(&database), |
222 Capture(&error)); | 276 Capture(&error, run_loop.QuitClosure())); |
223 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | 277 run_loop.Run(); |
224 EXPECT_EQ(mojom::DatabaseError::OK, error); | 278 EXPECT_EQ(mojom::DatabaseError::OK, error); |
225 | 279 |
226 // Write a key to the database. | 280 // Write a key to the database. |
227 error = mojom::DatabaseError::INVALID_ARGUMENT; | 281 error = mojom::DatabaseError::INVALID_ARGUMENT; |
228 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | 282 DatabaseSyncPut(database.get(), |
229 mojo::Array<uint8_t>::From(std::string("value")), | 283 mojo::Array<uint8_t>::From(std::string("key")), |
230 Capture(&error)); | 284 mojo::Array<uint8_t>::From(std::string("value")), &error); |
231 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
232 EXPECT_EQ(mojom::DatabaseError::OK, error); | 285 EXPECT_EQ(mojom::DatabaseError::OK, error); |
233 | 286 |
234 // The database should go out of scope here. | 287 // The database should go out of scope here. |
235 } | 288 } |
236 | 289 |
237 { | 290 { |
238 filesystem::mojom::DirectoryPtr directory; | 291 filesystem::mojom::DirectoryPtr directory; |
239 temp_directory->Clone(GetProxy(&directory)); | 292 temp_directory->Clone(GetProxy(&directory)); |
240 | 293 |
241 // Reconnect to the database. | 294 // Reconnect to the database. |
242 mojom::LevelDBDatabasePtr database; | 295 mojom::LevelDBDatabasePtr database; |
| 296 base::RunLoop run_loop; |
243 leveldb()->Open(std::move(directory), "test", GetProxy(&database), | 297 leveldb()->Open(std::move(directory), "test", GetProxy(&database), |
244 Capture(&error)); | 298 Capture(&error, run_loop.QuitClosure())); |
245 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | 299 run_loop.Run(); |
246 EXPECT_EQ(mojom::DatabaseError::OK, error); | 300 EXPECT_EQ(mojom::DatabaseError::OK, error); |
247 | 301 |
248 // We should still be able to read the key back from the database. | 302 // We should still be able to read the key back from the database. |
249 error = mojom::DatabaseError::INVALID_ARGUMENT; | 303 error = mojom::DatabaseError::INVALID_ARGUMENT; |
250 mojo::Array<uint8_t> value; | 304 mojo::Array<uint8_t> value; |
251 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | 305 DatabaseSyncGet(database.get(), |
252 Capture(&error, &value)); | 306 mojo::Array<uint8_t>::From(std::string("key")), &error, |
253 ASSERT_TRUE(database.WaitForIncomingResponse()); | 307 &value); |
254 EXPECT_EQ(mojom::DatabaseError::OK, error); | 308 EXPECT_EQ(mojom::DatabaseError::OK, error); |
255 EXPECT_EQ("value", value.To<std::string>()); | 309 EXPECT_EQ("value", value.To<std::string>()); |
256 } | 310 } |
257 } | 311 } |
258 | 312 |
259 TEST_F(LevelDBServiceTest, GetSnapshotSimple) { | 313 TEST_F(LevelDBServiceTest, GetSnapshotSimple) { |
260 mojom::DatabaseError error; | 314 mojom::DatabaseError error; |
261 mojom::LevelDBDatabasePtr database; | 315 mojom::LevelDBDatabasePtr database; |
262 leveldb()->OpenInMemory(GetProxy(&database), Capture(&error)); | 316 LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error); |
263 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
264 EXPECT_EQ(mojom::DatabaseError::OK, error); | 317 EXPECT_EQ(mojom::DatabaseError::OK, error); |
265 | 318 |
266 uint64_t snapshot_id = 0; | 319 uint64_t snapshot_id = 0; |
267 database->GetSnapshot(Capture(&snapshot_id)); | 320 base::RunLoop run_loop; |
268 ASSERT_TRUE(database.WaitForIncomingResponse()); | 321 database->GetSnapshot(Capture(&snapshot_id, run_loop.QuitClosure())); |
| 322 run_loop.Run(); |
269 EXPECT_NE(static_cast<uint64_t>(0), snapshot_id); | 323 EXPECT_NE(static_cast<uint64_t>(0), snapshot_id); |
270 } | 324 } |
271 | 325 |
272 TEST_F(LevelDBServiceTest, GetFromSnapshots) { | 326 TEST_F(LevelDBServiceTest, GetFromSnapshots) { |
273 mojom::DatabaseError error; | 327 mojom::DatabaseError error; |
274 mojom::LevelDBDatabasePtr database; | 328 mojom::LevelDBDatabasePtr database; |
275 leveldb()->OpenInMemory(GetProxy(&database), Capture(&error)); | 329 LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error); |
276 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
277 EXPECT_EQ(mojom::DatabaseError::OK, error); | 330 EXPECT_EQ(mojom::DatabaseError::OK, error); |
278 | 331 |
279 // Write a key to the database. | 332 // Write a key to the database. |
280 error = mojom::DatabaseError::INVALID_ARGUMENT; | 333 error = mojom::DatabaseError::INVALID_ARGUMENT; |
281 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | 334 DatabaseSyncPut(database.get(), |
282 mojo::Array<uint8_t>::From(std::string("value")), | 335 mojo::Array<uint8_t>::From(std::string("key")), |
283 Capture(&error)); | 336 mojo::Array<uint8_t>::From(std::string("value")), &error); |
284 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
285 EXPECT_EQ(mojom::DatabaseError::OK, error); | 337 EXPECT_EQ(mojom::DatabaseError::OK, error); |
286 | 338 |
287 // Take a snapshot where key=value. | 339 // Take a snapshot where key=value. |
288 uint64_t key_value_snapshot = 0; | 340 uint64_t key_value_snapshot = 0; |
289 database->GetSnapshot(Capture(&key_value_snapshot)); | 341 base::RunLoop run_loop; |
290 ASSERT_TRUE(database.WaitForIncomingResponse()); | 342 database->GetSnapshot(Capture(&key_value_snapshot, run_loop.QuitClosure())); |
| 343 run_loop.Run(); |
291 | 344 |
292 // Change key to "yek". | 345 // Change key to "yek". |
293 error = mojom::DatabaseError::INVALID_ARGUMENT; | 346 error = mojom::DatabaseError::INVALID_ARGUMENT; |
294 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | 347 DatabaseSyncPut(database.get(), |
295 mojo::Array<uint8_t>::From(std::string("yek")), | 348 mojo::Array<uint8_t>::From(std::string("key")), |
296 Capture(&error)); | 349 mojo::Array<uint8_t>::From(std::string("yek")), &error); |
297 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
298 EXPECT_EQ(mojom::DatabaseError::OK, error); | 350 EXPECT_EQ(mojom::DatabaseError::OK, error); |
299 | 351 |
300 // (Ensure this change is live on the database.) | 352 // (Ensure this change is live on the database.) |
301 error = mojom::DatabaseError::INVALID_ARGUMENT; | 353 error = mojom::DatabaseError::INVALID_ARGUMENT; |
302 mojo::Array<uint8_t> value; | 354 mojo::Array<uint8_t> value; |
303 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | 355 DatabaseSyncGet(database.get(), |
304 Capture(&error, &value)); | 356 mojo::Array<uint8_t>::From(std::string("key")), &error, |
305 ASSERT_TRUE(database.WaitForIncomingResponse()); | 357 &value); |
306 EXPECT_EQ(mojom::DatabaseError::OK, error); | 358 EXPECT_EQ(mojom::DatabaseError::OK, error); |
307 EXPECT_EQ("yek", value.To<std::string>()); | 359 EXPECT_EQ("yek", value.To<std::string>()); |
308 | 360 |
309 // But if we were to read from the snapshot, we'd still get value. | 361 // But if we were to read from the snapshot, we'd still get value. |
310 error = mojom::DatabaseError::INVALID_ARGUMENT; | 362 error = mojom::DatabaseError::INVALID_ARGUMENT; |
311 value.SetToEmpty(); | 363 value.SetToEmpty(); |
312 database->GetFromSnapshot( | 364 base::RunLoop run_loop2; |
313 key_value_snapshot, | 365 database->GetFromSnapshot(key_value_snapshot, |
314 mojo::Array<uint8_t>::From(std::string("key")), | 366 mojo::Array<uint8_t>::From(std::string("key")), |
315 Capture(&error, &value)); | 367 Capture(&error, &value, run_loop2.QuitClosure())); |
316 ASSERT_TRUE(database.WaitForIncomingResponse()); | 368 run_loop2.Run(); |
317 EXPECT_EQ(mojom::DatabaseError::OK, error); | 369 EXPECT_EQ(mojom::DatabaseError::OK, error); |
318 EXPECT_EQ("value", value.To<std::string>()); | 370 EXPECT_EQ("value", value.To<std::string>()); |
319 } | 371 } |
320 | 372 |
321 TEST_F(LevelDBServiceTest, InvalidArgumentOnInvalidSnapshot) { | 373 TEST_F(LevelDBServiceTest, InvalidArgumentOnInvalidSnapshot) { |
322 mojom::LevelDBDatabasePtr database; | 374 mojom::LevelDBDatabasePtr database; |
323 mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT; | 375 mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT; |
324 leveldb()->OpenInMemory(GetProxy(&database), Capture(&error)); | 376 LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error); |
325 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
326 EXPECT_EQ(mojom::DatabaseError::OK, error); | 377 EXPECT_EQ(mojom::DatabaseError::OK, error); |
327 | 378 |
328 uint64_t invalid_snapshot = 8; | 379 uint64_t invalid_snapshot = 8; |
329 | 380 |
330 error = mojom::DatabaseError::OK; | 381 error = mojom::DatabaseError::OK; |
331 mojo::Array<uint8_t> value; | 382 mojo::Array<uint8_t> value; |
332 database->GetFromSnapshot( | 383 base::RunLoop run_loop; |
333 invalid_snapshot, | 384 database->GetFromSnapshot(invalid_snapshot, |
334 mojo::Array<uint8_t>::From(std::string("key")), | 385 mojo::Array<uint8_t>::From(std::string("key")), |
335 Capture(&error, &value)); | 386 Capture(&error, &value, run_loop.QuitClosure())); |
336 ASSERT_TRUE(database.WaitForIncomingResponse()); | 387 run_loop.Run(); |
337 EXPECT_EQ(mojom::DatabaseError::INVALID_ARGUMENT, error); | 388 EXPECT_EQ(mojom::DatabaseError::INVALID_ARGUMENT, error); |
338 } | 389 } |
339 | 390 |
340 TEST_F(LevelDBServiceTest, MemoryDBReadWrite) { | 391 TEST_F(LevelDBServiceTest, MemoryDBReadWrite) { |
341 mojom::LevelDBDatabasePtr database; | 392 mojom::LevelDBDatabasePtr database; |
342 mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT; | 393 mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT; |
343 leveldb()->OpenInMemory(GetProxy(&database), Capture(&error)); | 394 LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error); |
344 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
345 EXPECT_EQ(mojom::DatabaseError::OK, error); | 395 EXPECT_EQ(mojom::DatabaseError::OK, error); |
346 | 396 |
347 // Write a key to the database. | 397 // Write a key to the database. |
348 error = mojom::DatabaseError::INVALID_ARGUMENT; | 398 error = mojom::DatabaseError::INVALID_ARGUMENT; |
349 database->Put(mojo::Array<uint8_t>::From(std::string("key")), | 399 DatabaseSyncPut(database.get(), |
350 mojo::Array<uint8_t>::From(std::string("value")), | 400 mojo::Array<uint8_t>::From(std::string("key")), |
351 Capture(&error)); | 401 mojo::Array<uint8_t>::From(std::string("value")), &error); |
352 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
353 EXPECT_EQ(mojom::DatabaseError::OK, error); | 402 EXPECT_EQ(mojom::DatabaseError::OK, error); |
354 | 403 |
355 // Read the key back from the database. | 404 // Read the key back from the database. |
356 error = mojom::DatabaseError::INVALID_ARGUMENT; | 405 error = mojom::DatabaseError::INVALID_ARGUMENT; |
357 mojo::Array<uint8_t> value; | 406 mojo::Array<uint8_t> value; |
358 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | 407 DatabaseSyncGet(database.get(), |
359 Capture(&error, &value)); | 408 mojo::Array<uint8_t>::From(std::string("key")), &error, |
360 ASSERT_TRUE(database.WaitForIncomingResponse()); | 409 &value); |
361 EXPECT_EQ(mojom::DatabaseError::OK, error); | 410 EXPECT_EQ(mojom::DatabaseError::OK, error); |
362 EXPECT_EQ("value", value.To<std::string>()); | 411 EXPECT_EQ("value", value.To<std::string>()); |
363 | 412 |
364 // Delete the key from the database. | 413 // Delete the key from the database. |
365 error = mojom::DatabaseError::INVALID_ARGUMENT; | 414 error = mojom::DatabaseError::INVALID_ARGUMENT; |
| 415 base::RunLoop run_loop; |
366 database->Delete(mojo::Array<uint8_t>::From(std::string("key")), | 416 database->Delete(mojo::Array<uint8_t>::From(std::string("key")), |
367 Capture(&error)); | 417 Capture(&error, run_loop.QuitClosure())); |
368 ASSERT_TRUE(database.WaitForIncomingResponse()); | 418 run_loop.Run(); |
369 EXPECT_EQ(mojom::DatabaseError::OK, error); | 419 EXPECT_EQ(mojom::DatabaseError::OK, error); |
370 | 420 |
371 // Read the key back from the database. | 421 // Read the key back from the database. |
372 error = mojom::DatabaseError::INVALID_ARGUMENT; | 422 error = mojom::DatabaseError::INVALID_ARGUMENT; |
373 value.SetToEmpty(); | 423 value.SetToEmpty(); |
374 database->Get(mojo::Array<uint8_t>::From(std::string("key")), | 424 DatabaseSyncGet(database.get(), |
375 Capture(&error, &value)); | 425 mojo::Array<uint8_t>::From(std::string("key")), &error, |
376 ASSERT_TRUE(database.WaitForIncomingResponse()); | 426 &value); |
377 EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error); | 427 EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error); |
378 EXPECT_EQ("", value.To<std::string>()); | 428 EXPECT_EQ("", value.To<std::string>()); |
379 } | 429 } |
380 | 430 |
381 TEST_F(LevelDBServiceTest, Prefixed) { | 431 TEST_F(LevelDBServiceTest, Prefixed) { |
382 // Open an in memory database for speed. | 432 // Open an in memory database for speed. |
383 mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT; | 433 mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT; |
384 mojom::LevelDBDatabasePtr database; | 434 mojom::LevelDBDatabasePtr database; |
385 leveldb()->OpenInMemory(GetProxy(&database), Capture(&error)); | 435 LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error); |
386 ASSERT_TRUE(leveldb().WaitForIncomingResponse()); | |
387 EXPECT_EQ(mojom::DatabaseError::OK, error); | 436 EXPECT_EQ(mojom::DatabaseError::OK, error); |
388 | 437 |
389 const std::string prefix("prefix"); | 438 const std::string prefix("prefix"); |
390 mojo::Array<mojom::KeyValuePtr> key_values; | 439 mojo::Array<mojom::KeyValuePtr> key_values; |
391 | 440 |
392 // Completely empty database. | 441 // Completely empty database. |
393 error = mojom::DatabaseError::INVALID_ARGUMENT; | 442 error = mojom::DatabaseError::INVALID_ARGUMENT; |
394 database->GetPrefixed(mojo::Array<uint8_t>::From(prefix), | 443 DatabaseSyncGetPrefixed(database.get(), mojo::Array<uint8_t>::From(prefix), |
395 Capture(&error, &key_values)); | 444 &error, &key_values); |
396 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
397 EXPECT_EQ(mojom::DatabaseError::OK, error); | 445 EXPECT_EQ(mojom::DatabaseError::OK, error); |
398 EXPECT_TRUE(key_values.empty()); | 446 EXPECT_TRUE(key_values.empty()); |
399 | 447 |
400 // No values with our prefix, but values before and after. | 448 // No values with our prefix, but values before and after. |
401 error = mojom::DatabaseError::INVALID_ARGUMENT; | 449 error = mojom::DatabaseError::INVALID_ARGUMENT; |
402 database->Put(mojo::Array<uint8_t>::From(std::string("a-before-prefix")), | 450 DatabaseSyncPut(database.get(), |
403 mojo::Array<uint8_t>::From(std::string("value")), | 451 mojo::Array<uint8_t>::From(std::string("a-before-prefix")), |
404 Capture(&error)); | 452 mojo::Array<uint8_t>::From(std::string("value")), &error); |
405 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
406 EXPECT_EQ(mojom::DatabaseError::OK, error); | 453 EXPECT_EQ(mojom::DatabaseError::OK, error); |
407 error = mojom::DatabaseError::INVALID_ARGUMENT; | 454 error = mojom::DatabaseError::INVALID_ARGUMENT; |
408 database->Put(mojo::Array<uint8_t>::From(std::string("z-after-prefix")), | 455 DatabaseSyncPut(database.get(), |
409 mojo::Array<uint8_t>::From(std::string("value")), | 456 mojo::Array<uint8_t>::From(std::string("z-after-prefix")), |
410 Capture(&error)); | 457 mojo::Array<uint8_t>::From(std::string("value")), &error); |
411 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
412 EXPECT_EQ(mojom::DatabaseError::OK, error); | 458 EXPECT_EQ(mojom::DatabaseError::OK, error); |
413 key_values.SetToEmpty(); | 459 key_values.SetToEmpty(); |
414 error = mojom::DatabaseError::INVALID_ARGUMENT; | 460 error = mojom::DatabaseError::INVALID_ARGUMENT; |
415 database->GetPrefixed(mojo::Array<uint8_t>::From(prefix), | 461 DatabaseSyncGetPrefixed(database.get(), mojo::Array<uint8_t>::From(prefix), |
416 Capture(&error, &key_values)); | 462 &error, &key_values); |
417 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
418 EXPECT_EQ(mojom::DatabaseError::OK, error); | 463 EXPECT_EQ(mojom::DatabaseError::OK, error); |
419 EXPECT_TRUE(key_values.empty()); | 464 EXPECT_TRUE(key_values.empty()); |
420 | 465 |
421 // One value with the exact prefix. | 466 // One value with the exact prefix. |
422 database->Put(mojo::Array<uint8_t>::From(prefix), | 467 DatabaseSyncPut(database.get(), mojo::Array<uint8_t>::From(prefix), |
423 mojo::Array<uint8_t>::From(std::string("value")), | 468 mojo::Array<uint8_t>::From(std::string("value")), &error); |
424 Capture(&error)); | |
425 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
426 EXPECT_EQ(mojom::DatabaseError::OK, error); | 469 EXPECT_EQ(mojom::DatabaseError::OK, error); |
427 error = mojom::DatabaseError::INVALID_ARGUMENT; | 470 error = mojom::DatabaseError::INVALID_ARGUMENT; |
428 key_values.SetToEmpty(); | 471 key_values.SetToEmpty(); |
429 database->GetPrefixed(mojo::Array<uint8_t>::From(prefix), | 472 DatabaseSyncGetPrefixed(database.get(), mojo::Array<uint8_t>::From(prefix), |
430 Capture(&error, &key_values)); | 473 &error, &key_values); |
431 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
432 EXPECT_EQ(mojom::DatabaseError::OK, error); | 474 EXPECT_EQ(mojom::DatabaseError::OK, error); |
433 EXPECT_EQ(1u, key_values.size()); | 475 EXPECT_EQ(1u, key_values.size()); |
434 EXPECT_EQ("prefix", key_values[0]->key.To<std::string>()); | 476 EXPECT_EQ("prefix", key_values[0]->key.To<std::string>()); |
435 EXPECT_EQ("value", key_values[0]->value.To<std::string>()); | 477 EXPECT_EQ("value", key_values[0]->value.To<std::string>()); |
436 | 478 |
437 // Multiple values with starting with the prefix. | 479 // Multiple values with starting with the prefix. |
438 database->Put(mojo::Array<uint8_t>::From(prefix + "2"), | 480 DatabaseSyncPut(database.get(), mojo::Array<uint8_t>::From(prefix + "2"), |
439 mojo::Array<uint8_t>::From(std::string("value2")), | 481 mojo::Array<uint8_t>::From(std::string("value2")), &error); |
440 Capture(&error)); | |
441 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
442 EXPECT_EQ(mojom::DatabaseError::OK, error); | 482 EXPECT_EQ(mojom::DatabaseError::OK, error); |
443 error = mojom::DatabaseError::INVALID_ARGUMENT; | 483 error = mojom::DatabaseError::INVALID_ARGUMENT; |
444 key_values.SetToEmpty(); | 484 key_values.SetToEmpty(); |
445 database->GetPrefixed(mojo::Array<uint8_t>::From(prefix), | 485 DatabaseSyncGetPrefixed(database.get(), mojo::Array<uint8_t>::From(prefix), |
446 Capture(&error, &key_values)); | 486 &error, &key_values); |
447 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
448 EXPECT_EQ(mojom::DatabaseError::OK, error); | 487 EXPECT_EQ(mojom::DatabaseError::OK, error); |
449 EXPECT_EQ(2u, key_values.size()); | 488 EXPECT_EQ(2u, key_values.size()); |
450 EXPECT_EQ("prefix", key_values[0]->key.To<std::string>()); | 489 EXPECT_EQ("prefix", key_values[0]->key.To<std::string>()); |
451 EXPECT_EQ("value", key_values[0]->value.To<std::string>()); | 490 EXPECT_EQ("value", key_values[0]->value.To<std::string>()); |
452 EXPECT_EQ("prefix2", key_values[1]->key.To<std::string>()); | 491 EXPECT_EQ("prefix2", key_values[1]->key.To<std::string>()); |
453 EXPECT_EQ("value2", key_values[1]->value.To<std::string>()); | 492 EXPECT_EQ("value2", key_values[1]->value.To<std::string>()); |
454 | 493 |
455 // Delete the prefixed values. | 494 // Delete the prefixed values. |
456 error = mojom::DatabaseError::INVALID_ARGUMENT; | 495 error = mojom::DatabaseError::INVALID_ARGUMENT; |
457 database->DeletePrefixed(mojo::Array<uint8_t>::From(prefix), | 496 DatabaseSyncDeletePrefixed(database.get(), mojo::Array<uint8_t>::From(prefix), |
458 Capture(&error)); | 497 &error); |
459 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
460 EXPECT_EQ(mojom::DatabaseError::OK, error); | 498 EXPECT_EQ(mojom::DatabaseError::OK, error); |
461 error = mojom::DatabaseError::INVALID_ARGUMENT; | 499 error = mojom::DatabaseError::INVALID_ARGUMENT; |
462 key_values.SetToEmpty(); | 500 key_values.SetToEmpty(); |
463 database->GetPrefixed(mojo::Array<uint8_t>::From(prefix), | 501 DatabaseSyncGetPrefixed(database.get(), mojo::Array<uint8_t>::From(prefix), |
464 Capture(&error, &key_values)); | 502 &error, &key_values); |
465 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
466 EXPECT_EQ(mojom::DatabaseError::OK, error); | 503 EXPECT_EQ(mojom::DatabaseError::OK, error); |
467 EXPECT_TRUE(key_values.empty()); | 504 EXPECT_TRUE(key_values.empty()); |
468 | 505 |
469 // Make sure the others are not deleted. | 506 // Make sure the others are not deleted. |
470 mojo::Array<uint8_t> value; | 507 mojo::Array<uint8_t> value; |
471 database->Get(mojo::Array<uint8_t>::From(std::string("a-before-prefix")), | 508 DatabaseSyncGet(database.get(), |
472 Capture(&error, &value)); | 509 mojo::Array<uint8_t>::From(std::string("a-before-prefix")), |
473 ASSERT_TRUE(database.WaitForIncomingResponse()); | 510 &error, &value); |
474 EXPECT_EQ(mojom::DatabaseError::OK, error); | 511 EXPECT_EQ(mojom::DatabaseError::OK, error); |
475 EXPECT_EQ("value", value.To<std::string>()); | 512 EXPECT_EQ("value", value.To<std::string>()); |
476 value.SetToEmpty(); | 513 value.SetToEmpty(); |
477 database->Get(mojo::Array<uint8_t>::From(std::string("z-after-prefix")), | 514 DatabaseSyncGet(database.get(), |
478 Capture(&error, &value)); | 515 mojo::Array<uint8_t>::From(std::string("z-after-prefix")), |
479 ASSERT_TRUE(database.WaitForIncomingResponse()); | 516 &error, &value); |
480 EXPECT_EQ(mojom::DatabaseError::OK, error); | 517 EXPECT_EQ(mojom::DatabaseError::OK, error); |
481 EXPECT_EQ("value", value.To<std::string>()); | 518 EXPECT_EQ("value", value.To<std::string>()); |
482 | 519 |
483 // A key having our prefix, but no key matching it exactly. | 520 // A key having our prefix, but no key matching it exactly. |
484 // Even thought there is no exact matching key, GetPrefixed | 521 // Even thought there is no exact matching key, GetPrefixed |
485 // and DeletePrefixed still operate on the values. | 522 // and DeletePrefixed still operate on the values. |
486 error = mojom::DatabaseError::INVALID_ARGUMENT; | 523 error = mojom::DatabaseError::INVALID_ARGUMENT; |
487 database->Put(mojo::Array<uint8_t>::From(prefix + "2"), | 524 DatabaseSyncPut(database.get(), mojo::Array<uint8_t>::From(prefix + "2"), |
488 mojo::Array<uint8_t>::From(std::string("value2")), | 525 mojo::Array<uint8_t>::From(std::string("value2")), &error); |
489 Capture(&error)); | |
490 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
491 EXPECT_EQ(mojom::DatabaseError::OK, error); | 526 EXPECT_EQ(mojom::DatabaseError::OK, error); |
492 error = mojom::DatabaseError::INVALID_ARGUMENT; | 527 error = mojom::DatabaseError::INVALID_ARGUMENT; |
493 key_values.SetToEmpty(); | 528 key_values.SetToEmpty(); |
494 database->GetPrefixed(mojo::Array<uint8_t>::From(prefix), | 529 DatabaseSyncGetPrefixed(database.get(), mojo::Array<uint8_t>::From(prefix), |
495 Capture(&error, &key_values)); | 530 &error, &key_values); |
496 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
497 EXPECT_EQ(mojom::DatabaseError::OK, error); | 531 EXPECT_EQ(mojom::DatabaseError::OK, error); |
498 EXPECT_EQ(1u, key_values.size()); | 532 EXPECT_EQ(1u, key_values.size()); |
499 EXPECT_EQ("prefix2", key_values[0]->key.To<std::string>()); | 533 EXPECT_EQ("prefix2", key_values[0]->key.To<std::string>()); |
500 EXPECT_EQ("value2", key_values[0]->value.To<std::string>()); | 534 EXPECT_EQ("value2", key_values[0]->value.To<std::string>()); |
501 error = mojom::DatabaseError::INVALID_ARGUMENT; | 535 error = mojom::DatabaseError::INVALID_ARGUMENT; |
502 database->DeletePrefixed(mojo::Array<uint8_t>::From(prefix), | 536 DatabaseSyncDeletePrefixed(database.get(), mojo::Array<uint8_t>::From(prefix), |
503 Capture(&error)); | 537 &error); |
504 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
505 EXPECT_EQ(mojom::DatabaseError::OK, error); | 538 EXPECT_EQ(mojom::DatabaseError::OK, error); |
506 error = mojom::DatabaseError::INVALID_ARGUMENT; | 539 error = mojom::DatabaseError::INVALID_ARGUMENT; |
507 key_values.SetToEmpty(); | 540 key_values.SetToEmpty(); |
508 database->GetPrefixed(mojo::Array<uint8_t>::From(prefix), | 541 DatabaseSyncGetPrefixed(database.get(), mojo::Array<uint8_t>::From(prefix), |
509 Capture(&error, &key_values)); | 542 &error, &key_values); |
510 ASSERT_TRUE(database.WaitForIncomingResponse()); | |
511 EXPECT_EQ(mojom::DatabaseError::OK, error); | 543 EXPECT_EQ(mojom::DatabaseError::OK, error); |
512 EXPECT_TRUE(key_values.empty()); | 544 EXPECT_TRUE(key_values.empty()); |
513 } | 545 } |
514 | 546 |
515 } // namespace | 547 } // namespace |
516 } // namespace leveldb | 548 } // namespace leveldb |
OLD | NEW |