auri.ee
keyboard stuff
1/* Copyright 2021 Balz Guenat
2 *
3 * This program is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15 */
16
17#include "gtest/gtest.h"
18#include "gmock/gmock.h"
19#include <vector>
20#include <algorithm>
21#include <stdio.h>
22
23extern "C" {
24#include "encoder.h"
25#include "encoder/tests/mock_split.h"
26}
27
28struct update {
29 int8_t index;
30 bool clockwise;
31};
32
33uint8_t updates_array_idx = 0;
34update updates[32];
35
36bool isMaster;
37bool isLeftHand;
38
39extern "C" {
40bool is_keyboard_master(void) {
41 return isMaster;
42}
43
44bool encoder_update_kb(uint8_t index, bool clockwise) {
45 if (!is_keyboard_master()) {
46 // this method has no effect on slave half
47 printf("ignoring update on slave (%d,%s)\n", index, clockwise ? "CW" : "CC");
48 return true;
49 }
50 updates[updates_array_idx % 32] = {index, clockwise};
51 updates_array_idx++;
52 return true;
53}
54};
55
56bool setAndRead(pin_t pin, bool val) {
57 setPin(pin, val);
58 return encoder_task();
59}
60
61class EncoderSplitTestLeftGreaterThanRight : public ::testing::Test {
62 protected:
63 void SetUp() override {
64 updates_array_idx = 0;
65 for (int i = 0; i < 32; i++) {
66 pinIsInputHigh[i] = 0;
67 pins[i] = 0;
68 }
69 }
70};
71
72TEST_F(EncoderSplitTestLeftGreaterThanRight, TestInitLeft) {
73 isLeftHand = true;
74 encoder_init();
75 EXPECT_EQ(pinIsInputHigh[0], true);
76 EXPECT_EQ(pinIsInputHigh[1], true);
77 EXPECT_EQ(pinIsInputHigh[2], true);
78 EXPECT_EQ(pinIsInputHigh[3], true);
79 EXPECT_EQ(pinIsInputHigh[4], true);
80 EXPECT_EQ(pinIsInputHigh[5], true);
81 EXPECT_EQ(pinIsInputHigh[6], false);
82 EXPECT_EQ(pinIsInputHigh[7], false);
83 EXPECT_EQ(pinIsInputHigh[8], false);
84 EXPECT_EQ(pinIsInputHigh[9], false);
85 EXPECT_EQ(updates_array_idx, 0); // no updates received
86}
87
88TEST_F(EncoderSplitTestLeftGreaterThanRight, TestInitRight) {
89 isLeftHand = false;
90 encoder_init();
91 EXPECT_EQ(pinIsInputHigh[0], false);
92 EXPECT_EQ(pinIsInputHigh[1], false);
93 EXPECT_EQ(pinIsInputHigh[2], false);
94 EXPECT_EQ(pinIsInputHigh[3], false);
95 EXPECT_EQ(pinIsInputHigh[4], false);
96 EXPECT_EQ(pinIsInputHigh[5], false);
97 EXPECT_EQ(pinIsInputHigh[6], true);
98 EXPECT_EQ(pinIsInputHigh[7], true);
99 EXPECT_EQ(pinIsInputHigh[8], true);
100 EXPECT_EQ(pinIsInputHigh[9], true);
101 EXPECT_EQ(updates_array_idx, 0); // no updates received
102}
103
104TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseLeftMaster) {
105 isMaster = true;
106 isLeftHand = true;
107 encoder_init();
108 // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
109 setAndRead(0, false);
110 setAndRead(1, false);
111 setAndRead(0, true);
112 setAndRead(1, true);
113
114 EXPECT_EQ(updates_array_idx, 1); // one update received
115 EXPECT_EQ(updates[0].index, 0);
116 EXPECT_EQ(updates[0].clockwise, true);
117
118 int events_queued = 0;
119 encoder_events_t events;
120 encoder_retrieve_events(&events);
121 while (events.tail != events.head) {
122 events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
123 ++events_queued;
124 }
125 EXPECT_EQ(events_queued, 0); // No events should be queued on master
126}
127
128TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseRightMaster) {
129 isMaster = true;
130 isLeftHand = false;
131 encoder_init();
132 // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
133 setAndRead(6, false);
134 setAndRead(7, false);
135 setAndRead(6, true);
136 setAndRead(7, true);
137
138 EXPECT_EQ(updates_array_idx, 1); // one update received
139 EXPECT_EQ(updates[0].index, 3);
140 EXPECT_EQ(updates[0].clockwise, true);
141
142 int events_queued = 0;
143 encoder_events_t events;
144 encoder_retrieve_events(&events);
145 while (events.tail != events.head) {
146 events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
147 ++events_queued;
148 }
149 EXPECT_EQ(events_queued, 0); // No events should be queued on master
150}
151
152TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseLeftSlave) {
153 isMaster = false;
154 isLeftHand = true;
155 encoder_init();
156 // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
157 setAndRead(0, false);
158 setAndRead(1, false);
159 setAndRead(0, true);
160 setAndRead(1, true);
161
162 EXPECT_EQ(updates_array_idx, 0); // no updates received
163
164 int events_queued = 0;
165 encoder_events_t events;
166 encoder_retrieve_events(&events);
167 while (events.tail != events.head) {
168 events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
169 ++events_queued;
170 }
171 EXPECT_EQ(events_queued, 1); // One event should be queued on slave
172}
173
174TEST_F(EncoderSplitTestLeftGreaterThanRight, TestOneClockwiseRightSlave) {
175 isMaster = false;
176 isLeftHand = false;
177 encoder_init();
178 // send 4 pulses. with resolution 4, that's one step and we should get 1 update.
179 setAndRead(6, false);
180 setAndRead(7, false);
181 setAndRead(6, true);
182 setAndRead(7, true);
183
184 EXPECT_EQ(updates_array_idx, 0); // no updates received
185
186 int events_queued = 0;
187 encoder_events_t events;
188 encoder_retrieve_events(&events);
189 while (events.tail != events.head) {
190 events.tail = (events.tail + 1) % MAX_QUEUED_ENCODER_EVENTS;
191 ++events_queued;
192 }
193 EXPECT_EQ(events_queued, 1); // One event should be queued on slave
194}