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 <string> | 5 #include <string> |
6 | 6 |
7 #include "base/memory/scoped_ptr.h" | 7 #include "base/memory/scoped_ptr.h" |
8 #include "base/memory/scoped_vector.h" | 8 #include "base/memory/scoped_vector.h" |
9 #include "chrome/browser/chromeos/file_system_provider/observer.h" | 9 #include "chrome/browser/chromeos/file_system_provider/observer.h" |
10 #include "chrome/browser/chromeos/file_system_provider/provided_file_system.h" | 10 #include "chrome/browser/chromeos/file_system_provider/provided_file_system.h" |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
66 scoped_ptr<TestingProfile> profile_; | 66 scoped_ptr<TestingProfile> profile_; |
67 scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_; | 67 scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_; |
68 FakeUserManager* user_manager_; | 68 FakeUserManager* user_manager_; |
69 scoped_ptr<Service> file_system_provider_service_; | 69 scoped_ptr<Service> file_system_provider_service_; |
70 }; | 70 }; |
71 | 71 |
72 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem) { | 72 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem) { |
73 LoggingObserver observer; | 73 LoggingObserver observer; |
74 file_system_provider_service_->AddObserver(&observer); | 74 file_system_provider_service_->AddObserver(&observer); |
75 | 75 |
76 const std::string file_system_id = | 76 int file_system_id = file_system_provider_service_->RegisterFileSystem( |
77 file_system_provider_service_->RegisterFileSystem(kExtensionId, | 77 kExtensionId, kFileSystemName); |
78 kFileSystemName); | |
79 | 78 |
80 EXPECT_NE("", file_system_id); | 79 EXPECT_LT(0, file_system_id); |
81 ASSERT_EQ(1u, observer.registered.size()); | 80 ASSERT_EQ(1u, observer.registered.size()); |
82 EXPECT_EQ(kExtensionId, observer.registered[0]->extension_id()); | 81 EXPECT_EQ(kExtensionId, observer.registered[0]->extension_id()); |
83 EXPECT_EQ("mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash", | 82 EXPECT_EQ(1, observer.registered[0]->file_system_id()); |
84 observer.registered[0]->file_system_id()); | |
85 EXPECT_EQ("/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash", | 83 EXPECT_EQ("/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash", |
86 observer.registered[0]->mount_path().AsUTF8Unsafe()); | 84 observer.registered[0]->mount_path().AsUTF8Unsafe()); |
87 EXPECT_EQ(kFileSystemName, observer.registered[0]->file_system_name()); | 85 EXPECT_EQ(kFileSystemName, observer.registered[0]->file_system_name()); |
88 ASSERT_EQ(0u, observer.unregistered.size()); | 86 ASSERT_EQ(0u, observer.unregistered.size()); |
89 | 87 |
90 std::vector<ProvidedFileSystem> provided_file_systems = | 88 std::vector<ProvidedFileSystem> provided_file_systems = |
91 file_system_provider_service_->GetRegisteredFileSystems(); | 89 file_system_provider_service_->GetRegisteredFileSystems(); |
92 ASSERT_EQ(1u, provided_file_systems.size()); | 90 ASSERT_EQ(1u, provided_file_systems.size()); |
93 | 91 |
94 file_system_provider_service_->RemoveObserver(&observer); | 92 file_system_provider_service_->RemoveObserver(&observer); |
95 } | 93 } |
96 | 94 |
97 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem_UniqueIds) { | 95 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem_UniqueIds) { |
98 LoggingObserver observer; | 96 LoggingObserver observer; |
99 file_system_provider_service_->AddObserver(&observer); | 97 file_system_provider_service_->AddObserver(&observer); |
100 | 98 |
101 std::string file_system_first_id = | 99 int file_system_first_id = file_system_provider_service_->RegisterFileSystem( |
102 file_system_provider_service_->RegisterFileSystem(kExtensionId, | 100 kExtensionId, kFileSystemName); |
103 kFileSystemName); | 101 ASSERT_LT(0, file_system_first_id); |
104 ASSERT_NE("", file_system_first_id); | |
105 | 102 |
106 std::string file_system_second_id = | 103 int file_system_second_id = file_system_provider_service_->RegisterFileSystem( |
107 file_system_provider_service_->RegisterFileSystem(kExtensionId, | 104 kExtensionId, kFileSystemName); |
108 kFileSystemName); | 105 ASSERT_LT(0, file_system_second_id); |
109 ASSERT_NE("", file_system_second_id); | |
110 | 106 |
111 ASSERT_NE(file_system_first_id, file_system_second_id); | 107 ASSERT_NE(file_system_first_id, file_system_second_id); |
112 ASSERT_EQ(2u, observer.registered.size()); | 108 ASSERT_EQ(2u, observer.registered.size()); |
113 | 109 |
114 std::vector<ProvidedFileSystem> provided_file_systems = | 110 std::vector<ProvidedFileSystem> provided_file_systems = |
115 file_system_provider_service_->GetRegisteredFileSystems(); | 111 file_system_provider_service_->GetRegisteredFileSystems(); |
116 ASSERT_EQ(2u, provided_file_systems.size()); | 112 ASSERT_EQ(2u, provided_file_systems.size()); |
117 | 113 |
118 file_system_provider_service_->RemoveObserver(&observer); | 114 file_system_provider_service_->RemoveObserver(&observer); |
119 } | 115 } |
120 | 116 |
121 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem_StressTest) { | 117 TEST_F(FileSystemProviderServiceTest, RegisterFileSystem_StressTest) { |
122 LoggingObserver observer; | 118 LoggingObserver observer; |
123 file_system_provider_service_->AddObserver(&observer); | 119 file_system_provider_service_->AddObserver(&observer); |
124 | 120 |
125 const size_t kMaxFileSystems = 16; | 121 const size_t kMaxFileSystems = 16; |
126 for (size_t i = 0; i < kMaxFileSystems; ++i) { | 122 for (size_t i = 0; i < kMaxFileSystems; ++i) { |
127 std::string file_system_id = | 123 int file_system_id = file_system_provider_service_->RegisterFileSystem( |
128 file_system_provider_service_->RegisterFileSystem(kExtensionId, | 124 kExtensionId, kFileSystemName); |
129 kFileSystemName); | 125 ASSERT_LT(0, file_system_id); |
130 ASSERT_NE("", file_system_id); | |
131 } | 126 } |
132 ASSERT_EQ(kMaxFileSystems, observer.registered.size()); | 127 ASSERT_EQ(kMaxFileSystems, observer.registered.size()); |
133 | 128 |
134 // The next file system is out of limit, and registering it should fail. | 129 // The next file system is out of limit, and registering it should fail. |
135 std::string file_system_id = | 130 int file_system_id = file_system_provider_service_->RegisterFileSystem( |
136 file_system_provider_service_->RegisterFileSystem(kExtensionId, | 131 kExtensionId, kFileSystemName); |
137 kFileSystemName); | 132 ASSERT_EQ(0, file_system_id); |
138 ASSERT_EQ("", file_system_id); | |
139 ASSERT_EQ(kMaxFileSystems, observer.registered.size()); | 133 ASSERT_EQ(kMaxFileSystems, observer.registered.size()); |
140 | 134 |
141 std::vector<ProvidedFileSystem> provided_file_systems = | 135 std::vector<ProvidedFileSystem> provided_file_systems = |
142 file_system_provider_service_->GetRegisteredFileSystems(); | 136 file_system_provider_service_->GetRegisteredFileSystems(); |
143 ASSERT_EQ(kMaxFileSystems, provided_file_systems.size()); | 137 ASSERT_EQ(kMaxFileSystems, provided_file_systems.size()); |
144 | 138 |
145 file_system_provider_service_->RemoveObserver(&observer); | 139 file_system_provider_service_->RemoveObserver(&observer); |
146 } | 140 } |
147 | 141 |
148 TEST_F(FileSystemProviderServiceTest, UnregisterFileSystem) { | 142 TEST_F(FileSystemProviderServiceTest, UnregisterFileSystem) { |
149 LoggingObserver observer; | 143 LoggingObserver observer; |
150 file_system_provider_service_->AddObserver(&observer); | 144 file_system_provider_service_->AddObserver(&observer); |
151 | 145 |
152 const std::string file_system_id = | 146 int file_system_id = file_system_provider_service_->RegisterFileSystem( |
153 file_system_provider_service_->RegisterFileSystem(kExtensionId, | 147 kExtensionId, kFileSystemName); |
154 kFileSystemName); | 148 ASSERT_LT(0, file_system_id); |
155 ASSERT_NE("", file_system_id); | |
156 ASSERT_EQ(1u, observer.registered.size()); | 149 ASSERT_EQ(1u, observer.registered.size()); |
157 | 150 |
158 const bool result = file_system_provider_service_->UnregisterFileSystem( | 151 const bool result = file_system_provider_service_->UnregisterFileSystem( |
159 kExtensionId, file_system_id); | 152 kExtensionId, file_system_id); |
160 ASSERT_TRUE(result); | 153 ASSERT_TRUE(result); |
161 ASSERT_EQ(1u, observer.unregistered.size()); | 154 ASSERT_EQ(1u, observer.unregistered.size()); |
162 | 155 |
163 EXPECT_EQ(kExtensionId, observer.unregistered[0]->extension_id()); | 156 EXPECT_EQ(kExtensionId, observer.unregistered[0]->extension_id()); |
164 EXPECT_EQ("mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash", | 157 EXPECT_EQ(1, observer.unregistered[0]->file_system_id()); |
165 observer.unregistered[0]->file_system_id()); | |
166 EXPECT_EQ("/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash", | 158 EXPECT_EQ("/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash", |
167 observer.unregistered[0]->mount_path().AsUTF8Unsafe()); | 159 observer.unregistered[0]->mount_path().AsUTF8Unsafe()); |
168 EXPECT_EQ(kFileSystemName, observer.unregistered[0]->file_system_name()); | 160 EXPECT_EQ(kFileSystemName, observer.unregistered[0]->file_system_name()); |
169 | 161 |
170 std::vector<ProvidedFileSystem> provided_file_systems = | 162 std::vector<ProvidedFileSystem> provided_file_systems = |
171 file_system_provider_service_->GetRegisteredFileSystems(); | 163 file_system_provider_service_->GetRegisteredFileSystems(); |
172 ASSERT_EQ(0u, provided_file_systems.size()); | 164 ASSERT_EQ(0u, provided_file_systems.size()); |
173 | 165 |
174 file_system_provider_service_->RemoveObserver(&observer); | 166 file_system_provider_service_->RemoveObserver(&observer); |
175 } | 167 } |
176 | 168 |
177 TEST_F(FileSystemProviderServiceTest, UnregisterFileSystem_WrongExtensionId) { | 169 TEST_F(FileSystemProviderServiceTest, UnregisterFileSystem_WrongExtensionId) { |
178 LoggingObserver observer; | 170 LoggingObserver observer; |
179 file_system_provider_service_->AddObserver(&observer); | 171 file_system_provider_service_->AddObserver(&observer); |
180 | 172 |
181 const std::string kWrongExtensionId = "helloworldhelloworldhelloworldhe"; | 173 const std::string kWrongExtensionId = "helloworldhelloworldhelloworldhe"; |
182 | 174 |
183 const std::string file_system_id = | 175 int file_system_id = file_system_provider_service_->RegisterFileSystem( |
184 file_system_provider_service_->RegisterFileSystem(kExtensionId, | 176 kExtensionId, kFileSystemName); |
185 kFileSystemName); | 177 ASSERT_LT(0, file_system_id); |
186 ASSERT_NE("", file_system_id); | |
187 ASSERT_EQ(1u, observer.registered.size()); | 178 ASSERT_EQ(1u, observer.registered.size()); |
188 | 179 |
189 const bool result = file_system_provider_service_->UnregisterFileSystem( | 180 const bool result = file_system_provider_service_->UnregisterFileSystem( |
190 kWrongExtensionId, file_system_id); | 181 kWrongExtensionId, file_system_id); |
191 ASSERT_FALSE(result); | 182 ASSERT_FALSE(result); |
192 ASSERT_EQ(0u, observer.unregistered.size()); | 183 ASSERT_EQ(0u, observer.unregistered.size()); |
193 | 184 |
194 std::vector<ProvidedFileSystem> provided_file_systems = | 185 std::vector<ProvidedFileSystem> provided_file_systems = |
195 file_system_provider_service_->GetRegisteredFileSystems(); | 186 file_system_provider_service_->GetRegisteredFileSystems(); |
196 ASSERT_EQ(1u, provided_file_systems.size()); | 187 ASSERT_EQ(1u, provided_file_systems.size()); |
197 | 188 |
198 file_system_provider_service_->RemoveObserver(&observer); | 189 file_system_provider_service_->RemoveObserver(&observer); |
199 } | 190 } |
200 | 191 |
201 } // namespace file_system_provider | 192 } // namespace file_system_provider |
202 } // namespace chromeos | 193 } // namespace chromeos |
OLD | NEW |