OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "device/gamepad/gamepad_provider.h" | 5 #include "device/gamepad/gamepad_provider.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "base/macros.h" | 9 #include "base/macros.h" |
10 #include "base/memory/weak_ptr.h" | 10 #include "base/memory/weak_ptr.h" |
11 #include "base/run_loop.h" | 11 #include "base/run_loop.h" |
12 #include "base/threading/platform_thread.h" | 12 #include "base/threading/platform_thread.h" |
13 #include "build/build_config.h" | 13 #include "build/build_config.h" |
14 #include "device/gamepad/gamepad_data_fetcher.h" | 14 #include "device/gamepad/gamepad_data_fetcher.h" |
15 #include "device/gamepad/gamepad_test_helpers.h" | 15 #include "device/gamepad/gamepad_test_helpers.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
17 | 17 |
18 namespace device { | 18 namespace device { |
19 | 19 |
20 namespace { | 20 namespace { |
21 | 21 |
22 using blink::WebGamepads; | |
23 | |
24 // Helper class to generate and record user gesture callbacks. | 22 // Helper class to generate and record user gesture callbacks. |
25 class UserGestureListener { | 23 class UserGestureListener { |
26 public: | 24 public: |
27 UserGestureListener() : has_user_gesture_(false), weak_factory_(this) {} | 25 UserGestureListener() : has_user_gesture_(false), weak_factory_(this) {} |
28 | 26 |
29 base::Closure GetClosure() { | 27 base::Closure GetClosure() { |
30 return base::Bind(&UserGestureListener::GotUserGesture, | 28 return base::Bind(&UserGestureListener::GotUserGesture, |
31 weak_factory_.GetWeakPtr()); | 29 weak_factory_.GetWeakPtr()); |
32 } | 30 } |
33 | 31 |
34 bool has_user_gesture() const { return has_user_gesture_; } | 32 bool has_user_gesture() const { return has_user_gesture_; } |
35 | 33 |
36 private: | 34 private: |
37 void GotUserGesture() { has_user_gesture_ = true; } | 35 void GotUserGesture() { has_user_gesture_ = true; } |
38 | 36 |
39 bool has_user_gesture_; | 37 bool has_user_gesture_; |
40 base::WeakPtrFactory<UserGestureListener> weak_factory_; | 38 base::WeakPtrFactory<UserGestureListener> weak_factory_; |
41 }; | 39 }; |
42 | 40 |
43 // Main test fixture | 41 // Main test fixture |
44 class GamepadProviderTest : public testing::Test, public GamepadTestHelper { | 42 class GamepadProviderTest : public testing::Test, public GamepadTestHelper { |
45 public: | 43 public: |
46 GamepadProvider* CreateProvider(const WebGamepads& test_data) { | 44 GamepadProvider* CreateProvider(const Gamepads& test_data) { |
47 mock_data_fetcher_ = new MockGamepadDataFetcher(test_data); | 45 mock_data_fetcher_ = new MockGamepadDataFetcher(test_data); |
48 provider_.reset(new GamepadProvider( | 46 provider_.reset(new GamepadProvider( |
49 nullptr, std::unique_ptr<GamepadDataFetcher>(mock_data_fetcher_))); | 47 nullptr, std::unique_ptr<GamepadDataFetcher>(mock_data_fetcher_))); |
50 return provider_.get(); | 48 return provider_.get(); |
51 } | 49 } |
52 | 50 |
53 // Sleep until the shared memory buffer's seqlock advances the buffer version, | 51 // Sleep until the shared memory buffer's seqlock advances the buffer version, |
54 // indicating that the gamepad provider has written to it after polling the | 52 // indicating that the gamepad provider has written to it after polling the |
55 // gamepad fetchers. The buffer will report an odd value for the version if | 53 // gamepad fetchers. The buffer will report an odd value for the version if |
56 // the buffer is not in a consistent state, so we also require that the value | 54 // the buffer is not in a consistent state, so we also require that the value |
57 // is even before continuing. | 55 // is even before continuing. |
58 void WaitForData(GamepadHardwareBuffer* buffer) { | 56 void WaitForData(GamepadHardwareBuffer* buffer) { |
59 const base::subtle::Atomic32 initial_version = buffer->seqlock.ReadBegin(); | 57 const base::subtle::Atomic32 initial_version = buffer->seqlock.ReadBegin(); |
60 base::subtle::Atomic32 current_version; | 58 base::subtle::Atomic32 current_version; |
61 do { | 59 do { |
62 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10)); | 60 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10)); |
63 current_version = buffer->seqlock.ReadBegin(); | 61 current_version = buffer->seqlock.ReadBegin(); |
64 } while (current_version % 2 || current_version == initial_version); | 62 } while (current_version % 2 || current_version == initial_version); |
65 } | 63 } |
66 | 64 |
67 // The provider polls the data on the background thread and then issues | 65 // The provider polls the data on the background thread and then issues |
68 // the callback on the client thread. Waiting for it to poll twice ensures | 66 // the callback on the client thread. Waiting for it to poll twice ensures |
69 // that it was able to issue callbacks for the first poll. | 67 // that it was able to issue callbacks for the first poll. |
70 void WaitForDataAndCallbacksIssued(GamepadHardwareBuffer* buffer) { | 68 void WaitForDataAndCallbacksIssued(GamepadHardwareBuffer* buffer) { |
71 WaitForData(buffer); | 69 WaitForData(buffer); |
72 WaitForData(buffer); | 70 WaitForData(buffer); |
73 } | 71 } |
74 | 72 |
75 void ReadGamepadHardwareBuffer(GamepadHardwareBuffer* buffer, | 73 void ReadGamepadHardwareBuffer(GamepadHardwareBuffer* buffer, |
76 WebGamepads* output) { | 74 Gamepads* output) { |
77 memset(output, 0, sizeof(WebGamepads)); | 75 memset(output, 0, sizeof(Gamepads)); |
78 base::subtle::Atomic32 version; | 76 base::subtle::Atomic32 version; |
79 do { | 77 do { |
80 version = buffer->seqlock.ReadBegin(); | 78 version = buffer->seqlock.ReadBegin(); |
81 memcpy(output, &buffer->data, sizeof(WebGamepads)); | 79 memcpy(output, &buffer->data, sizeof(Gamepads)); |
82 } while (buffer->seqlock.ReadRetry(version)); | 80 } while (buffer->seqlock.ReadRetry(version)); |
83 } | 81 } |
84 | 82 |
85 protected: | 83 protected: |
86 GamepadProviderTest() {} | 84 GamepadProviderTest() {} |
87 | 85 |
88 std::unique_ptr<GamepadProvider> provider_; | 86 std::unique_ptr<GamepadProvider> provider_; |
89 | 87 |
90 // Pointer owned by the provider. | 88 // Pointer owned by the provider. |
91 MockGamepadDataFetcher* mock_data_fetcher_; | 89 MockGamepadDataFetcher* mock_data_fetcher_; |
92 | 90 |
93 DISALLOW_COPY_AND_ASSIGN(GamepadProviderTest); | 91 DISALLOW_COPY_AND_ASSIGN(GamepadProviderTest); |
94 }; | 92 }; |
95 | 93 |
96 TEST_F(GamepadProviderTest, PollingAccess) { | 94 TEST_F(GamepadProviderTest, PollingAccess) { |
97 WebGamepads test_data; | 95 Gamepads test_data; |
98 memset(&test_data, 0, sizeof(WebGamepads)); | 96 memset(&test_data, 0, sizeof(Gamepads)); |
99 test_data.items[0].connected = true; | 97 test_data.items[0].connected = true; |
100 test_data.items[0].timestamp = 0; | 98 test_data.items[0].timestamp = 0; |
101 test_data.items[0].buttons_length = 1; | 99 test_data.items[0].buttons_length = 1; |
102 test_data.items[0].axes_length = 2; | 100 test_data.items[0].axes_length = 2; |
103 test_data.items[0].buttons[0].value = 1.f; | 101 test_data.items[0].buttons[0].value = 1.f; |
104 test_data.items[0].buttons[0].pressed = true; | 102 test_data.items[0].buttons[0].pressed = true; |
105 test_data.items[0].axes[0] = -1.f; | 103 test_data.items[0].axes[0] = -1.f; |
106 test_data.items[0].axes[1] = .5f; | 104 test_data.items[0].axes[1] = .5f; |
107 | 105 |
108 GamepadProvider* provider = CreateProvider(test_data); | 106 GamepadProvider* provider = CreateProvider(test_data); |
109 provider->SetSanitizationEnabled(false); | 107 provider->SetSanitizationEnabled(false); |
110 provider->Resume(); | 108 provider->Resume(); |
111 | 109 |
112 base::RunLoop().RunUntilIdle(); | 110 base::RunLoop().RunUntilIdle(); |
113 | 111 |
114 // Renderer-side, pull data out of poll buffer. | 112 // Renderer-side, pull data out of poll buffer. |
115 base::SharedMemoryHandle handle = provider->GetSharedMemoryHandleForProcess( | 113 base::SharedMemoryHandle handle = provider->GetSharedMemoryHandleForProcess( |
116 base::GetCurrentProcessHandle()); | 114 base::GetCurrentProcessHandle()); |
117 std::unique_ptr<base::SharedMemory> shared_memory( | 115 std::unique_ptr<base::SharedMemory> shared_memory( |
118 new base::SharedMemory(handle, true)); | 116 new base::SharedMemory(handle, true)); |
119 EXPECT_TRUE(shared_memory->Map(sizeof(GamepadHardwareBuffer))); | 117 EXPECT_TRUE(shared_memory->Map(sizeof(GamepadHardwareBuffer))); |
120 | 118 |
121 GamepadHardwareBuffer* buffer = | 119 GamepadHardwareBuffer* buffer = |
122 static_cast<GamepadHardwareBuffer*>(shared_memory->memory()); | 120 static_cast<GamepadHardwareBuffer*>(shared_memory->memory()); |
123 | 121 |
124 // Wait until the shared memory buffer has been written at least once. | 122 // Wait until the shared memory buffer has been written at least once. |
125 WaitForData(buffer); | 123 WaitForData(buffer); |
126 | 124 |
127 WebGamepads output; | 125 Gamepads output; |
128 ReadGamepadHardwareBuffer(buffer, &output); | 126 ReadGamepadHardwareBuffer(buffer, &output); |
129 | 127 |
130 EXPECT_EQ(1u, output.items[0].buttons_length); | 128 EXPECT_EQ(1u, output.items[0].buttons_length); |
131 EXPECT_EQ(1.f, output.items[0].buttons[0].value); | 129 EXPECT_EQ(1.f, output.items[0].buttons[0].value); |
132 EXPECT_EQ(true, output.items[0].buttons[0].pressed); | 130 EXPECT_EQ(true, output.items[0].buttons[0].pressed); |
133 EXPECT_EQ(2u, output.items[0].axes_length); | 131 EXPECT_EQ(2u, output.items[0].axes_length); |
134 EXPECT_EQ(-1.f, output.items[0].axes[0]); | 132 EXPECT_EQ(-1.f, output.items[0].axes[0]); |
135 EXPECT_EQ(0.5f, output.items[0].axes[1]); | 133 EXPECT_EQ(0.5f, output.items[0].axes[1]); |
136 } | 134 } |
137 | 135 |
138 TEST_F(GamepadProviderTest, ConnectDisconnectMultiple) { | 136 TEST_F(GamepadProviderTest, ConnectDisconnectMultiple) { |
139 WebGamepads test_data; | 137 Gamepads test_data; |
140 test_data.items[0].connected = true; | 138 test_data.items[0].connected = true; |
141 test_data.items[0].timestamp = 0; | 139 test_data.items[0].timestamp = 0; |
142 test_data.items[0].axes_length = 2; | 140 test_data.items[0].axes_length = 2; |
143 test_data.items[0].axes[0] = -1.f; | 141 test_data.items[0].axes[0] = -1.f; |
144 test_data.items[0].axes[1] = .5f; | 142 test_data.items[0].axes[1] = .5f; |
145 | 143 |
146 test_data.items[1].connected = true; | 144 test_data.items[1].connected = true; |
147 test_data.items[1].timestamp = 0; | 145 test_data.items[1].timestamp = 0; |
148 test_data.items[1].axes_length = 2; | 146 test_data.items[1].axes_length = 2; |
149 test_data.items[1].axes[0] = 1.f; | 147 test_data.items[1].axes[0] = 1.f; |
150 test_data.items[1].axes[1] = -.5f; | 148 test_data.items[1].axes[1] = -.5f; |
151 | 149 |
152 WebGamepads test_data_onedisconnected; | 150 Gamepads test_data_onedisconnected; |
153 test_data_onedisconnected.items[1].connected = true; | 151 test_data_onedisconnected.items[1].connected = true; |
154 test_data_onedisconnected.items[1].timestamp = 0; | 152 test_data_onedisconnected.items[1].timestamp = 0; |
155 test_data_onedisconnected.items[1].axes_length = 2; | 153 test_data_onedisconnected.items[1].axes_length = 2; |
156 test_data_onedisconnected.items[1].axes[0] = 1.f; | 154 test_data_onedisconnected.items[1].axes[0] = 1.f; |
157 test_data_onedisconnected.items[1].axes[1] = -.5f; | 155 test_data_onedisconnected.items[1].axes[1] = -.5f; |
158 | 156 |
159 GamepadProvider* provider = CreateProvider(test_data); | 157 GamepadProvider* provider = CreateProvider(test_data); |
160 provider->SetSanitizationEnabled(false); | 158 provider->SetSanitizationEnabled(false); |
161 provider->Resume(); | 159 provider->Resume(); |
162 | 160 |
163 base::RunLoop().RunUntilIdle(); | 161 base::RunLoop().RunUntilIdle(); |
164 | 162 |
165 // Renderer-side, pull data out of poll buffer. | 163 // Renderer-side, pull data out of poll buffer. |
166 base::SharedMemoryHandle handle = provider->GetSharedMemoryHandleForProcess( | 164 base::SharedMemoryHandle handle = provider->GetSharedMemoryHandleForProcess( |
167 base::GetCurrentProcessHandle()); | 165 base::GetCurrentProcessHandle()); |
168 std::unique_ptr<base::SharedMemory> shared_memory( | 166 std::unique_ptr<base::SharedMemory> shared_memory( |
169 new base::SharedMemory(handle, true)); | 167 new base::SharedMemory(handle, true)); |
170 EXPECT_TRUE(shared_memory->Map(sizeof(GamepadHardwareBuffer))); | 168 EXPECT_TRUE(shared_memory->Map(sizeof(GamepadHardwareBuffer))); |
171 | 169 |
172 GamepadHardwareBuffer* buffer = | 170 GamepadHardwareBuffer* buffer = |
173 static_cast<GamepadHardwareBuffer*>(shared_memory->memory()); | 171 static_cast<GamepadHardwareBuffer*>(shared_memory->memory()); |
174 | 172 |
175 // Wait until the shared memory buffer has been written at least once. | 173 // Wait until the shared memory buffer has been written at least once. |
176 WaitForData(buffer); | 174 WaitForData(buffer); |
177 | 175 |
178 WebGamepads output; | 176 Gamepads output; |
179 ReadGamepadHardwareBuffer(buffer, &output); | 177 ReadGamepadHardwareBuffer(buffer, &output); |
180 | 178 |
181 EXPECT_EQ(2u, output.items[0].axes_length); | 179 EXPECT_EQ(2u, output.items[0].axes_length); |
182 EXPECT_EQ(-1.f, output.items[0].axes[0]); | 180 EXPECT_EQ(-1.f, output.items[0].axes[0]); |
183 EXPECT_EQ(0.5f, output.items[0].axes[1]); | 181 EXPECT_EQ(0.5f, output.items[0].axes[1]); |
184 EXPECT_EQ(2u, output.items[1].axes_length); | 182 EXPECT_EQ(2u, output.items[1].axes_length); |
185 EXPECT_EQ(1.f, output.items[1].axes[0]); | 183 EXPECT_EQ(1.f, output.items[1].axes[0]); |
186 EXPECT_EQ(-0.5f, output.items[1].axes[1]); | 184 EXPECT_EQ(-0.5f, output.items[1].axes[1]); |
187 | 185 |
188 mock_data_fetcher_->SetTestData(test_data_onedisconnected); | 186 mock_data_fetcher_->SetTestData(test_data_onedisconnected); |
189 | 187 |
190 WaitForDataAndCallbacksIssued(buffer); | 188 WaitForDataAndCallbacksIssued(buffer); |
191 | 189 |
192 ReadGamepadHardwareBuffer(buffer, &output); | 190 ReadGamepadHardwareBuffer(buffer, &output); |
193 | 191 |
194 EXPECT_EQ(0u, output.items[0].axes_length); | 192 EXPECT_EQ(0u, output.items[0].axes_length); |
195 EXPECT_EQ(2u, output.items[1].axes_length); | 193 EXPECT_EQ(2u, output.items[1].axes_length); |
196 EXPECT_EQ(1.f, output.items[1].axes[0]); | 194 EXPECT_EQ(1.f, output.items[1].axes[0]); |
197 EXPECT_EQ(-0.5f, output.items[1].axes[1]); | 195 EXPECT_EQ(-0.5f, output.items[1].axes[1]); |
198 } | 196 } |
199 | 197 |
200 // Tests that waiting for a user gesture works properly. | 198 // Tests that waiting for a user gesture works properly. |
201 TEST_F(GamepadProviderTest, UserGesture) { | 199 TEST_F(GamepadProviderTest, UserGesture) { |
202 WebGamepads no_button_data; | 200 Gamepads no_button_data; |
203 no_button_data.items[0].connected = true; | 201 no_button_data.items[0].connected = true; |
204 no_button_data.items[0].timestamp = 0; | 202 no_button_data.items[0].timestamp = 0; |
205 no_button_data.items[0].buttons_length = 1; | 203 no_button_data.items[0].buttons_length = 1; |
206 no_button_data.items[0].axes_length = 2; | 204 no_button_data.items[0].axes_length = 2; |
207 no_button_data.items[0].buttons[0].value = 0.f; | 205 no_button_data.items[0].buttons[0].value = 0.f; |
208 no_button_data.items[0].buttons[0].pressed = false; | 206 no_button_data.items[0].buttons[0].pressed = false; |
209 no_button_data.items[0].axes[0] = 0.f; | 207 no_button_data.items[0].axes[0] = 0.f; |
210 no_button_data.items[0].axes[1] = .4f; | 208 no_button_data.items[0].axes[1] = .4f; |
211 | 209 |
212 WebGamepads button_down_data = no_button_data; | 210 Gamepads button_down_data = no_button_data; |
213 button_down_data.items[0].buttons[0].value = 1.f; | 211 button_down_data.items[0].buttons[0].value = 1.f; |
214 button_down_data.items[0].buttons[0].pressed = true; | 212 button_down_data.items[0].buttons[0].pressed = true; |
215 | 213 |
216 UserGestureListener listener; | 214 UserGestureListener listener; |
217 GamepadProvider* provider = CreateProvider(no_button_data); | 215 GamepadProvider* provider = CreateProvider(no_button_data); |
218 provider->SetSanitizationEnabled(false); | 216 provider->SetSanitizationEnabled(false); |
219 provider->Resume(); | 217 provider->Resume(); |
220 | 218 |
221 provider->RegisterForUserGesture(listener.GetClosure()); | 219 provider->RegisterForUserGesture(listener.GetClosure()); |
222 | 220 |
(...skipping 22 matching lines...) Expand all Loading... |
245 // been updated. Wait for the second update to ensure callbacks have fired. | 243 // been updated. Wait for the second update to ensure callbacks have fired. |
246 WaitForDataAndCallbacksIssued(buffer); | 244 WaitForDataAndCallbacksIssued(buffer); |
247 | 245 |
248 // It should have issued our callback. | 246 // It should have issued our callback. |
249 base::RunLoop().RunUntilIdle(); | 247 base::RunLoop().RunUntilIdle(); |
250 EXPECT_TRUE(listener.has_user_gesture()); | 248 EXPECT_TRUE(listener.has_user_gesture()); |
251 } | 249 } |
252 | 250 |
253 // Tests that waiting for a user gesture works properly. | 251 // Tests that waiting for a user gesture works properly. |
254 TEST_F(GamepadProviderTest, Sanitization) { | 252 TEST_F(GamepadProviderTest, Sanitization) { |
255 WebGamepads active_data; | 253 Gamepads active_data; |
256 active_data.items[0].connected = true; | 254 active_data.items[0].connected = true; |
257 active_data.items[0].timestamp = 0; | 255 active_data.items[0].timestamp = 0; |
258 active_data.items[0].buttons_length = 1; | 256 active_data.items[0].buttons_length = 1; |
259 active_data.items[0].axes_length = 1; | 257 active_data.items[0].axes_length = 1; |
260 active_data.items[0].buttons[0].value = 1.f; | 258 active_data.items[0].buttons[0].value = 1.f; |
261 active_data.items[0].buttons[0].pressed = true; | 259 active_data.items[0].buttons[0].pressed = true; |
262 active_data.items[0].axes[0] = -1.f; | 260 active_data.items[0].axes[0] = -1.f; |
263 | 261 |
264 WebGamepads zero_data; | 262 Gamepads zero_data; |
265 zero_data.items[0].connected = true; | 263 zero_data.items[0].connected = true; |
266 zero_data.items[0].timestamp = 0; | 264 zero_data.items[0].timestamp = 0; |
267 zero_data.items[0].buttons_length = 1; | 265 zero_data.items[0].buttons_length = 1; |
268 zero_data.items[0].axes_length = 1; | 266 zero_data.items[0].axes_length = 1; |
269 zero_data.items[0].buttons[0].value = 0.f; | 267 zero_data.items[0].buttons[0].value = 0.f; |
270 zero_data.items[0].buttons[0].pressed = false; | 268 zero_data.items[0].buttons[0].pressed = false; |
271 zero_data.items[0].axes[0] = 0.f; | 269 zero_data.items[0].axes[0] = 0.f; |
272 | 270 |
273 UserGestureListener listener; | 271 UserGestureListener listener; |
274 GamepadProvider* provider = CreateProvider(active_data); | 272 GamepadProvider* provider = CreateProvider(active_data); |
275 provider->SetSanitizationEnabled(true); | 273 provider->SetSanitizationEnabled(true); |
276 provider->Resume(); | 274 provider->Resume(); |
277 | 275 |
278 base::RunLoop().RunUntilIdle(); | 276 base::RunLoop().RunUntilIdle(); |
279 | 277 |
280 // Renderer-side, pull data out of poll buffer. | 278 // Renderer-side, pull data out of poll buffer. |
281 base::SharedMemoryHandle handle = provider->GetSharedMemoryHandleForProcess( | 279 base::SharedMemoryHandle handle = provider->GetSharedMemoryHandleForProcess( |
282 base::GetCurrentProcessHandle()); | 280 base::GetCurrentProcessHandle()); |
283 std::unique_ptr<base::SharedMemory> shared_memory( | 281 std::unique_ptr<base::SharedMemory> shared_memory( |
284 new base::SharedMemory(handle, true)); | 282 new base::SharedMemory(handle, true)); |
285 EXPECT_TRUE(shared_memory->Map(sizeof(GamepadHardwareBuffer))); | 283 EXPECT_TRUE(shared_memory->Map(sizeof(GamepadHardwareBuffer))); |
286 | 284 |
287 GamepadHardwareBuffer* buffer = | 285 GamepadHardwareBuffer* buffer = |
288 static_cast<GamepadHardwareBuffer*>(shared_memory->memory()); | 286 static_cast<GamepadHardwareBuffer*>(shared_memory->memory()); |
289 | 287 |
290 // Wait until the shared memory buffer has been written at least once. | 288 // Wait until the shared memory buffer has been written at least once. |
291 WaitForData(buffer); | 289 WaitForData(buffer); |
292 | 290 |
293 WebGamepads output; | 291 Gamepads output; |
294 ReadGamepadHardwareBuffer(buffer, &output); | 292 ReadGamepadHardwareBuffer(buffer, &output); |
295 | 293 |
296 // Initial data should all be zeroed out due to sanitization, even though the | 294 // Initial data should all be zeroed out due to sanitization, even though the |
297 // gamepad reported input | 295 // gamepad reported input |
298 EXPECT_EQ(1u, output.items[0].buttons_length); | 296 EXPECT_EQ(1u, output.items[0].buttons_length); |
299 EXPECT_EQ(0.f, output.items[0].buttons[0].value); | 297 EXPECT_EQ(0.f, output.items[0].buttons[0].value); |
300 EXPECT_FALSE(output.items[0].buttons[0].pressed); | 298 EXPECT_FALSE(output.items[0].buttons[0].pressed); |
301 EXPECT_EQ(1u, output.items[0].axes_length); | 299 EXPECT_EQ(1u, output.items[0].axes_length); |
302 EXPECT_EQ(0.f, output.items[0].axes[0]); | 300 EXPECT_EQ(0.f, output.items[0].axes[0]); |
303 | 301 |
(...skipping 24 matching lines...) Expand all Loading... |
328 EXPECT_EQ(1u, output.items[0].buttons_length); | 326 EXPECT_EQ(1u, output.items[0].buttons_length); |
329 EXPECT_EQ(1.f, output.items[0].buttons[0].value); | 327 EXPECT_EQ(1.f, output.items[0].buttons[0].value); |
330 EXPECT_TRUE(output.items[0].buttons[0].pressed); | 328 EXPECT_TRUE(output.items[0].buttons[0].pressed); |
331 EXPECT_EQ(1u, output.items[0].axes_length); | 329 EXPECT_EQ(1u, output.items[0].axes_length); |
332 EXPECT_EQ(-1.f, output.items[0].axes[0]); | 330 EXPECT_EQ(-1.f, output.items[0].axes[0]); |
333 } | 331 } |
334 | 332 |
335 } // namespace | 333 } // namespace |
336 | 334 |
337 } // namespace device | 335 } // namespace device |
OLD | NEW |