Make InterruptIn test much more sophisticated

Author: multiplemonomials

CI-Shield-Tests/CMakeLists.txt

@@ -44,10 +44,14 @@ mbed_greentea_add_test(
 	HOST_TESTS_DIR host_tests
 )
 
+if(NOT "DEVICE_I2CSLAVE=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(I2C_SLAVE_TEST_SKIPPED "No I2C slave support")
+endif()
 mbed_greentea_add_test(
     TEST_NAME testshield-i2c-slave-comms
     TEST_SOURCES I2CSlaveCommsTest.cpp
 	HOST_TESTS_DIR host_tests
+    TEST_SKIPPED ${I2C_SLAVE_TEST_SKIPPED}
 )
 
 mbed_greentea_add_test(
@@ -70,10 +74,14 @@ mbed_greentea_add_test(
 	HOST_TESTS_DIR host_tests
 )
 
+if(NOT "DEVICE_SPISLAVE=1" IN_LIST MBED_TARGET_DEFINITIONS)
+	set(SPI_SLAVE_TEST_SKIPPED "No SPI slave support")
+endif()
 mbed_greentea_add_test(
 	TEST_NAME testshield-spi-slave-comms
 	TEST_SOURCES SPISlaveCommsTest.cpp
 	HOST_TESTS_DIR host_tests
+    TEST_SKIPPED ${SPI_SLAVE_TEST_SKIPPED}
 )
 
 mbed_greentea_add_test(

CI-Shield-Tests/InterruptInTest.cpp

@@ -23,61 +23,130 @@
 #include "unity.h"
 #include "utest.h"
 #include "ci_test_common.h"
-//#include "rtos.h"
+
+#include <atomic>
+#include <cinttypes>
 
 using namespace utest::v1;
 
-volatile bool result = false;
+std::atomic<uint32_t> callbackCounts;
 
 // Callback for all InterruptInput functions
 void cbfn(void)
 {
-	result = true;
+	++callbackCounts;
 }
 
 // Template to check Falling edge and Rising edge interrupts.
 template <PinName int_pin, PinName dout_pin>
 void InterruptInTest()
 {
-	result = false;
+	callbackCounts = 0;
 	InterruptIn intin(int_pin);
-	DigitalOut dout(dout_pin);
+	DigitalOut dout(dout_pin, 0);
 
 	// Test Rising Edge InterruptIn
 	DEBUG_PRINTF("***** Rising Edge Test \n");
-	dout = 0;
-	result = false;
 	intin.rise(cbfn);
 	dout = 1;
 	wait_us(GPIO_PROPAGATION_TIME);
-	DEBUG_PRINTF("Value of result is : %d\n",result);
-	TEST_ASSERT_MESSAGE(result,"cbfn was not triggered on rising edge of pin");
-
-	result = false;
+	DEBUG_PRINTF("Value of callbackCounts is: %" PRIu32 "\n", callbackCounts.load());
+	TEST_ASSERT_MESSAGE(callbackCounts == 1, "cbfn was not triggered on rising edge of pin");
 
 	// Check that callback is not triggered again
 	for(size_t checkCounter = 0; checkCounter < 10; ++checkCounter)
 	{
-		TEST_ASSERT_MESSAGE(!result, "Interrupt was triggered again!")
+		TEST_ASSERT_MESSAGE(callbackCounts == 1, "Interrupt was triggered again!")
 	}
 
+	dout = 0;
+	wait_us(GPIO_PROPAGATION_TIME);
+	TEST_ASSERT_MESSAGE(callbackCounts == 1, "cbfn was triggered on falling edge of pin");
+	
+	// Clear rising edge interrupt
+	intin.rise(nullptr);
+
 	// Test Falling Edge InterruptIn
 	DEBUG_PRINTF("***** Falling Edge Test \n");
 	dout = 1;
-	result = false;
+	callbackCounts = 0;
 	intin.fall(cbfn);
 	dout = 0;
     wait_us(GPIO_PROPAGATION_TIME);
-	DEBUG_PRINTF("Value of result is : %d\n",result);
-	TEST_ASSERT_MESSAGE(result,"cbfn was not triggered on falling edge of pin");
-
-	result = false;
+	DEBUG_PRINTF("Value of callbackCounts is: %" PRIu32 "\n", callbackCounts.load());
+	TEST_ASSERT_MESSAGE(callbackCounts == 1, "cbfn was not triggered on falling edge of pin");
 
 	// Check that callback is not triggered again
 	for(size_t checkCounter = 0; checkCounter < 10; ++checkCounter)
 	{
-		TEST_ASSERT_MESSAGE(!result, "Interrupt was triggered again!")
+		TEST_ASSERT_MESSAGE(callbackCounts == 1, "Interrupt was triggered again!")
 	}
+
+	dout = 1;
+	wait_us(GPIO_PROPAGATION_TIME);
+	TEST_ASSERT_MESSAGE(callbackCounts == 1, "cbfn was triggered on rising edge of pin");
+
+	// Clear falling edge interrupt
+	intin.fall(nullptr);
+}
+
+// Test that a rising and falling edge callback can both be set at the same time,
+// and the correct one will be executed depending on the edge type
+template <PinName int_pin, PinName dout_pin>
+void InterruptInBothEdgesTest()
+{
+	std::atomic<bool> gotRisingEdge = false;
+	std::atomic<bool> gotFallingEdge = false;
+
+	auto risingEdgeLambda = [&](){ gotRisingEdge = true; };
+	auto fallingEdgeLambda = [&](){ gotFallingEdge = true; };
+
+	InterruptIn intin(int_pin);
+	DigitalOut dout(dout_pin, 0);
+
+	intin.fall(fallingEdgeLambda);
+	intin.rise(risingEdgeLambda);
+
+	DEBUG_PRINTF("***** Rising Edge Test \n");
+	dout = 1;
+	wait_us(GPIO_PROPAGATION_TIME);
+
+	TEST_ASSERT_MESSAGE(gotRisingEdge, "rising edge callback was not triggered on rising edge of pin");
+	TEST_ASSERT_MESSAGE(!gotFallingEdge, "falling edge callback was triggered on rising edge of pin!");
+
+	gotRisingEdge = false;
+
+	DEBUG_PRINTF("***** Falling Edge Test \n");
+	dout = 0;
+	wait_us(GPIO_PROPAGATION_TIME);
+
+	TEST_ASSERT_MESSAGE(gotFallingEdge, "falling edge callback was not triggered on falling edge of pin");
+	TEST_ASSERT_MESSAGE(!gotRisingEdge, "rising edge callback was triggered on falling edge of pin!");
+}
+
+template <PinName int_pin, PinName dout_pin>
+void InterruptInReadValueTest()
+{
+	InterruptIn intin(int_pin);
+	DigitalOut dout(dout_pin, 0);
+
+	dout = 1;
+	wait_us(GPIO_PROPAGATION_TIME);
+	TEST_ASSERT_MESSAGE(intin.read(), "InterruptIn read failed with no callback!");
+
+	dout = 0;
+	wait_us(GPIO_PROPAGATION_TIME);
+	TEST_ASSERT_MESSAGE(!intin.read(), "InterruptIn read failed with no callback!");
+
+	intin.rise(cbfn);
+
+	dout = 1;
+	wait_us(GPIO_PROPAGATION_TIME);
+	TEST_ASSERT_MESSAGE(intin.read(), "InterruptIn read failed with callback!");
+
+	dout = 0;
+	wait_us(GPIO_PROPAGATION_TIME);
+	TEST_ASSERT_MESSAGE(!intin.read(), "InterruptIn read failed with callback!");
 }
 
 utest::v1::status_t test_setup(const size_t number_of_cases)
@@ -102,12 +171,15 @@ utest::v1::status_t greentea_failure_handler(const Case *const source, const fai
 
 // Test cases
 Case cases[] = {
-		Case("Interrupt from GPOUT_2 -> GPIN_2", InterruptInTest<PIN_GPIN_2,PIN_GPOUT_2>,greentea_failure_handler),
-		Case("Interrupt from GPIN_2 -> GPOUT_2", InterruptInTest<PIN_GPOUT_2,PIN_GPIN_2>,greentea_failure_handler),
-		Case("Interrupt from GPOUT_1 -> GPIN_1", InterruptInTest<PIN_GPIN_1,PIN_GPOUT_1_PWM>,greentea_failure_handler),
+		// Case("Interrupt from GPOUT_2 -> GPIN_2", InterruptInTest<PIN_GPIN_2,PIN_GPOUT_2>,greentea_failure_handler),
+		// Case("Interrupt from GPIN_2 -> GPOUT_2", InterruptInTest<PIN_GPOUT_2,PIN_GPIN_2>,greentea_failure_handler),
+		// Case("Interrupt from GPOUT_1 -> GPIN_1", InterruptInTest<PIN_GPIN_1,PIN_GPOUT_1_PWM>,greentea_failure_handler),
 		Case("Interrupt from GPIN_1 -> GPOUT_1", InterruptInTest<PIN_GPOUT_1_PWM,PIN_GPIN_1>,greentea_failure_handler),
-		Case("Interrupt from GPOUT_0 -> GPIN_0", InterruptInTest<PIN_GPIN_0,PIN_GPOUT_0>,greentea_failure_handler),
-		Case("Interrupt from GPIN_0 -> GPOUT_0", InterruptInTest<PIN_GPOUT_0,PIN_GPIN_0>,greentea_failure_handler),
+		// Case("Interrupt from GPOUT_0 -> GPIN_0", InterruptInTest<PIN_GPIN_0,PIN_GPOUT_0>,greentea_failure_handler),
+		// Case("Interrupt from GPIN_0 -> GPOUT_0", InterruptInTest<PIN_GPOUT_0,PIN_GPIN_0>,greentea_failure_handler),
+
+		Case("InterruptIn Both Edges", InterruptInBothEdgesTest<PIN_GPIN_0,PIN_GPOUT_0>, greentea_failure_handler),
+		Case("InterruptIn Read Value", InterruptInReadValueTest<PIN_GPIN_0,PIN_GPOUT_0>, greentea_failure_handler),
 };
 
 Specification specification(test_setup, cases);

CI-Shield-Tests/PWMAndADCTest.cpp

@@ -73,9 +73,7 @@ std::pair<float, float> read_freq_and_duty_cycle_via_host_test()
 }
 
 /*
- * Generate a failure if the HAL does not provide the new DEVICE_SPI_COUNT /
- * spi_get_peripheral_name() functionality.
- * See https://github.com/mbed-ce/mbed-os/issues/255 for details.
+ * Generate a failure if this target's JSON does not set the target.default-adc-vref option
  */
 void verify_target_default_adc_vref_set()
 {

CI-Shield-Tests/SPIBasicTest.cpp

@@ -145,7 +145,7 @@ void host_assert_standard_message()
 void verify_spi_get_peripheral_name_exists()
 {
 #ifndef DEVICE_SPI_COUNT
-    TEST_FAIL_MESSAGE("HAL should provide DEVICE_SPI_COUNT and spi_get_peripheral_name()")
+    TEST_FAIL_MESSAGE("HAL should provide DEVICE_SPI_COUNT and spi_get_peripheral_name()");
 #endif
 }
 
@@ -172,7 +172,7 @@ void write_single_word_uint8()
  */
 void write_single_word_uint16()
 {
-    TEST_SKIP_UNLESS(supportsThisWordSize<uint16_t>());
+    TEST_SKIP_UNLESS_MESSAGE(supportsThisWordSize<uint16_t>(), "16-bit SPI words not supported");
 
     host_start_spi_logging();
 
@@ -467,6 +467,11 @@ void async_queue_and_abort()
     // Allow the second transfer to run to completion
     rtos::ThisThread::sleep_for(10ms);
 
+    // The first transfer should have delivered no flags.
+    // The second transfer should have delivered a completion flag.
+    TEST_ASSERT_EQUAL(0, callbackEvent1);
+    TEST_ASSERT_EQUAL(SPI_EVENT_COMPLETE, callbackEvent2);
+
     // The first transfer should have been canceled after writing at least one byte but before filling the entire Rx buffer
     size_t testPatternCountBuf1 = std::count(logMessageRxData1.begin(), logMessageRxData1.end(), TEST_PATTERN);
     // Depending on DMA behavior, some or none of the bytes may have been written back to the buffer.
@@ -477,10 +482,6 @@ void async_queue_and_abort()
     size_t testPatternCountBuf2 = std::count(logMessageRxData2.begin(), logMessageRxData2.end(), TEST_PATTERN);
     TEST_ASSERT_EQUAL(0, testPatternCountBuf2);
 
-    // The first transfer should have delivered no flags.
-    // The second transfer should have delivered a completion flag.
-    TEST_ASSERT_EQUAL(0, callbackEvent1);
-    TEST_ASSERT_EQUAL(SPI_EVENT_COMPLETE, callbackEvent2);
 
     greentea_send_kv("verify_queue_and_abort_test", "please");
     assert_next_message_from_host("verify_queue_and_abort_test", "pass");

CI-Shield-Tests/SPIMicroSDTest.cpp

@@ -199,7 +199,11 @@ void test_sd_file()
     // sizeof(SD_TEST_STRING) - 1 chars.
 	char read_string[SD_TEST_STRING_MAX] = {0};
     file = fopen("/sd/test_sd_w.txt", "r");
-	TEST_ASSERT_MESSAGE(file != nullptr,"Failed to open file");
+    if(!file)
+    {
+        TEST_FAIL_MESSAGE("Failed to open file");
+        return;
+    }
 
 	ret = fread(read_string, sizeof(char), sizeof(SD_TEST_STRING) - 1, file);
 	TEST_ASSERT_MESSAGE(ret == (sizeof(SD_TEST_STRING) - 1), "Failed to read data");
@@ -252,12 +256,12 @@ Case cases[] = {
     Case("SPI - Write, Read, and Delete File (100kHz)", test_sd_file<100000, false, DMA_USAGE_NEVER>),
 
 #if DEVICE_SPI_ASYNCH
-    Case("[Async Interrupts] SPI - SD card present (1MHz)", test_card_present<1000000, true, DMA_USAGE_NEVER>),
-    Case("[Async Interrupts] SPI - Mount FS, Create File (1MHz)", mount_fs_create_file<1000000, true, DMA_USAGE_NEVER>),
-    Case("[Async Interrupts] SPI - Write, Read, and Delete File (1MHz)", test_sd_file<1000000, true, DMA_USAGE_NEVER>),
     Case("[Async DMA] SPI - SD card present (1MHz)", test_card_present<1000000, true, DMA_USAGE_ALWAYS>),
     Case("[Async DMA] SPI - Mount FS, Create File (1MHz)", mount_fs_create_file<1000000, true, DMA_USAGE_ALWAYS>),
     Case("[Async DMA] SPI - Write, Read, and Delete File (1MHz)", test_sd_file<1000000, true, DMA_USAGE_ALWAYS>),
+    Case("[Async Interrupts] SPI - SD card present (1MHz)", test_card_present<1000000, true, DMA_USAGE_NEVER>),
+    Case("[Async Interrupts] SPI - Mount FS, Create File (1MHz)", mount_fs_create_file<1000000, true, DMA_USAGE_NEVER>),
+    Case("[Async Interrupts] SPI - Write, Read, and Delete File (1MHz)", test_sd_file<1000000, true, DMA_USAGE_NEVER>),
 #endif
 };
 

CI-Shield-Tests/mbed_app.json5

@@ -5,7 +5,13 @@
             "platform.stdio-buffered-serial": 1,
 			"target.components_add" : ["SD", "I2CEE"],
             "sd.CRC_ENABLED": 1,
-            "drivers.spi_transaction_queue_len": 3
+            "drivers.spi_transaction_queue_len": 3,
+
+            // Don't auto reboot on error, it makes debugging harder
+            "fatal-error-auto-reboot-enabled": false,
+
+            // Emit a KV pair when an assert fail or hardfault occurs
+            "platform.mbed-error-emit-greentea-kv": true,
         },
         "STM32L452xE": {
             // This was added because not using it seemed to cause intermittent