| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "chrome/browser/chromeos/input_method/virtual_keyboard_selector.h" |
| 6 |
| 7 #include "base/logging.h" |
| 8 #include "testing/gtest/include/gtest/gtest.h" |
| 9 |
| 10 // For EXPECT_TRUE calls below. The operator has to be in the global namespace. |
| 11 static bool operator==(const chromeos::input_method::VirtualKeyboard& lhs, |
| 12 const chromeos::input_method::VirtualKeyboard& rhs) { |
| 13 return lhs.GetURLForLayout("") == rhs.GetURLForLayout(""); |
| 14 } |
| 15 |
| 16 namespace { |
| 17 |
| 18 template <size_t L> |
| 19 std::set<std::string> CreateLayoutSet(const char* (&layouts)[L]) { |
| 20 std::set<std::string> result; |
| 21 for (size_t i = 0; i < L; ++i) { |
| 22 result.insert(layouts[i]); |
| 23 } |
| 24 return result; |
| 25 } |
| 26 |
| 27 } // namespace |
| 28 |
| 29 namespace chromeos { |
| 30 namespace input_method { |
| 31 |
| 32 class TestableVirtualKeyboardSelector : public VirtualKeyboardSelector { |
| 33 public: |
| 34 // Change access rights. |
| 35 using VirtualKeyboardSelector::SelectVirtualKeyboardInternal; |
| 36 }; |
| 37 |
| 38 TEST(VirtualKeyboardSelectorTest, TestNoKeyboard) { |
| 39 TestableVirtualKeyboardSelector selector; |
| 40 EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("us")); |
| 41 EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("")); |
| 42 } |
| 43 |
| 44 TEST(VirtualKeyboardSelectorTest, TestSystemKeyboard) { |
| 45 static const char* layouts[] = { "a", "b", "c" }; |
| 46 VirtualKeyboard system_virtual_keyboard( |
| 47 GURL("http://system"), CreateLayoutSet(layouts), true /* is_system */); |
| 48 |
| 49 TestableVirtualKeyboardSelector selector; |
| 50 selector.AddVirtualKeyboard(system_virtual_keyboard.url(), |
| 51 system_virtual_keyboard.supported_layouts(), |
| 52 system_virtual_keyboard.is_system()); |
| 53 |
| 54 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 55 EXPECT_TRUE(system_virtual_keyboard == *selector.SelectVirtualKeyboard("a")); |
| 56 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("b")); |
| 57 EXPECT_TRUE(system_virtual_keyboard == *selector.SelectVirtualKeyboard("b")); |
| 58 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 59 EXPECT_TRUE(system_virtual_keyboard == *selector.SelectVirtualKeyboard("c")); |
| 60 EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("d")); |
| 61 EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("aa")); |
| 62 EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("")); |
| 63 } |
| 64 |
| 65 TEST(VirtualKeyboardSelectorTest, TestTwoSystemKeyboards) { |
| 66 static const char* layouts_1[] = { "a", "b", "c" }; |
| 67 static const char* layouts_2[] = { "a", "c", "d" }; |
| 68 |
| 69 VirtualKeyboard system_virtual_keyboard_1( |
| 70 GURL("http://system1"), CreateLayoutSet(layouts_1), true /* is_system */); |
| 71 VirtualKeyboard system_virtual_keyboard_2( |
| 72 GURL("http://system2"), CreateLayoutSet(layouts_2), true /* is_system */); |
| 73 |
| 74 TestableVirtualKeyboardSelector selector; |
| 75 selector.AddVirtualKeyboard(system_virtual_keyboard_1.url(), |
| 76 system_virtual_keyboard_1.supported_layouts(), |
| 77 system_virtual_keyboard_1.is_system()); |
| 78 selector.AddVirtualKeyboard(system_virtual_keyboard_2.url(), |
| 79 system_virtual_keyboard_2.supported_layouts(), |
| 80 system_virtual_keyboard_2.is_system()); |
| 81 |
| 82 // At this point, system_virtual_keyboard_2 has higher priority since it's |
| 83 // added later than system_virtual_keyboard_1. |
| 84 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 85 EXPECT_TRUE(system_virtual_keyboard_2 == |
| 86 *selector.SelectVirtualKeyboard("a")); |
| 87 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 88 EXPECT_TRUE(system_virtual_keyboard_2 == |
| 89 *selector.SelectVirtualKeyboard("c")); |
| 90 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("d")); |
| 91 EXPECT_TRUE(system_virtual_keyboard_2 == |
| 92 *selector.SelectVirtualKeyboard("d")); |
| 93 |
| 94 // Request "b". system_virtual_keyboard_1 should be returned. |
| 95 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("b")); |
| 96 EXPECT_TRUE(system_virtual_keyboard_1 == |
| 97 *selector.SelectVirtualKeyboard("b")); |
| 98 |
| 99 // Now system_virtual_keyboard_1 should be selected for 'a' and 'c' since |
| 100 // it's the current virtual keyboard. |
| 101 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 102 EXPECT_TRUE(system_virtual_keyboard_1 == |
| 103 *selector.SelectVirtualKeyboard("a")); |
| 104 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 105 EXPECT_TRUE(system_virtual_keyboard_1 == |
| 106 *selector.SelectVirtualKeyboard("c")); |
| 107 |
| 108 // Request "d" again. system_virtual_keyboard_2 should be returned. |
| 109 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("d")); |
| 110 EXPECT_TRUE(system_virtual_keyboard_2 == |
| 111 *selector.SelectVirtualKeyboard("d")); |
| 112 // This time, system_virtual_keyboard_2 should be selected for 'a' and 'c'. |
| 113 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 114 EXPECT_TRUE(system_virtual_keyboard_2 == |
| 115 *selector.SelectVirtualKeyboard("a")); |
| 116 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 117 EXPECT_TRUE(system_virtual_keyboard_2 == |
| 118 *selector.SelectVirtualKeyboard("c")); |
| 119 } |
| 120 |
| 121 TEST(VirtualKeyboardSelectorTest, TestUserKeyboard) { |
| 122 static const char* layouts[] = { "a", "b", "c" }; |
| 123 VirtualKeyboard user_virtual_keyboard( |
| 124 GURL("http://user"), CreateLayoutSet(layouts), false /* is_system */); |
| 125 |
| 126 TestableVirtualKeyboardSelector selector; |
| 127 selector.AddVirtualKeyboard(user_virtual_keyboard.url(), |
| 128 user_virtual_keyboard.supported_layouts(), |
| 129 user_virtual_keyboard.is_system()); |
| 130 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 131 EXPECT_TRUE(user_virtual_keyboard == *selector.SelectVirtualKeyboard("a")); |
| 132 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("b")); |
| 133 EXPECT_TRUE(user_virtual_keyboard == *selector.SelectVirtualKeyboard("b")); |
| 134 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 135 EXPECT_TRUE(user_virtual_keyboard == *selector.SelectVirtualKeyboard("c")); |
| 136 EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("d")); |
| 137 EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("aa")); |
| 138 EXPECT_EQ(NULL, selector.SelectVirtualKeyboard("")); |
| 139 } |
| 140 |
| 141 TEST(VirtualKeyboardSelectorTest, TestTwoUserKeyboards) { |
| 142 static const char* layouts_1[] = { "a", "b", "c" }; |
| 143 static const char* layouts_2[] = { "a", "c", "d" }; |
| 144 |
| 145 VirtualKeyboard user_virtual_keyboard_1( |
| 146 GURL("http://user1"), CreateLayoutSet(layouts_1), false /* is_system */); |
| 147 VirtualKeyboard user_virtual_keyboard_2( |
| 148 GURL("http://user2"), CreateLayoutSet(layouts_2), false /* is_system */); |
| 149 |
| 150 TestableVirtualKeyboardSelector selector; |
| 151 selector.AddVirtualKeyboard(user_virtual_keyboard_1.url(), |
| 152 user_virtual_keyboard_1.supported_layouts(), |
| 153 user_virtual_keyboard_1.is_system()); |
| 154 selector.AddVirtualKeyboard(user_virtual_keyboard_2.url(), |
| 155 user_virtual_keyboard_2.supported_layouts(), |
| 156 user_virtual_keyboard_2.is_system()); |
| 157 |
| 158 // At this point, user_virtual_keyboard_2 has higher priority since it's |
| 159 // added later than user_virtual_keyboard_1. |
| 160 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 161 EXPECT_TRUE(user_virtual_keyboard_2 == |
| 162 *selector.SelectVirtualKeyboard("a")); |
| 163 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 164 EXPECT_TRUE(user_virtual_keyboard_2 == |
| 165 *selector.SelectVirtualKeyboard("c")); |
| 166 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("d")); |
| 167 EXPECT_TRUE(user_virtual_keyboard_2 == |
| 168 *selector.SelectVirtualKeyboard("d")); |
| 169 |
| 170 // Request "b". user_virtual_keyboard_1 should be returned. |
| 171 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("b")); |
| 172 EXPECT_TRUE(user_virtual_keyboard_1 == |
| 173 *selector.SelectVirtualKeyboard("b")); |
| 174 |
| 175 // Now user_virtual_keyboard_1 should be selected for 'a' and 'c' since |
| 176 // it's the current virtual keyboard. |
| 177 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 178 EXPECT_TRUE(user_virtual_keyboard_1 == |
| 179 *selector.SelectVirtualKeyboard("a")); |
| 180 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 181 EXPECT_TRUE(user_virtual_keyboard_1 == |
| 182 *selector.SelectVirtualKeyboard("c")); |
| 183 |
| 184 // Request "d" again. user_virtual_keyboard_2 should be returned. |
| 185 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("d")); |
| 186 EXPECT_TRUE(user_virtual_keyboard_2 == |
| 187 *selector.SelectVirtualKeyboard("d")); |
| 188 // This time, user_virtual_keyboard_2 should be selected for 'a' and 'c'. |
| 189 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 190 EXPECT_TRUE(user_virtual_keyboard_2 == |
| 191 *selector.SelectVirtualKeyboard("a")); |
| 192 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 193 EXPECT_TRUE(user_virtual_keyboard_2 == |
| 194 *selector.SelectVirtualKeyboard("c")); |
| 195 } |
| 196 |
| 197 TEST(VirtualKeyboardSelectorTest, TestUserSystemMixed) { |
| 198 static const char* ulayouts_1[] = { "a", "b", "c" }; |
| 199 static const char* ulayouts_2[] = { "a", "c", "d" }; |
| 200 static const char* layouts_1[] = { "a", "x", "y" }; |
| 201 static const char* layouts_2[] = { "a", "y", "z" }; |
| 202 |
| 203 VirtualKeyboard user_virtual_keyboard_1( |
| 204 GURL("http://user1"), CreateLayoutSet(ulayouts_1), false /* is_system */); |
| 205 VirtualKeyboard user_virtual_keyboard_2( |
| 206 GURL("http://user2"), CreateLayoutSet(ulayouts_2), false /* is_system */); |
| 207 VirtualKeyboard system_virtual_keyboard_1( |
| 208 GURL("http://system1"), CreateLayoutSet(layouts_1), true /* is_system */); |
| 209 VirtualKeyboard system_virtual_keyboard_2( |
| 210 GURL("http://system2"), CreateLayoutSet(layouts_2), true /* is_system */); |
| 211 |
| 212 TestableVirtualKeyboardSelector selector; |
| 213 selector.AddVirtualKeyboard(user_virtual_keyboard_1.url(), |
| 214 user_virtual_keyboard_1.supported_layouts(), |
| 215 user_virtual_keyboard_1.is_system()); |
| 216 selector.AddVirtualKeyboard(user_virtual_keyboard_2.url(), |
| 217 user_virtual_keyboard_2.supported_layouts(), |
| 218 user_virtual_keyboard_2.is_system()); |
| 219 selector.AddVirtualKeyboard(system_virtual_keyboard_1.url(), |
| 220 system_virtual_keyboard_1.supported_layouts(), |
| 221 system_virtual_keyboard_1.is_system()); |
| 222 selector.AddVirtualKeyboard(system_virtual_keyboard_2.url(), |
| 223 system_virtual_keyboard_2.supported_layouts(), |
| 224 system_virtual_keyboard_2.is_system()); |
| 225 |
| 226 // At this point, user_virtual_keyboard_2 has the highest priority. |
| 227 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 228 EXPECT_TRUE(user_virtual_keyboard_2 == |
| 229 *selector.SelectVirtualKeyboard("a")); |
| 230 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 231 EXPECT_TRUE(user_virtual_keyboard_2 == |
| 232 *selector.SelectVirtualKeyboard("c")); |
| 233 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("d")); |
| 234 EXPECT_TRUE(user_virtual_keyboard_2 == |
| 235 *selector.SelectVirtualKeyboard("d")); |
| 236 |
| 237 // Request "b". user_virtual_keyboard_1 should be returned. |
| 238 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("b")); |
| 239 EXPECT_TRUE(user_virtual_keyboard_1 == |
| 240 *selector.SelectVirtualKeyboard("b")); |
| 241 // Now user_virtual_keyboard_1 should be selected for 'a' and 'c' since |
| 242 // it's the current virtual keyboard. |
| 243 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 244 EXPECT_TRUE(user_virtual_keyboard_1 == |
| 245 *selector.SelectVirtualKeyboard("a")); |
| 246 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 247 EXPECT_TRUE(user_virtual_keyboard_1 == |
| 248 *selector.SelectVirtualKeyboard("c")); |
| 249 |
| 250 // Request "x". system_virtual_keyboard_2 should be returned (since it's |
| 251 // added later than system_virtual_keyboard_1). |
| 252 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("x")); |
| 253 EXPECT_TRUE(system_virtual_keyboard_1 == |
| 254 *selector.SelectVirtualKeyboard("x")); |
| 255 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("y")); |
| 256 EXPECT_TRUE(system_virtual_keyboard_1 == |
| 257 *selector.SelectVirtualKeyboard("y")); |
| 258 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 259 EXPECT_TRUE(system_virtual_keyboard_1 == |
| 260 *selector.SelectVirtualKeyboard("a")); |
| 261 |
| 262 // Switch to system_virtual_keyboard_2. |
| 263 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("z")); |
| 264 EXPECT_TRUE(system_virtual_keyboard_2 == |
| 265 *selector.SelectVirtualKeyboard("z")); |
| 266 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("y")); |
| 267 EXPECT_TRUE(system_virtual_keyboard_2 == |
| 268 *selector.SelectVirtualKeyboard("y")); |
| 269 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 270 EXPECT_TRUE(system_virtual_keyboard_2 == |
| 271 *selector.SelectVirtualKeyboard("a")); |
| 272 |
| 273 // Switch back to system_virtual_keyboard_2. |
| 274 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("x")); |
| 275 EXPECT_TRUE(system_virtual_keyboard_1 == |
| 276 *selector.SelectVirtualKeyboard("x")); |
| 277 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("y")); |
| 278 EXPECT_TRUE(system_virtual_keyboard_1 == |
| 279 *selector.SelectVirtualKeyboard("y")); |
| 280 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("a")); |
| 281 EXPECT_TRUE(system_virtual_keyboard_1 == |
| 282 *selector.SelectVirtualKeyboard("a")); |
| 283 |
| 284 // Switch back to user_virtual_keyboard_1. |
| 285 ASSERT_TRUE(selector.SelectVirtualKeyboardInternal("c")); |
| 286 EXPECT_TRUE(user_virtual_keyboard_2 == |
| 287 *selector.SelectVirtualKeyboard("c")); |
| 288 } |
| 289 |
| 290 TEST(VirtualKeyboardTest, TestUrl) { |
| 291 static const char* layouts[] = { "a", "b", "c" }; |
| 292 VirtualKeyboard system_virtual_keyboard( |
| 293 GURL("http://system"), CreateLayoutSet(layouts), true); |
| 294 |
| 295 EXPECT_EQ("http://system/index.html#a", |
| 296 system_virtual_keyboard.GetURLForLayout("a").spec()); |
| 297 EXPECT_EQ("http://system/index.html#b", |
| 298 system_virtual_keyboard.GetURLForLayout("b").spec()); |
| 299 EXPECT_EQ("http://system/index.html#c", |
| 300 system_virtual_keyboard.GetURLForLayout("c").spec()); |
| 301 EXPECT_EQ("http://system/index.html#not-supported", |
| 302 system_virtual_keyboard.GetURLForLayout("not-supported").spec()); |
| 303 EXPECT_EQ("http://system/index.html#not(supported)", |
| 304 system_virtual_keyboard.GetURLForLayout("not(supported)").spec()); |
| 305 EXPECT_EQ("http://system/", |
| 306 system_virtual_keyboard.GetURLForLayout("").spec()); |
| 307 } |
| 308 |
| 309 } // namespace input_method |
| 310 } // namespace chromeos |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 7074008:
initial version of auto VK switching. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src