OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "google_apis/gcm/engine/gcm_store_impl.h" | 5 #include "google_apis/gcm/engine/gcm_store_impl.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
42 public: | 42 public: |
43 GCMStoreImplTest(); | 43 GCMStoreImplTest(); |
44 virtual ~GCMStoreImplTest(); | 44 virtual ~GCMStoreImplTest(); |
45 | 45 |
46 scoped_ptr<GCMStore> BuildGCMStore(); | 46 scoped_ptr<GCMStore> BuildGCMStore(); |
47 | 47 |
48 std::string GetNextPersistentId(); | 48 std::string GetNextPersistentId(); |
49 | 49 |
50 void PumpLoop(); | 50 void PumpLoop(); |
51 | 51 |
52 void LoadCallback(GCMStore::LoadResult* result_dst, | 52 void LoadCallback(scoped_ptr<GCMStore::LoadResult>* result_dst, |
53 const GCMStore::LoadResult& result); | 53 scoped_ptr<GCMStore::LoadResult> result); |
54 void UpdateCallback(bool success); | 54 void UpdateCallback(bool success); |
55 | 55 |
56 protected: | 56 protected: |
57 base::MessageLoop message_loop_; | 57 base::MessageLoop message_loop_; |
58 base::ScopedTempDir temp_directory_; | 58 base::ScopedTempDir temp_directory_; |
59 bool expected_success_; | 59 bool expected_success_; |
60 scoped_ptr<base::RunLoop> run_loop_; | 60 scoped_ptr<base::RunLoop> run_loop_; |
61 }; | 61 }; |
62 | 62 |
63 GCMStoreImplTest::GCMStoreImplTest() | 63 GCMStoreImplTest::GCMStoreImplTest() |
(...skipping 10 matching lines...) Expand all Loading... |
74 temp_directory_.path(), | 74 temp_directory_.path(), |
75 message_loop_.message_loop_proxy())); | 75 message_loop_.message_loop_proxy())); |
76 } | 76 } |
77 | 77 |
78 std::string GCMStoreImplTest::GetNextPersistentId() { | 78 std::string GCMStoreImplTest::GetNextPersistentId() { |
79 return base::Uint64ToString(base::Time::Now().ToInternalValue()); | 79 return base::Uint64ToString(base::Time::Now().ToInternalValue()); |
80 } | 80 } |
81 | 81 |
82 void GCMStoreImplTest::PumpLoop() { message_loop_.RunUntilIdle(); } | 82 void GCMStoreImplTest::PumpLoop() { message_loop_.RunUntilIdle(); } |
83 | 83 |
84 void GCMStoreImplTest::LoadCallback(GCMStore::LoadResult* result_dst, | 84 void GCMStoreImplTest::LoadCallback( |
85 const GCMStore::LoadResult& result) { | 85 scoped_ptr<GCMStore::LoadResult>* result_dst, |
86 ASSERT_TRUE(result.success); | 86 scoped_ptr<GCMStore::LoadResult> result) { |
87 *result_dst = result; | 87 ASSERT_TRUE(result->success); |
| 88 *result_dst = result.Pass(); |
88 run_loop_->Quit(); | 89 run_loop_->Quit(); |
89 run_loop_.reset(new base::RunLoop()); | 90 run_loop_.reset(new base::RunLoop()); |
90 } | 91 } |
91 | 92 |
92 void GCMStoreImplTest::UpdateCallback(bool success) { | 93 void GCMStoreImplTest::UpdateCallback(bool success) { |
93 ASSERT_EQ(expected_success_, success); | 94 ASSERT_EQ(expected_success_, success); |
94 } | 95 } |
95 | 96 |
96 // Verify creating a new database and loading it. | 97 // Verify creating a new database and loading it. |
97 TEST_F(GCMStoreImplTest, LoadNew) { | 98 TEST_F(GCMStoreImplTest, LoadNew) { |
98 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); | 99 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); |
99 GCMStore::LoadResult load_result; | 100 scoped_ptr<GCMStore::LoadResult> load_result; |
100 gcm_store->Load(base::Bind( | 101 gcm_store->Load(base::Bind( |
101 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 102 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
102 PumpLoop(); | 103 PumpLoop(); |
103 | 104 |
104 EXPECT_EQ(0U, load_result.device_android_id); | 105 EXPECT_EQ(0U, load_result->device_android_id); |
105 EXPECT_EQ(0U, load_result.device_security_token); | 106 EXPECT_EQ(0U, load_result->device_security_token); |
106 EXPECT_TRUE(load_result.incoming_messages.empty()); | 107 EXPECT_TRUE(load_result->incoming_messages.empty()); |
107 EXPECT_TRUE(load_result.outgoing_messages.empty()); | 108 EXPECT_TRUE(load_result->outgoing_messages.empty()); |
108 EXPECT_EQ(1LL, load_result.serial_number_mappings.next_serial_number); | 109 EXPECT_EQ(1LL, load_result->serial_number_mappings.next_serial_number); |
109 EXPECT_TRUE(load_result.serial_number_mappings.user_serial_numbers.empty()); | 110 EXPECT_TRUE(load_result->serial_number_mappings.user_serial_numbers.empty()); |
110 } | 111 } |
111 | 112 |
112 TEST_F(GCMStoreImplTest, DeviceCredentials) { | 113 TEST_F(GCMStoreImplTest, DeviceCredentials) { |
113 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); | 114 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); |
114 GCMStore::LoadResult load_result; | 115 scoped_ptr<GCMStore::LoadResult> load_result; |
115 gcm_store->Load(base::Bind( | 116 gcm_store->Load(base::Bind( |
116 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 117 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
117 PumpLoop(); | 118 PumpLoop(); |
118 | 119 |
119 gcm_store->SetDeviceCredentials( | 120 gcm_store->SetDeviceCredentials( |
120 kDeviceId, | 121 kDeviceId, |
121 kDeviceToken, | 122 kDeviceToken, |
122 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 123 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
123 PumpLoop(); | 124 PumpLoop(); |
124 | 125 |
125 gcm_store = BuildGCMStore().Pass(); | 126 gcm_store = BuildGCMStore().Pass(); |
126 gcm_store->Load(base::Bind( | 127 gcm_store->Load(base::Bind( |
127 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 128 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
128 PumpLoop(); | 129 PumpLoop(); |
129 | 130 |
130 ASSERT_EQ(kDeviceId, load_result.device_android_id); | 131 ASSERT_EQ(kDeviceId, load_result->device_android_id); |
131 ASSERT_EQ(kDeviceToken, load_result.device_security_token); | 132 ASSERT_EQ(kDeviceToken, load_result->device_security_token); |
132 } | 133 } |
133 | 134 |
134 // Verify saving some incoming messages, reopening the directory, and then | 135 // Verify saving some incoming messages, reopening the directory, and then |
135 // removing those incoming messages. | 136 // removing those incoming messages. |
136 TEST_F(GCMStoreImplTest, IncomingMessages) { | 137 TEST_F(GCMStoreImplTest, IncomingMessages) { |
137 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); | 138 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); |
138 GCMStore::LoadResult load_result; | 139 scoped_ptr<GCMStore::LoadResult> load_result; |
139 gcm_store->Load(base::Bind( | 140 gcm_store->Load(base::Bind( |
140 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 141 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
141 PumpLoop(); | 142 PumpLoop(); |
142 | 143 |
143 std::vector<std::string> persistent_ids; | 144 std::vector<std::string> persistent_ids; |
144 for (int i = 0; i < kNumPersistentIds; ++i) { | 145 for (int i = 0; i < kNumPersistentIds; ++i) { |
145 persistent_ids.push_back(GetNextPersistentId()); | 146 persistent_ids.push_back(GetNextPersistentId()); |
146 gcm_store->AddIncomingMessage( | 147 gcm_store->AddIncomingMessage( |
147 persistent_ids.back(), | 148 persistent_ids.back(), |
148 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 149 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
149 PumpLoop(); | 150 PumpLoop(); |
150 } | 151 } |
151 | 152 |
152 gcm_store = BuildGCMStore().Pass(); | 153 gcm_store = BuildGCMStore().Pass(); |
153 gcm_store->Load(base::Bind( | 154 gcm_store->Load(base::Bind( |
154 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 155 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
155 PumpLoop(); | 156 PumpLoop(); |
156 | 157 |
157 ASSERT_EQ(persistent_ids, load_result.incoming_messages); | 158 ASSERT_EQ(persistent_ids, load_result->incoming_messages); |
158 ASSERT_TRUE(load_result.outgoing_messages.empty()); | 159 ASSERT_TRUE(load_result->outgoing_messages.empty()); |
159 | 160 |
160 gcm_store->RemoveIncomingMessages( | 161 gcm_store->RemoveIncomingMessages( |
161 persistent_ids, | 162 persistent_ids, |
162 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 163 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
163 PumpLoop(); | 164 PumpLoop(); |
164 | 165 |
165 gcm_store = BuildGCMStore().Pass(); | 166 gcm_store = BuildGCMStore().Pass(); |
166 load_result.incoming_messages.clear(); | 167 load_result->incoming_messages.clear(); |
167 gcm_store->Load(base::Bind( | 168 gcm_store->Load(base::Bind( |
168 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 169 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
169 PumpLoop(); | 170 PumpLoop(); |
170 | 171 |
171 ASSERT_TRUE(load_result.incoming_messages.empty()); | 172 ASSERT_TRUE(load_result->incoming_messages.empty()); |
172 ASSERT_TRUE(load_result.outgoing_messages.empty()); | 173 ASSERT_TRUE(load_result->outgoing_messages.empty()); |
173 } | 174 } |
174 | 175 |
175 // Verify saving some outgoing messages, reopening the directory, and then | 176 // Verify saving some outgoing messages, reopening the directory, and then |
176 // removing those outgoing messages. | 177 // removing those outgoing messages. |
177 // Fails on linux_asan crbug.com/337560 | 178 TEST_F(GCMStoreImplTest, OutgoingMessages) { |
178 #if !defined(OS_POSIX) | |
179 #define MAYBE_OutgoingMessages OutgoingMessages | |
180 #else | |
181 #define MAYBE_OutgoingMessages DISABLED_OutgoingMessages | |
182 #endif | |
183 TEST_F(GCMStoreImplTest, MAYBE_OutgoingMessages) { | |
184 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); | 179 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); |
185 GCMStore::LoadResult load_result; | 180 scoped_ptr<GCMStore::LoadResult> load_result; |
186 gcm_store->Load(base::Bind( | 181 gcm_store->Load(base::Bind( |
187 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 182 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
188 PumpLoop(); | 183 PumpLoop(); |
189 | 184 |
190 std::vector<std::string> persistent_ids; | 185 std::vector<std::string> persistent_ids; |
191 const int kNumPersistentIds = 10; | 186 const int kNumPersistentIds = 10; |
192 for (int i = 0; i < kNumPersistentIds; ++i) { | 187 for (int i = 0; i < kNumPersistentIds; ++i) { |
193 persistent_ids.push_back(GetNextPersistentId()); | 188 persistent_ids.push_back(GetNextPersistentId()); |
194 mcs_proto::DataMessageStanza message; | 189 mcs_proto::DataMessageStanza message; |
195 message.set_from(kAppName + persistent_ids.back()); | 190 message.set_from(kAppName + persistent_ids.back()); |
196 message.set_category(kCategoryName + persistent_ids.back()); | 191 message.set_category(kCategoryName + persistent_ids.back()); |
197 gcm_store->AddOutgoingMessage( | 192 gcm_store->AddOutgoingMessage( |
198 persistent_ids.back(), | 193 persistent_ids.back(), |
199 MCSMessage(message), | 194 MCSMessage(message), |
200 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 195 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
201 PumpLoop(); | 196 PumpLoop(); |
202 } | 197 } |
203 | 198 |
204 gcm_store = BuildGCMStore().Pass(); | 199 gcm_store = BuildGCMStore().Pass(); |
205 gcm_store->Load(base::Bind( | 200 gcm_store->Load(base::Bind( |
206 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 201 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
207 PumpLoop(); | 202 PumpLoop(); |
208 | 203 |
209 ASSERT_TRUE(load_result.incoming_messages.empty()); | 204 ASSERT_TRUE(load_result->incoming_messages.empty()); |
210 ASSERT_EQ(load_result.outgoing_messages.size(), persistent_ids.size()); | 205 ASSERT_EQ(load_result->outgoing_messages.size(), persistent_ids.size()); |
211 for (int i = 0; i < kNumPersistentIds; ++i) { | 206 for (int i = 0; i < kNumPersistentIds; ++i) { |
212 std::string id = persistent_ids[i]; | 207 std::string id = persistent_ids[i]; |
213 ASSERT_TRUE(load_result.outgoing_messages[id]); | 208 ASSERT_TRUE(load_result->outgoing_messages[id].get()); |
214 const mcs_proto::DataMessageStanza* message = | 209 const mcs_proto::DataMessageStanza* message = |
215 reinterpret_cast<mcs_proto::DataMessageStanza*>( | 210 reinterpret_cast<mcs_proto::DataMessageStanza*>( |
216 load_result.outgoing_messages[id]); | 211 load_result->outgoing_messages[id].get()); |
217 ASSERT_EQ(message->from(), kAppName + id); | 212 ASSERT_EQ(message->from(), kAppName + id); |
218 ASSERT_EQ(message->category(), kCategoryName + id); | 213 ASSERT_EQ(message->category(), kCategoryName + id); |
219 } | 214 } |
220 | 215 |
221 gcm_store->RemoveOutgoingMessages( | 216 gcm_store->RemoveOutgoingMessages( |
222 persistent_ids, | 217 persistent_ids, |
223 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 218 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
224 PumpLoop(); | 219 PumpLoop(); |
225 | 220 |
226 gcm_store = BuildGCMStore().Pass(); | 221 gcm_store = BuildGCMStore().Pass(); |
227 load_result.outgoing_messages.clear(); | 222 load_result->outgoing_messages.clear(); |
228 gcm_store->Load(base::Bind( | 223 gcm_store->Load(base::Bind( |
229 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 224 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
230 PumpLoop(); | 225 PumpLoop(); |
231 | 226 |
232 ASSERT_TRUE(load_result.incoming_messages.empty()); | 227 ASSERT_TRUE(load_result->incoming_messages.empty()); |
233 ASSERT_TRUE(load_result.outgoing_messages.empty()); | 228 ASSERT_TRUE(load_result->outgoing_messages.empty()); |
234 } | 229 } |
235 | 230 |
236 // Verify incoming and outgoing messages don't conflict. | 231 // Verify incoming and outgoing messages don't conflict. |
237 // Fails on linux_asan crbug.com/337560 | 232 TEST_F(GCMStoreImplTest, IncomingAndOutgoingMessages) { |
238 #if !defined(OS_POSIX) | |
239 #define MAYBE_IncomingAndOutgoingMessages IncomingAndOutgoingMessages | |
240 #else | |
241 #define MAYBE_IncomingAndOutgoingMessages DISABLED_IncomingAndOutgoingMessages | |
242 #endif | |
243 TEST_F(GCMStoreImplTest, MAYBE_IncomingAndOutgoingMessages) { | |
244 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); | 233 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); |
245 GCMStore::LoadResult load_result; | 234 scoped_ptr<GCMStore::LoadResult> load_result; |
246 gcm_store->Load(base::Bind( | 235 gcm_store->Load(base::Bind( |
247 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 236 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
248 PumpLoop(); | 237 PumpLoop(); |
249 | 238 |
250 std::vector<std::string> persistent_ids; | 239 std::vector<std::string> persistent_ids; |
251 const int kNumPersistentIds = 10; | 240 const int kNumPersistentIds = 10; |
252 for (int i = 0; i < kNumPersistentIds; ++i) { | 241 for (int i = 0; i < kNumPersistentIds; ++i) { |
253 persistent_ids.push_back(GetNextPersistentId()); | 242 persistent_ids.push_back(GetNextPersistentId()); |
254 gcm_store->AddIncomingMessage( | 243 gcm_store->AddIncomingMessage( |
255 persistent_ids.back(), | 244 persistent_ids.back(), |
256 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 245 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
257 PumpLoop(); | 246 PumpLoop(); |
258 | 247 |
259 mcs_proto::DataMessageStanza message; | 248 mcs_proto::DataMessageStanza message; |
260 message.set_from(kAppName + persistent_ids.back()); | 249 message.set_from(kAppName + persistent_ids.back()); |
261 message.set_category(kCategoryName + persistent_ids.back()); | 250 message.set_category(kCategoryName + persistent_ids.back()); |
262 gcm_store->AddOutgoingMessage( | 251 gcm_store->AddOutgoingMessage( |
263 persistent_ids.back(), | 252 persistent_ids.back(), |
264 MCSMessage(message), | 253 MCSMessage(message), |
265 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 254 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
266 PumpLoop(); | 255 PumpLoop(); |
267 } | 256 } |
268 | 257 |
269 gcm_store = BuildGCMStore().Pass(); | 258 gcm_store = BuildGCMStore().Pass(); |
270 gcm_store->Load(base::Bind( | 259 gcm_store->Load(base::Bind( |
271 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 260 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
272 PumpLoop(); | 261 PumpLoop(); |
273 | 262 |
274 ASSERT_EQ(persistent_ids, load_result.incoming_messages); | 263 ASSERT_EQ(persistent_ids, load_result->incoming_messages); |
275 ASSERT_EQ(load_result.outgoing_messages.size(), persistent_ids.size()); | 264 ASSERT_EQ(load_result->outgoing_messages.size(), persistent_ids.size()); |
276 for (int i = 0; i < kNumPersistentIds; ++i) { | 265 for (int i = 0; i < kNumPersistentIds; ++i) { |
277 std::string id = persistent_ids[i]; | 266 std::string id = persistent_ids[i]; |
278 ASSERT_TRUE(load_result.outgoing_messages[id]); | 267 ASSERT_TRUE(load_result->outgoing_messages[id].get()); |
279 const mcs_proto::DataMessageStanza* message = | 268 const mcs_proto::DataMessageStanza* message = |
280 reinterpret_cast<mcs_proto::DataMessageStanza*>( | 269 reinterpret_cast<mcs_proto::DataMessageStanza*>( |
281 load_result.outgoing_messages[id]); | 270 load_result->outgoing_messages[id].get()); |
282 ASSERT_EQ(message->from(), kAppName + id); | 271 ASSERT_EQ(message->from(), kAppName + id); |
283 ASSERT_EQ(message->category(), kCategoryName + id); | 272 ASSERT_EQ(message->category(), kCategoryName + id); |
284 } | 273 } |
285 | 274 |
286 gcm_store->RemoveIncomingMessages( | 275 gcm_store->RemoveIncomingMessages( |
287 persistent_ids, | 276 persistent_ids, |
288 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 277 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
289 PumpLoop(); | 278 PumpLoop(); |
290 gcm_store->RemoveOutgoingMessages( | 279 gcm_store->RemoveOutgoingMessages( |
291 persistent_ids, | 280 persistent_ids, |
292 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 281 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
293 PumpLoop(); | 282 PumpLoop(); |
294 | 283 |
295 gcm_store = BuildGCMStore().Pass(); | 284 gcm_store = BuildGCMStore().Pass(); |
296 load_result.incoming_messages.clear(); | 285 load_result->incoming_messages.clear(); |
297 load_result.outgoing_messages.clear(); | 286 load_result->outgoing_messages.clear(); |
298 gcm_store->Load(base::Bind( | 287 gcm_store->Load(base::Bind( |
299 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 288 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
300 PumpLoop(); | 289 PumpLoop(); |
301 | 290 |
302 ASSERT_TRUE(load_result.incoming_messages.empty()); | 291 ASSERT_TRUE(load_result->incoming_messages.empty()); |
303 ASSERT_TRUE(load_result.outgoing_messages.empty()); | 292 ASSERT_TRUE(load_result->outgoing_messages.empty()); |
304 } | 293 } |
305 | 294 |
306 // Verify that the next serial number of persisted properly. | 295 // Verify that the next serial number of persisted properly. |
307 TEST_F(GCMStoreImplTest, NextSerialNumber) { | 296 TEST_F(GCMStoreImplTest, NextSerialNumber) { |
308 const int64 kNextSerialNumber = 77LL; | 297 const int64 kNextSerialNumber = 77LL; |
309 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); | 298 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); |
310 GCMStore::LoadResult load_result; | 299 scoped_ptr<GCMStore::LoadResult> load_result; |
311 gcm_store->Load(base::Bind( | 300 gcm_store->Load(base::Bind( |
312 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 301 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
313 PumpLoop(); | 302 PumpLoop(); |
314 | 303 |
315 gcm_store->SetNextSerialNumber( | 304 gcm_store->SetNextSerialNumber( |
316 kNextSerialNumber, | 305 kNextSerialNumber, |
317 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 306 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
318 PumpLoop(); | 307 PumpLoop(); |
319 | 308 |
320 gcm_store = BuildGCMStore().Pass(); | 309 gcm_store = BuildGCMStore().Pass(); |
321 gcm_store->Load(base::Bind( | 310 gcm_store->Load(base::Bind( |
322 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 311 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
323 PumpLoop(); | 312 PumpLoop(); |
324 | 313 |
325 EXPECT_EQ(kNextSerialNumber, | 314 EXPECT_EQ(kNextSerialNumber, |
326 load_result.serial_number_mappings.next_serial_number); | 315 load_result->serial_number_mappings.next_serial_number); |
327 } | 316 } |
328 | 317 |
329 // Verify that user serial number mappings are persisted properly. | 318 // Verify that user serial number mappings are persisted properly. |
330 TEST_F(GCMStoreImplTest, UserSerialNumberMappings) { | 319 TEST_F(GCMStoreImplTest, UserSerialNumberMappings) { |
331 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); | 320 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); |
332 GCMStore::LoadResult load_result; | 321 scoped_ptr<GCMStore::LoadResult> load_result; |
333 gcm_store->Load(base::Bind( | 322 gcm_store->Load(base::Bind( |
334 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 323 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
335 PumpLoop(); | 324 PumpLoop(); |
336 | 325 |
337 std::string username1 = "username1"; | 326 std::string username1 = "username1"; |
338 int64 serial_number1 = 34LL; | 327 int64 serial_number1 = 34LL; |
339 gcm_store->AddUserSerialNumber( | 328 gcm_store->AddUserSerialNumber( |
340 username1, | 329 username1, |
341 serial_number1, | 330 serial_number1, |
342 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 331 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
343 | 332 |
344 std::string username2 = "username2"; | 333 std::string username2 = "username2"; |
345 int64 serial_number2 = 56LL; | 334 int64 serial_number2 = 56LL; |
346 gcm_store->AddUserSerialNumber( | 335 gcm_store->AddUserSerialNumber( |
347 username2, | 336 username2, |
348 serial_number2, | 337 serial_number2, |
349 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 338 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
350 PumpLoop(); | 339 PumpLoop(); |
351 | 340 |
352 gcm_store = BuildGCMStore().Pass(); | 341 gcm_store = BuildGCMStore().Pass(); |
353 gcm_store->Load(base::Bind( | 342 gcm_store->Load(base::Bind( |
354 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); | 343 &GCMStoreImplTest::LoadCallback, base::Unretained(this), &load_result)); |
355 PumpLoop(); | 344 PumpLoop(); |
356 | 345 |
357 ASSERT_EQ(2u, load_result.serial_number_mappings.user_serial_numbers.size()); | 346 ASSERT_EQ(2u, load_result->serial_number_mappings.user_serial_numbers.size()); |
358 ASSERT_NE( | 347 ASSERT_NE( |
359 load_result.serial_number_mappings.user_serial_numbers.end(), | 348 load_result->serial_number_mappings.user_serial_numbers.end(), |
360 load_result.serial_number_mappings.user_serial_numbers.find(username1)); | 349 load_result->serial_number_mappings.user_serial_numbers.find(username1)); |
361 EXPECT_EQ(serial_number1, | 350 EXPECT_EQ(serial_number1, |
362 load_result.serial_number_mappings.user_serial_numbers[username1]); | 351 load_result->serial_number_mappings.user_serial_numbers[username1]); |
363 ASSERT_NE( | 352 ASSERT_NE( |
364 load_result.serial_number_mappings.user_serial_numbers.end(), | 353 load_result->serial_number_mappings.user_serial_numbers.end(), |
365 load_result.serial_number_mappings.user_serial_numbers.find(username2)); | 354 load_result->serial_number_mappings.user_serial_numbers.find(username2)); |
366 EXPECT_EQ(serial_number2, | 355 EXPECT_EQ(serial_number2, |
367 load_result.serial_number_mappings.user_serial_numbers[username2]); | 356 load_result->serial_number_mappings.user_serial_numbers[username2]); |
368 } | 357 } |
369 | 358 |
370 // Test that per-app message limits are enforced, persisted across restarts, | 359 // Test that per-app message limits are enforced, persisted across restarts, |
371 // and updated as messages are removed. | 360 // and updated as messages are removed. |
372 // Fails on linux_asan crbug.com/337560 | 361 TEST_F(GCMStoreImplTest, PerAppMessageLimits) { |
373 #if !defined(OS_POSIX) | |
374 #define MAYBE_PerAppMessageLimits PerAppMessageLimits | |
375 #else | |
376 #define MAYBE_PerAppMessageLimits DISABLED_PerAppMessageLimits | |
377 #endif | |
378 TEST_F(GCMStoreImplTest, MAYBE_PerAppMessageLimits) { | |
379 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); | 362 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); |
380 GCMStore::LoadResult load_result; | 363 scoped_ptr<GCMStore::LoadResult> load_result; |
381 gcm_store->Load(base::Bind(&GCMStoreImplTest::LoadCallback, | 364 gcm_store->Load(base::Bind(&GCMStoreImplTest::LoadCallback, |
382 base::Unretained(this), | 365 base::Unretained(this), |
383 &load_result)); | 366 &load_result)); |
384 | 367 |
385 // Add the initial (below app limit) messages. | 368 // Add the initial (below app limit) messages. |
386 for (int i = 0; i < kNumMessagesPerApp; ++i) { | 369 for (int i = 0; i < kNumMessagesPerApp; ++i) { |
387 mcs_proto::DataMessageStanza message; | 370 mcs_proto::DataMessageStanza message; |
388 message.set_from(kAppName); | 371 message.set_from(kAppName); |
389 message.set_category(kCategoryName); | 372 message.set_category(kCategoryName); |
390 EXPECT_TRUE(gcm_store->AddOutgoingMessage( | 373 EXPECT_TRUE(gcm_store->AddOutgoingMessage( |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
449 base::Unretained(this)))); | 432 base::Unretained(this)))); |
450 PumpLoop(); | 433 PumpLoop(); |
451 } | 434 } |
452 } | 435 } |
453 | 436 |
454 // When the database is destroyed, all database updates should fail. At the | 437 // When the database is destroyed, all database updates should fail. At the |
455 // same time, they per-app message counts should not go up, as failures should | 438 // same time, they per-app message counts should not go up, as failures should |
456 // result in decrementing the counts. | 439 // result in decrementing the counts. |
457 TEST_F(GCMStoreImplTest, AddMessageAfterDestroy) { | 440 TEST_F(GCMStoreImplTest, AddMessageAfterDestroy) { |
458 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); | 441 scoped_ptr<GCMStore> gcm_store(BuildGCMStore()); |
459 GCMStore::LoadResult load_result; | 442 scoped_ptr<GCMStore::LoadResult> load_result; |
460 gcm_store->Load(base::Bind(&GCMStoreImplTest::LoadCallback, | 443 gcm_store->Load(base::Bind(&GCMStoreImplTest::LoadCallback, |
461 base::Unretained(this), | 444 base::Unretained(this), |
462 &load_result)); | 445 &load_result)); |
463 PumpLoop(); | 446 PumpLoop(); |
464 gcm_store->Destroy(base::Bind(&GCMStoreImplTest::UpdateCallback, | 447 gcm_store->Destroy(base::Bind(&GCMStoreImplTest::UpdateCallback, |
465 base::Unretained(this))); | 448 base::Unretained(this))); |
466 PumpLoop(); | 449 PumpLoop(); |
467 | 450 |
468 expected_success_ = false; | 451 expected_success_ = false; |
469 for (int i = 0; i < kNumMessagesPerApp * 2; ++i) { | 452 for (int i = 0; i < kNumMessagesPerApp * 2; ++i) { |
470 mcs_proto::DataMessageStanza message; | 453 mcs_proto::DataMessageStanza message; |
471 message.set_from(kAppName); | 454 message.set_from(kAppName); |
472 message.set_category(kCategoryName); | 455 message.set_category(kCategoryName); |
473 // Because all adds are failing, none should hit the per-app message limits. | 456 // Because all adds are failing, none should hit the per-app message limits. |
474 EXPECT_TRUE(gcm_store->AddOutgoingMessage( | 457 EXPECT_TRUE(gcm_store->AddOutgoingMessage( |
475 base::IntToString(i), | 458 base::IntToString(i), |
476 MCSMessage(message), | 459 MCSMessage(message), |
477 base::Bind(&GCMStoreImplTest::UpdateCallback, | 460 base::Bind(&GCMStoreImplTest::UpdateCallback, |
478 base::Unretained(this)))); | 461 base::Unretained(this)))); |
479 PumpLoop(); | 462 PumpLoop(); |
480 } | 463 } |
481 } | 464 } |
482 | 465 |
483 } // namespace | 466 } // namespace |
484 | 467 |
485 } // namespace gcm | 468 } // namespace gcm |
OLD | NEW |