diff options
Diffstat (limited to 'quantum/encoder')
16 files changed, 783 insertions, 85 deletions
| diff --git a/quantum/encoder/tests/config_mock.h b/quantum/encoder/tests/config_mock.h new file mode 100644 index 0000000000..703dcaf103 --- /dev/null +++ b/quantum/encoder/tests/config_mock.h @@ -0,0 +1,22 @@ +// Copyright 2022 Nick Brassel (@tzarc) +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#define MATRIX_ROWS 1 +#define MATRIX_COLS 1 + +/* Here, "pins" from 0 to 31 are allowed. */ +#define ENCODERS_PAD_A \ +    { 0 } +#define ENCODERS_PAD_B \ +    { 1 } + +#ifdef __cplusplus +extern "C" { +#endif + +#include "mock.h" + +#ifdef __cplusplus +}; +#endif diff --git a/quantum/encoder/tests/config_mock_split_left_eq_right.h b/quantum/encoder/tests/config_mock_split_left_eq_right.h new file mode 100644 index 0000000000..c80ac4d519 --- /dev/null +++ b/quantum/encoder/tests/config_mock_split_left_eq_right.h @@ -0,0 +1,26 @@ +// Copyright 2022 Nick Brassel (@tzarc) +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#define MATRIX_ROWS 1 +#define MATRIX_COLS 1 + +/* Here, "pins" from 0 to 31 are allowed. */ +#define ENCODERS_PAD_A \ +    { 0, 2 } +#define ENCODERS_PAD_B \ +    { 1, 3 } +#define ENCODERS_PAD_A_RIGHT \ +    { 4, 6 } +#define ENCODERS_PAD_B_RIGHT \ +    { 5, 7 } + +#ifdef __cplusplus +extern "C" { +#endif + +#include "mock_split.h" + +#ifdef __cplusplus +}; +#endif diff --git a/quantum/encoder/tests/config_mock_split_left_gt_right.h b/quantum/encoder/tests/config_mock_split_left_gt_right.h new file mode 100644 index 0000000000..91d5f3d605 --- /dev/null +++ b/quantum/encoder/tests/config_mock_split_left_gt_right.h @@ -0,0 +1,26 @@ +// Copyright 2022 Nick Brassel (@tzarc) +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#define MATRIX_ROWS 1 +#define MATRIX_COLS 1 + +/* Here, "pins" from 0 to 31 are allowed. */ +#define ENCODERS_PAD_A \ +    { 0, 2, 4 } +#define ENCODERS_PAD_B \ +    { 1, 3, 5 } +#define ENCODERS_PAD_A_RIGHT \ +    { 6, 8 } +#define ENCODERS_PAD_B_RIGHT \ +    { 7, 9 } + +#ifdef __cplusplus +extern "C" { +#endif + +#include "mock_split.h" + +#ifdef __cplusplus +}; +#endif diff --git a/quantum/encoder/tests/config_mock_split_left_lt_right.h b/quantum/encoder/tests/config_mock_split_left_lt_right.h new file mode 100644 index 0000000000..4108a184a6 --- /dev/null +++ b/quantum/encoder/tests/config_mock_split_left_lt_right.h @@ -0,0 +1,26 @@ +// Copyright 2022 Nick Brassel (@tzarc) +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#define MATRIX_ROWS 1 +#define MATRIX_COLS 1 + +/* Here, "pins" from 0 to 31 are allowed. */ +#define ENCODERS_PAD_A \ +    { 0, 2 } +#define ENCODERS_PAD_B \ +    { 1, 3 } +#define ENCODERS_PAD_A_RIGHT \ +    { 4, 6, 8 } +#define ENCODERS_PAD_B_RIGHT \ +    { 5, 7, 9 } + +#ifdef __cplusplus +extern "C" { +#endif + +#include "mock_split.h" + +#ifdef __cplusplus +}; +#endif diff --git a/quantum/encoder/tests/config_mock_split_no_left.h b/quantum/encoder/tests/config_mock_split_no_left.h new file mode 100644 index 0000000000..9db7fa7e41 --- /dev/null +++ b/quantum/encoder/tests/config_mock_split_no_left.h @@ -0,0 +1,26 @@ +// Copyright 2022 Nick Brassel (@tzarc) +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#define MATRIX_ROWS 1 +#define MATRIX_COLS 1 + +/* Here, "pins" from 0 to 31 are allowed. */ +#define ENCODERS_PAD_A \ +    {} +#define ENCODERS_PAD_B \ +    {} +#define ENCODERS_PAD_A_RIGHT \ +    { 0, 2 } +#define ENCODERS_PAD_B_RIGHT \ +    { 1, 3 } + +#ifdef __cplusplus +extern "C" { +#endif + +#include "mock_split.h" + +#ifdef __cplusplus +}; +#endif diff --git a/quantum/encoder/tests/config_mock_split_no_right.h b/quantum/encoder/tests/config_mock_split_no_right.h new file mode 100644 index 0000000000..14f18015e6 --- /dev/null +++ b/quantum/encoder/tests/config_mock_split_no_right.h @@ -0,0 +1,26 @@ +// Copyright 2022 Nick Brassel (@tzarc) +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#define MATRIX_ROWS 1 +#define MATRIX_COLS 1 + +/* Here, "pins" from 0 to 31 are allowed. */ +#define ENCODERS_PAD_A \ +    { 0, 2 } +#define ENCODERS_PAD_B \ +    { 1, 3 } +#define ENCODERS_PAD_A_RIGHT \ +    {} +#define ENCODERS_PAD_B_RIGHT \ +    {} + +#ifdef __cplusplus +extern "C" { +#endif + +#include "mock_split.h" + +#ifdef __cplusplus +}; +#endif diff --git a/quantum/encoder/tests/encoder_tests.cpp b/quantum/encoder/tests/encoder_tests.cpp index 1888fdab8d..b7c18aeec0 100644 --- a/quantum/encoder/tests/encoder_tests.cpp +++ b/quantum/encoder/tests/encoder_tests.cpp @@ -30,12 +30,12 @@ struct update {      bool   clockwise;  }; -uint8_t uidx = 0; +uint8_t updates_array_idx = 0;  update  updates[32];  bool encoder_update_kb(uint8_t index, bool clockwise) { -    updates[uidx % 32] = {index, clockwise}; -    uidx++; +    updates[updates_array_idx % 32] = {index, clockwise}; +    updates_array_idx++;      return true;  } @@ -47,15 +47,15 @@ bool setAndRead(pin_t pin, bool val) {  class EncoderTest : public ::testing::Test {};  TEST_F(EncoderTest, TestInit) { -    uidx = 0; +    updates_array_idx = 0;      encoder_init();      EXPECT_EQ(pinIsInputHigh[0], true);      EXPECT_EQ(pinIsInputHigh[1], true); -    EXPECT_EQ(uidx, 0); +    EXPECT_EQ(updates_array_idx, 0);  }  TEST_F(EncoderTest, TestOneClockwise) { -    uidx = 0; +    updates_array_idx = 0;      encoder_init();      // send 4 pulses. with resolution 4, that's one step and we should get 1 update.      setAndRead(0, false); @@ -63,26 +63,26 @@ TEST_F(EncoderTest, TestOneClockwise) {      setAndRead(0, true);      setAndRead(1, true); -    EXPECT_EQ(uidx, 1); +    EXPECT_EQ(updates_array_idx, 1);      EXPECT_EQ(updates[0].index, 0);      EXPECT_EQ(updates[0].clockwise, true);  }  TEST_F(EncoderTest, TestOneCounterClockwise) { -    uidx = 0; +    updates_array_idx = 0;      encoder_init();      setAndRead(1, false);      setAndRead(0, false);      setAndRead(1, true);      setAndRead(0, true); -    EXPECT_EQ(uidx, 1); +    EXPECT_EQ(updates_array_idx, 1);      EXPECT_EQ(updates[0].index, 0);      EXPECT_EQ(updates[0].clockwise, false);  }  TEST_F(EncoderTest, TestTwoClockwiseOneCC) { -    uidx = 0; +    updates_array_idx = 0;      encoder_init();      setAndRead(0, false);      setAndRead(1, false); @@ -97,7 +97,7 @@ TEST_F(EncoderTest, TestTwoClockwiseOneCC) {      setAndRead(1, true);      setAndRead(0, true); -    EXPECT_EQ(uidx, 3); +    EXPECT_EQ(updates_array_idx, 3);      EXPECT_EQ(updates[0].index, 0);      EXPECT_EQ(updates[0].clockwise, true);      EXPECT_EQ(updates[1].index, 0); @@ -107,38 +107,38 @@ TEST_F(EncoderTest, TestTwoClockwiseOneCC) {  }  TEST_F(EncoderTest, TestNoEarly) { -    uidx = 0; +    updates_array_idx = 0;      encoder_init();      // send 3 pulses. with resolution 4, that's not enough for a step.      setAndRead(0, false);      setAndRead(1, false);      setAndRead(0, true); -    EXPECT_EQ(uidx, 0); +    EXPECT_EQ(updates_array_idx, 0);      // now send last pulse      setAndRead(1, true); -    EXPECT_EQ(uidx, 1); +    EXPECT_EQ(updates_array_idx, 1);      EXPECT_EQ(updates[0].index, 0);      EXPECT_EQ(updates[0].clockwise, true);  }  TEST_F(EncoderTest, TestHalfway) { -    uidx = 0; +    updates_array_idx = 0;      encoder_init();      // go halfway      setAndRead(0, false);      setAndRead(1, false); -    EXPECT_EQ(uidx, 0); +    EXPECT_EQ(updates_array_idx, 0);      // back off      setAndRead(1, true);      setAndRead(0, true); -    EXPECT_EQ(uidx, 0); +    EXPECT_EQ(updates_array_idx, 0);      // go all the way      setAndRead(0, false);      setAndRead(1, false);      setAndRead(0, true);      setAndRead(1, true);      // should result in 1 update -    EXPECT_EQ(uidx, 1); +    EXPECT_EQ(updates_array_idx, 1);      EXPECT_EQ(updates[0].index, 0);      EXPECT_EQ(updates[0].clockwise, true);  } diff --git a/quantum/encoder/tests/encoder_tests_split_left_eq_right.cpp b/quantum/encoder/tests/encoder_tests_split_left_eq_right.cpp new file mode 100644 index 0000000000..916e47b185 --- /dev/null +++ b/quantum/encoder/tests/encoder_tests_split_left_eq_right.cpp @@ -0,0 +1,135 @@ +/* Copyright 2021 Balz Guenat + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program.  If not, see <http://www.gnu.org/licenses/>. + */ + +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include <vector> +#include <algorithm> +#include <stdio.h> + +extern "C" { +#include "encoder.h" +#include "encoder/tests/mock_split.h" +} + +struct update { +    int8_t index; +    bool   clockwise; +}; + +uint8_t updates_array_idx = 0; +update  updates[32]; + +bool isLeftHand; + +bool encoder_update_kb(uint8_t index, bool clockwise) { +    if (!isLeftHand) { +        // this method has no effect on slave half +        printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC"); +        return true; +    } +    updates[updates_array_idx % 32] = {index, clockwise}; +    updates_array_idx++; +    return true; +} + +bool setAndRead(pin_t pin, bool val) { +    setPin(pin, val); +    return encoder_read(); +} + +class EncoderSplitTestLeftEqRight : public ::testing::Test { +   protected: +    void SetUp() override { +        updates_array_idx = 0; +        for (int i = 0; i < 32; i++) { +            pinIsInputHigh[i] = 0; +            pins[i]           = 0; +        } +    } +}; + +TEST_F(EncoderSplitTestLeftEqRight, TestInitLeft) { +    isLeftHand = true; +    encoder_init(); +    EXPECT_EQ(pinIsInputHigh[0], true); +    EXPECT_EQ(pinIsInputHigh[1], true); +    EXPECT_EQ(pinIsInputHigh[2], true); +    EXPECT_EQ(pinIsInputHigh[3], true); +    EXPECT_EQ(pinIsInputHigh[4], false); +    EXPECT_EQ(pinIsInputHigh[5], false); +    EXPECT_EQ(pinIsInputHigh[6], false); +    EXPECT_EQ(pinIsInputHigh[7], false); +    EXPECT_EQ(updates_array_idx, 0); // no updates received +} + +TEST_F(EncoderSplitTestLeftEqRight, TestInitRight) { +    isLeftHand = false; +    encoder_init(); +    EXPECT_EQ(pinIsInputHigh[0], false); +    EXPECT_EQ(pinIsInputHigh[1], false); +    EXPECT_EQ(pinIsInputHigh[2], false); +    EXPECT_EQ(pinIsInputHigh[3], false); +    EXPECT_EQ(pinIsInputHigh[4], true); +    EXPECT_EQ(pinIsInputHigh[5], true); +    EXPECT_EQ(pinIsInputHigh[6], true); +    EXPECT_EQ(pinIsInputHigh[7], true); +    EXPECT_EQ(updates_array_idx, 0); // no updates received +} + +TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseLeft) { +    isLeftHand = true; +    encoder_init(); +    // send 4 pulses. with resolution 4, that's one step and we should get 1 update. +    setAndRead(0, false); +    setAndRead(1, false); +    setAndRead(0, true); +    setAndRead(1, true); + +    EXPECT_EQ(updates_array_idx, 1); // one update received +    EXPECT_EQ(updates[0].index, 0); +    EXPECT_EQ(updates[0].clockwise, true); +} + +TEST_F(EncoderSplitTestLeftEqRight, TestOneClockwiseRightSent) { +    isLeftHand = false; +    encoder_init(); +    // send 4 pulses. with resolution 4, that's one step and we should get 1 update. +    setAndRead(6, false); +    setAndRead(7, false); +    setAndRead(6, true); +    setAndRead(7, true); + +    uint8_t slave_state[32] = {0}; +    encoder_state_raw(slave_state); + +    EXPECT_EQ(slave_state[0], 0); +    EXPECT_EQ(slave_state[1], 0xFF); +} + +TEST_F(EncoderSplitTestLeftEqRight, TestMultipleEncodersRightReceived) { +    isLeftHand = true; +    encoder_init(); + +    uint8_t slave_state[32] = {1, 0xFF}; // First right encoder is CCW, Second right encoder CW +    encoder_update_raw(slave_state); + +    EXPECT_EQ(updates_array_idx, 2); // two updates received, one for each changed item on the right side +    EXPECT_EQ(updates[0].index, 2); +    EXPECT_EQ(updates[0].clockwise, false); +    EXPECT_EQ(updates[1].index, 3); +    EXPECT_EQ(updates[1].clockwise, true); +} diff --git a/quantum/encoder/tests/encoder_tests_split_left_gt_right.cpp b/quantum/encoder/tests/encoder_tests_split_left_gt_right.cpp new file mode 100644 index 0000000000..7b64bb2981 --- /dev/null +++ b/quantum/encoder/tests/encoder_tests_split_left_gt_right.cpp @@ -0,0 +1,139 @@ +/* Copyright 2021 Balz Guenat + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program.  If not, see <http://www.gnu.org/licenses/>. + */ + +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include <vector> +#include <algorithm> +#include <stdio.h> + +extern "C" { +#include "encoder.h" +#include "encoder/tests/mock_split.h" +} + +struct update { +    int8_t index; +    bool   clockwise; +}; + +uint8_t updates_array_idx = 0; +update  updates[32]; + +bool isLeftHand; + +bool encoder_update_kb(uint8_t index, bool clockwise) { +    if (!isLeftHand) { +        // this method has no effect on slave half +        printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC"); +        return true; +    } +    updates[updates_array_idx % 32] = {index, clockwise}; +    updates_array_idx++; +    return true; +} + +bool setAndRead(pin_t pin, bool val) { +    setPin(pin, val); +    return encoder_read(); +} + +class EncoderSplitTestLeftGreaterThanRight : public ::testing::Test { +   protected: +    void SetUp() override { +        updates_array_idx = 0; +        for (int i = 0; i < 32; i++) { +            pinIsInputHigh[i] = 0; +            pins[i]           = 0; +        } +    } +}; + +TEST_F(EncoderSplitTestLeftGreaterThanRight, TestInitLeft) { +    isLeftHand = true; +    encoder_init(); +    EXPECT_EQ(pinIsInputHigh[0], true); +    EXPECT_EQ(pinIsInputHigh[1], true); +    EXPECT_EQ(pinIsInputHigh[2], true); +    EXPECT_EQ(pinIsInputHigh[3], true); +    EXPECT_EQ(pinIsInputHigh[4], true); +    EXPECT_EQ(pinIsInputHigh[5], true); +    EXPECT_EQ(pinIsInputHigh[6], false); +    EXPECT_EQ(pinIsInputHigh[7], false); +    EXPECT_EQ(pinIsInputHigh[8], false); +    EXPECT_EQ(pinIsInputHigh[9], false); +    EXPECT_EQ(updates_array_idx, 0); // no updates received +} + +TEST_F(EncoderSplitTestLeftGreaterThanRight, TestInitRight) { +    isLeftHand = false; +    encoder_init(); +    EXPECT_EQ(pinIsInputHigh[0], false); +    EXPECT_EQ(pinIsInputHigh[1], false); +    EXPECT_EQ(pinIsInputHigh[2], false); +    EXPECT_EQ(pinIsInputHigh[3], false); +    EXPECT_EQ(pinIsInputHigh[4], false); +    EXPECT_EQ(pinIsInputHigh[5], false); +    EXPECT_EQ(pinIsInputHigh[6], true); +    EXPECT_EQ(pinIsInputHigh[7], true); +    EXPECT_EQ(pinIsInputHigh[8], true); +    EXPECT_EQ(pinIsInputHigh[9], true); +    EXPECT_EQ(updates_array_idx, 0); // no updates received +} + +TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseLeft) { +    isLeftHand = true; +    encoder_init(); +    // send 4 pulses. with resolution 4, that's one step and we should get 1 update. +    setAndRead(0, false); +    setAndRead(1, false); +    setAndRead(0, true); +    setAndRead(1, true); + +    EXPECT_EQ(updates_array_idx, 1); // one update received +    EXPECT_EQ(updates[0].index, 0); +    EXPECT_EQ(updates[0].clockwise, true); +} + +TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseRightSent) { +    isLeftHand = false; +    encoder_init(); +    // send 4 pulses. with resolution 4, that's one step and we should get 1 update. +    setAndRead(6, false); +    setAndRead(7, false); +    setAndRead(6, true); +    setAndRead(7, true); + +    uint8_t slave_state[32] = {0}; +    encoder_state_raw(slave_state); + +    EXPECT_EQ(slave_state[0], 0xFF); +    EXPECT_EQ(slave_state[1], 0); +} + +TEST_F(EncoderSplitTestLeftGreaterThanRight, TestMultipleEncodersRightReceived) { +    isLeftHand = true; +    encoder_init(); + +    uint8_t slave_state[32] = {1, 0xFF}; // First right encoder is CCW, Second right encoder no change, third right encoder CW +    encoder_update_raw(slave_state); + +    EXPECT_EQ(updates_array_idx, 2); // two updates received, one for each changed item on the right side +    EXPECT_EQ(updates[0].index, 3); +    EXPECT_EQ(updates[0].clockwise, false); +    EXPECT_EQ(updates[1].index, 4); +    EXPECT_EQ(updates[1].clockwise, true); +} diff --git a/quantum/encoder/tests/encoder_tests_split_left_lt_right.cpp b/quantum/encoder/tests/encoder_tests_split_left_lt_right.cpp new file mode 100644 index 0000000000..a6519c5762 --- /dev/null +++ b/quantum/encoder/tests/encoder_tests_split_left_lt_right.cpp @@ -0,0 +1,139 @@ +/* Copyright 2021 Balz Guenat + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program.  If not, see <http://www.gnu.org/licenses/>. + */ + +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include <vector> +#include <algorithm> +#include <stdio.h> + +extern "C" { +#include "encoder.h" +#include "encoder/tests/mock_split.h" +} + +struct update { +    int8_t index; +    bool   clockwise; +}; + +uint8_t updates_array_idx = 0; +update  updates[32]; + +bool isLeftHand; + +bool encoder_update_kb(uint8_t index, bool clockwise) { +    if (!isLeftHand) { +        // this method has no effect on slave half +        printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC"); +        return true; +    } +    updates[updates_array_idx % 32] = {index, clockwise}; +    updates_array_idx++; +    return true; +} + +bool setAndRead(pin_t pin, bool val) { +    setPin(pin, val); +    return encoder_read(); +} + +class EncoderSplitTestLeftLessThanRight : public ::testing::Test { +   protected: +    void SetUp() override { +        updates_array_idx = 0; +        for (int i = 0; i < 32; i++) { +            pinIsInputHigh[i] = 0; +            pins[i]           = 0; +        } +    } +}; + +TEST_F(EncoderSplitTestLeftLessThanRight, TestInitLeft) { +    isLeftHand = true; +    encoder_init(); +    EXPECT_EQ(pinIsInputHigh[0], true); +    EXPECT_EQ(pinIsInputHigh[1], true); +    EXPECT_EQ(pinIsInputHigh[2], true); +    EXPECT_EQ(pinIsInputHigh[3], true); +    EXPECT_EQ(pinIsInputHigh[4], false); +    EXPECT_EQ(pinIsInputHigh[5], false); +    EXPECT_EQ(pinIsInputHigh[6], false); +    EXPECT_EQ(pinIsInputHigh[7], false); +    EXPECT_EQ(pinIsInputHigh[8], false); +    EXPECT_EQ(pinIsInputHigh[9], false); +    EXPECT_EQ(updates_array_idx, 0); // no updates received +} + +TEST_F(EncoderSplitTestLeftLessThanRight, TestInitRight) { +    isLeftHand = false; +    encoder_init(); +    EXPECT_EQ(pinIsInputHigh[0], false); +    EXPECT_EQ(pinIsInputHigh[1], false); +    EXPECT_EQ(pinIsInputHigh[2], false); +    EXPECT_EQ(pinIsInputHigh[3], false); +    EXPECT_EQ(pinIsInputHigh[4], true); +    EXPECT_EQ(pinIsInputHigh[5], true); +    EXPECT_EQ(pinIsInputHigh[6], true); +    EXPECT_EQ(pinIsInputHigh[7], true); +    EXPECT_EQ(pinIsInputHigh[8], true); +    EXPECT_EQ(pinIsInputHigh[9], true); +    EXPECT_EQ(updates_array_idx, 0); // no updates received +} + +TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseLeft) { +    isLeftHand = true; +    encoder_init(); +    // send 4 pulses. with resolution 4, that's one step and we should get 1 update. +    setAndRead(0, false); +    setAndRead(1, false); +    setAndRead(0, true); +    setAndRead(1, true); + +    EXPECT_EQ(updates_array_idx, 1); // one update received +    EXPECT_EQ(updates[0].index, 0); +    EXPECT_EQ(updates[0].clockwise, true); +} + +TEST_F(EncoderSplitTestLeftLessThanRight, TestOneClockwiseRightSent) { +    isLeftHand = false; +    encoder_init(); +    // send 4 pulses. with resolution 4, that's one step and we should get 1 update. +    setAndRead(6, false); +    setAndRead(7, false); +    setAndRead(6, true); +    setAndRead(7, true); + +    uint8_t slave_state[32] = {0}; +    encoder_state_raw(slave_state); + +    EXPECT_EQ(slave_state[0], 0); +    EXPECT_EQ(slave_state[1], 0xFF); +} + +TEST_F(EncoderSplitTestLeftLessThanRight, TestMultipleEncodersRightReceived) { +    isLeftHand = true; +    encoder_init(); + +    uint8_t slave_state[32] = {1, 0, 0xFF}; // First right encoder is CCW, Second right encoder no change, third right encoder CW +    encoder_update_raw(slave_state); + +    EXPECT_EQ(updates_array_idx, 2); // two updates received, one for each changed item on the right side +    EXPECT_EQ(updates[0].index, 2); +    EXPECT_EQ(updates[0].clockwise, false); +    EXPECT_EQ(updates[1].index, 4); +    EXPECT_EQ(updates[1].clockwise, true); +} diff --git a/quantum/encoder/tests/encoder_tests_split.cpp b/quantum/encoder/tests/encoder_tests_split_no_left.cpp index 25e52c83f9..b6b2d7e2d1 100644 --- a/quantum/encoder/tests/encoder_tests_split.cpp +++ b/quantum/encoder/tests/encoder_tests_split_no_left.cpp @@ -30,7 +30,7 @@ struct update {      bool   clockwise;  }; -uint8_t uidx = 0; +uint8_t updates_array_idx = 0;  update  updates[32];  bool isLeftHand; @@ -41,8 +41,8 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {          printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC");          return true;      } -    updates[uidx % 32] = {index, clockwise}; -    uidx++; +    updates[updates_array_idx % 32] = {index, clockwise}; +    updates_array_idx++;      return true;  } @@ -51,10 +51,10 @@ bool setAndRead(pin_t pin, bool val) {      return encoder_read();  } -class EncoderTest : public ::testing::Test { +class EncoderSplitTestNoLeft : public ::testing::Test {     protected:      void SetUp() override { -        uidx = 0; +        updates_array_idx = 0;          for (int i = 0; i < 32; i++) {              pinIsInputHigh[i] = 0;              pins[i]           = 0; @@ -62,27 +62,27 @@ class EncoderTest : public ::testing::Test {      }  }; -TEST_F(EncoderTest, TestInitLeft) { +TEST_F(EncoderSplitTestNoLeft, TestInitLeft) {      isLeftHand = true;      encoder_init(); -    EXPECT_EQ(pinIsInputHigh[0], true); -    EXPECT_EQ(pinIsInputHigh[1], true); +    EXPECT_EQ(pinIsInputHigh[0], false); +    EXPECT_EQ(pinIsInputHigh[1], false);      EXPECT_EQ(pinIsInputHigh[2], false);      EXPECT_EQ(pinIsInputHigh[3], false); -    EXPECT_EQ(uidx, 0); +    EXPECT_EQ(updates_array_idx, 0); // no updates received  } -TEST_F(EncoderTest, TestInitRight) { +TEST_F(EncoderSplitTestNoLeft, TestInitRight) {      isLeftHand = false;      encoder_init(); -    EXPECT_EQ(pinIsInputHigh[0], false); -    EXPECT_EQ(pinIsInputHigh[1], false); +    EXPECT_EQ(pinIsInputHigh[0], true); +    EXPECT_EQ(pinIsInputHigh[1], true);      EXPECT_EQ(pinIsInputHigh[2], true);      EXPECT_EQ(pinIsInputHigh[3], true); -    EXPECT_EQ(uidx, 0); +    EXPECT_EQ(updates_array_idx, 0); // no updates received  } -TEST_F(EncoderTest, TestOneClockwiseLeft) { +TEST_F(EncoderSplitTestNoLeft, TestOneClockwiseLeft) {      isLeftHand = true;      encoder_init();      // send 4 pulses. with resolution 4, that's one step and we should get 1 update. @@ -91,12 +91,10 @@ TEST_F(EncoderTest, TestOneClockwiseLeft) {      setAndRead(0, true);      setAndRead(1, true); -    EXPECT_EQ(uidx, 1); -    EXPECT_EQ(updates[0].index, 0); -    EXPECT_EQ(updates[0].clockwise, true); +    EXPECT_EQ(updates_array_idx, 0); // no updates received  } -TEST_F(EncoderTest, TestOneClockwiseRightSent) { +TEST_F(EncoderSplitTestNoLeft, TestOneClockwiseRightSent) {      isLeftHand = false;      encoder_init();      // send 4 pulses. with resolution 4, that's one step and we should get 1 update. @@ -105,39 +103,23 @@ TEST_F(EncoderTest, TestOneClockwiseRightSent) {      setAndRead(2, true);      setAndRead(3, true); -    uint8_t slave_state[2] = {0}; +    uint8_t slave_state[32] = {0};      encoder_state_raw(slave_state); -    EXPECT_EQ((int8_t)slave_state[0], -1); +    EXPECT_EQ(slave_state[0], 0); +    EXPECT_EQ(slave_state[1], 0xFF);  } -/* this test will not work after the previous test. - * this is due to encoder_value[1] already being set to -1 when simulating the right half. - * When we now receive this update acting as the left half, there is no change. - * This is hard to mock, as the static values inside encoder.c normally exist twice, once on each half, - * but here, they only exist once. - */ - -// TEST_F(EncoderTest, TestOneClockwiseRightReceived) { -//     isLeftHand = true; -//     encoder_init(); - -//     uint8_t slave_state[2] = {255, 0}; -//     encoder_update_raw(slave_state); - -//     EXPECT_EQ(uidx, 1); -//     EXPECT_EQ(updates[0].index, 1); -//     EXPECT_EQ(updates[0].clockwise, true); -// } - -TEST_F(EncoderTest, TestOneCounterClockwiseRightReceived) { +TEST_F(EncoderSplitTestNoLeft, TestMultipleEncodersRightReceived) {      isLeftHand = true;      encoder_init(); -    uint8_t slave_state[2] = {0, 0}; +    uint8_t slave_state[32] = {1, 0xFF}; // First right encoder is CCW, Second right encoder no change, third right encoder CW      encoder_update_raw(slave_state); -    EXPECT_EQ(uidx, 1); -    EXPECT_EQ(updates[0].index, 1); +    EXPECT_EQ(updates_array_idx, 2); // two updates received, one for each changed item on the right side +    EXPECT_EQ(updates[0].index, 0);      EXPECT_EQ(updates[0].clockwise, false); +    EXPECT_EQ(updates[1].index, 1); +    EXPECT_EQ(updates[1].clockwise, true);  } diff --git a/quantum/encoder/tests/encoder_tests_split_no_right.cpp b/quantum/encoder/tests/encoder_tests_split_no_right.cpp new file mode 100644 index 0000000000..fa0a7c18a8 --- /dev/null +++ b/quantum/encoder/tests/encoder_tests_split_no_right.cpp @@ -0,0 +1,118 @@ +/* Copyright 2021 Balz Guenat + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program.  If not, see <http://www.gnu.org/licenses/>. + */ + +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include <vector> +#include <algorithm> +#include <stdio.h> + +extern "C" { +#include "encoder.h" +#include "encoder/tests/mock_split.h" +} + +struct update { +    int8_t index; +    bool   clockwise; +}; + +uint8_t updates_array_idx = 0; +update  updates[32]; + +bool isLeftHand; + +bool encoder_update_kb(uint8_t index, bool clockwise) { +    if (!isLeftHand) { +        // this method has no effect on slave half +        printf("ignoring update on right hand (%d,%s)\n", index, clockwise ? "CW" : "CC"); +        return true; +    } +    updates[updates_array_idx % 32] = {index, clockwise}; +    updates_array_idx++; +    return true; +} + +bool setAndRead(pin_t pin, bool val) { +    setPin(pin, val); +    return encoder_read(); +} + +class EncoderSplitTestNoRight : public ::testing::Test { +   protected: +    void SetUp() override { +        updates_array_idx = 0; +        for (int i = 0; i < 32; i++) { +            pinIsInputHigh[i] = 0; +            pins[i]           = 0; +        } +    } +}; + +TEST_F(EncoderSplitTestNoRight, TestInitLeft) { +    isLeftHand = true; +    encoder_init(); +    EXPECT_EQ(pinIsInputHigh[0], true); +    EXPECT_EQ(pinIsInputHigh[1], true); +    EXPECT_EQ(pinIsInputHigh[2], true); +    EXPECT_EQ(pinIsInputHigh[3], true); +    EXPECT_EQ(updates_array_idx, 0); // no updates received +} + +TEST_F(EncoderSplitTestNoRight, TestInitRight) { +    isLeftHand = false; +    encoder_init(); +    EXPECT_EQ(pinIsInputHigh[0], false); +    EXPECT_EQ(pinIsInputHigh[1], false); +    EXPECT_EQ(pinIsInputHigh[2], false); +    EXPECT_EQ(pinIsInputHigh[3], false); +    EXPECT_EQ(updates_array_idx, 0); // no updates received +} + +TEST_F(EncoderSplitTestNoRight, TestOneClockwiseLeft) { +    isLeftHand = true; +    encoder_init(); +    // send 4 pulses. with resolution 4, that's one step and we should get 1 update. +    setAndRead(0, false); +    setAndRead(1, false); +    setAndRead(0, true); +    setAndRead(1, true); + +    EXPECT_EQ(updates_array_idx, 1); // one updates received +    EXPECT_EQ(updates[0].index, 0); +    EXPECT_EQ(updates[0].clockwise, true); +} + +TEST_F(EncoderSplitTestNoRight, TestOneClockwiseRightSent) { +    isLeftHand = false; +    encoder_init(); + +    uint8_t slave_state[32] = {0xAA, 0xAA}; +    encoder_state_raw(slave_state); + +    EXPECT_EQ(slave_state[0], 0xAA); +    EXPECT_EQ(slave_state[1], 0xAA); +} + +TEST_F(EncoderSplitTestNoRight, TestMultipleEncodersRightReceived) { +    isLeftHand = true; +    encoder_init(); + +    uint8_t slave_state[32] = {1, 0xFF}; // These values would trigger updates if there were encoders on the other side +    encoder_update_raw(slave_state); + +    EXPECT_EQ(updates_array_idx, 0); // no updates received -- no right-hand encoders +} diff --git a/quantum/encoder/tests/mock.h b/quantum/encoder/tests/mock.h index dbc25a0846..80c336b5ef 100644 --- a/quantum/encoder/tests/mock.h +++ b/quantum/encoder/tests/mock.h @@ -19,12 +19,6 @@  #include <stdint.h>  #include <stdbool.h> -/* Here, "pins" from 0 to 31 are allowed. */ -#define ENCODERS_PAD_A \ -    { 0 } -#define ENCODERS_PAD_B \ -    { 1 } -  typedef uint8_t pin_t;  extern bool pins[]; diff --git a/quantum/encoder/tests/mock_split.h b/quantum/encoder/tests/mock_split.h index 0ae62652f9..2fc12f1830 100644 --- a/quantum/encoder/tests/mock_split.h +++ b/quantum/encoder/tests/mock_split.h @@ -20,20 +20,10 @@  #include <stdbool.h>  #define SPLIT_KEYBOARD -/* Here, "pins" from 0 to 31 are allowed. */ -#define ENCODERS_PAD_A \ -    { 0 } -#define ENCODERS_PAD_B \ -    { 1 } -#define ENCODERS_PAD_A_RIGHT \ -    { 2 } -#define ENCODERS_PAD_B_RIGHT \ -    { 3 } -  typedef uint8_t pin_t; -extern bool     isLeftHand; -void            encoder_state_raw(uint8_t* slave_state); -void            encoder_update_raw(uint8_t* slave_state); + +void encoder_state_raw(uint8_t* slave_state); +void encoder_update_raw(uint8_t* slave_state);  extern bool pins[];  extern bool pinIsInputHigh[]; diff --git a/quantum/encoder/tests/rules.mk b/quantum/encoder/tests/rules.mk index b826ce3aed..6a2611952c 100644 --- a/quantum/encoder/tests/rules.mk +++ b/quantum/encoder/tests/rules.mk @@ -1,13 +1,58 @@ -encoder_DEFS := -DENCODER_MOCK_SINGLE +encoder_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SINGLE +encoder_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock.h  encoder_SRC := \ +	platforms/test/timer.c \  	$(QUANTUM_PATH)/encoder/tests/mock.c \  	$(QUANTUM_PATH)/encoder/tests/encoder_tests.cpp \  	$(QUANTUM_PATH)/encoder.c -encoder_split_DEFS := -DENCODER_MOCK_SPLIT +encoder_split_left_eq_right_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SPLIT +encoder_split_left_eq_right_INC := $(QUANTUM_PATH)/split_common +encoder_split_left_eq_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_left_eq_right.h -encoder_split_SRC := \ +encoder_split_left_eq_right_SRC := \ +	platforms/test/timer.c \  	$(QUANTUM_PATH)/encoder/tests/mock_split.c \ -	$(QUANTUM_PATH)/encoder/tests/encoder_tests_split.cpp \ +	$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_left_eq_right.cpp \ +	$(QUANTUM_PATH)/encoder.c + +encoder_split_left_gt_right_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SPLIT +encoder_split_left_gt_right_INC := $(QUANTUM_PATH)/split_common +encoder_split_left_gt_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_left_gt_right.h + +encoder_split_left_gt_right_SRC := \ +	platforms/test/timer.c \ +	$(QUANTUM_PATH)/encoder/tests/mock_split.c \ +	$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_left_gt_right.cpp \ +	$(QUANTUM_PATH)/encoder.c + +encoder_split_left_lt_right_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SPLIT +encoder_split_left_lt_right_INC := $(QUANTUM_PATH)/split_common +encoder_split_left_lt_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_left_lt_right.h + +encoder_split_left_lt_right_SRC := \ +	platforms/test/timer.c \ +	$(QUANTUM_PATH)/encoder/tests/mock_split.c \ +	$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_left_lt_right.cpp \ +	$(QUANTUM_PATH)/encoder.c + +encoder_split_no_left_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SPLIT +encoder_split_no_left_INC := $(QUANTUM_PATH)/split_common +encoder_split_no_left_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_no_left.h + +encoder_split_no_left_SRC := \ +	platforms/test/timer.c \ +	$(QUANTUM_PATH)/encoder/tests/mock_split.c \ +	$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_no_left.cpp \ +	$(QUANTUM_PATH)/encoder.c + +encoder_split_no_right_DEFS := -DENCODER_TESTS -DENCODER_ENABLE -DENCODER_MOCK_SPLIT +encoder_split_no_right_INC := $(QUANTUM_PATH)/split_common +encoder_split_no_right_CONFIG := $(QUANTUM_PATH)/encoder/tests/config_mock_split_no_right.h + +encoder_split_no_right_SRC := \ +	platforms/test/timer.c \ +	$(QUANTUM_PATH)/encoder/tests/mock_split.c \ +	$(QUANTUM_PATH)/encoder/tests/encoder_tests_split_no_right.cpp \  	$(QUANTUM_PATH)/encoder.c diff --git a/quantum/encoder/tests/testlist.mk b/quantum/encoder/tests/testlist.mk index 1be9f4a054..6b2fd84d96 100644 --- a/quantum/encoder/tests/testlist.mk +++ b/quantum/encoder/tests/testlist.mk @@ -1,3 +1,7 @@  TEST_LIST += \  	encoder \ -	encoder_split +	encoder_split_left_eq_right \ +	encoder_split_left_gt_right \ +	encoder_split_left_lt_right \ +	encoder_split_no_left \ +	encoder_split_no_right | 
