c2b13bd77b71ea73db12a6cda64871565036a6dc
- Author
- Stefan Kerkmann <karlk90@pm.me>
- Committer
- GitHub <noreply@github.com>
- Date
Message
Introduce VERIFY_AND_CLEAR shorthand (#19370) Which is just a syntactic sugar for testing::Mock::VerifyAndClearExpectations to reduce the visual clutter in unit-tests.
Diff
This diff is truncated to protect this page.
1diff --git a/tests/auto_shift/test_auto_shift.cpp b/tests/auto_shift/test_auto_shift.cpp
2index a83f436c3323aad631f332ece3c525565fef0603..1d80634b2fd17ace5e67409743a960400cd2e149 100644
3--- a/tests/auto_shift/test_auto_shift.cpp
4+++ b/tests/auto_shift/test_auto_shift.cpp
5@@ -37,14 +37,14 @@ TEST_F(AutoShift, key_release_before_timeout) {
6 EXPECT_NO_REPORT(driver);
7 regular_key.press();
8 run_one_scan_loop();
9- testing::Mock::VerifyAndClearExpectations(&driver);
10+ VERIFY_AND_CLEAR(driver);
11
12 /* Release regular key */
13 EXPECT_REPORT(driver, (KC_A));
14 EXPECT_EMPTY_REPORT(driver);
15 regular_key.release();
16 run_one_scan_loop();
17- testing::Mock::VerifyAndClearExpectations(&driver);
18+ VERIFY_AND_CLEAR(driver);
19 }
20
21 TEST_F(AutoShift, key_release_after_timeout) {
22@@ -58,7 +58,7 @@ TEST_F(AutoShift, key_release_after_timeout) {
23 EXPECT_NO_REPORT(driver);
24 regular_key.press();
25 idle_for(AUTO_SHIFT_TIMEOUT);
26- testing::Mock::VerifyAndClearExpectations(&driver);
27+ VERIFY_AND_CLEAR(driver);
28
29 /* Release regular key */
30 EXPECT_REPORT(driver, (KC_LSFT, KC_A));
31@@ -66,5 +66,5 @@ TEST_F(AutoShift, key_release_after_timeout) {
32 EXPECT_EMPTY_REPORT(driver);
33 regular_key.release();
34 run_one_scan_loop();
35- testing::Mock::VerifyAndClearExpectations(&driver);
36+ VERIFY_AND_CLEAR(driver);
37 }
38diff --git a/tests/autocorrect/test_autocorrect.cpp b/tests/autocorrect/test_autocorrect.cpp
39index 509c1c9ea410dbd1f67360f3d5f04c207d6ca19b..9b8db3d68d9437676d45983b82bb3145cf7018ab 100644
40--- a/tests/autocorrect/test_autocorrect.cpp
41+++ b/tests/autocorrect/test_autocorrect.cpp
42@@ -51,7 +51,7 @@ TEST_F(AutoCorrect, OnOffToggle) {
43 autocorrect_toggle();
44 EXPECT_EQ(autocorrect_is_enabled(), true);
45
46- testing::Mock::VerifyAndClearExpectations(&driver);
47+ VERIFY_AND_CLEAR(driver);
48 }
49
50 // Test that typing "fales" autocorrects to "false"
51@@ -80,7 +80,7 @@ TEST_F(AutoCorrect, fales_to_false_autocorrection) {
52
53 TapKeys(key_f, key_a, key_l, key_e, key_s);
54
55- testing::Mock::VerifyAndClearExpectations(&driver);
56+ VERIFY_AND_CLEAR(driver);
57 }
58
59 // Test that typing "fales" doesn't autocorrect if disabled
60@@ -109,7 +109,7 @@ TEST_F(AutoCorrect, fales_disabled_autocorrect) {
61 TapKeys(key_f, key_a, key_l, key_e, key_s);
62 autocorrect_enable();
63
64- testing::Mock::VerifyAndClearExpectations(&driver);
65+ VERIFY_AND_CLEAR(driver);
66 }
67
68 // Test that typing "falsify" doesn't autocorrect if disabled
69@@ -139,7 +139,7 @@ TEST_F(AutoCorrect, falsify_should_not_autocorrect) {
70
71 TapKeys(key_f, key_a, key_l, key_s, key_i, key_f, key_y);
72
73- testing::Mock::VerifyAndClearExpectations(&driver);
74+ VERIFY_AND_CLEAR(driver);
75 }
76
77 // Test that typing "ture" autocorrect to "true"
78@@ -169,7 +169,7 @@ TEST_F(AutoCorrect, ture_to_true_autocorrect) {
79
80 TapKeys(key_space, key_t_code, key_u, key_r, key_e);
81
82- testing::Mock::VerifyAndClearExpectations(&driver);
83+ VERIFY_AND_CLEAR(driver);
84 }
85
86 // Test that typing "overture" does not autocorrect
87@@ -200,5 +200,5 @@ TEST_F(AutoCorrect, overture_should_not_autocorrect) {
88
89 TapKeys(key_o, key_v, key_e, key_r, key_t_code, key_u, key_r, key_e);
90
91- testing::Mock::VerifyAndClearExpectations(&driver);
92+ VERIFY_AND_CLEAR(driver);
93 }
94diff --git a/tests/basic/test_action_layer.cpp b/tests/basic/test_action_layer.cpp
95index d0a28d42c08bb46f240490a9dc75fd30921953f9..883d99b4040b449cbd668777691304ba29c79cb5 100644
96--- a/tests/basic/test_action_layer.cpp
97+++ b/tests/basic/test_action_layer.cpp
98@@ -28,7 +28,7 @@ TEST_F(ActionLayer, LayerStateDBG) {
99
100 layer_state_set(0);
101
102- testing::Mock::VerifyAndClearExpectations(&driver);
103+ VERIFY_AND_CLEAR(driver);
104 }
105
106 TEST_F(ActionLayer, LayerStateSet) {
107@@ -39,7 +39,7 @@ TEST_F(ActionLayer, LayerStateSet) {
108 layer_state_set(0b001100);
109 EXPECT_EQ(layer_state, 0b001100);
110
111- testing::Mock::VerifyAndClearExpectations(&driver);
112+ VERIFY_AND_CLEAR(driver);
113 }
114
115 TEST_F(ActionLayer, LayerStateIs) {
116@@ -56,7 +56,7 @@ TEST_F(ActionLayer, LayerStateIs) {
117 EXPECT_EQ(layer_state_is(1), true);
118 EXPECT_EQ(layer_state_is(2), false);
119
120- testing::Mock::VerifyAndClearExpectations(&driver);
121+ VERIFY_AND_CLEAR(driver);
122 }
123
124 TEST_F(ActionLayer, LayerStateCmp) {
125@@ -76,7 +76,7 @@ TEST_F(ActionLayer, LayerStateCmp) {
126 EXPECT_EQ(layer_state_cmp(prev_layer, 1), true);
127 EXPECT_EQ(layer_state_cmp(prev_layer, 2), false);
128
129- testing::Mock::VerifyAndClearExpectations(&driver);
130+ VERIFY_AND_CLEAR(driver);
131 }
132
133 TEST_F(ActionLayer, LayerClear) {
134@@ -85,7 +85,7 @@ TEST_F(ActionLayer, LayerClear) {
135 layer_clear();
136 EXPECT_EQ(layer_state, 0);
137
138- testing::Mock::VerifyAndClearExpectations(&driver);
139+ VERIFY_AND_CLEAR(driver);
140 }
141
142 TEST_F(ActionLayer, LayerMove) {
143@@ -96,7 +96,7 @@ TEST_F(ActionLayer, LayerMove) {
144 layer_move(3);
145 EXPECT_EQ(layer_state, 0b1000);
146
147- testing::Mock::VerifyAndClearExpectations(&driver);
148+ VERIFY_AND_CLEAR(driver);
149 }
150
151 TEST_F(ActionLayer, LayerOn) {
152@@ -108,7 +108,7 @@ TEST_F(ActionLayer, LayerOn) {
153 layer_on(3);
154 EXPECT_EQ(layer_state, 0b1010);
155
156- testing::Mock::VerifyAndClearExpectations(&driver);
157+ VERIFY_AND_CLEAR(driver);
158 }
159
160 TEST_F(ActionLayer, LayerOff) {
161@@ -121,7 +121,7 @@ TEST_F(ActionLayer, LayerOff) {
162 layer_off(2);
163 EXPECT_EQ(layer_state, 0b0010);
164
165- testing::Mock::VerifyAndClearExpectations(&driver);
166+ VERIFY_AND_CLEAR(driver);
167 }
168
169 TEST_F(ActionLayer, MomentaryLayerDoesNothing) {
170@@ -134,12 +134,12 @@ TEST_F(ActionLayer, MomentaryLayerDoesNothing) {
171 EXPECT_NO_REPORT(driver);
172 layer_key.press();
173 run_one_scan_loop();
174- testing::Mock::VerifyAndClearExpectations(&driver);
175+ VERIFY_AND_CLEAR(driver);
176
177 EXPECT_NO_REPORT(driver);
178 layer_key.release();
179 run_one_scan_loop();
180- testing::Mock::VerifyAndClearExpectations(&driver);
181+ VERIFY_AND_CLEAR(driver);
182 }
183
184 TEST_F(ActionLayer, MomentaryLayerWithKeypress) {
185@@ -155,28 +155,28 @@ TEST_F(ActionLayer, MomentaryLayerWithKeypress) {
186 layer_key.press();
187 run_one_scan_loop();
188 EXPECT_TRUE(layer_state_is(1));
189- testing::Mock::VerifyAndClearExpectations(&driver);
190+ VERIFY_AND_CLEAR(driver);
191
192 /* Press key on layer 1 */
193 EXPECT_REPORT(driver, (KC_B)).Times(1);
194 regular_key.press();
195 run_one_scan_loop();
196 EXPECT_TRUE(layer_state_is(1));
197- testing::Mock::VerifyAndClearExpectations(&driver);
198diff --git a/tests/basic/test_keypress.cpp b/tests/basic/test_keypress.cpp
199index 6d5b502a005906f8fac176d91699118ab4138973..34682654b01f869a6ed2c61e36e37365cc341add 100644
200--- a/tests/basic/test_keypress.cpp
201+++ b/tests/basic/test_keypress.cpp
202@@ -175,23 +175,23 @@ TEST_F(KeyPress, PressPlusEqualReleaseBeforePress) {
203 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
204 EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL));
205 run_one_scan_loop();
206- testing::Mock::VerifyAndClearExpectations(&driver);
207+ VERIFY_AND_CLEAR(driver);
208
209 key_plus.release();
210 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
211 EXPECT_EMPTY_REPORT(driver);
212 run_one_scan_loop();
213- testing::Mock::VerifyAndClearExpectations(&driver);
214+ VERIFY_AND_CLEAR(driver);
215
216 key_eql.press();
217 EXPECT_REPORT(driver, (key_eql.report_code));
218 run_one_scan_loop();
219- testing::Mock::VerifyAndClearExpectations(&driver);
220+ VERIFY_AND_CLEAR(driver);
221
222 key_eql.release();
223 EXPECT_EMPTY_REPORT(driver);
224 run_one_scan_loop();
225- testing::Mock::VerifyAndClearExpectations(&driver);
226+ VERIFY_AND_CLEAR(driver);
227 }
228
229 TEST_F(KeyPress, PressPlusEqualDontReleaseBeforePress) {
230@@ -206,24 +206,24 @@ TEST_F(KeyPress, PressPlusEqualDontReleaseBeforePress) {
231 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
232 EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL));
233 run_one_scan_loop();
234- testing::Mock::VerifyAndClearExpectations(&driver);
235+ VERIFY_AND_CLEAR(driver);
236
237 key_eql.press();
238 EXPECT_EMPTY_REPORT(driver);
239 EXPECT_REPORT(driver, (KC_EQUAL));
240 run_one_scan_loop();
241- testing::Mock::VerifyAndClearExpectations(&driver);
242+ VERIFY_AND_CLEAR(driver);
243
244 key_plus.release();
245 // BUG: Should really still return KC_EQUAL, but this is fine too
246 EXPECT_EMPTY_REPORT(driver);
247 run_one_scan_loop();
248- testing::Mock::VerifyAndClearExpectations(&driver);
249+ VERIFY_AND_CLEAR(driver);
250
251 key_eql.release();
252 EXPECT_NO_REPORT(driver);
253 run_one_scan_loop();
254- testing::Mock::VerifyAndClearExpectations(&driver);
255+ VERIFY_AND_CLEAR(driver);
256 }
257
258 TEST_F(KeyPress, PressEqualPlusReleaseBeforePress) {
259@@ -237,24 +237,24 @@ TEST_F(KeyPress, PressEqualPlusReleaseBeforePress) {
260 key_eql.press();
261 EXPECT_REPORT(driver, (KC_EQUAL));
262 run_one_scan_loop();
263- testing::Mock::VerifyAndClearExpectations(&driver);
264+ VERIFY_AND_CLEAR(driver);
265
266 key_eql.release();
267 EXPECT_EMPTY_REPORT(driver);
268 run_one_scan_loop();
269- testing::Mock::VerifyAndClearExpectations(&driver);
270+ VERIFY_AND_CLEAR(driver);
271
272 key_plus.press();
273 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
274 EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL));
275 run_one_scan_loop();
276- testing::Mock::VerifyAndClearExpectations(&driver);
277+ VERIFY_AND_CLEAR(driver);
278
279 key_plus.release();
280 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
281 EXPECT_EMPTY_REPORT(driver);
282 run_one_scan_loop();
283- testing::Mock::VerifyAndClearExpectations(&driver);
284+ VERIFY_AND_CLEAR(driver);
285 }
286
287 TEST_F(KeyPress, PressEqualPlusDontReleaseBeforePress) {
288@@ -268,7 +268,7 @@ TEST_F(KeyPress, PressEqualPlusDontReleaseBeforePress) {
289 key_eql.press();
290 EXPECT_REPORT(driver, (KC_EQUAL));
291 run_one_scan_loop();
292- testing::Mock::VerifyAndClearExpectations(&driver);
293+ VERIFY_AND_CLEAR(driver);
294
295 key_plus.press();
296 // BUG: The sequence is a bit strange, but it works, the end result is that
297@@ -277,16 +277,16 @@ TEST_F(KeyPress, PressEqualPlusDontReleaseBeforePress) {
298 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
299 EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL));
300 run_one_scan_loop();
301- testing::Mock::VerifyAndClearExpectations(&driver);
302diff --git a/tests/basic/test_one_shot_keys.cpp b/tests/basic/test_one_shot_keys.cpp
303index bb14221140309648d2eb31219c1c7c99e0c8874d..2401c2c837a50a602577a0900e72e9163ab31c89 100644
304--- a/tests/basic/test_one_shot_keys.cpp
305+++ b/tests/basic/test_one_shot_keys.cpp
306@@ -36,12 +36,12 @@ TEST_F(OneShot, OSMWithoutAdditionalKeypressDoesNothing) {
307 run_one_scan_loop();
308 osm_key.release();
309 run_one_scan_loop();
310- testing::Mock::VerifyAndClearExpectations(&driver);
311+ VERIFY_AND_CLEAR(driver);
312
313 /* OSM are added when an actual report is send */
314 EXPECT_REPORT(driver, (osm_key.report_code));
315 send_keyboard_report();
316- testing::Mock::VerifyAndClearExpectations(&driver);
317+ VERIFY_AND_CLEAR(driver);
318
319 /* Make unit-test pass */
320 clear_oneshot_mods();
321@@ -62,19 +62,19 @@ TEST_P(OneShotParametrizedTestFixture, OSMExpiredDoesNothing) {
322 run_one_scan_loop();
323 osm_key.release();
324 idle_for(ONESHOT_TIMEOUT);
325- testing::Mock::VerifyAndClearExpectations(&driver);
326+ VERIFY_AND_CLEAR(driver);
327
328 /* Press regular key */
329 EXPECT_REPORT(driver, (regular_key.report_code)).Times(1);
330 regular_key.press();
331 run_one_scan_loop();
332- testing::Mock::VerifyAndClearExpectations(&driver);
333+ VERIFY_AND_CLEAR(driver);
334
335 /* Release regular key */
336 EXPECT_EMPTY_REPORT(driver);
337 regular_key.release();
338 run_one_scan_loop();
339- testing::Mock::VerifyAndClearExpectations(&driver);
340+ VERIFY_AND_CLEAR(driver);
341 }
342
343 #endif
344@@ -92,19 +92,19 @@ TEST_P(OneShotParametrizedTestFixture, OSMWithAdditionalKeypress) {
345 run_one_scan_loop();
346 osm_key.release();
347 run_one_scan_loop();
348- testing::Mock::VerifyAndClearExpectations(&driver);
349+ VERIFY_AND_CLEAR(driver);
350
351 /* Press regular key */
352 EXPECT_REPORT(driver, (osm_key.report_code, regular_key.report_code)).Times(1);
353 regular_key.press();
354 run_one_scan_loop();
355- testing::Mock::VerifyAndClearExpectations(&driver);
356+ VERIFY_AND_CLEAR(driver);
357
358 /* Release regular key */
359 EXPECT_EMPTY_REPORT(driver);
360 regular_key.release();
361 run_one_scan_loop();
362- testing::Mock::VerifyAndClearExpectations(&driver);
363+ VERIFY_AND_CLEAR(driver);
364 }
365
366 TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypress) {
367@@ -120,26 +120,26 @@ TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypres
368 EXPECT_NO_REPORT(driver);
369 osm_key.press();
370 run_one_scan_loop();
371- testing::Mock::VerifyAndClearExpectations(&driver);
372+ VERIFY_AND_CLEAR(driver);
373
374 /* Press regular key */
375 EXPECT_NO_REPORT(driver);
376 regular_key.press();
377 run_one_scan_loop();
378- testing::Mock::VerifyAndClearExpectations(&driver);
379+ VERIFY_AND_CLEAR(driver);
380
381 /* Release regular key */
382 EXPECT_NO_REPORT(driver);
383 regular_key.release();
384 run_one_scan_loop();
385- testing::Mock::VerifyAndClearExpectations(&driver);
386+ VERIFY_AND_CLEAR(driver);
387
388 /* Release OSM */
389 EXPECT_REPORT(driver, (regular_key.report_code, osm_key.report_code)).Times(1);
390 EXPECT_EMPTY_REPORT(driver);
391 osm_key.release();
392 run_one_scan_loop();
393- testing::Mock::VerifyAndClearExpectations(&driver);
394+ VERIFY_AND_CLEAR(driver);
395 }
396
397 // clang-format off
398@@ -172,24 +172,24 @@ TEST_F(OneShot, OSLWithAdditionalKeypress) {
399 EXPECT_NO_REPORT(driver);
400 osl_key.press();
401 run_one_scan_loop();
402- testing::Mock::VerifyAndClearExpectations(&driver);
403+ VERIFY_AND_CLEAR(driver);
404
405 /* Release OSL key */
406diff --git a/tests/basic/test_tapping.cpp b/tests/basic/test_tapping.cpp
407index faf9b9fe91360a4612e02aff0b95ccf252b02851..3246f9cdfbdc3be3994695df1e6966b2ea2e0203 100644
408--- a/tests/basic/test_tapping.cpp
409+++ b/tests/basic/test_tapping.cpp
410@@ -134,7 +134,7 @@ TEST_F(Tapping, TapA_CTL_T_KeyWhileReleasingShift) {
411 // Shift is reported
412 EXPECT_REPORT(driver, (KC_LSFT));
413 run_one_scan_loop();
414- testing::Mock::VerifyAndClearExpectations(&driver);
415+ VERIFY_AND_CLEAR(driver);
416
417 mod_tap_hold_key.press();
418 // Tapping keys does nothing on press
419@@ -145,7 +145,7 @@ TEST_F(Tapping, TapA_CTL_T_KeyWhileReleasingShift) {
420 // Releasing shift is delayed while tapping is in progress
421 EXPECT_NO_REPORT(driver);
422 run_one_scan_loop();
423- testing::Mock::VerifyAndClearExpectations(&driver);
424+ VERIFY_AND_CLEAR(driver);
425
426 mod_tap_hold_key.release();
427 // Releasing mod-tap key reports the tap and releases shift
428@@ -153,7 +153,7 @@ TEST_F(Tapping, TapA_CTL_T_KeyWhileReleasingShift) {
429 EXPECT_REPORT(driver, (KC_P));
430 EXPECT_EMPTY_REPORT(driver);
431 run_one_scan_loop();
432- testing::Mock::VerifyAndClearExpectations(&driver);
433+ VERIFY_AND_CLEAR(driver);
434 }
435
436 TEST_F(Tapping, TapA_CTL_T_KeyWhileReleasingLayer) {
437@@ -180,7 +180,7 @@ TEST_F(Tapping, TapA_CTL_T_KeyWhileReleasingLayer) {
438 // Releasing layer is delayed while tapping is in progress
439 EXPECT_NO_REPORT(driver);
440 run_one_scan_loop();
441- testing::Mock::VerifyAndClearExpectations(&driver);
442+ VERIFY_AND_CLEAR(driver);
443
444 mod_tap_hold_key1.release();
445 // Releasing mod-tap key reports the tap of the layer 1 key
446@@ -188,5 +188,5 @@ TEST_F(Tapping, TapA_CTL_T_KeyWhileReleasingLayer) {
447 EXPECT_REPORT(driver, (KC_Q));
448 EXPECT_EMPTY_REPORT(driver);
449 run_one_scan_loop();
450- testing::Mock::VerifyAndClearExpectations(&driver);
451+ VERIFY_AND_CLEAR(driver);
452 }
453diff --git a/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp b/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp
454index ba21c527a67dc7e71aa0325f6d8cfdaa1ac21da4..01b1a78a5f44a73b8aa3a448997958fec58ecf52 100644
455--- a/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp
456+++ b/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp
457@@ -64,7 +64,7 @@ TEST_F(CapsWord, AutoShiftKeys) {
458 tap_key(key_spc);
459 tap_key(key_a);
460
461- testing::Mock::VerifyAndClearExpectations(&driver);
462+ VERIFY_AND_CLEAR(driver);
463 }
464
465 // Test Caps Word + Auto Shift where keys A and B are rolled.
466@@ -104,7 +104,7 @@ TEST_F(CapsWord, AutoShiftRolledShiftedKeys) {
467 run_one_scan_loop();
468
469 caps_word_off();
470- testing::Mock::VerifyAndClearExpectations(&driver);
471+ VERIFY_AND_CLEAR(driver);
472 }
473
474 // Tests that with tap-hold keys with Retro Shift, letter keys are shifted by
475@@ -133,5 +133,5 @@ TEST_F(CapsWord, RetroShiftKeys) {
476 tap_key(key_modtap_a); // Tap A quickly.
477
478 EXPECT_EQ(is_caps_word_on(), true);
479- testing::Mock::VerifyAndClearExpectations(&driver);
480+ VERIFY_AND_CLEAR(driver);
481 }
482diff --git a/tests/caps_word/caps_word_combo/test_caps_word_combo.cpp b/tests/caps_word/caps_word_combo/test_caps_word_combo.cpp
483index 3a0530b8543b14ac8790a5f176fba5dc94a2d2e5..0876cc91a307d09c2e40c5d30b79d8408dfa7dd4 100644
484--- a/tests/caps_word/caps_word_combo/test_caps_word_combo.cpp
485+++ b/tests/caps_word/caps_word_combo/test_caps_word_combo.cpp
486@@ -102,7 +102,7 @@ TEST_P(CapsWord, SingleCombo) {
487 EXPECT_TRUE(is_caps_word_on());
488 caps_word_off();
489
490- testing::Mock::VerifyAndClearExpectations(&driver);
491+ VERIFY_AND_CLEAR(driver);
492 }
493
494 // Test a longer 4-key combo.
495@@ -123,7 +123,7 @@ TEST_P(CapsWord, LongerCombo) {
496 EXPECT_TRUE(is_caps_word_on());
497 caps_word_off();
498
499- testing::Mock::VerifyAndClearExpectations(&driver);
500+ VERIFY_AND_CLEAR(driver);
501 }
502
503 // Test with two overlapping combos on regular keys:
504@@ -161,7 +161,7 @@ TEST_P(CapsWord, ComboRegularKeys) {
505 tap_key(key_a);
506
507 EXPECT_FALSE(is_caps_word_on());
508- testing::Mock::VerifyAndClearExpectations(&driver);
509+ VERIFY_AND_CLEAR(driver);
510 }
511
512 // Test where combo chords involve tap-hold keys:
513@@ -194,7 +194,7 @@ TEST_P(CapsWord, ComboModTapKey) {
514 EXPECT_TRUE(is_caps_word_on());
515 caps_word_off();
516
517- testing::Mock::VerifyAndClearExpectations(&driver);
518+ VERIFY_AND_CLEAR(driver);
519 }
520
521 // clang-format off
522diff --git a/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp b/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp
523index fb8f9333bb867e76a4381ea13a5ff67c9e4f45ab..01cdfd6408d26149c36fd8b8ab1b068694de4708 100644
524--- a/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp
525+++ b/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp
526@@ -93,7 +93,7 @@ TEST_F(CapsWord, ShiftedUnicodeMapKey) {
527 tap_keys(key_delta, key_spc, key_delta);
528
529 EXPECT_EQ(is_caps_word_on(), false);
530- testing::Mock::VerifyAndClearExpectations(&driver);
531+ VERIFY_AND_CLEAR(driver);
532 }
533
534 // Tests typing U_ENDASH while Caps Word is on.
535@@ -117,5 +117,5 @@ TEST_F(CapsWord, UnshiftedUnicodeMapKey) {
536 tap_key(key_dash);
537
538 EXPECT_EQ(is_caps_word_on(), true);
539- testing::Mock::VerifyAndClearExpectations(&driver);
540+ VERIFY_AND_CLEAR(driver);
541 }
542diff --git a/tests/caps_word/test_caps_word.cpp b/tests/caps_word/test_caps_word.cpp
543index fa970c7d0efbd4d9155e3f7e4d2b068c64699db9..6d38b383f31de4842f1c384920abe3523d1344f5 100644
544--- a/tests/caps_word/test_caps_word.cpp
545+++ b/tests/caps_word/test_caps_word.cpp
546@@ -90,7 +90,7 @@ TEST_F(CapsWord, OnOffToggleFuns) {
547 caps_word_toggle();
548 EXPECT_EQ(is_caps_word_on(), false);
549
550- testing::Mock::VerifyAndClearExpectations(&driver);
551+ VERIFY_AND_CLEAR(driver);
552 }
553
554 // Tests the default `caps_word_press_user()` function.
555@@ -133,7 +133,7 @@ TEST_F(CapsWord, CapswrdKey) {
556 tap_key(key_capswrd); // Tap the QK_CAPS_WORD_TOGGLE key again.
557 EXPECT_EQ(is_caps_word_on(), false);
558
559- testing::Mock::VerifyAndClearExpectations(&driver);
560+ VERIFY_AND_CLEAR(driver);
561 }
562
563 // Tests that being idle for CAPS_WORD_IDLE_TIMEOUT turns off Caps Word.
564@@ -157,7 +157,7 @@ TEST_F(CapsWord, IdleTimeout) {
565 caps_word_on();
566 tap_key(key_a);
567
568- testing::Mock::VerifyAndClearExpectations(&driver);
569+ VERIFY_AND_CLEAR(driver);
570
571 idle_for(CAPS_WORD_IDLE_TIMEOUT);
572 run_one_scan_loop();
573@@ -171,7 +171,7 @@ TEST_F(CapsWord, IdleTimeout) {
574 EXPECT_REPORT(driver, (KC_A));
575 tap_key(key_a);
576
577- testing::Mock::VerifyAndClearExpectations(&driver);
578+ VERIFY_AND_CLEAR(driver);
579 }
580
581 // Tests that typing "A, 4, A, 4" produces "Shift+A, 4, Shift+A, 4".
582@@ -201,7 +201,7 @@ TEST_F(CapsWord, ShiftsLettersButNotDigits) {
583 caps_word_on();
584 tap_keys(key_a, key_4, key_a, key_4);
585
586- testing::Mock::VerifyAndClearExpectations(&driver);
587+ VERIFY_AND_CLEAR(driver);
588 }
589
590 // Tests that typing "A, Space, A" produces "Shift+A, Space, A".
591@@ -230,7 +230,7 @@ TEST_F(CapsWord, SpaceTurnsOffCapsWord) {
592 caps_word_on();
593 tap_keys(key_a, key_spc, key_a);
594
595- testing::Mock::VerifyAndClearExpectations(&driver);
596+ VERIFY_AND_CLEAR(driver);
597 }
598
599 // Tests that typing "AltGr + A" produces "Shift + AltGr + A".
600@@ -260,7 +260,7 @@ TEST_F(CapsWord, ShiftsAltGrSymbols) {
601 run_one_scan_loop();
602 key_altgr.release();
603
604- testing::Mock::VerifyAndClearExpectations(&driver);
605+ VERIFY_AND_CLEAR(driver);
606 }
607
608 // Tests typing "AltGr + A" using a mod-tap key.
609@@ -291,7 +291,7 @@ TEST_F(CapsWord, ShiftsModTapAltGrSymbols) {
610 key_altgr_t.release();
611
612 EXPECT_TRUE(is_caps_word_on());
613- testing::Mock::VerifyAndClearExpectations(&driver);
614+ VERIFY_AND_CLEAR(driver);
615 }
616
617 struct CapsWordPressUserParams {
618@@ -326,7 +326,7 @@ TEST_P(CapsWordPressUser, KeyCode) {
619 EXPECT_EQ(passed_keycode, GetParam().expected_passed_keycode);
620 EXPECT_EQ(is_caps_word_on(), GetParam().continues_caps_word);
621 clear_oneshot_mods();
622- testing::Mock::VerifyAndClearExpectations(&driver);
623+ VERIFY_AND_CLEAR(driver);
624 }
625
626 const uint16_t LT_1_KC_A = LT(1, KC_A);
627@@ -431,7 +431,7 @@ TEST_P(CapsWordBothShifts, PressLRLR) {
628
629 EXPECT_EQ(is_caps_word_on(), true);
630
631- testing::Mock::VerifyAndClearExpectations(&driver);
632+ VERIFY_AND_CLEAR(driver);
633 }
634
635 // Pressing shifts as "Left down, Right down, Right up, Left up".
636@@ -468,7 +468,7 @@ TEST_P(CapsWordBothShifts, PressLRRL) {
637
638 EXPECT_EQ(is_caps_word_on(), true);
639
640- testing::Mock::VerifyAndClearExpectations(&driver);
641+ VERIFY_AND_CLEAR(driver);
642 }
643
644 // clang-format off
645@@ -524,7 +524,7 @@ TEST_P(CapsWordDoubleTapShift, Activation) {
646diff --git a/tests/secure/test_secure.cpp b/tests/secure/test_secure.cpp
647index 6ca98d78f3f12a33c9b6f4f852f0f0831805fc99..3162e9d5dfc9e9c68e27a11636310d356e358144 100644
648--- a/tests/secure/test_secure.cpp
649+++ b/tests/secure/test_secure.cpp
650@@ -43,7 +43,7 @@ TEST_F(Secure, test_lock) {
651 secure_lock();
652 EXPECT_FALSE(secure_is_unlocked());
653
654- testing::Mock::VerifyAndClearExpectations(&driver);
655+ VERIFY_AND_CLEAR(driver);
656 }
657
658 TEST_F(Secure, test_unlock_timeout) {
659@@ -58,7 +58,7 @@ TEST_F(Secure, test_unlock_timeout) {
660 idle_for(SECURE_IDLE_TIMEOUT + 1);
661 EXPECT_FALSE(secure_is_unlocked());
662
663- testing::Mock::VerifyAndClearExpectations(&driver);
664+ VERIFY_AND_CLEAR(driver);
665 }
666
667 TEST_F(Secure, test_unlock_request) {
668@@ -80,7 +80,7 @@ TEST_F(Secure, test_unlock_request) {
669 tap_keys(key_a, key_b, key_c, key_d);
670 EXPECT_TRUE(secure_is_unlocked());
671
672- testing::Mock::VerifyAndClearExpectations(&driver);
673+ VERIFY_AND_CLEAR(driver);
674 }
675
676 TEST_F(Secure, test_unlock_request_fail) {
677@@ -108,7 +108,7 @@ TEST_F(Secure, test_unlock_request_fail) {
678 tap_keys(key_e, key_a, key_b, key_c, key_d);
679 EXPECT_FALSE(secure_is_unlocked());
680
681- testing::Mock::VerifyAndClearExpectations(&driver);
682+ VERIFY_AND_CLEAR(driver);
683 }
684
685 TEST_F(Secure, test_unlock_request_timeout) {
686@@ -124,7 +124,7 @@ TEST_F(Secure, test_unlock_request_timeout) {
687 EXPECT_FALSE(secure_is_unlocking());
688 EXPECT_FALSE(secure_is_unlocked());
689
690- testing::Mock::VerifyAndClearExpectations(&driver);
691+ VERIFY_AND_CLEAR(driver);
692 }
693
694 TEST_F(Secure, test_unlock_request_fail_mid) {
695@@ -151,7 +151,7 @@ TEST_F(Secure, test_unlock_request_fail_mid) {
696 EXPECT_FALSE(secure_is_unlocking());
697 EXPECT_FALSE(secure_is_unlocked());
698
699- testing::Mock::VerifyAndClearExpectations(&driver);
700+ VERIFY_AND_CLEAR(driver);
701 }
702
703 TEST_F(Secure, test_unlock_request_fail_out_of_order) {
704@@ -179,7 +179,7 @@ TEST_F(Secure, test_unlock_request_fail_out_of_order) {
705 EXPECT_FALSE(secure_is_unlocking());
706 EXPECT_FALSE(secure_is_unlocked());
707
708- testing::Mock::VerifyAndClearExpectations(&driver);
709+ VERIFY_AND_CLEAR(driver);
710 }
711
712 TEST_F(Secure, test_unlock_request_on_layer) {
713@@ -206,7 +206,7 @@ TEST_F(Secure, test_unlock_request_on_layer) {
714 EXPECT_TRUE(secure_is_unlocked());
715 EXPECT_FALSE(layer_state_is(1));
716
717- testing::Mock::VerifyAndClearExpectations(&driver);
718+ VERIFY_AND_CLEAR(driver);
719 }
720
721 TEST_F(Secure, test_unlock_request_mid_stroke) {
722@@ -231,7 +231,7 @@ TEST_F(Secure, test_unlock_request_mid_stroke) {
723 tap_keys(key_a, key_b, key_c, key_d);
724 EXPECT_TRUE(secure_is_unlocked());
725
726- testing::Mock::VerifyAndClearExpectations(&driver);
727+ VERIFY_AND_CLEAR(driver);
728 }
729
730 TEST_F(Secure, test_unlock_request_mods) {
731@@ -256,5 +256,5 @@ TEST_F(Secure, test_unlock_request_mods) {
732 tap_keys(key_a, key_b, key_c, key_d);
733 EXPECT_TRUE(secure_is_unlocked());
734
735- testing::Mock::VerifyAndClearExpectations(&driver);
736+ VERIFY_AND_CLEAR(driver);
737 }
738diff --git a/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp b/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp
739index 01943c10d26186798fbdd614d81b0df986adf167..6d82af6725c2182f7424cd7bc0e4d10032325676 100644
740--- a/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp
741+++ b/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp
742@@ -38,19 +38,19 @@ TEST_F(DefaultTapHold, tap_regular_key_while_mod_tap_key_is_held) {
743 EXPECT_NO_REPORT(driver);
744 mod_tap_hold_key.press();
745 run_one_scan_loop();
746- testing::Mock::VerifyAndClearExpectations(&driver);
747+ VERIFY_AND_CLEAR(driver);
748
749 /* Press regular key. */
750 EXPECT_NO_REPORT(driver);
751 regular_key.press();
752 run_one_scan_loop();
753- testing::Mock::VerifyAndClearExpectations(&driver);
754+ VERIFY_AND_CLEAR(driver);
755
756 /* Release regular key. */
757 EXPECT_NO_REPORT(driver);
758 regular_key.release();
759 run_one_scan_loop();
760- testing::Mock::VerifyAndClearExpectations(&driver);
761+ VERIFY_AND_CLEAR(driver);
762
763 /* Release mod-tap-hold key. */
764 EXPECT_REPORT(driver, (KC_P));
765@@ -59,11 +59,11 @@ TEST_F(DefaultTapHold, tap_regular_key_while_mod_tap_key_is_held) {
766 EXPECT_EMPTY_REPORT(driver);
767 mod_tap_hold_key.release();
768 run_one_scan_loop();
769- testing::Mock::VerifyAndClearExpectations(&driver);
770+ VERIFY_AND_CLEAR(driver);
771
772 /* Idle for tapping term of mod tap hold key. */
773 idle_for(TAPPING_TERM - 3);
774- testing::Mock::VerifyAndClearExpectations(&driver);
775+ VERIFY_AND_CLEAR(driver);
776 }
777
778 TEST_F(DefaultTapHold, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) {
779@@ -78,19 +78,19 @@ TEST_F(DefaultTapHold, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) {
780 EXPECT_NO_REPORT(driver);
781 first_mod_tap_hold_key.press();
782 run_one_scan_loop();
783- testing::Mock::VerifyAndClearExpectations(&driver);
784+ VERIFY_AND_CLEAR(driver);
785
786 /* Press second tap-hold key */
787 EXPECT_NO_REPORT(driver);
788 second_mod_tap_hold_key.press();
789 run_one_scan_loop();
790- testing::Mock::VerifyAndClearExpectations(&driver);
791+ VERIFY_AND_CLEAR(driver);
792
793 /* Release second tap-hold key */
794 EXPECT_NO_REPORT(driver);
795 second_mod_tap_hold_key.release();
796 run_one_scan_loop();
797- testing::Mock::VerifyAndClearExpectations(&driver);
798+ VERIFY_AND_CLEAR(driver);
799
800 /* Release first mod-tap-hold key */
801 EXPECT_REPORT(driver, (KC_P));
802@@ -99,7 +99,7 @@ TEST_F(DefaultTapHold, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) {
803 EXPECT_EMPTY_REPORT(driver);
804 first_mod_tap_hold_key.release();
805 run_one_scan_loop();
806- testing::Mock::VerifyAndClearExpectations(&driver);
807+ VERIFY_AND_CLEAR(driver);
808 }
809
810 TEST_F(DefaultTapHold, tap_regular_key_while_layer_tap_key_is_held) {
811@@ -115,19 +115,19 @@ TEST_F(DefaultTapHold, tap_regular_key_while_layer_tap_key_is_held) {
812 EXPECT_NO_REPORT(driver);
813 layer_tap_hold_key.press();
814 run_one_scan_loop();
815- testing::Mock::VerifyAndClearExpectations(&driver);
816+ VERIFY_AND_CLEAR(driver);
817
818 /* Press regular key */
819 EXPECT_NO_REPORT(driver);
820 regular_key.press();
821 run_one_scan_loop();
822- testing::Mock::VerifyAndClearExpectations(&driver);
823+ VERIFY_AND_CLEAR(driver);
824
825 /* Release regular key */
826 EXPECT_NO_REPORT(driver);
827 regular_key.release();
828 run_one_scan_loop();
829- testing::Mock::VerifyAndClearExpectations(&driver);
830+ VERIFY_AND_CLEAR(driver);
831
832 /* Release layer-tap-hold key */
833 EXPECT_REPORT(driver, (KC_P));
834@@ -136,7 +136,7 @@ TEST_F(DefaultTapHold, tap_regular_key_while_layer_tap_key_is_held) {
835 EXPECT_EMPTY_REPORT(driver);
836 layer_tap_hold_key.release();
837 run_one_scan_loop();
838- testing::Mock::VerifyAndClearExpectations(&driver);
839+ VERIFY_AND_CLEAR(driver);
840 }
841
842diff --git a/tests/tap_hold_configurations/hold_on_other_key_press/test_tap_hold.cpp b/tests/tap_hold_configurations/hold_on_other_key_press/test_tap_hold.cpp
843index e77c756624bc4aa7e1bc3722c13794045f4174ee..84a6f6996dded14e259c859d59b55878384fd897 100644
844--- a/tests/tap_hold_configurations/hold_on_other_key_press/test_tap_hold.cpp
845+++ b/tests/tap_hold_configurations/hold_on_other_key_press/test_tap_hold.cpp
846@@ -38,26 +38,26 @@ TEST_F(HoldOnOtherKeyPress, short_distinct_taps_of_mod_tap_key_and_regular_key)
847 EXPECT_NO_REPORT(driver);
848 mod_tap_hold_key.press();
849 run_one_scan_loop();
850- testing::Mock::VerifyAndClearExpectations(&driver);
851+ VERIFY_AND_CLEAR(driver);
852
853 /* Release mod-tap-hold key. */
854 EXPECT_REPORT(driver, (KC_P));
855 EXPECT_EMPTY_REPORT(driver);
856 mod_tap_hold_key.release();
857 run_one_scan_loop();
858- testing::Mock::VerifyAndClearExpectations(&driver);
859+ VERIFY_AND_CLEAR(driver);
860
861 /* Press regular key. */
862 EXPECT_REPORT(driver, (KC_A));
863 regular_key.press();
864 run_one_scan_loop();
865- testing::Mock::VerifyAndClearExpectations(&driver);
866+ VERIFY_AND_CLEAR(driver);
867
868 /* Release regular key. */
869 EXPECT_EMPTY_REPORT(driver);
870 regular_key.release();
871 run_one_scan_loop();
872- testing::Mock::VerifyAndClearExpectations(&driver);
873+ VERIFY_AND_CLEAR(driver);
874 }
875
876 TEST_F(HoldOnOtherKeyPress, long_distinct_taps_of_mod_tap_key_and_regular_key) {
877@@ -72,30 +72,30 @@ TEST_F(HoldOnOtherKeyPress, long_distinct_taps_of_mod_tap_key_and_regular_key) {
878 EXPECT_NO_REPORT(driver);
879 mod_tap_hold_key.press();
880 run_one_scan_loop();
881- testing::Mock::VerifyAndClearExpectations(&driver);
882+ VERIFY_AND_CLEAR(driver);
883
884 /* Idle for tapping term of mod tap hold key. */
885 EXPECT_REPORT(driver, (KC_LSFT));
886 idle_for(TAPPING_TERM + 1);
887- testing::Mock::VerifyAndClearExpectations(&driver);
888+ VERIFY_AND_CLEAR(driver);
889
890 /* Release mod-tap-hold key. */
891 EXPECT_EMPTY_REPORT(driver);
892 mod_tap_hold_key.release();
893 run_one_scan_loop();
894- testing::Mock::VerifyAndClearExpectations(&driver);
895+ VERIFY_AND_CLEAR(driver);
896
897 /* Press regular key. */
898 EXPECT_REPORT(driver, (KC_A));
899 regular_key.press();
900 run_one_scan_loop();
901- testing::Mock::VerifyAndClearExpectations(&driver);
902+ VERIFY_AND_CLEAR(driver);
903
904 /* Release regular key. */
905 EXPECT_EMPTY_REPORT(driver);
906 regular_key.release();
907 run_one_scan_loop();
908- testing::Mock::VerifyAndClearExpectations(&driver);
909+ VERIFY_AND_CLEAR(driver);
910 }
911
912 TEST_F(HoldOnOtherKeyPress, short_distinct_taps_of_layer_tap_key_and_regular_key) {
913@@ -111,26 +111,26 @@ TEST_F(HoldOnOtherKeyPress, short_distinct_taps_of_layer_tap_key_and_regular_key
914 EXPECT_NO_REPORT(driver);
915 layer_tap_hold_key.press();
916 run_one_scan_loop();
917- testing::Mock::VerifyAndClearExpectations(&driver);
918+ VERIFY_AND_CLEAR(driver);
919
920 /* Release layer-tap-hold key. */
921 EXPECT_REPORT(driver, (KC_P));
922 EXPECT_EMPTY_REPORT(driver);
923 layer_tap_hold_key.release();
924 run_one_scan_loop();
925- testing::Mock::VerifyAndClearExpectations(&driver);
926+ VERIFY_AND_CLEAR(driver);
927
928 /* Press regular key. */
929 EXPECT_REPORT(driver, (KC_A));
930 regular_key.press();
931 run_one_scan_loop();
932- testing::Mock::VerifyAndClearExpectations(&driver);
933+ VERIFY_AND_CLEAR(driver);
934
935 /* Release regular key. */
936 EXPECT_EMPTY_REPORT(driver);
937 regular_key.release();
938 run_one_scan_loop();
939- testing::Mock::VerifyAndClearExpectations(&driver);
940+ VERIFY_AND_CLEAR(driver);
941 }
942
943 TEST_F(HoldOnOtherKeyPress, long_distinct_taps_of_layer_tap_key_and_regular_key) {
944@@ -146,30 +146,30 @@ TEST_F(HoldOnOtherKeyPress, long_distinct_taps_of_layer_tap_key_and_regular_key)
945 EXPECT_NO_REPORT(driver);
946diff --git a/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp b/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp
947index 1328b5fc0fb5a13c096c10e36ee857c61cb48384..81f7fe718ec45e7aa1a05a4b5f0e3a53775f7e65 100644
948--- a/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp
949+++ b/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp
950@@ -35,26 +35,26 @@ TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypres
951 EXPECT_NO_REPORT(driver);
952 osm_key.press();
953 run_one_scan_loop();
954- testing::Mock::VerifyAndClearExpectations(&driver);
955+ VERIFY_AND_CLEAR(driver);
956
957 /* Press regular key */
958 EXPECT_NO_REPORT(driver);
959 regular_key.press();
960 run_one_scan_loop();
961- testing::Mock::VerifyAndClearExpectations(&driver);
962+ VERIFY_AND_CLEAR(driver);
963
964 /* Release regular key */
965 EXPECT_REPORT(driver, (osm_key.report_code)).Times(2);
966 EXPECT_REPORT(driver, (regular_key.report_code, osm_key.report_code)).Times(1);
967 regular_key.release();
968 run_one_scan_loop();
969- testing::Mock::VerifyAndClearExpectations(&driver);
970+ VERIFY_AND_CLEAR(driver);
971
972 /* Release OSM */
973 EXPECT_EMPTY_REPORT(driver).Times(1);
974 osm_key.release();
975 run_one_scan_loop();
976- testing::Mock::VerifyAndClearExpectations(&driver);
977+ VERIFY_AND_CLEAR(driver);
978 }
979
980 // clang-format off
981diff --git a/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp b/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp
982index e6ecc86401500b27b00ee33cb44adbe3cb4ea598..8acae6ae67816899e52aa6e3ca37833afa4b38f2 100644
983--- a/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp
984+++ b/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp
985@@ -37,13 +37,13 @@ TEST_F(PermissiveHold, tap_regular_key_while_mod_tap_key_is_held) {
986 EXPECT_NO_REPORT(driver);
987 mod_tap_hold_key.press();
988 run_one_scan_loop();
989- testing::Mock::VerifyAndClearExpectations(&driver);
990+ VERIFY_AND_CLEAR(driver);
991
992 /* Press regular key */
993 EXPECT_NO_REPORT(driver);
994 regular_key.press();
995 run_one_scan_loop();
996- testing::Mock::VerifyAndClearExpectations(&driver);
997+ VERIFY_AND_CLEAR(driver);
998
999 /* Release regular key */
1000 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
1001@@ -51,13 +51,13 @@ TEST_F(PermissiveHold, tap_regular_key_while_mod_tap_key_is_held) {
1002 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
1003 regular_key.release();
1004 run_one_scan_loop();
1005- testing::Mock::VerifyAndClearExpectations(&driver);
1006+ VERIFY_AND_CLEAR(driver);
1007
1008 /* Release mod-tap-hold key */
1009 EXPECT_EMPTY_REPORT(driver);
1010 mod_tap_hold_key.release();
1011 run_one_scan_loop();
1012- testing::Mock::VerifyAndClearExpectations(&driver);
1013+ VERIFY_AND_CLEAR(driver);
1014 }
1015
1016 TEST_F(PermissiveHold, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) {
1017@@ -72,13 +72,13 @@ TEST_F(PermissiveHold, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) {
1018 EXPECT_NO_REPORT(driver);
1019 first_mod_tap_hold_key.press();
1020 run_one_scan_loop();
1021- testing::Mock::VerifyAndClearExpectations(&driver);
1022+ VERIFY_AND_CLEAR(driver);
1023
1024 /* Press second mod-tap-hold key */
1025 EXPECT_NO_REPORT(driver);
1026 second_mod_tap_hold_key.press();
1027 run_one_scan_loop();
1028- testing::Mock::VerifyAndClearExpectations(&driver);
1029+ VERIFY_AND_CLEAR(driver);
1030
1031 /* Release second mod-tap-hold key */
1032 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
1033@@ -86,13 +86,13 @@ TEST_F(PermissiveHold, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) {
1034 EXPECT_REPORT(driver, (KC_LEFT_SHIFT));
1035 second_mod_tap_hold_key.release();
1036 run_one_scan_loop();
1037- testing::Mock::VerifyAndClearExpectations(&driver);
1038+ VERIFY_AND_CLEAR(driver);
1039
1040 /* Release first mod-tap-hold key */
1041 EXPECT_EMPTY_REPORT(driver);
1042 first_mod_tap_hold_key.release();
1043 run_one_scan_loop();
1044- testing::Mock::VerifyAndClearExpectations(&driver);
1045+ VERIFY_AND_CLEAR(driver);
1046 }
1047
1048 TEST_F(PermissiveHold, tap_regular_key_while_layer_tap_key_is_held) {
1049@@ -108,24 +108,24 @@ TEST_F(PermissiveHold, tap_regular_key_while_layer_tap_key_is_held) {
1050 EXPECT_NO_REPORT(driver);
1051 layer_tap_hold_key.press();
1052 run_one_scan_loop();
1053- testing::Mock::VerifyAndClearExpectations(&driver);
1054+ VERIFY_AND_CLEAR(driver);
1055
1056 /* Press regular key */
1057 EXPECT_NO_REPORT(driver);
1058 regular_key.press();
1059 run_one_scan_loop();
1060- testing::Mock::VerifyAndClearExpectations(&driver);
1061+ VERIFY_AND_CLEAR(driver);
1062
1063 /* Release regular key */
1064 EXPECT_REPORT(driver, (layer_key.report_code));
1065 EXPECT_EMPTY_REPORT(driver);
1066 regular_key.release();
1067 run_one_scan_loop();
1068- testing::Mock::VerifyAndClearExpectations(&driver);
1069+ VERIFY_AND_CLEAR(driver);
1070
1071 /* Release layer-tap-hold key */
1072 EXPECT_NO_REPORT(driver);
1073 layer_tap_hold_key.release();
1074 run_one_scan_loop();
1075- testing::Mock::VerifyAndClearExpectations(&driver);
1076+ VERIFY_AND_CLEAR(driver);
1077 }
1078diff --git a/tests/tap_hold_configurations/quick_tap/test_action_layer.cpp b/tests/tap_hold_configurations/quick_tap/test_action_layer.cpp
1079index 9c3b38050a92810f5d81d488088ad89089006853..44dd14c033e52031c65431d7ed615e6cb9df084a 100644
1080--- a/tests/tap_hold_configurations/quick_tap/test_action_layer.cpp
1081+++ b/tests/tap_hold_configurations/quick_tap/test_action_layer.cpp
1082@@ -66,17 +66,17 @@ TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) {
1083 run_one_scan_loop();
1084 expect_layer_state(0);
1085
1086- testing::Mock::VerifyAndClearExpectations(&driver);
1087+ VERIFY_AND_CLEAR(driver);
1088
1089 EXPECT_REPORT(driver, (KC_A)).Times(1);
1090 regular_key.press();
1091 run_one_scan_loop();
1092 expect_layer_state(0);
1093- testing::Mock::VerifyAndClearExpectations(&driver);
1094+ VERIFY_AND_CLEAR(driver);
1095
1096 EXPECT_EMPTY_REPORT(driver).Times(1);
1097 regular_key.release();
1098 run_one_scan_loop();
1099 expect_layer_state(0);
1100- testing::Mock::VerifyAndClearExpectations(&driver);
1101+ VERIFY_AND_CLEAR(driver);
1102 }
1103diff --git a/tests/tap_hold_configurations/quick_tap/test_quick_tap.cpp b/tests/tap_hold_configurations/quick_tap/test_quick_tap.cpp
1104index e2f8c513406c009384ba4e7fcc0169243fcf0246..8ec6ea62a3ea9239d9c6734cf30dcbb050519770 100644
1105--- a/tests/tap_hold_configurations/quick_tap/test_quick_tap.cpp
1106+++ b/tests/tap_hold_configurations/quick_tap/test_quick_tap.cpp
1107@@ -39,32 +39,32 @@ TEST_F(QuickTap, tap_regular_key_while_mod_tap_key_is_held) {
1108 EXPECT_NO_REPORT(driver);
1109 mod_tap_key.press();
1110 run_one_scan_loop();
1111- testing::Mock::VerifyAndClearExpectations(&driver);
1112+ VERIFY_AND_CLEAR(driver);
1113
1114 /* Press regular key. */
1115 EXPECT_NO_REPORT(driver);
1116 regular_key.press();
1117 run_one_scan_loop();
1118- testing::Mock::VerifyAndClearExpectations(&driver);
1119+ VERIFY_AND_CLEAR(driver);
1120
1121 /* Release regular key. */
1122 EXPECT_NO_REPORT(driver);
1123 regular_key.release();
1124 run_one_scan_loop();
1125- testing::Mock::VerifyAndClearExpectations(&driver);
1126+ VERIFY_AND_CLEAR(driver);
1127
1128 /* Release mod-tap key. */
1129 EXPECT_REPORT(driver, (KC_LSFT));
1130 mod_tap_key.release();
1131 run_one_scan_loop();
1132- testing::Mock::VerifyAndClearExpectations(&driver);
1133+ VERIFY_AND_CLEAR(driver);
1134
1135 /* Idle for tapping term of mod tap hold key. */
1136 EXPECT_REPORT(driver, (KC_LSFT, KC_A));
1137 EXPECT_REPORT(driver, (KC_LSFT));
1138 EXPECT_EMPTY_REPORT(driver);
1139 idle_for(TAPPING_TERM - 3);
1140- testing::Mock::VerifyAndClearExpectations(&driver);
1141+ VERIFY_AND_CLEAR(driver);
1142 }
1143
1144 TEST_F(QuickTap, tap_mod_tap_key_while_mod_tap_key_is_held) {
1145@@ -79,32 +79,32 @@ TEST_F(QuickTap, tap_mod_tap_key_while_mod_tap_key_is_held) {
1146 EXPECT_NO_REPORT(driver);
1147 first_mod_tap_key.press();
1148 run_one_scan_loop();
1149- testing::Mock::VerifyAndClearExpectations(&driver);
1150+ VERIFY_AND_CLEAR(driver);
1151
1152 /* Press second mod-tap key */
1153 EXPECT_NO_REPORT(driver);
1154 second_mod_tap_key.press();
1155 run_one_scan_loop();
1156- testing::Mock::VerifyAndClearExpectations(&driver);
1157+ VERIFY_AND_CLEAR(driver);
1158
1159 /* Release second tap-hold key */
1160 EXPECT_NO_REPORT(driver);
1161 second_mod_tap_key.release();
1162 run_one_scan_loop();
1163- testing::Mock::VerifyAndClearExpectations(&driver);
1164+ VERIFY_AND_CLEAR(driver);
1165
1166 /* Release first mod-tap key */
1167 EXPECT_REPORT(driver, (KC_LSFT));
1168 first_mod_tap_key.release();
1169 run_one_scan_loop();
1170- testing::Mock::VerifyAndClearExpectations(&driver);
1171+ VERIFY_AND_CLEAR(driver);
1172
1173 /* Idle for tapping term of first mod-tap key. */
1174 EXPECT_REPORT(driver, (KC_LSFT, KC_A));
1175 EXPECT_REPORT(driver, (KC_LSFT));
1176 EXPECT_EMPTY_REPORT(driver);
1177 idle_for(TAPPING_TERM - 3);
1178- testing::Mock::VerifyAndClearExpectations(&driver);
1179+ VERIFY_AND_CLEAR(driver);
1180 }
1181
1182 TEST_F(QuickTap, tap_regular_key_while_layer_tap_key_is_held) {
1183@@ -120,19 +120,19 @@ TEST_F(QuickTap, tap_regular_key_while_layer_tap_key_is_held) {
1184 EXPECT_NO_REPORT(driver);
1185 layer_tap_key.press();
1186 run_one_scan_loop();
1187- testing::Mock::VerifyAndClearExpectations(&driver);
1188+ VERIFY_AND_CLEAR(driver);
1189
1190 /* Press regular key */
1191 EXPECT_NO_REPORT(driver);
1192 regular_key.press();
1193 run_one_scan_loop();
1194- testing::Mock::VerifyAndClearExpectations(&driver);
1195+ VERIFY_AND_CLEAR(driver);
1196
1197 /* Release regular key */
1198 EXPECT_NO_REPORT(driver);
1199 regular_key.release();
1200 run_one_scan_loop();
1201- testing::Mock::VerifyAndClearExpectations(&driver);
1202+ VERIFY_AND_CLEAR(driver);
1203
1204 /* Release layer-tap key */
1205 EXPECT_REPORT(driver, (KC_P));
1206@@ -141,7 +141,7 @@ TEST_F(QuickTap, tap_regular_key_while_layer_tap_key_is_held) {
1207diff --git a/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp b/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp
1208index e08c600dbd050c7ff4e5e432e5bedbb51f95dc0c..2b49cddccebd23b2bfc167ee2ad0d05fe7af93e9 100644
1209--- a/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp
1210+++ b/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp
1211@@ -38,7 +38,7 @@ TEST_F(RetroTapping, tap_and_hold_mod_tap_hold_key) {
1212 EXPECT_NO_REPORT(driver);
1213 mod_tap_hold_key.press();
1214 idle_for(TAPPING_TERM);
1215- testing::Mock::VerifyAndClearExpectations(&driver);
1216+ VERIFY_AND_CLEAR(driver);
1217
1218 /* Release mod-tap-hold key. */
1219 /* TODO: Why is LSHIFT send at all? */
1220@@ -48,5 +48,5 @@ TEST_F(RetroTapping, tap_and_hold_mod_tap_hold_key) {
1221 EXPECT_EMPTY_REPORT(driver);
1222 mod_tap_hold_key.release();
1223 run_one_scan_loop();
1224- testing::Mock::VerifyAndClearExpectations(&driver);
1225+ VERIFY_AND_CLEAR(driver);
1226 }
1227diff --git a/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp b/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp
1228index 42139d50da20a85ecd32d5bc7e23201ec7c57674..db81c39101d3b71f9c483567f84253f7d7263a0c 100644
1229--- a/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp
1230+++ b/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp
1231@@ -35,18 +35,18 @@ TEST_F(Tapping, HoldA_SHFT_T_KeyReportsShift) {
1232 EXPECT_NO_REPORT(driver);
1233 mod_tap_hold_key.press();
1234 idle_for(TAPPING_TERM);
1235- testing::Mock::VerifyAndClearExpectations(&driver);
1236+ VERIFY_AND_CLEAR(driver);
1237
1238 EXPECT_REPORT(driver, (KC_LSFT));
1239 run_one_scan_loop();
1240- testing::Mock::VerifyAndClearExpectations(&driver);
1241+ VERIFY_AND_CLEAR(driver);
1242
1243 EXPECT_EMPTY_REPORT(driver);
1244 EXPECT_REPORT(driver, (KC_P));
1245 EXPECT_EMPTY_REPORT(driver);
1246 mod_tap_hold_key.release();
1247 run_one_scan_loop();
1248- testing::Mock::VerifyAndClearExpectations(&driver);
1249+ VERIFY_AND_CLEAR(driver);
1250 }
1251
1252 TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) {
1253@@ -60,45 +60,45 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) {
1254 EXPECT_NO_REPORT(driver);
1255 key_shift_hold_p_tap.press();
1256 run_one_scan_loop();
1257- testing::Mock::VerifyAndClearExpectations(&driver);
1258+ VERIFY_AND_CLEAR(driver);
1259
1260 /* Release mod_tap_hold key */
1261 EXPECT_REPORT(driver, (KC_P));
1262 EXPECT_EMPTY_REPORT(driver);
1263 key_shift_hold_p_tap.release();
1264 run_one_scan_loop();
1265- testing::Mock::VerifyAndClearExpectations(&driver);
1266+ VERIFY_AND_CLEAR(driver);
1267
1268 /* Press mod_tap_hold key again */
1269 EXPECT_REPORT(driver, (KC_P));
1270 key_shift_hold_p_tap.press();
1271 run_one_scan_loop();
1272- testing::Mock::VerifyAndClearExpectations(&driver);
1273+ VERIFY_AND_CLEAR(driver);
1274
1275 /* Release mod_tap_hold key again */
1276 EXPECT_EMPTY_REPORT(driver);
1277 key_shift_hold_p_tap.release();
1278 idle_for(TAPPING_TERM + 1);
1279- testing::Mock::VerifyAndClearExpectations(&driver);
1280+ VERIFY_AND_CLEAR(driver);
1281
1282 /* Press mod_tap_hold key again */
1283 EXPECT_NO_REPORT(driver);
1284 key_shift_hold_p_tap.press();
1285 run_one_scan_loop();
1286- testing::Mock::VerifyAndClearExpectations(&driver);
1287+ VERIFY_AND_CLEAR(driver);
1288
1289 /* Release mod_tap_hold key again */
1290 EXPECT_REPORT(driver, (KC_P));
1291 EXPECT_EMPTY_REPORT(driver);
1292 key_shift_hold_p_tap.release();
1293 idle_for(TAPPING_TERM + 1);
1294- testing::Mock::VerifyAndClearExpectations(&driver);
1295+ VERIFY_AND_CLEAR(driver);
1296
1297 /* Press mod_tap_hold key again */
1298 EXPECT_NO_REPORT(driver);
1299 key_shift_hold_p_tap.press();
1300 idle_for(TAPPING_TERM);
1301- testing::Mock::VerifyAndClearExpectations(&driver);
1302+ VERIFY_AND_CLEAR(driver);
1303
1304 /* Release mod_tap_hold key again */
1305 /* TODO: Why is KC_LSFT send? */
1306@@ -108,5 +108,5 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) {
1307 EXPECT_EMPTY_REPORT(driver);
1308 key_shift_hold_p_tap.release();
1309 run_one_scan_loop();
1310- testing::Mock::VerifyAndClearExpectations(&driver);
1311+ VERIFY_AND_CLEAR(driver);
1312 }
1313diff --git a/tests/test_common/test_driver.hpp b/tests/test_common/test_driver.hpp
1314index 982aec6c83ff30c2b98192c04cc4c2f4967946ca..8d09e448405a1620b9ebf62bf9bf811d848decb1 100644
1315--- a/tests/test_common/test_driver.hpp
1316+++ b/tests/test_common/test_driver.hpp
1317@@ -98,6 +98,12 @@ class TestDriver {
1318 */
1319 #define EXPECT_NO_REPORT(driver) EXPECT_ANY_REPORT(driver).Times(0)
1320
1321+/**
1322+ * @brief Verify and clear all gmock expectations that have been setup until
1323+ * this point.
1324+ */
1325+#define VERIFY_AND_CLEAR(driver) testing::Mock::VerifyAndClearExpectations(&driver)
1326+
1327 namespace internal {
1328 void expect_unicode_code_point(TestDriver& driver, uint32_t code_point);
1329 } // namespace internal
1330diff --git a/tests/test_common/test_fixture.cpp b/tests/test_common/test_fixture.cpp
1331index 5dc5db1848204664a45ddc28e5c6a429af106957..76daa625ad8e0ec96164c3340396d30a40dbfae8 100644
1332--- a/tests/test_common/test_fixture.cpp
1333+++ b/tests/test_common/test_fixture.cpp
1334@@ -82,12 +82,12 @@ TestFixture::~TestFixture() {
1335 #endif
1336
1337 idle_for(TAPPING_TERM * 10);
1338- testing::Mock::VerifyAndClearExpectations(&driver);
1339+ VERIFY_AND_CLEAR(driver);
1340
1341 /* Verify that the matrix really is cleared */
1342 EXPECT_NO_REPORT(driver);
1343 idle_for(TAPPING_TERM * 10);
1344- testing::Mock::VerifyAndClearExpectations(&driver);
1345+ VERIFY_AND_CLEAR(driver);
1346 m_this = nullptr;
1347
1348 test_logger.info() << "test fixture clean-up end." << std::endl;