OLD | NEW |
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 1 // Copyright 2011 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 "components/sessions/core/session_backend.h" |
| 6 |
5 #include <stddef.h> | 7 #include <stddef.h> |
| 8 #include <utility> |
6 | 9 |
7 #include "base/files/file_util.h" | 10 #include "base/files/file_util.h" |
8 #include "base/files/scoped_temp_dir.h" | 11 #include "base/files/scoped_temp_dir.h" |
9 #include "base/macros.h" | 12 #include "base/macros.h" |
10 #include "base/stl_util.h" | 13 #include "base/stl_util.h" |
11 #include "base/strings/string_util.h" | 14 #include "base/strings/string_util.h" |
12 #include "components/sessions/core/session_backend.h" | |
13 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
14 | 16 |
15 namespace sessions { | 17 namespace sessions { |
16 namespace { | 18 namespace { |
17 | 19 |
18 typedef ScopedVector<sessions::SessionCommand> SessionCommands; | 20 typedef ScopedVector<sessions::SessionCommand> SessionCommands; |
19 | 21 |
20 struct TestData { | 22 struct TestData { |
21 sessions::SessionCommand::id_type command_id; | 23 sessions::SessionCommand::id_type command_id; |
22 std::string data; | 24 std::string data; |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
54 base::FilePath path_; | 56 base::FilePath path_; |
55 base::ScopedTempDir temp_dir_; | 57 base::ScopedTempDir temp_dir_; |
56 }; | 58 }; |
57 | 59 |
58 TEST_F(SessionBackendTest, SimpleReadWrite) { | 60 TEST_F(SessionBackendTest, SimpleReadWrite) { |
59 scoped_refptr<SessionBackend> backend( | 61 scoped_refptr<SessionBackend> backend( |
60 new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_)); | 62 new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_)); |
61 struct TestData data = { 1, "a" }; | 63 struct TestData data = { 1, "a" }; |
62 SessionCommands commands; | 64 SessionCommands commands; |
63 commands.push_back(CreateCommandFromData(data)); | 65 commands.push_back(CreateCommandFromData(data)); |
64 backend->AppendCommands(commands.Pass(), false); | 66 backend->AppendCommands(std::move(commands), false); |
65 ASSERT_TRUE(commands.empty()); | 67 ASSERT_TRUE(commands.empty()); |
66 | 68 |
67 // Read it back in. | 69 // Read it back in. |
68 backend = NULL; | 70 backend = NULL; |
69 backend = new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, | 71 backend = new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, |
70 path_); | 72 path_); |
71 backend->ReadLastSessionCommandsImpl(&commands); | 73 backend->ReadLastSessionCommandsImpl(&commands); |
72 | 74 |
73 ASSERT_EQ(1U, commands.size()); | 75 ASSERT_EQ(1U, commands.size()); |
74 AssertCommandEqualsData(data, commands[0]); | 76 AssertCommandEqualsData(data, commands[0]); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
111 path_)); | 113 path_)); |
112 SessionCommands commands; | 114 SessionCommands commands; |
113 if (i != 0) { | 115 if (i != 0) { |
114 // Read previous data. | 116 // Read previous data. |
115 backend->ReadLastSessionCommandsImpl(&commands); | 117 backend->ReadLastSessionCommandsImpl(&commands); |
116 ASSERT_EQ(i, commands.size()); | 118 ASSERT_EQ(i, commands.size()); |
117 for (std::vector<sessions::SessionCommand*>::iterator j = | 119 for (std::vector<sessions::SessionCommand*>::iterator j = |
118 commands.begin(); j != commands.end(); ++j) { | 120 commands.begin(); j != commands.end(); ++j) { |
119 AssertCommandEqualsData(data[j - commands.begin()], *j); | 121 AssertCommandEqualsData(data[j - commands.begin()], *j); |
120 } | 122 } |
121 backend->AppendCommands(commands.Pass(), false); | 123 backend->AppendCommands(std::move(commands), false); |
122 } | 124 } |
123 commands.push_back(CreateCommandFromData(data[i])); | 125 commands.push_back(CreateCommandFromData(data[i])); |
124 backend->AppendCommands(commands.Pass(), false); | 126 backend->AppendCommands(std::move(commands), false); |
125 } | 127 } |
126 } | 128 } |
127 | 129 |
128 TEST_F(SessionBackendTest, BigData) { | 130 TEST_F(SessionBackendTest, BigData) { |
129 struct TestData data[] = { | 131 struct TestData data[] = { |
130 { 1, "a" }, | 132 { 1, "a" }, |
131 { 2, "ab" }, | 133 { 2, "ab" }, |
132 }; | 134 }; |
133 | 135 |
134 scoped_refptr<SessionBackend> backend( | 136 scoped_refptr<SessionBackend> backend( |
135 new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_)); | 137 new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_)); |
136 ScopedVector<sessions::SessionCommand> commands; | 138 ScopedVector<sessions::SessionCommand> commands; |
137 | 139 |
138 commands.push_back(CreateCommandFromData(data[0])); | 140 commands.push_back(CreateCommandFromData(data[0])); |
139 const sessions::SessionCommand::size_type big_size = | 141 const sessions::SessionCommand::size_type big_size = |
140 SessionBackend::kFileReadBufferSize + 100; | 142 SessionBackend::kFileReadBufferSize + 100; |
141 const sessions::SessionCommand::id_type big_id = 50; | 143 const sessions::SessionCommand::id_type big_id = 50; |
142 sessions::SessionCommand* big_command = | 144 sessions::SessionCommand* big_command = |
143 new sessions::SessionCommand(big_id, big_size); | 145 new sessions::SessionCommand(big_id, big_size); |
144 reinterpret_cast<char*>(big_command->contents())[0] = 'a'; | 146 reinterpret_cast<char*>(big_command->contents())[0] = 'a'; |
145 reinterpret_cast<char*>(big_command->contents())[big_size - 1] = 'z'; | 147 reinterpret_cast<char*>(big_command->contents())[big_size - 1] = 'z'; |
146 commands.push_back(big_command); | 148 commands.push_back(big_command); |
147 commands.push_back(CreateCommandFromData(data[1])); | 149 commands.push_back(CreateCommandFromData(data[1])); |
148 backend->AppendCommands(commands.Pass(), false); | 150 backend->AppendCommands(std::move(commands), false); |
149 | 151 |
150 backend = NULL; | 152 backend = NULL; |
151 backend = new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, | 153 backend = new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, |
152 path_); | 154 path_); |
153 | 155 |
154 backend->ReadLastSessionCommandsImpl(&commands); | 156 backend->ReadLastSessionCommandsImpl(&commands); |
155 ASSERT_EQ(3U, commands.size()); | 157 ASSERT_EQ(3U, commands.size()); |
156 AssertCommandEqualsData(data[0], commands[0]); | 158 AssertCommandEqualsData(data[0], commands[0]); |
157 AssertCommandEqualsData(data[1], commands[2]); | 159 AssertCommandEqualsData(data[1], commands[2]); |
158 | 160 |
159 EXPECT_EQ(big_id, commands[1]->id()); | 161 EXPECT_EQ(big_id, commands[1]->id()); |
160 ASSERT_EQ(big_size, commands[1]->size()); | 162 ASSERT_EQ(big_size, commands[1]->size()); |
161 EXPECT_EQ('a', reinterpret_cast<char*>(commands[1]->contents())[0]); | 163 EXPECT_EQ('a', reinterpret_cast<char*>(commands[1]->contents())[0]); |
162 EXPECT_EQ('z', | 164 EXPECT_EQ('z', |
163 reinterpret_cast<char*>(commands[1]->contents())[big_size - 1]); | 165 reinterpret_cast<char*>(commands[1]->contents())[big_size - 1]); |
164 commands.clear(); | 166 commands.clear(); |
165 } | 167 } |
166 | 168 |
167 TEST_F(SessionBackendTest, EmptyCommand) { | 169 TEST_F(SessionBackendTest, EmptyCommand) { |
168 TestData empty_command; | 170 TestData empty_command; |
169 empty_command.command_id = 1; | 171 empty_command.command_id = 1; |
170 scoped_refptr<SessionBackend> backend( | 172 scoped_refptr<SessionBackend> backend( |
171 new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_)); | 173 new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_)); |
172 SessionCommands empty_commands; | 174 SessionCommands empty_commands; |
173 empty_commands.push_back(CreateCommandFromData(empty_command)); | 175 empty_commands.push_back(CreateCommandFromData(empty_command)); |
174 backend->AppendCommands(empty_commands.Pass(), true); | 176 backend->AppendCommands(std::move(empty_commands), true); |
175 backend->MoveCurrentSessionToLastSession(); | 177 backend->MoveCurrentSessionToLastSession(); |
176 | 178 |
177 SessionCommands commands; | 179 SessionCommands commands; |
178 backend->ReadLastSessionCommandsImpl(&commands); | 180 backend->ReadLastSessionCommandsImpl(&commands); |
179 ASSERT_EQ(1U, commands.size()); | 181 ASSERT_EQ(1U, commands.size()); |
180 AssertCommandEqualsData(empty_command, commands[0]); | 182 AssertCommandEqualsData(empty_command, commands[0]); |
181 commands.clear(); | 183 commands.clear(); |
182 } | 184 } |
183 | 185 |
184 // Writes a command, appends another command with reset to true, then reads | 186 // Writes a command, appends another command with reset to true, then reads |
185 // making sure we only get back the second command. | 187 // making sure we only get back the second command. |
186 TEST_F(SessionBackendTest, Truncate) { | 188 TEST_F(SessionBackendTest, Truncate) { |
187 scoped_refptr<SessionBackend> backend( | 189 scoped_refptr<SessionBackend> backend( |
188 new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_)); | 190 new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, path_)); |
189 struct TestData first_data = { 1, "a" }; | 191 struct TestData first_data = { 1, "a" }; |
190 SessionCommands commands; | 192 SessionCommands commands; |
191 commands.push_back(CreateCommandFromData(first_data)); | 193 commands.push_back(CreateCommandFromData(first_data)); |
192 backend->AppendCommands(commands.Pass(), false); | 194 backend->AppendCommands(std::move(commands), false); |
193 | 195 |
194 // Write another command, this time resetting the file when appending. | 196 // Write another command, this time resetting the file when appending. |
195 struct TestData second_data = { 2, "b" }; | 197 struct TestData second_data = { 2, "b" }; |
196 commands.push_back(CreateCommandFromData(second_data)); | 198 commands.push_back(CreateCommandFromData(second_data)); |
197 backend->AppendCommands(commands.Pass(), true); | 199 backend->AppendCommands(std::move(commands), true); |
198 | 200 |
199 // Read it back in. | 201 // Read it back in. |
200 backend = NULL; | 202 backend = NULL; |
201 backend = new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, | 203 backend = new SessionBackend(sessions::BaseSessionService::SESSION_RESTORE, |
202 path_); | 204 path_); |
203 backend->ReadLastSessionCommandsImpl(&commands); | 205 backend->ReadLastSessionCommandsImpl(&commands); |
204 | 206 |
205 // And make sure we get back the expected data. | 207 // And make sure we get back the expected data. |
206 ASSERT_EQ(1U, commands.size()); | 208 ASSERT_EQ(1U, commands.size()); |
207 AssertCommandEqualsData(second_data, commands[0]); | 209 AssertCommandEqualsData(second_data, commands[0]); |
208 | 210 |
209 commands.clear(); | 211 commands.clear(); |
210 } | 212 } |
211 | 213 |
212 } // namespace sessions | 214 } // namespace sessions |
OLD | NEW |