1533 lines
57 KiB
C++
1533 lines
57 KiB
C++
#line 2 "AceButtonTest.ino"
|
|
/*
|
|
MIT License
|
|
|
|
Copyright (c) 2018 Brian T. Park
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
*/
|
|
|
|
/*
|
|
* Using Multiple Cpp Files:
|
|
*
|
|
* I tried to spread the tests of this .ino file into 6 .cpp files (and one
|
|
* .h file), matching the 6 logical sections indicated below. Unfortunately,
|
|
* on the AVR platform (Arduino Nano), the flash memory consumption increased
|
|
* from 26768 (87%) to 28630 (93%), a difference of 1862 bytes. Since an Arduino
|
|
* Nano has only 32720 bytes in flash, the difference of 1862 bytes (5.7%) is
|
|
* signficant. I'm not sure where the flash consumption is coming from. Maybe
|
|
* the compiler is includeing debugging information to the 6 additional .cpp
|
|
* file names, or maybe the compiler/linker is using 4-bytes references to
|
|
* various global variables instead of 2-bytes? For now, let's leave all the
|
|
* tests in this single .ino file. I also noticed that changing from "const int
|
|
* PIN = 13" to "#define PIN 13" (and the same with BUTTON_ID) in the .h header
|
|
* file, the #define saved 210 bytes.
|
|
*
|
|
* On the Teensy-ARM platform (Teensy LC), using 6 separate .cpp files instead
|
|
* of one giant .ino file caused the flash memory to *decrease* from 31408 to
|
|
* 31204 bytes(!). And on the ARM platform, there was no difference in flash
|
|
* memory size between "const int PIN = 13" and "#define PIN 13".
|
|
*
|
|
* Conclusion, this seems to be a problem with the avr-gcc compiler, or a
|
|
* suboptimal compiler flags set by the Arduino IDE.
|
|
*/
|
|
|
|
#define USE_AUNIT 1
|
|
|
|
#if USE_AUNIT == 1
|
|
#include <AUnit.h>
|
|
#else
|
|
#include <ArduinoUnit.h>
|
|
#endif
|
|
|
|
#include <AceButton.h>
|
|
#include <ace_button/testing/TestableButtonConfig.h>
|
|
#include <ace_button/testing/EventTracker.h>
|
|
#include <ace_button/testing/TestHelper.h>
|
|
|
|
using namespace ace_button;
|
|
using namespace ace_button::testing;
|
|
|
|
const uint8_t PIN = 13;
|
|
const uint8_t BUTTON_ID = 1;
|
|
|
|
ButtonConfig buttonConfig;
|
|
|
|
TestableButtonConfig testableConfig;
|
|
AceButton button(&testableConfig);
|
|
EventTracker eventTracker;
|
|
TestHelper helper(&testableConfig, &button, &eventTracker);
|
|
|
|
// The event handler takes the arguments sent with the event and stored them
|
|
// into the EventTracker circular buffer.
|
|
void handleEvent(AceButton* /* button */, uint8_t eventType,
|
|
uint8_t buttonState) {
|
|
eventTracker.addEvent(eventType, buttonState);
|
|
}
|
|
|
|
void setup() {
|
|
delay(1000); // Wait for stability on some boards, otherwise garage on Serial
|
|
Serial.begin(115200); // ESP8266 default 74880 not supported on Linux
|
|
while (!Serial); // for the Arduino Leonardo/Micro only
|
|
|
|
testableConfig.setEventHandler(handleEvent);
|
|
|
|
// The default was 50 ms (not the current 20 ms) when these tests were written
|
|
// and some of the timing delays are hardcoded to assume that, so we have to
|
|
// revert back to the old value.
|
|
testableConfig.setDebounceDelay(50);
|
|
|
|
Serial.print(F("sizeof(AceButton): "));
|
|
Serial.println(sizeof(AceButton));
|
|
Serial.print(F("sizeof(ButtonConfig): "));
|
|
Serial.println(sizeof(ButtonConfig));
|
|
Serial.print(F("sizeof(TestableButtonConfig): "));
|
|
Serial.println(sizeof(TestableButtonConfig));
|
|
|
|
/*
|
|
aunit::TestRunner::exclude("*");
|
|
aunit::TestRunner::include("suppress_click_before_double_click");
|
|
*/
|
|
}
|
|
|
|
void loop() {
|
|
#if USE_AUNIT == 1
|
|
aunit::TestRunner::run();
|
|
#else
|
|
Test::run();
|
|
#endif
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
// Basic tests
|
|
// ------------------------------------------------------------------
|
|
|
|
// Test that the pin is properly set and retrieved.
|
|
test(pin) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
assertEqual(PIN, button.getPin());
|
|
}
|
|
|
|
// Test that the custom id is properly set and retrieved.
|
|
test(custom_id) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
assertEqual(BUTTON_ID, button.getId());
|
|
}
|
|
|
|
// Test that the getLastButtonPressed() returns BUTTON_STATE_UKNOWN initially.
|
|
test(button_state_unknown) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
|
|
uint8_t expected = AceButton::kButtonStateUnknown;
|
|
assertEqual(expected, button.getLastButtonState());
|
|
}
|
|
|
|
test(feature_flags_off_by_default) {
|
|
assertFalse(buttonConfig.isFeature(ButtonConfig::kFeatureClick));
|
|
assertFalse(buttonConfig.isFeature(ButtonConfig::kFeatureDoubleClick));
|
|
assertFalse(buttonConfig.isFeature(ButtonConfig::kFeatureLongPress));
|
|
assertFalse(buttonConfig.isFeature(ButtonConfig::kFeatureRepeatPress));
|
|
|
|
assertFalse(buttonConfig.isFeature(
|
|
ButtonConfig::kFeatureSuppressAfterClick));
|
|
assertFalse(buttonConfig.isFeature(
|
|
ButtonConfig::kFeatureSuppressAfterDoubleClick));
|
|
assertFalse(buttonConfig.isFeature(
|
|
ButtonConfig::kFeatureSuppressAfterLongPress));
|
|
assertFalse(buttonConfig.isFeature(
|
|
ButtonConfig::kFeatureSuppressAfterRepeatPress));
|
|
}
|
|
|
|
// Test that the button transitions out of the kButtonStateUnknown after
|
|
// getDebounceDelay() time.
|
|
test(init_while_released) {
|
|
uint8_t expected;
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
|
|
// button is released when the board is rebooted, should trigger an immediate
|
|
// debouncing
|
|
helper.releaseButton(0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
expected = AceButton::kButtonStateUnknown;
|
|
assertEqual(expected, button.getLastButtonState());
|
|
|
|
// button is bouncing pressed/released, but must wait to debounce
|
|
helper.pressButton(40);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
expected = AceButton::kButtonStateUnknown;
|
|
assertEqual(expected, button.getLastButtonState());
|
|
|
|
// button is bouncing pressed/released, but must wait to debounce
|
|
helper.releaseButton(45);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
expected = AceButton::kButtonStateUnknown;
|
|
assertEqual(expected, button.getLastButtonState());
|
|
|
|
// finally button is known to be released, this doesn't not trigger event
|
|
helper.releaseButton(60);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
assertEqual(HIGH, button.getLastButtonState());
|
|
}
|
|
|
|
// Test that the button transitions out of the kButtonStateUnknown when
|
|
// rebooted with the button pressed.
|
|
test(init_while_pressed) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
uint8_t expected;
|
|
|
|
// button is pressed when the board is rebooted, should trigger an immediate
|
|
// debouncing
|
|
helper.pressButton(0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
expected = AceButton::kButtonStateUnknown;
|
|
assertEqual(expected, button.getLastButtonState());
|
|
|
|
// button is bouncing pressed/released, but must wait to debounce
|
|
helper.releaseButton(40);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
expected = AceButton::kButtonStateUnknown;
|
|
assertEqual(expected, button.getLastButtonState());
|
|
|
|
// button is bouncing pressed/released, but must wait to debounce
|
|
helper.pressButton(45);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
expected = AceButton::kButtonStateUnknown;
|
|
assertEqual(expected, button.getLastButtonState());
|
|
|
|
// finally button is known to be released, this doesn't not trigger event
|
|
helper.pressButton(60);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
assertEqual(LOW, button.getLastButtonState());
|
|
}
|
|
|
|
// Test that the TestableButtonConfig overrides the corresponding
|
|
// parameters on AceButton properly.
|
|
test(testable_config) {
|
|
testableConfig.setClock(0);
|
|
assertEqual(0UL, button.getButtonConfig()->getClock());
|
|
|
|
testableConfig.setClock(40);
|
|
assertEqual(40UL, button.getButtonConfig()->getClock());
|
|
|
|
testableConfig.setButtonState(HIGH);
|
|
assertEqual(HIGH, button.getButtonConfig()->readButton(0));
|
|
|
|
testableConfig.setButtonState(LOW);
|
|
assertEqual(LOW, button.getButtonConfig()->readButton(0));
|
|
}
|
|
|
|
// Test that the ButtonConfig parameters are mutable, just like the
|
|
// original AdjustableButtonConfig.
|
|
test(adjustable_config) {
|
|
buttonConfig.setDebounceDelay(1);
|
|
assertEqual((uint16_t)1, buttonConfig.getDebounceDelay());
|
|
|
|
buttonConfig.setClickDelay(2);
|
|
assertEqual((uint16_t)2, buttonConfig.getClickDelay());
|
|
|
|
buttonConfig.setDoubleClickDelay(3);
|
|
assertEqual((uint16_t)3, buttonConfig.getDoubleClickDelay());
|
|
|
|
buttonConfig.setLongPressDelay(4);
|
|
assertEqual((uint16_t)4, buttonConfig.getLongPressDelay());
|
|
|
|
buttonConfig.setRepeatPressDelay(5);
|
|
assertEqual((uint16_t)5, buttonConfig.getRepeatPressDelay());
|
|
|
|
buttonConfig.setRepeatPressInterval(6);
|
|
assertEqual((uint16_t)6, buttonConfig.getRepeatPressInterval());
|
|
}
|
|
|
|
// Detect if a button is pressed while the device is booted.
|
|
test(is_released_raw) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
button.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.init();
|
|
|
|
testableConfig.setButtonState(HIGH);
|
|
assertFalse(button.isPressedRaw());
|
|
|
|
testableConfig.setButtonState(LOW);
|
|
assertTrue(button.isPressedRaw());
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
// Press and Release tests
|
|
// ------------------------------------------------------------------
|
|
|
|
// We assume this will be the common case because of the Aruino boards provide
|
|
// internal pullup resistors on the digital input pins.
|
|
test(press_and_release_pullup) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
|
|
// initial button state
|
|
helper.releaseButton(0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// must wait until the initial debouncing
|
|
helper.releaseButton(50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(100);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// still in debouncing period, so no event yet
|
|
helper.releaseButton(110);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after more than 50 ms, we should get an event
|
|
helper.pressButton(190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button
|
|
helper.releaseButton(1000);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// wait more than 50 ms
|
|
helper.releaseButton(1060);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
}
|
|
|
|
// Do the same test as press_and_release_pullup, but using
|
|
// the logic levels of an external pulldown resistor.
|
|
test(press_and_release_pulldown) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = LOW;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
|
|
// initial button state
|
|
helper.releaseButton(0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// must wait until the initial debouncing
|
|
helper.releaseButton(50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(100);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// still in debouncing period, so no event yet
|
|
helper.pressButton(110);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after more than 50 ms, we should get an event
|
|
helper.pressButton(190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
|
|
// release the button
|
|
helper.releaseButton(1000);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// wait more than 50 ms
|
|
helper.releaseButton(1060);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
}
|
|
|
|
// The AceButton class uses 16-bit timer variables for memory efficiency.
|
|
// Verify that we can rollover those variables without affecting the logic.
|
|
test(clock_rollover) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500; // rolls over in 36 milliseconds
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initialization phase, so no event yet
|
|
helper.releaseButton(BASE_TIME + 60);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// press after the initialization phase, no event, must wait for debouncing
|
|
helper.pressButton(BASE_TIME + 100);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after more than 50 ms, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button
|
|
helper.releaseButton(BASE_TIME + 1000);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// wait more than 50 ms
|
|
helper.releaseButton(BASE_TIME + 1060);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
// Click tests
|
|
// ------------------------------------------------------------------
|
|
|
|
// Test a single click.
|
|
test(click_without_suppression) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureClick);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click
|
|
helper.releaseButton(BASE_TIME + 300);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms to get event
|
|
helper.releaseButton(BASE_TIME + 350);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
}
|
|
|
|
// Test a single click.
|
|
test(click_with_suppression) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureClick);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureSuppressAfterClick);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click
|
|
helper.releaseButton(BASE_TIME + 300);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms to get event
|
|
helper.releaseButton(BASE_TIME + 350);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
}
|
|
|
|
// Test that no click generated with isFeature() flag off.
|
|
test(no_click_without_feature_flag) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
// make sure isFeatureClick flag is cleared
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.clearFeature(ButtonConfig::kFeatureClick);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click
|
|
helper.releaseButton(BASE_TIME + 300);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms to get event. Only a Released event should be generated.
|
|
helper.releaseButton(BASE_TIME + 350);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
// DoubleClick tests
|
|
// ------------------------------------------------------------------
|
|
|
|
// Test a double click. Verify also that a triple-click does not generate a
|
|
// spurious second double click. It should generate only the following:
|
|
// Pressed, Clicked, Pressed, DoubleClicked, Pressed, Clicked
|
|
// because we have suppressed the Released events.
|
|
test(double_click_suppressed) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureDoubleClick);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureSuppressAfterClick);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureSuppressAfterDoubleClick);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// generate first click
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 300);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce.
|
|
helper.releaseButton(BASE_TIME + 350);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// generate generate second click within 400 ms of the CLICK event (which
|
|
// occurred at +350 ms) for a double click
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 500);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 550);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 650);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce. Should get a double-click.
|
|
helper.releaseButton(BASE_TIME + 700);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventDoubleClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// generate third click within 400 ms of the DoubleClicked event (which
|
|
// occurred at +700 ms)
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 900);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event,
|
|
helper.pressButton(BASE_TIME + 950);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 1050);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce.
|
|
// Verify that we get only 1 Clicked event not another DoubleClicked.
|
|
helper.releaseButton(BASE_TIME + 1100);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
}
|
|
|
|
// Test a double click without kFeatureSuppressAfterDoubleClick.
|
|
// Three rapid clicks should generate the following:
|
|
// Pressed, Released, Clicked, Pressed, Released, DoubleClicked, Pressed,
|
|
// Released, Clicked.
|
|
test(double_click_not_suppressed) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureDoubleClick);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// generate first click
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 300);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce.
|
|
helper.releaseButton(BASE_TIME + 350);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
|
|
// generate second click within 400 ms of the Clicked event (which
|
|
// occurred at +350 ms) for a double click
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 500);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 550);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 650);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce. Should get a DoubleClicked, and a
|
|
// Released because we don't suppress.
|
|
helper.releaseButton(BASE_TIME + 700);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventDoubleClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
|
|
// generate third click within 400 ms of the DoubleClicked event (which
|
|
// occurred at +700 ms)
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 900);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event,
|
|
helper.pressButton(BASE_TIME + 950);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 1050);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce.
|
|
// Verify that we get only 1 Clicked event not another DoubleClicked,
|
|
// and an unsuppressed Released.
|
|
helper.releaseButton(BASE_TIME + 1100);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
}
|
|
|
|
// Test that no double clicks generated with isFeature() flag off.
|
|
test(no_double_click_without_feature_flag) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
// make sure isFeatureDoubleClick flag is cleared
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureClick);
|
|
testableConfig.clearFeature(ButtonConfig::kFeatureDoubleClick);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// generate first click
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 300);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce to get Released
|
|
helper.releaseButton(BASE_TIME + 350);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
|
|
// generate second click within 400 ms of the Clicked event (which
|
|
// occurred at +350 ms) for a double click
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 500);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 550);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 650);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce. Should get just another click since
|
|
// double-click is turned off.
|
|
helper.releaseButton(BASE_TIME + 700);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
}
|
|
|
|
// Test that an orphaned click is properly removed to prevent spurious
|
|
// double-click if the second click happens slightly over 65.536 seconds later.
|
|
test(orphaned_click_cleared) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
const unsigned long ROLLOVER_TIME = 65536;
|
|
uint8_t expected;
|
|
|
|
// reset the button, and enable double-click
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureClick);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureDoubleClick);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 300);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms to get event
|
|
helper.releaseButton(BASE_TIME + 350);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
|
|
// Move time forward, so that the orphaned click is cleared.
|
|
// If AceButton.checkOrphanedClick() is disabled, or this statement is removed
|
|
// (thereby preventing a call to checkOrphanedClick()), then the asserts below
|
|
// will fail.
|
|
helper.checkTime(BASE_TIME + 5000);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Generate another click between (65.535s, 65.535s + 400 ms) of the first
|
|
// CLICK event (i.e. +250 ms). If the first orphaned click was not properly
|
|
// reset, then this will genearte a double click instead of a single click.
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(ROLLOVER_TIME + BASE_TIME + 400);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(ROLLOVER_TIME + BASE_TIME + 450);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(ROLLOVER_TIME + BASE_TIME + 550);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce. Should get a single click, not
|
|
// a double click.
|
|
helper.releaseButton(ROLLOVER_TIME + BASE_TIME + 600);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
}
|
|
|
|
// Test that an orphaned click generates a double click if not cleared.
|
|
test(orphaned_click_causes_double_click_if_not_cleared) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
const unsigned long ROLLOVER_TIME = 65536;
|
|
uint8_t expected;
|
|
|
|
// reset the button, and enable double-click
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureClick);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureDoubleClick);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 300);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms to get event
|
|
helper.releaseButton(BASE_TIME + 350);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
|
|
// Simulate an orphaned click not getting cleared by not calling
|
|
// AceButton.check() for 65536 milliseconds.
|
|
|
|
// Generate another click between (65.535s, 65.535s + 400 ms) of the first
|
|
// CLICK event (i.e. +250 ms). If the first orphaned click was not properly
|
|
// reset, then this will genearte a double click instead of a single click.
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(ROLLOVER_TIME + BASE_TIME + 400);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(ROLLOVER_TIME + BASE_TIME + 450);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(ROLLOVER_TIME + BASE_TIME + 550);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce. Should get a double click because the
|
|
// orphaned click was not removed before the 16-bit integer overflowed .
|
|
helper.releaseButton(ROLLOVER_TIME + BASE_TIME + 600);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventDoubleClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
}
|
|
|
|
// Test that an orphaned click is removed if Click is enabled.
|
|
test(orphaned_click_removed_if_click_enabled) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
const unsigned long ROLLOVER_TIME = 65536;
|
|
uint8_t expected;
|
|
|
|
// reset the button, and enable double-click
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureClick);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 300);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms to get event
|
|
helper.releaseButton(BASE_TIME + 350);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
|
|
// Move time forward, so that the orphaned click is cleared.
|
|
// If AceButton.checkOrphanedClick() is disabled, or this statement is removed
|
|
// (thereby preventing a call to checkOrphanedClick()), then the asserts below
|
|
// will fail.
|
|
helper.checkTime(BASE_TIME + 5000);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Turn on DoubleClick in the middle of click processing. If we called
|
|
// checkOrphanedClick() only if DoubleClick was enabled (instead of checking
|
|
// it when Click is enabled as well), then this change in ButtonConfig will
|
|
// cause this test to fail.
|
|
testableConfig.setFeature(ButtonConfig::kFeatureDoubleClick);
|
|
|
|
// Generate another click between (65.535s, 65.535s + 400 ms) of the first
|
|
// CLICK event (i.e. +250 ms). If the first orphaned click was not properly
|
|
// reset, then this will genearte a double click instead of a single click.
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(ROLLOVER_TIME + BASE_TIME + 400);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(ROLLOVER_TIME + BASE_TIME + 450);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(ROLLOVER_TIME + BASE_TIME + 550);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce. Should get a single click, not
|
|
// a double click.
|
|
helper.releaseButton(ROLLOVER_TIME + BASE_TIME + 600);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
}
|
|
|
|
// Test that kFeatureSuppressClickBeforeDoubleClick causes the first Clicked to
|
|
// be postponed until it can determine if a DoubleClick actually occurred.
|
|
test(suppress_click_before_double_click) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureDoubleClick);
|
|
testableConfig.setFeature(
|
|
ButtonConfig::kFeatureSuppressClickBeforeDoubleClick);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// generate first click
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 300);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce. Check that this first Click is
|
|
// postponed, so we get only the Released.
|
|
helper.releaseButton(BASE_TIME + 350);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// generate second click within 400 ms of the Clicked event (which
|
|
// occurred at +350 ms) for a double click
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 500);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get a Pressed
|
|
helper.pressButton(BASE_TIME + 550);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 650);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce. Should get a (DoubleClicked, Released) but
|
|
// not a Clicked because we suppressed the first postponed Clicked.
|
|
helper.releaseButton(BASE_TIME + 700);
|
|
assertEqual(2, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventDoubleClicked;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(1).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(1).getButtonState());
|
|
|
|
// generate third click within 400 ms of the DoubleClicked event (which
|
|
// occurred at +700 ms)
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 900);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get a Pressed event
|
|
helper.pressButton(BASE_TIME + 950);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// release the button within 200 ms for a click, but must wait for debounce
|
|
helper.releaseButton(BASE_TIME + 1050);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait another 50 ms for debounce.
|
|
// Verify that we get only a Released event not another DoubleClicked.
|
|
// The Clicked event is postponed again.
|
|
helper.releaseButton(BASE_TIME + 1100);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// Wait 300 ms, nothing should happen.
|
|
helper.checkTime(BASE_TIME + 1400);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Wait 400 ms to get the long postponed Clicked.
|
|
helper.checkTime(BASE_TIME + 1500);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
assertEqual(+AceButton::kEventClicked,
|
|
eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
// LongPress tests
|
|
// ------------------------------------------------------------------
|
|
|
|
// Test a long press without suppression should generate a released event at
|
|
// the end.
|
|
test(long_press_without_suppression) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureLongPress);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// keeping holding the button
|
|
helper.pressButton(BASE_TIME + 1100);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// keeping holding the button longer than 1000 ms
|
|
helper.pressButton(BASE_TIME + 1200);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventLongPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// finally release the button
|
|
helper.releaseButton(BASE_TIME + 1600);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Must wait for debouncing for the kEventReleased.
|
|
helper.releaseButton(BASE_TIME + 1660);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
}
|
|
|
|
// Test a long press with suppression should produce no released event.
|
|
test(long_press_with_supression) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureLongPress);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureSuppressAfterLongPress);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// keeping holding the button
|
|
helper.pressButton(BASE_TIME + 1100);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// keeping holding the button longer than 1000 ms
|
|
helper.pressButton(BASE_TIME + 1200);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventLongPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// finally release the button
|
|
helper.releaseButton(BASE_TIME + 1600);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Must wait for debouncing. We elected kFeatureSuppressAfterLongPress so
|
|
// no kEventReleased is generated.
|
|
helper.releaseButton(BASE_TIME + 1660);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
}
|
|
|
|
// Test that no LongPress generated with isFeature() flag off.
|
|
test(no_long_press_without_feature_flag) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.clearFeature(ButtonConfig::kFeatureLongPress);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// keeping holding the button
|
|
helper.pressButton(BASE_TIME + 1100);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// keeping holding the button longer than 1000 ms
|
|
helper.pressButton(BASE_TIME + 1200);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// finally release the button
|
|
helper.releaseButton(BASE_TIME + 1600);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Must wait for debouncing. Only a Released event should be generated.
|
|
helper.releaseButton(BASE_TIME + 1660);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
// RepeatPress tests
|
|
// ------------------------------------------------------------------
|
|
|
|
// Test repeated press
|
|
test(repeat_press_without_suppression) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureRepeatPress);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// keeping holding the button
|
|
helper.pressButton(BASE_TIME + 1100);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// keeping holding the button longer than 1000 ms, the kEventRepeatPressed
|
|
// should trigger immediately after this duration
|
|
helper.pressButton(BASE_TIME + 1200);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventRepeatPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// keeping holding the button for longer than repeat interval (200ms)
|
|
helper.pressButton(BASE_TIME + 1400);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventRepeatPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// finally release the button
|
|
helper.releaseButton(BASE_TIME + 1700);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Must wait for debouncing for the kEventReleased.
|
|
helper.releaseButton(BASE_TIME + 1760);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
}
|
|
|
|
// Test repeated press
|
|
test(repeat_press_with_suppression) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureRepeatPress);
|
|
testableConfig.setFeature(ButtonConfig::kFeatureSuppressAfterRepeatPress);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// keeping holding the button
|
|
helper.pressButton(BASE_TIME + 1100);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// keeping holding the button longer than 1000 ms, the kEventRepeatPressed
|
|
// should trigger immediately after this duration
|
|
helper.pressButton(BASE_TIME + 1200);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventRepeatPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// keeping holding the button for longer than repeat interval (200ms)
|
|
helper.pressButton(BASE_TIME + 1400);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventRepeatPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// finally release the button
|
|
helper.releaseButton(BASE_TIME + 1700);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Must wait for debouncing for the kEventReleased.
|
|
// But there is no Released event because of suppression.
|
|
helper.releaseButton(BASE_TIME + 1760);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
}
|
|
|
|
// Test that no RepeatPress generated with isFeature() flag off.
|
|
test(no_repeat_press_without_feature_flag) {
|
|
const uint8_t DEFAULT_RELEASED_STATE = HIGH;
|
|
const unsigned long BASE_TIME = 65500;
|
|
uint8_t expected;
|
|
|
|
// reset the button
|
|
helper.init(PIN, DEFAULT_RELEASED_STATE, BUTTON_ID);
|
|
testableConfig.clearFeature(ButtonConfig::kFeatureRepeatPress);
|
|
|
|
// initial button state
|
|
helper.releaseButton(BASE_TIME + 0);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// initilization phase
|
|
helper.releaseButton(BASE_TIME + 50);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// button pressed, but must wait to debounce
|
|
helper.pressButton(BASE_TIME + 140);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// after 50 ms or more, we should get an event
|
|
helper.pressButton(BASE_TIME + 190);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventPressed;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(LOW, eventTracker.getRecord(0).getButtonState());
|
|
|
|
// keeping holding the button
|
|
helper.pressButton(BASE_TIME + 1100);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// keeping holding the button longer than 1000 ms, nothing should
|
|
// should trigger
|
|
helper.pressButton(BASE_TIME + 1200);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// keeping holding the button for longer than repeat interval (200ms)
|
|
helper.pressButton(BASE_TIME + 1400);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// finally release the button
|
|
helper.releaseButton(BASE_TIME + 1700);
|
|
assertEqual(0, eventTracker.getNumEvents());
|
|
|
|
// Must wait for debouncing. Only a Released event should be generated.
|
|
helper.releaseButton(BASE_TIME + 1760);
|
|
assertEqual(1, eventTracker.getNumEvents());
|
|
expected = AceButton::kEventReleased;
|
|
assertEqual(expected, eventTracker.getRecord(0).getEventType());
|
|
assertEqual(HIGH, eventTracker.getRecord(0).getButtonState());
|
|
}
|