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