AI_Slop/joeylib2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
joeylib2/tests/host/inputHost.c

504 lines
17 KiB
C
Raw Blame History

// Part of JoeyLib, Copyright (c) 2026 Scott Duensing, under the MIT License.
// See LICENSE.md for license information.
// SPDX-License-Identifier: MIT
//
// inputHost.c - Host-cc harness for the typed-character queue
// (jlInputGetChar / jlInputCharPush in src/core/input.c). Exercises
// FIFO ordering, the character filter, drop-newest overflow, reset
// semantics, and the jlInputPoll refill path via a mocked
// jlpInputPoll; a one-button stick's tap (button 0) and hold
// (button 1), with a mocked jlMillisElapsed; the dead zone, axis scaling
// and chord rule every port shares (inputDeadZone, inputAxisScale,
// inputCharTyped); a key two physical keys give, down while either is
// held (inputKeyHeld); the mouse every port starts in the middle of the
// stage and keeps on it (inputReset, inputMouseMove); and what ends
// jlWaitForAnyKey, through a scripted jlpInputPoll.
//
// Built by scripts/check-input.sh with -DJOEYLIB_PLATFORM_BLANK so
// port.h routes jlpInputPoll/jlpJoystickReset to the mocks below.
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include "joey/core.h"
#include "joey/input.h"
#include "inputInternal.h"
#include "port.h"
// Characters the mocked jlpInputPoll delivers on its next call
// (one-shot; cleared after delivery).
static const uint8_t *gMockChars = NULL;
static int gMockCount = 0;
// What the mocked jlpInputPoll reports for stick 0's buttons, and the
// mocked clock.
static uint8_t gMockButtons[JL_JOY_BUTTON_COUNT];
static uint32_t gMockMillis = 0;
// A script for jlWaitForAnyKey: each poll applies its next step, the keys
// held and the characters typed. Past its end the poll holds ESCAPE, which
// ends any wait, and says so in gWaitOverrun.
typedef struct {
uint8_t key; // a jlKeyE held this step, or JL_KEY_NONE
uint8_t key2; // another, or JL_KEY_NONE
const char *chars; // typed this step
} WaitStepT;
// One of a key's two physical keys going down or up, and whether the key
// must then be down.
typedef struct {
uint8_t key; // the key, with INPUT_KEY_SECOND for its second
bool down;
bool held;
} KeyStepT;
static const WaitStepT *gWaitScript = NULL;
static int gWaitSteps = 0;
static int gWaitAt = 0;
static bool gWaitOverrun = false;
// Prototypes (harness-local, alphabetical).
static bool checkEmpty(const char *name);
static bool pollJoy(const char *name, uint32_t millis, bool fire, bool down0, bool down1);
static bool popExpect(const char *name, const uint8_t *expect, int count);
static void pushAll(const uint8_t *chars, int count);
static bool runAxisScale(void);
static bool runChord(void);
static bool runDeadZone(void);
static bool runFilter(void);
static bool runInterleave(void);
static bool runMouse(void);
static bool runOrder(void);
static bool runOverflow(void);
static bool runPollRefill(void);
static bool runReset(void);
static bool runSecondKey(void);
static bool runTapOrHold(void);
static bool runWait(void);
static bool waitEndsAt(const char *name, const WaitStepT *script, int steps, int expect);
void jlpInputPoll(void) {
const char *c;
int i;
if (gWaitScript != NULL) {
memset(gKeyState, 0, sizeof(gKeyState));
if (gWaitAt < gWaitSteps) {
gKeyState[gWaitScript[gWaitAt].key] = 1u;
gKeyState[gWaitScript[gWaitAt].key2] = 1u;
for (c = gWaitScript[gWaitAt].chars; *c != '\0'; c++) {
jlInputCharPush((uint8_t)*c);
}
gWaitAt++;
} else {
gKeyState[JL_KEY_ESCAPE] = 1u;
gWaitOverrun = true;
}
gKeyState[JL_KEY_NONE] = 0u;
return;
}
for (i = 0; i < gMockCount; i++) {
jlInputCharPush(gMockChars[i]);
}
gMockCount = 0;
gJoyButtonState[JL_JOYSTICK_0][JL_JOY_BUTTON_0] = gMockButtons[JL_JOY_BUTTON_0];
gJoyButtonState[JL_JOYSTICK_0][JL_JOY_BUTTON_1] = gMockButtons[JL_JOY_BUTTON_1];
}
uint32_t jlMillisElapsed(void) {
return gMockMillis;
}
void jlpJoystickReset(jlJoystickE js) {
(void)js;
}
static bool checkEmpty(const char *name) {
int got;
got = jlInputGetChar();
if (got != -1) {
printf(" %s: expected empty (-1), got %d\n", name, got);
return false;
}
return true;
}
// One poll at `millis` with stick 0's (first) button `fire`; true when
// buttons 0 and 1 then read down0 and down1.
static bool pollJoy(const char *name, uint32_t millis, bool fire, bool down0, bool down1) {
bool got0;
bool got1;
gMockMillis = millis;
gMockButtons[JL_JOY_BUTTON_0] = fire;
jlInputPoll();
got0 = jlJoyDown(JL_JOYSTICK_0, JL_JOY_BUTTON_0);
got1 = jlJoyDown(JL_JOYSTICK_0, JL_JOY_BUTTON_1);
if (got0 != down0 || got1 != down1) {
printf(" %s: at %u ms, fire %d: buttons %d %d, want %d %d\n", name, (unsigned)millis, fire, got0, got1, down0, down1);
return false;
}
return true;
}
static bool popExpect(const char *name, const uint8_t *expect, int count) {
int got;
int i;
for (i = 0; i < count; i++) {
got = jlInputGetChar();
if (got != (int)expect[i]) {
printf(" %s: index %d: expected 0x%02X, got %d\n", name, i, expect[i], got);
return false;
}
}
return checkEmpty(name);
}
static void pushAll(const uint8_t *chars, int count) {
int i;
for (i = 0; i < count; i++) {
jlInputCharPush(chars[i]);
}
}
// A raw axis reads -127..127 rounded to the nearest: the ends at the ends,
// and a centred stick 0 from either middle value of an even span (DVX's
// -32768..32767 read -1 at rest before it was rounded).
static bool runAxisScale(void) {
static const int32_t kPos[] = { INT16_MIN, INT16_MAX, 0, -1, 32767, 32768, 0, 65535, -100 };
static const int32_t kMin[] = { INT16_MIN, INT16_MIN, INT16_MIN, INT16_MIN, 0, 0, 0, 0, 0 };
static const int32_t kMax[] = { INT16_MAX, INT16_MAX, INT16_MAX, INT16_MAX, 65535, 65535, 65535, 65535, 65535 };
static const int8_t kOut[] = { -127, 127, 0, 0, 0, 0, -127, 127, -127 };
uint16_t i;
bool ok;
ok = true;
for (i = 0u; i < (uint16_t)(sizeof(kPos) / sizeof(kPos[0])); i++) {
if (inputAxisScale(kPos[i], kMin[i], kMax[i]) != kOut[i]) {
printf(" axis-scale: %ld in %ld..%ld gave %d, want %d\n", (long)kPos[i], (long)kMin[i], (long)kMax[i], inputAxisScale(kPos[i], kMin[i], kMax[i]), kOut[i]);
ok = false;
}
}
printf(" axis-scale: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
// A chord types nothing, printable or not; the same characters typed
// plainly arrive.
static bool runChord(void) {
bool ok;
jlInputCharReset();
inputCharTyped('m', true);
inputCharTyped(JL_CHAR_RETURN, true);
inputCharTyped(JL_CHAR_DELETE, true);
ok = jlInputGetChar() == -1;
inputCharTyped('m', false);
inputCharTyped(JL_CHAR_RETURN, false);
ok = ok && jlInputGetChar() == 'm' && jlInputGetChar() == JL_CHAR_RETURN && jlInputGetChar() == -1;
printf(" chord: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
// A reading within the dead zone of centre is 0, at its edge too; one past
// it is the reading; a zone of 0 leaves every reading but 0 alone.
static bool runDeadZone(void) {
static const int8_t kIn[] = { 10, 11, -10, -11, 0, 1, -1, 127, -127 };
static const uint8_t kZone[] = { 10, 10, 10, 10, 0, 0, 0, 10, 10 };
static const int8_t kOut[] = { 0, 11, 0, -11, 0, 1, -1, 127, -127 };
uint16_t i;
bool ok;
ok = true;
for (i = 0u; i < (uint16_t)(sizeof(kIn) / sizeof(kIn[0])); i++) {
if (inputDeadZone(kIn[i], kZone[i]) != kOut[i]) {
printf(" dead-zone: %d in a zone of %u gave %d, want %d\n", kIn[i], kZone[i], inputDeadZone(kIn[i], kZone[i]), kOut[i]);
ok = false;
}
}
printf(" dead-zone: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
// Control characters other than BS/TAB/CR/ESC, and 8-bit values, must
// never surface; those four, the printable range and JL_CHAR_DELETE
// (0x7F, forward delete) must pass through unchanged.
static bool runFilter(void) {
static const uint8_t rejected[] = { 0x00, 0x01, 0x07, 0x0A, 0x0C, 0x1F, 0x80, 0xA0, 0xFF };
static const uint8_t accepted[] = {
JL_CHAR_BACKSPACE, JL_CHAR_TAB, JL_CHAR_RETURN, JL_CHAR_ESCAPE,
0x20, '0', 'Z', 'z', '~', 0x7E, JL_CHAR_DELETE
};
bool ok;
jlInputCharReset();
pushAll(rejected, (int)sizeof(rejected));
ok = checkEmpty("filter-rejects");
pushAll(accepted, (int)sizeof(accepted));
ok &= popExpect("filter-accepts", accepted, (int)sizeof(accepted));
printf(" filter: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
// Pops interleaved with pushes keep FIFO order across the wrap point.
static bool runInterleave(void) {
static const uint8_t first[] = { 'a', 'b', 'c' };
static const uint8_t second[] = { 'd', 'e' };
static const uint8_t rest[] = { 'b', 'c', 'd', 'e' };
bool ok;
int got;
jlInputCharReset();
pushAll(first, (int)sizeof(first));
got = jlInputGetChar();
ok = (got == 'a');
if (!ok) {
printf(" interleave: expected 'a', got %d\n", got);
}
pushAll(second, (int)sizeof(second));
ok &= popExpect("interleave", rest, (int)sizeof(rest));
printf(" interleave: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
// The definition-of-done string from the RetroNet handoff must come
// back byte-for-byte.
// jlInit's reset puts the mouse in the middle of the stage; a port's moves
// stay on it.
static bool runMouse(void) {
bool ok;
inputMouseMove(5, 7);
inputReset();
ok = jlMouseX() == JL_SURFACE_WIDTH / 2 && jlMouseY() == JL_SURFACE_HEIGHT / 2;
inputMouseMove(-5, 250);
ok = ok && jlMouseX() == 0 && jlMouseY() == JL_SURFACE_HEIGHT - 1;
inputMouseMove(400, -1);
ok = ok && jlMouseX() == JL_SURFACE_WIDTH - 1 && jlMouseY() == 0;
inputMouseMove(100, 50);
ok = ok && jlMouseX() == 100 && jlMouseY() == 50;
printf(" mouse: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
static bool runOrder(void) {
static const char target[] = "192.168.1.10:6510";
bool ok;
jlInputCharReset();
pushAll((const uint8_t *)target, (int)(sizeof(target) - 1));
ok = popExpect("order", (const uint8_t *)target, (int)(sizeof(target) - 1));
printf(" order: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
// Overflow drops the NEWEST characters: exactly JL_CHAR_QUEUE_SIZE - 1
// survive, and they are the first ones pushed.
static bool runOverflow(void) {
uint8_t burst[JL_CHAR_QUEUE_SIZE + 8];
bool ok;
int i;
jlInputCharReset();
for (i = 0; i < (int)sizeof(burst); i++) {
burst[i] = (uint8_t)('!' + (i % 0x5E));
}
pushAll(burst, (int)sizeof(burst));
ok = popExpect("overflow", burst, JL_CHAR_QUEUE_SIZE - 1);
printf(" overflow: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
// The real app-facing path: jlInputPoll runs the port poll, which
// pushes translated characters; jlInputGetChar then pops them.
static bool runPollRefill(void) {
static const uint8_t typed[] = { 'H', 'i', '!', JL_CHAR_RETURN };
bool ok;
jlInputCharReset();
gMockChars = typed;
gMockCount = (int)sizeof(typed);
jlInputPoll();
ok = popExpect("poll-refill", typed, (int)sizeof(typed));
jlInputPoll();
ok &= checkEmpty("poll-refill-once");
printf(" poll-refill: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
// jlInputCharReset empties the queue (the jlInit path).
static bool runReset(void) {
static const uint8_t some[] = { 'x', 'y', 'z' };
bool ok;
jlInputCharReset();
pushAll(some, (int)sizeof(some));
jlInputCharReset();
ok = checkEmpty("reset");
printf(" reset: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
// A one-button stick: a press let go within half a second is button 0,
// down for the one poll after it is let go; a longer press is button 1
// from half a second until it is let go, with no button 0 after it. A
// two-button stick's buttons pass through as they are.
// A key two physical keys give is down while either is held, whichever goes
// up first; a repeated press or a stray release of one changes nothing.
static bool runSecondKey(void) {
static const KeyStepT kSteps[] = {
{ JL_KEY_UP, true, true },
{ JL_KEY_UP | INPUT_KEY_SECOND, true, true },
{ JL_KEY_UP, false, true },
{ JL_KEY_UP, true, true },
{ JL_KEY_UP | INPUT_KEY_SECOND, false, true },
{ JL_KEY_UP | INPUT_KEY_SECOND, false, true },
{ JL_KEY_UP, false, false },
{ JL_KEY_UP | INPUT_KEY_SECOND, true, true },
{ JL_KEY_UP | INPUT_KEY_SECOND, true, true },
{ JL_KEY_UP | INPUT_KEY_SECOND, false, false },
};
uint16_t i;
uint8_t held;
bool ok;
ok = true;
held = 0u;
for (i = 0u; i < (uint16_t)(sizeof(kSteps) / sizeof(kSteps[0])); i++) {
held = inputKeyHeld(held, kSteps[i].key, kSteps[i].down);
if ((held != 0u) != kSteps[i].held) {
printf(" second-key: step %u left the key %s\n", i, held != 0u ? "down" : "up");
ok = false;
}
}
printf(" second-key: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
static bool runTapOrHold(void) {
bool ok = true;
gJoyOneButton[JL_JOYSTICK_0] = true;
ok &= pollJoy("tap down", 1000u, true, false, false);
ok &= pollJoy("tap held", 1300u, true, false, false);
ok &= pollJoy("tap let go", 1350u, false, true, false);
ok &= jlJoyPressed(JL_JOYSTICK_0, JL_JOY_BUTTON_0);
ok &= pollJoy("tap over", 1370u, false, false, false);
ok &= jlJoyReleased(JL_JOYSTICK_0, JL_JOY_BUTTON_0);
ok &= pollJoy("hold down", 2000u, true, false, false);
ok &= pollJoy("hold at 499 ms", 2499u, true, false, false);
ok &= pollJoy("hold at 500 ms", 2500u, true, false, true);
ok &= jlJoyPressed(JL_JOYSTICK_0, JL_JOY_BUTTON_1);
ok &= pollJoy("hold on", 2900u, true, false, true);
ok &= pollJoy("hold let go", 2950u, false, false, false);
ok &= jlJoyReleased(JL_JOYSTICK_0, JL_JOY_BUTTON_1);
ok &= pollJoy("hold over", 2970u, false, false, false);
gJoyOneButton[JL_JOYSTICK_0] = false;
gMockButtons[JL_JOY_BUTTON_1] = true;
ok &= pollJoy("two buttons", 3000u, true, true, true);
gMockButtons[JL_JOY_BUTTON_1] = false;
ok &= pollJoy("two buttons up", 3020u, false, false, false);
printf(" tap-or-hold: %s\n", ok ? "PASS" : "FAIL");
return ok;
}
// What ends jlWaitForAnyKey: a named key pressed, or a character typed, but
// not a key held from the start, nor a held key's own auto-repeat.
static bool runWait(void) {
static const WaitStepT kPunctuation[] = {
{ JL_KEY_NONE, JL_KEY_NONE, "" }, { JL_KEY_NONE, JL_KEY_NONE, "" }, { JL_KEY_NONE, JL_KEY_NONE, "," }
};
static const WaitStepT kRepeat[] = {
{ JL_KEY_SPACE, JL_KEY_NONE, "" }, { JL_KEY_SPACE, JL_KEY_NONE, " " }, { JL_KEY_SPACE, JL_KEY_NONE, " " },
{ JL_KEY_NONE, JL_KEY_NONE, "" }, { JL_KEY_NONE, JL_KEY_NONE, "." }
};
static const WaitStepT kShifted[] = {
{ JL_KEY_NONE, JL_KEY_NONE, "" }, { JL_KEY_LSHIFT, JL_KEY_NONE, "<" }
};
static const WaitStepT kNamed[] = {
{ JL_KEY_NONE, JL_KEY_NONE, "" }, { JL_KEY_NONE, JL_KEY_NONE, "" }, { JL_KEY_A, JL_KEY_NONE, "a" }
};
static const WaitStepT kHeld[] = {
{ JL_KEY_A, JL_KEY_NONE, "" }, { JL_KEY_A, JL_KEY_NONE, "a" }, { JL_KEY_A, JL_KEY_NONE, "a" },
{ JL_KEY_NONE, JL_KEY_NONE, "" }, { JL_KEY_A, JL_KEY_NONE, "a" }
};
bool ok = true;
ok &= waitEndsAt("wait: a punctuation key", kPunctuation, 3, 3);
ok &= waitEndsAt("wait: a held key's repeat", kRepeat, 5, 5);
ok &= waitEndsAt("wait: shifted punctuation", kShifted, 2, 2);
ok &= waitEndsAt("wait: a named key", kNamed, 3, 3);
ok &= waitEndsAt("wait: a key held from the start", kHeld, 5, 5);
return ok;
}
// Run jlWaitForAnyKey on script: it should return on poll expect (the
// first poll is 1), and the character queue be empty.
static bool waitEndsAt(const char *name, const WaitStepT *script, int steps, int expect) {
bool ok;
jlInputCharReset();
memset(gKeyState, 0, sizeof(gKeyState));
gWaitScript = script;
gWaitSteps = steps;
gWaitAt = 0;
gWaitOverrun = false;
jlWaitForAnyKey();
gWaitScript = NULL;
ok = !gWaitOverrun && gWaitAt == expect && jlInputGetChar() == -1;
printf(" %-34s %s (ended on poll %d%s, %d expected)\n", name, ok ? "PASS" : "FAIL", gWaitAt, gWaitOverrun ? ", past the script" : "", expect);
return ok;
}
int main(void) {
bool ok = true;
printf("inputHost: typed-character queue, joystick, and mouse scenarios\n");
ok &= runOrder();
ok &= runFilter();
ok &= runOverflow();
ok &= runInterleave();
ok &= runReset();
ok &= runPollRefill();
ok &= runTapOrHold();
ok &= runDeadZone();
ok &= runAxisScale();
ok &= runChord();
ok &= runSecondKey();
ok &= runMouse();
ok &= runWait();
if (!ok) {
printf("inputHost: FAIL\n");
return 1;
}
printf("inputHost: PASS\n");
return 0;
}
Reference in a new issue View git blame Copy permalink