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