@ -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 |
@ -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 |
@ -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 |
@ -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 |
@ -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 |
@ -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 |
@ -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); | |||
} |
@ -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); | |||
} |
@ -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); | |||
} |
@ -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 | |||
} |
@ -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 |
@ -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 |