From a8f3143e300be25b2d2107f656b4cc55a019e431 Mon Sep 17 00:00:00 2001 From: Robert Hargreaves Date: Fri, 6 Sep 2024 17:53:18 +0100 Subject: [PATCH] Separate out idea of comm hardware present & ready vs ready only --- src/comm.c | 24 +++++++++++---------- src/comm_demo.c | 5 +++++ src/comm_demo.h | 1 + src/comm_everdrive.c | 32 ++++++++++++++++++++++++++-- src/comm_everdrive.h | 2 ++ src/comm_everdrive_pro.c | 5 +++++ src/comm_everdrive_pro.h | 1 + src/comm_megawifi.c | 8 +++++++ src/comm_megawifi.h | 1 + src/comm_serial.c | 5 +++++ src/comm_serial.h | 1 + tests/Makefile | 9 ++++++++ tests/asserts.c | 5 +++++ tests/asserts.h | 1 + tests/system/test_e2e.c | 32 ++++++++++++++++++++++++---- tests/unit/main.c | 3 ++- tests/unit/test_comm.c | 33 ++++++++++++++++++++++------- tests/wraps.c | 45 ++++++++++++++++++++++++++++++++++++++++ tests/wraps.h | 32 +++++++++++++++++++++------- 19 files changed, 212 insertions(+), 33 deletions(-) diff --git a/src/comm.c b/src/comm.c index 5f39674..4b06221 100644 --- a/src/comm.c +++ b/src/comm.c @@ -19,27 +19,29 @@ static bool countsInBounds(void); typedef struct CommVTable { void (*init)(void); + bool (*is_present)(void); u8 (*read_ready)(void); u8 (*read)(void); u8 (*write_ready)(void); void (*write)(u8 data); } CommVTable; -static const CommVTable Demo_VTable = { comm_demo_init, comm_demo_read_ready, comm_demo_read, - comm_demo_write_ready, comm_demo_write }; +static const CommVTable Demo_VTable = { comm_demo_init, comm_demo_is_present, comm_demo_read_ready, + comm_demo_read, comm_demo_write_ready, comm_demo_write }; -static const CommVTable Everdrive_VTable = { comm_everdrive_init, comm_everdrive_read_ready, - comm_everdrive_read, comm_everdrive_write_ready, comm_everdrive_write }; +static const CommVTable Everdrive_VTable + = { comm_everdrive_init, comm_everdrive_is_present, comm_everdrive_read_ready, + comm_everdrive_read, comm_everdrive_write_ready, comm_everdrive_write }; static const CommVTable EverdrivePro_VTable - = { comm_everdrive_pro_init, comm_everdrive_pro_read_ready, comm_everdrive_pro_read, - comm_everdrive_pro_write_ready, comm_everdrive_pro_write }; + = { comm_everdrive_pro_init, comm_everdrive_pro_is_present, comm_everdrive_pro_read_ready, + comm_everdrive_pro_read, comm_everdrive_pro_write_ready, comm_everdrive_pro_write }; -static const CommVTable Serial_VTable = { comm_serial_init, comm_serial_read_ready, - comm_serial_read, comm_serial_write_ready, comm_serial_write }; +static const CommVTable Serial_VTable = { comm_serial_init, comm_serial_is_present, + comm_serial_read_ready, comm_serial_read, comm_serial_write_ready, comm_serial_write }; -static const CommVTable Megawifi_VTable = { comm_megawifi_init, comm_megawifi_read_ready, - comm_megawifi_read, comm_megawifi_write_ready, comm_megawifi_write }; +static const CommVTable Megawifi_VTable = { comm_megawifi_init, comm_megawifi_is_present, + comm_megawifi_read_ready, comm_megawifi_read, comm_megawifi_write_ready, comm_megawifi_write }; static const CommVTable* commTypes[] = { #if COMM_EVERDRIVE_X7 == 1 @@ -73,7 +75,7 @@ static bool readReady(void) { if (activeCommType == NULL) { for (u16 i = 0; i < COMM_TYPES; i++) { - if (commTypes[i]->read_ready()) { + if (commTypes[i]->is_present() && commTypes[i]->read_ready()) { activeCommType = commTypes[i]; return true; } diff --git a/src/comm_demo.c b/src/comm_demo.c index 2a9e80f..b2142e9 100644 --- a/src/comm_demo.c +++ b/src/comm_demo.c @@ -48,6 +48,11 @@ void comm_demo_init(void) program = 0; } +bool comm_demo_is_present(void) +{ + return true; +} + u8 comm_demo_read_ready(void) { if (!enabled) { diff --git a/src/comm_demo.h b/src/comm_demo.h index 2b77c7c..453a4dc 100644 --- a/src/comm_demo.h +++ b/src/comm_demo.h @@ -2,6 +2,7 @@ #include "types.h" void comm_demo_init(void); +bool comm_demo_is_present(void); u8 comm_demo_read_ready(void); u8 comm_demo_read(void); u8 comm_demo_write_ready(void); diff --git a/src/comm_everdrive.c b/src/comm_everdrive.c index acce294..72e5504 100644 --- a/src/comm_everdrive.c +++ b/src/comm_everdrive.c @@ -2,10 +2,38 @@ #include "everdrive_led.h" #define SSF_REG16(reg) *((volatile u16*)(0xA13000 + reg)) -#define REG_USB 226 -#define REG_STE 228 +#define REG_USB 0xE2 +#define REG_STE 0xE4 #define STE_USB_RD_RDY 4 #define STE_USB_WR_RDY 2 // usb write ready bit +#define STE_SPI_RDY 1 + +#define IO_STATUS_HI_SD 0x00 +#define IO_STATUS_HI_SDHC 0x40 + +bool comm_everdrive_is_present(void) +{ + /* REG_STE values: + 0x3F00 with OpenEmu v2.4.1 + 0x3F00 with Exodus + 0x3F00 with Regen v0.97d + 0xFFFF with Fusion 3.6.4 + 0x3F00 with BlastEm nightly (0.6.3-pre-4c418ee9a9d8) Win + 0x3015 with BlastEm nightly (0.6.3-pre) (also 0x3014) + 0x4003 when ME X7 idle with USB in + 0x4009 when ME X7 idle loaded via SD without USB cable connected + 0x4003 when ME X7 idle loaded via SD with USB cable connected + 0x3F00 with ME PRO + */ + + u8 status = SSF_REG16(REG_STE) >> 8; + return status == IO_STATUS_HI_SD || status == IO_STATUS_HI_SDHC; +} + +u16 comm_everdrive_raw(void) +{ + return SSF_REG16(REG_STE); +} u8 comm_everdrive_read_ready(void) { diff --git a/src/comm_everdrive.h b/src/comm_everdrive.h index 4b628a8..8f89ef5 100644 --- a/src/comm_everdrive.h +++ b/src/comm_everdrive.h @@ -2,7 +2,9 @@ #include "types.h" void comm_everdrive_init(void); +bool comm_everdrive_is_present(void); u8 comm_everdrive_read_ready(void); u8 comm_everdrive_read(void); u8 comm_everdrive_write_ready(void); void comm_everdrive_write(u8 data); +u16 comm_everdrive_raw(void); diff --git a/src/comm_everdrive_pro.c b/src/comm_everdrive_pro.c index e986041..ceab816 100644 --- a/src/comm_everdrive_pro.c +++ b/src/comm_everdrive_pro.c @@ -104,3 +104,8 @@ void comm_everdrive_pro_write(u8 data) void comm_everdrive_pro_init(void) { } + +bool comm_everdrive_pro_is_present(void) +{ + return pro_present(); +} diff --git a/src/comm_everdrive_pro.h b/src/comm_everdrive_pro.h index 02d05f9..a5afdfa 100644 --- a/src/comm_everdrive_pro.h +++ b/src/comm_everdrive_pro.h @@ -2,6 +2,7 @@ #include "types.h" void comm_everdrive_pro_init(void); +bool comm_everdrive_pro_is_present(void); u8 comm_everdrive_pro_read_ready(void); u8 comm_everdrive_pro_read(void); u8 comm_everdrive_pro_write_ready(void); diff --git a/src/comm_megawifi.c b/src/comm_megawifi.c index 0834740..9bf7426 100644 --- a/src/comm_megawifi.c +++ b/src/comm_megawifi.c @@ -3,6 +3,7 @@ #include "log.h" #include "ext/mw/megawifi.h" #include "ext/mw/lsd.h" +#include "ext/mw/16c550.h" #include "vstring.h" #include "settings.h" #include "buffer.h" @@ -145,6 +146,13 @@ void comm_megawifi_init(void) status = Listening; } +bool comm_megawifi_is_present(void) +{ + u16 current = UART_SPR; + UART_SPR++; + return (current != UART_SPR); +} + u8 comm_megawifi_read_ready(void) { if (!recvData) diff --git a/src/comm_megawifi.h b/src/comm_megawifi.h index a0c7383..31fd06c 100644 --- a/src/comm_megawifi.h +++ b/src/comm_megawifi.h @@ -2,6 +2,7 @@ #include "types.h" void comm_megawifi_init(void); +bool comm_megawifi_is_present(void); u8 comm_megawifi_read_ready(void); u8 comm_megawifi_read(void); u8 comm_megawifi_write_ready(void); diff --git a/src/comm_serial.c b/src/comm_serial.c index 7e05e50..adfbe4e 100644 --- a/src/comm_serial.c +++ b/src/comm_serial.c @@ -51,6 +51,11 @@ void comm_serial_init(void) } } +bool comm_serial_is_present(void) +{ + return true; +} + u8 comm_serial_read_ready(void) { if (!recvData) diff --git a/src/comm_serial.h b/src/comm_serial.h index e681562..fc23532 100644 --- a/src/comm_serial.h +++ b/src/comm_serial.h @@ -2,6 +2,7 @@ #include "types.h" void comm_serial_init(void); +bool comm_serial_is_present(void); u8 comm_serial_read_ready(void); u8 comm_serial_read(void); u8 comm_serial_write_ready(void); diff --git a/tests/Makefile b/tests/Makefile index 5bcafa6..55d8230 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -128,22 +128,31 @@ MD_MOCKS=SYS_setVIntCallback \ SPR_setFrame \ SPR_setAnimAndFrame \ SPR_setVisibility \ + comm_megawifi_is_present \ + comm_megawifi_read_ready \ + comm_megawifi_read \ + comm_megawifi_write_ready \ + comm_megawifi_write \ comm_serial_init \ + comm_serial_is_present \ comm_serial_read_ready \ comm_serial_read \ comm_serial_write_ready \ comm_serial_write \ comm_everdrive_init \ + comm_everdrive_is_present \ comm_everdrive_read_ready \ comm_everdrive_read \ comm_everdrive_write_ready \ comm_everdrive_write \ comm_everdrive_pro_init \ + comm_everdrive_pro_is_present \ comm_everdrive_pro_read_ready \ comm_everdrive_pro_read \ comm_everdrive_pro_write_ready \ comm_everdrive_pro_write \ comm_demo_init \ + comm_demo_is_present \ comm_demo_read_ready \ comm_demo_read \ comm_demo_ready \ diff --git a/tests/asserts.c b/tests/asserts.c index c97bd01..8391ad0 100644 --- a/tests/asserts.c +++ b/tests/asserts.c @@ -2,6 +2,11 @@ #include "asserts.h" #include "comm.h" +void expect_everdrive_to_be_present(void) +{ + will_return(__wrap_comm_everdrive_is_present, true); +} + void stub_usb_receive_nothing(void) { will_return(__wrap_comm_everdrive_read_ready, 0); diff --git a/tests/asserts.h b/tests/asserts.h index cbbf217..5ce9abe 100644 --- a/tests/asserts.h +++ b/tests/asserts.h @@ -3,6 +3,7 @@ #include "debug.h" #include "cmocka.h" +void expect_everdrive_to_be_present(void); void expect_usb_sent_byte(u8 value); void stub_usb_receive_nothing(void); void stub_usb_receive_byte(u8 value); diff --git a/tests/system/test_e2e.c b/tests/system/test_e2e.c index 3d5578b..839f6e3 100644 --- a/tests/system/test_e2e.c +++ b/tests/system/test_e2e.c @@ -47,6 +47,7 @@ static int test_e2e_setup(void** state) static void test_midi_note_on_event_sent_to_ym2612(void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_note_on(TEST_MIDI_CHANNEL_1, 48, 127); expect_ym2612_write_channel(0, 0xA4, 0x1A); expect_ym2612_write_channel(0, 0xA0, 0x84); @@ -56,6 +57,7 @@ static void test_midi_note_on_event_sent_to_ym2612(void** state) static void test_polyphonic_midi_sent_to_separate_ym2612_channels(void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_cc(TEST_MIDI_CHANNEL_1, TEST_CC_POLYPHONIC, TEST_POLYPHONIC_ON); midi_receiver_read(); @@ -75,6 +77,7 @@ static void test_polyphonic_midi_sent_to_separate_ym2612_channels(void** state) static void test_psg_audible_if_note_on_event_triggered(void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_note_on(TEST_MIDI_CHANNEL_PSG_1, 60, TEST_VELOCITY_MAX); expect_any(__wrap_PSG_setTone, channel); expect_any(__wrap_PSG_setTone, value); @@ -86,12 +89,15 @@ static void test_psg_audible_if_note_on_event_triggered(void** state) static void test_psg_not_audible_if_midi_channel_volume_set_and_there_is_no_note_on_event( void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_cc(TEST_MIDI_CHANNEL_PSG_1, TEST_CC_VOLUME, TEST_VOLUME_MAX); midi_receiver_read(); } static void test_general_midi_reset_sysex_stops_all_notes(void** state) { + expect_everdrive_to_be_present(); + const u8 noteOnKey = 48; // FM note @@ -136,6 +142,8 @@ static void remapChannel(u8 midiChannel, u8 deviceChannel) static void test_remap_midi_channel_1_to_psg_channel_1() { + expect_everdrive_to_be_present(); + const u8 MIDI_CHANNEL_UNASSIGNED = 0x7F; const u8 DEVICE_PSG_1 = 0x06; const u8 DEVICE_FM_1 = 0; @@ -156,6 +164,7 @@ static void test_remap_midi_channel_1_to_psg_channel_1() static void test_set_device_for_midi_channel_1_to_psg() { + expect_everdrive_to_be_present(); stub_usb_receive_cc(TEST_MIDI_CHANNEL_1, TEST_CC_POLYPHONIC, TEST_POLYPHONIC_ON); midi_receiver_read(); @@ -178,6 +187,8 @@ static void test_pong_received_after_ping_sent() const u8 sysExPongSequence[] = { SYSEX_START, SYSEX_MANU_EXTENDED, SYSEX_MANU_REGION, SYSEX_MANU_ID, SYSEX_COMMAND_PONG, SYSEX_END }; + expect_everdrive_to_be_present(); + for (u16 i = 0; i < sizeof(sysExPingSequence); i++) { stub_usb_receive_byte(sysExPingSequence[i]); } @@ -193,6 +204,8 @@ static void test_loads_psg_envelope() { const u8 sysExPingSequence[] = { SYSEX_START, SYSEX_MANU_EXTENDED, SYSEX_MANU_REGION, SYSEX_MANU_ID, SYSEX_COMMAND_LOAD_PSG_ENVELOPE, 0x06, 0x06, SYSEX_END }; + + expect_everdrive_to_be_present(); for (u16 i = 0; i < sizeof(sysExPingSequence); i++) { stub_usb_receive_byte(sysExPingSequence[i]); } @@ -208,6 +221,7 @@ static void test_loads_psg_envelope() static void test_enables_ch3_special_mode(void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_cc(TEST_MIDI_CHANNEL_1, TEST_CC_SPECIAL_MODE, TEST_SPECIAL_MODE_ON); expect_ym2612_write_reg(0, 0x27, 0x40); midi_receiver_read(); @@ -215,6 +229,7 @@ static void test_enables_ch3_special_mode(void** state) static void test_sets_separate_ch3_operator_frequencies(void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_cc(TEST_MIDI_CHANNEL_1, TEST_CC_SPECIAL_MODE, TEST_SPECIAL_MODE_ON); expect_ym2612_write_reg(0, 0x27, 0x40); midi_receiver_read(); @@ -238,6 +253,7 @@ static void test_sets_separate_ch3_operator_frequencies(void** state) static void test_pitch_bends_ch3_special_mode_operators(void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_cc(TEST_MIDI_CHANNEL_1, TEST_CC_SPECIAL_MODE, TEST_SPECIAL_MODE_ON); expect_ym2612_write_reg(0, 0x27, 0x40); midi_receiver_read(); @@ -260,6 +276,8 @@ static void test_pitch_bends_ch3_special_mode_operators(void** state) static void test_write_directly_to_ym2612_regs_via_sysex(void** state) { + expect_everdrive_to_be_present(); + const u8 sysExSeq[] = { 0xF0, 0x00, 0x22, 0x77, 0x08, 0x0B, 0x01, 0x01, 0x02, 0xF7 }; for (u16 i = 0; i < sizeof(sysExSeq); i++) { stub_usb_receive_byte(sysExSeq[i]); @@ -270,6 +288,7 @@ static void test_write_directly_to_ym2612_regs_via_sysex(void** state) static void test_plays_pcm_sample(void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_cc(TEST_MIDI_CHANNEL_1, TEST_CC_ENABLE_DAC, 127); expect_ym2612_write_reg(0, 0x2B, 0x80); midi_receiver_read(); @@ -285,6 +304,7 @@ static void test_plays_pcm_sample(void** state) static void test_midi_last_note_played_priority_respected_on_fm(void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_note_on(TEST_MIDI_CHANNEL_1, 48, 127); expect_ym2612_write_channel(0, 0xA4, 0x1A); expect_ym2612_write_channel(0, 0xA0, 0x84); @@ -306,6 +326,7 @@ static void test_midi_last_note_played_priority_respected_on_fm(void** state) static void test_midi_last_note_played_remembers_velocity_on_fm(void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_note_on(TEST_MIDI_CHANNEL_1, 48, 100); expect_ym2612_write_channel(0, 0x40, 0x27); expect_ym2612_write_channel(0, 0x48, 0x04); @@ -331,6 +352,7 @@ static void test_midi_last_note_played_remembers_velocity_on_fm(void** state) static void test_midi_last_note_played_cleared_when_released_on_fm(void** state) { + expect_everdrive_to_be_present(); stub_usb_receive_note_on(TEST_MIDI_CHANNEL_1, 48, 127); expect_ym2612_write_channel(0, 0xA4, 0x1A); expect_ym2612_write_channel(0, 0xA0, 0x84); @@ -353,14 +375,14 @@ static void test_midi_last_note_played_cleared_when_released_on_fm(void** state) static void test_midi_changing_program_retains_pan(void** state) { + expect_everdrive_to_be_present(); + const u8 chan = 0; - // print_message("Change pan\n"); stub_usb_receive_cc(TEST_MIDI_CHANNEL_1, TEST_CC_PAN, 0); // left expect_ym2612_write_channel(chan, 0xB4, 0x80); // pan, alg, fb midi_receiver_read(); - // print_message("Change program\n"); stub_usb_receive_program(TEST_MIDI_CHANNEL_1, 1); expect_ym2612_write_channel_any_data(chan, 0xB0); expect_ym2612_write_channel(chan, 0xB4, 0x80); // pan, alg, fb @@ -397,9 +419,10 @@ static void test_midi_changing_program_retains_pan(void** state) static void test_midi_changing_program_retains_volume(void** state) { + expect_everdrive_to_be_present(); + const u8 chan = 0; - // print_message("Change volume\n"); stub_usb_receive_cc(TEST_MIDI_CHANNEL_1, TEST_CC_VOLUME, 0); expect_ym2612_write_channel(chan, 0x40, 0x27); expect_ym2612_write_channel(chan, 0x48, 0x04); @@ -407,7 +430,6 @@ static void test_midi_changing_program_retains_volume(void** state) expect_ym2612_write_channel(chan, 0x4C, 0x7F); // output operator mute midi_receiver_read(); - // print_message("Change program\n"); stub_usb_receive_program(TEST_MIDI_CHANNEL_1, 1); expect_ym2612_write_channel_any_data(chan, 0xB0); expect_ym2612_write_channel_any_data(chan, 0xB4); @@ -444,6 +466,8 @@ static void test_midi_changing_program_retains_volume(void** state) static void test_midi_portamento_glides_note(void** state) { + expect_everdrive_to_be_present(); + stub_usb_receive_cc(TEST_MIDI_CHANNEL_1, TEST_CC_PORTAMENTO_TIME, 95); midi_receiver_read(); stub_usb_receive_cc(TEST_MIDI_CHANNEL_1, TEST_CC_PORTAMENTO_ON, 0x7F); diff --git a/tests/unit/main.c b/tests/unit/main.c index f579e5d..36be658 100644 --- a/tests/unit/main.c +++ b/tests/unit/main.c @@ -275,7 +275,8 @@ int main(void) synth_test(test_does_not_release_Z80_bus_when_taken_prior_to_call), comm_test(test_comm_reads_from_serial_when_ready), - comm_test(test_comm_reads_when_ready), + comm_test(test_comm_reads_everdrive_when_ready), + comm_test(test_comm_reads_demo_when_ready), comm_test(test_comm_writes_when_ready), comm_test(test_comm_idle_count_is_correct), comm_test(test_comm_busy_count_is_correct), diff --git a/tests/unit/test_comm.c b/tests/unit/test_comm.c index 1e834d4..3e2247e 100644 --- a/tests/unit/test_comm.c +++ b/tests/unit/test_comm.c @@ -13,6 +13,7 @@ static int test_comm_setup(UNUSED void** state) static void switch_comm_type_to_everdrive(void) { + will_return(__wrap_comm_everdrive_is_present, true); will_return(__wrap_comm_everdrive_read_ready, 1); will_return(__wrap_comm_everdrive_read, 50); __real_comm_read(); @@ -21,8 +22,9 @@ static void switch_comm_type_to_everdrive(void) static void test_comm_reads_from_serial_when_ready(UNUSED void** state) { - will_return(__wrap_comm_everdrive_read_ready, 0); - will_return(__wrap_comm_everdrive_pro_read_ready, 0); + will_return(__wrap_comm_everdrive_is_present, false); + will_return(__wrap_comm_everdrive_pro_is_present, false); + will_return(__wrap_comm_serial_is_present, true); will_return(__wrap_comm_serial_read_ready, 1); will_return(__wrap_comm_serial_read, 50); @@ -31,12 +33,9 @@ static void test_comm_reads_from_serial_when_ready(UNUSED void** state) assert_int_equal(read, 50); } -static void test_comm_reads_when_ready(UNUSED void** state) +static void test_comm_reads_everdrive_when_ready(UNUSED void** state) { - will_return(__wrap_comm_everdrive_read_ready, 0); - will_return(__wrap_comm_everdrive_pro_read_ready, 0); - will_return(__wrap_comm_serial_read_ready, 0); - will_return(__wrap_comm_demo_read_ready, 0); + will_return(__wrap_comm_everdrive_is_present, true); will_return(__wrap_comm_everdrive_read_ready, 1); will_return(__wrap_comm_everdrive_read, 50); @@ -45,10 +44,28 @@ static void test_comm_reads_when_ready(UNUSED void** state) assert_int_equal(read, 50); } +static void test_comm_reads_demo_when_ready(UNUSED void** state) +{ + will_return(__wrap_comm_everdrive_is_present, false); + will_return(__wrap_comm_everdrive_pro_is_present, false); + will_return(__wrap_comm_serial_is_present, true); + will_return(__wrap_comm_serial_read_ready, 0); + will_return(__wrap_comm_megawifi_is_present, true); + will_return(__wrap_comm_megawifi_read_ready, 0); + will_return(__wrap_comm_demo_is_present, true); + will_return(__wrap_comm_demo_read_ready, 1); + will_return(__wrap_comm_demo_read, 50); + + u8 read = __real_comm_read(); + + assert_int_equal(read, 50); +} + static void test_comm_writes_when_ready(UNUSED void** state) { const u8 test_data = 50; + will_return(__wrap_comm_everdrive_is_present, true); will_return(__wrap_comm_everdrive_read_ready, 1); will_return(__wrap_comm_everdrive_read, 50); __real_comm_read(); @@ -62,6 +79,7 @@ static void test_comm_writes_when_ready(UNUSED void** state) static void test_comm_idle_count_is_correct(UNUSED void** state) { + will_return(__wrap_comm_everdrive_is_present, true); will_return(__wrap_comm_everdrive_read_ready, 1); will_return(__wrap_comm_everdrive_read, 50); __real_comm_read(); @@ -79,6 +97,7 @@ static void test_comm_idle_count_is_correct(UNUSED void** state) static void test_comm_busy_count_is_correct(UNUSED void** state) { + will_return(__wrap_comm_everdrive_is_present, true); will_return(__wrap_comm_everdrive_read_ready, 1); will_return(__wrap_comm_everdrive_read, 50); __real_comm_read(); diff --git a/tests/wraps.c b/tests/wraps.c index 7f36894..89e0fdd 100644 --- a/tests/wraps.c +++ b/tests/wraps.c @@ -500,6 +500,11 @@ void __wrap_comm_everdrive_init(void) { } +bool __wrap_comm_everdrive_is_present(void) +{ + return mock_type(bool); +} + u8 __wrap_comm_everdrive_read_ready(void) { return mock_type(u8); @@ -524,6 +529,11 @@ void __wrap_comm_everdrive_pro_init(void) { } +bool __wrap_comm_everdrive_pro_is_present(void) +{ + return mock_type(bool); +} + u8 __wrap_comm_everdrive_pro_read_ready(void) { return mock_type(u8); @@ -548,6 +558,11 @@ void __wrap_comm_demo_init(void) { } +bool __wrap_comm_demo_is_present(void) +{ + return mock_type(bool); +} + u8 __wrap_comm_demo_read_ready(void) { return mock_type(u8); @@ -572,6 +587,31 @@ void __wrap_comm_demo_vsync(void) function_called(); } +bool __wrap_comm_megawifi_is_present(void) +{ + return mock_type(bool); +} + +u8 __wrap_comm_megawifi_read_ready(void) +{ + return mock_type(u8); +} + +u8 __wrap_comm_megawifi_read(void) +{ + return mock_type(u8); +} + +u8 __wrap_comm_megawifi_write_ready(void) +{ + return mock_type(u8); +} + +void __wrap_comm_megawifi_write(u8 data) +{ + check_expected(data); +} + void __wrap_SPR_setAnim(Sprite* sprite, s16 anim) { } @@ -612,6 +652,11 @@ void __wrap_comm_serial_init(void) { } +bool __wrap_comm_serial_is_present(void) +{ + return mock_type(bool); +} + u8 __wrap_comm_serial_read_ready(void) { return mock_type(u8); diff --git a/tests/wraps.h b/tests/wraps.h index c5c52b9..4bc7c5e 100644 --- a/tests/wraps.h +++ b/tests/wraps.h @@ -85,21 +85,25 @@ bool __wrap_comm_read_ready(void); u8 __wrap_comm_read(void); void __wrap_comm_write(u8 data); void __wrap_comm_serial_init(void); +bool __wrap_comm_serial_is_present(void); u8 __wrap_comm_serial_read_ready(void); u8 __wrap_comm_serial_read(void); u8 __wrap_comm_serial_write_ready(void); void __wrap_comm_serial_write(u8 data); void __wrap_comm_everdrive_init(void); +bool __wrap_comm_everdrive_is_present(void); u8 __wrap_comm_everdrive_read_ready(void); u8 __wrap_comm_everdrive_read(void); u8 __wrap_comm_everdrive_write_ready(void); void __wrap_comm_everdrive_write(u8 data); void __wrap_comm_everdrive_pro_init(void); +bool __wrap_comm_everdrive_pro_is_present(void); u8 __wrap_comm_everdrive_pro_read_ready(void); u8 __wrap_comm_everdrive_pro_read(void); u8 __wrap_comm_everdrive_pro_write_ready(void); void __wrap_comm_everdrive_pro_write(u8 data); void __wrap_comm_demo_init(void); +bool __wrap_comm_demo_is_present(void); u8 __wrap_comm_demo_read_ready(void); u8 __wrap_comm_demo_read(void); u8 __wrap_comm_demo_write_ready(void); @@ -109,21 +113,33 @@ void __wrap_comm_megawifi_init(void); void __wrap_comm_megawifi_midiEmitCallback(u8 midiByte); void __wrap_comm_megawifi_tick(void); void __wrap_comm_megawifi_send(u8 ch, char* data, u16 len); -extern bool __real_comm_read_ready(void); -extern void __real_comm_init(void); -extern void __real_comm_write(u8 data); -extern u8 __real_comm_read(void); -extern u16 __real_comm_idle_count(void); -extern u16 __real_comm_busy_count(void); -extern void __real_comm_reset_counts(void); +bool __wrap_comm_megawifi_is_present(void); +u8 __wrap_comm_megawifi_read_ready(void); +u8 __wrap_comm_megawifi_read(void); +u8 __wrap_comm_megawifi_write_ready(void); +void __wrap_comm_megawifi_write(u8 data); + extern void __real_comm_megawifi_midiEmitCallback(u8 midiByte); +extern void __real_comm_megawifi_init(void); +extern bool __real_comm_read_ready(void); extern void __real_comm_demo_init(void); extern u8 __real_comm_demo_read_ready(void); extern u8 __real_comm_demo_read(void); extern u8 __real_comm_demo_write_ready(void); extern void __real_comm_demo_write(u8 data); extern void __real_comm_demo_vsync(void); -extern void __real_comm_megawifi_init(void); +extern bool __real_comm_megawifi_is_present(void); +extern u8 __real_comm_megawifi_read_ready(void); +extern u8 __real_comm_megawifi_read(void); +extern u8 __real_comm_megawifi_write_ready(void); +extern void __real_comm_megawifi_write(u8 data); + +extern void __real_comm_init(void); +extern void __real_comm_write(u8 data); +extern u8 __real_comm_read(void); +extern u16 __real_comm_idle_count(void); +extern u16 __real_comm_busy_count(void); +extern void __real_comm_reset_counts(void); void __wrap_psg_note_on(u8 channel, u16 freq); void __wrap_psg_note_off(u8 channel);