C++ DEFINE_TEST_SUITE函数代码示例

/**
 * \brief Run TRNG driver unit tests.
 */
int main(void)
{
	const usart_serial_options_t usart_serial_options = {
		.baudrate   = CONF_TEST_BAUDRATE,
		.charlength = CONF_TEST_CHARLENGTH,
		.paritytype = CONF_TEST_PARITY,
		.stopbits   = CONF_TEST_STOPBITS
	};

	sysclk_init();
	board_init();

	sysclk_enable_peripheral_clock(CONSOLE_UART_ID);
	stdio_serial_init(CONF_TEST_USART, &usart_serial_options);

	/* Define all the test cases */
	DEFINE_TEST_CASE(trng_test, NULL, run_trng_test, NULL,
			"trng random value generate test");

	/* Put test case addresses in an array */
	DEFINE_TEST_ARRAY(trng_test_array) = {
		&trng_test,};

	/* Define the test suite */
	DEFINE_TEST_SUITE(trng_suite, trng_test_array,
			"trng driver test suite");

	/* Run all tests in the test suite */
	test_suite_run(&trng_suite);

	while (1) {
		/* Busy-wait forever */
	}
}

/**
 * \brief Run unit tests for MT48LC16m16a2tg7 SDRAM
 * \return 0  which should never occur.
 */
int main (void)
{

	const usart_serial_options_t usart_serial_options = {
		.baudrate   = CONF_TEST_BAUDRATE,
		.charlength = CONF_TEST_CHARLENGTH,
		.paritytype = CONF_TEST_PARITY,
		.stopbits   = CONF_TEST_STOPBITS,
	};
	sysclk_init();
	board_init();
	stdio_serial_init(CONF_TEST_USART, &usart_serial_options);
	sdramc_init(sysclk_get_cpu_hz());

	// Define all the test cases
	DEFINE_TEST_CASE(data_integrity_test, NULL, run_data_integrity_test,
			NULL, "Data integrity test");

	// Put test case addresses in an array
	DEFINE_TEST_ARRAY(ebi_sdram_tests) = {
		&data_integrity_test,
	};

	// Define the test suite
	DEFINE_TEST_SUITE(ebi_sdram_suite, ebi_sdram_tests,
			"UC3 EBI driver w/ SDRAM test suite");

	// Set up the test data pointer and run all tests in the suite
	test_set_data(&params);
	test_suite_run(&ebi_sdram_suite);

	while (true);

	return (0);
}

/**
 * \brief Run GPBR driver unit tests
 */
int main(void)
{
	const usart_serial_options_t usart_serial_options = {
		.baudrate = CONF_TEST_BAUDRATE,
		.paritytype = CONF_TEST_PARITY
	};

	/* Initialize the system clock and board */
	sysclk_init();
	board_init();

	/* Enable the debug uart */
	sysclk_enable_peripheral_clock(CONSOLE_UART_ID);
	stdio_serial_init(CONF_TEST_USART, &usart_serial_options);

	/* Define all the test cases */
	DEFINE_TEST_CASE(gpbr_test, NULL, run_gpbr_test, NULL,
			"GPBR read/write test");

	/* Put test case addresses in an array */
	DEFINE_TEST_ARRAY(gpbr_tests) = {
	&gpbr_test};

	/* Define the test suite */
	DEFINE_TEST_SUITE(gpbr_suite, gpbr_tests, "SAM GPBR driver test suite");

	/* Run all tests in the test suite */
	test_suite_run(&gpbr_suite);

	while (1) {
		/* Busy-wait forever. */
	}
}

/**
 * \brief Run Sleep Manager unit tests
 *
 * Initializes the clock system, board and serial output, then sets up the
 * Sleep Manager unit test suite and runs it.
 */
int main(void)
{
    const usart_serial_options_t usart_serial_options = {
        .baudrate   = CONF_TEST_BAUDRATE,
        .charlength = CONF_TEST_CHARLENGTH,
        .paritytype = CONF_TEST_PARITY,
        .stopbits   = CONF_TEST_STOPBITS,
    };

    board_init();
    sysclk_init();
    stdio_serial_init(CONF_TEST_USART, &usart_serial_options);

    DEFINE_TEST_CASE(sleep_trigger_test, NULL, run_sleep_trigger_test, NULL,
                     "Test sleep interrupt is getting triggered");
    DEFINE_TEST_CASE(set_functions_test, NULL, run_set_functions_test, NULL,
                     "Test setting of various lock modes");

    /* Put test case addresses in an array */
    DEFINE_TEST_ARRAY(sleep_manager_tests) = {
        &set_functions_test,
        &sleep_trigger_test,
    };

    /* Define the test suite */
    DEFINE_TEST_SUITE(sleep_manager_suite, sleep_manager_tests,
                      "MEGARF SLEEP MANAGER test suite");

    /* Run all tests in the suite */
    test_suite_run(&sleep_manager_suite);

    while (1) {
        /* Intentionally left empty. */
    }
}

void main_cdc_set_dtr(bool b_enable)
{
	if (b_enable) {
		DEFINE_TEST_CASE(nlme_reset_test, NULL, run_nlme_reset_test,
				NULL, "NWK Reset request");
		DEFINE_TEST_CASE(nlme_start_test, NULL, run_nlme_start_test,
				NULL, "NWK Start request");
		DEFINE_TEST_CASE(zid_rec_connect_test, NULL,
				run_zid_rec_connect_test,
				NULL, "Push button pairing Request");

		/* Put test case addresses in an array. */
		DEFINE_TEST_ARRAY(nwk_tests) = {
			&nlme_reset_test,
			&nlme_start_test,
			&zid_rec_connect_test
		};

		/* Define the test suite. */
		DEFINE_TEST_SUITE(nwk_suite, nwk_tests,
				"NWK unit test suite");

		/* Run all tests in the test suite. */
		test_suite_run(&nwk_suite);
	} else {
	}
}

void main_cdc_set_dtr(bool b_enable)
{
	if (b_enable) {
		DEFINE_TEST_CASE(at86rfx_init_test, NULL, run_at86rfx_init_test,
				NULL, "AT86RFx initialization");
		DEFINE_TEST_CASE(at86rfx_reg_access_test, NULL,
				run_at86rfx_reg_access_test, NULL,
				"Read/write AT86RFx register access");
		DEFINE_TEST_CASE(at86rfx_tx_test, NULL, run_at86rfx_tx_test,
				NULL, "AT86RFx frame transmission");

		// Put test case addresses in an array.
		DEFINE_TEST_ARRAY(at86rfx_tests) = {
		&at86rfx_init_test,
					&at86rfx_reg_access_test,
					&at86rfx_tx_test};

		// Define the test suite.
		DEFINE_TEST_SUITE(at86rfx_suite, at86rfx_tests,
				"AT86RFx component unit test suite");

		// Run all tests in the test suite.
		test_suite_run(&at86rfx_suite);
	} else {

	}
}

/**
 * \brief Run IOPORT unit tests
 *
 * Initializes the clock system, board and serial output, then sets up the
 * IOPORT Service unit test suite and runs it.
 */
int main(void)
{
	const usart_serial_options_t usart_serial_options = {
		.baudrate   = CONF_TEST_BAUDRATE,
		.charlength = CONF_TEST_CHARLENGTH,
		.paritytype = CONF_TEST_PARITY,
		.stopbits   = CONF_TEST_STOPBITS,
	};

	board_init();
	sysclk_init();
	stdio_serial_init(CONF_TEST_USART, &usart_serial_options);

	DEFINE_TEST_CASE(ioport_port_test, NULL, run_ioport_port_test, NULL,
			"Test setting of various IOPORT functions");
	DEFINE_TEST_CASE(ioport_pin_test, NULL, run_ioport_pin_test, NULL,
			"Test IOPORT pin level is getting changed");

	/* Put test case addresses in an array */
	DEFINE_TEST_ARRAY(ioport_test) = {
		&ioport_port_test,
		&ioport_pin_test,
	};

	/* Define the test suite */
	DEFINE_TEST_SUITE(ioport_suite, ioport_test,
			"MEGARF IOPORT test suite");

	/* Run all tests in the suite */
	test_suite_run(&ioport_suite);

	while (1) {
		/* Intentionally left empty. */
	}
}

/**
 * \brief Run TRNG unit tests
 *
 * Initializes the system and serial output, then sets up the
 * TRNG unit test suite and runs it.
 */
int main(void)
{
	system_init();
	cdc_uart_init();

	/* Define Test Cases */
	DEFINE_TEST_CASE(trng_polling_read_test,
			NULL,
			run_trng_polling_read_test,
			NULL,
			"Testing TRNG polling read");

	DEFINE_TEST_CASE(trng_callback_read_test,
			NULL,
			run_trng_callback_read_test,
			NULL,
			"Testing TRNG callback read");

	/* Put test case addresses in an array */
	DEFINE_TEST_ARRAY(trng_tests) = {
		&trng_polling_read_test,
		&trng_callback_read_test,
	};

	/* Define the test suite */
	DEFINE_TEST_SUITE(trng_test_suite, trng_tests,
			"SAM TRNG driver test suite");

	/* Run all tests in the suite*/
	test_suite_run(&trng_test_suite);

	while (true) {
		/* Intentionally left empty */
	}
}

/**
 * \brief Run TCC unit tests
 *
 * Initializes the system and serial output, then sets up the TCC unit test
 * suite and runs it.
 */
int main(void)
{
	system_init();
	cdc_uart_init();

	/* Define Test Cases */
	DEFINE_TEST_CASE(init_test, NULL,
			run_init_test, NULL,
			"Initialize tcc_xmodules");

	DEFINE_TEST_CASE(basic_functionality_test, NULL,
			run_basic_functionality_test, NULL,
			"test start stop and getters and setters");

	DEFINE_TEST_CASE(callback_test, NULL,
			run_callback_test, NULL,
			"test callback API");

	DEFINE_TEST_CASE(reset_test, NULL,
			run_reset_test, NULL,
			"Setup, reset TCC module");

	DEFINE_TEST_CASE(capture_and_compare_test, NULL,
			run_capture_and_compare_test, NULL,
			"Test capture and compare");

	DEFINE_TEST_CASE(faultx_test, NULL,
			run_faultx_test, NULL,
			"Test Non-Recoverable Fault");

	DEFINE_TEST_CASE(faultn_test, NULL,
			run_faultn_test, NULL,
			"Test Recoverable Fault");

	/* Put test case addresses in an array */
	DEFINE_TEST_ARRAY(tcc_tests) = {
		&init_test,
		&basic_functionality_test,
		&callback_test,
		&reset_test,
		&capture_and_compare_test,
		&faultx_test,
		&faultn_test,
	};

	/* Define the test suite */
	DEFINE_TEST_SUITE(tcc_suite, tcc_tests,
			"SAM D21/R21 TCC driver test suite");

	/* Run all tests in the suite*/
	test_suite_run(&tcc_suite);

	tcc_reset(&tcc_test0_module);
	tcc_reset(&tcc_test1_module);

	while (true) {
		/* Intentionally left empty */
	}
}

/**
 * \brief Run SPI unit tests
 *
 * Initializes the system and serial output, then sets up the
 * SPI unit test suite and runs it.
 */
int main(void)
{
	system_init();
	cdc_uart_init();
	cpu_irq_enable();

	/* Fill the transmit buffers with some data */
	for (uint16_t i = 0; i < BUFFER_LENGTH; i++) {
		tx_buf[i] = i + 1;
		slave_tx_buf[i] = i + 1;
	}

	/* Define Test Cases */
	DEFINE_TEST_CASE(spi_init_test, NULL,
			run_spi_init_test, NULL,
			"Initialization test for SPI master & slave");

	DEFINE_TEST_CASE(single_byte_polled_test, NULL,
			run_single_byte_polled_test, NULL,
			"Transfer single byte and readback by polling");

	DEFINE_TEST_CASE(buffer_polled_write_interrupt_read_test,
			setup_buffer_polled_write_interrupt_read_test,
			run_buffer_polled_write_interrupt_read_test,
			cleanup_buffer_polled_write_interrupt_read_test,
			"Transfer bytes by polling and read back with interrupt");

	DEFINE_TEST_CASE(transceive_buffer_test, NULL,
			run_transceive_buffer_test, NULL,
			"Transmit & receive bytes using transceive functions");

	DEFINE_TEST_CASE(baud_test, NULL, run_baud_test, NULL,
			"Transfer byte at different baud rates");

	DEFINE_TEST_CASE(transfer_9bit_test, setup_transfer_9bit_test,
			run_transfer_9bit_test, NULL,
			"Transfer 9-bit character and readback by polling");

	/* Put test case addresses in an array */
	DEFINE_TEST_ARRAY(spi_tests) = {
		&spi_init_test,
		&single_byte_polled_test,
		&buffer_polled_write_interrupt_read_test,
		&transceive_buffer_test,
		&baud_test,
		&transfer_9bit_test,
	};

	/* Define the test suite */
	DEFINE_TEST_SUITE(spi_test_suite, spi_tests,
			"SAM SPI driver test suite");

	/* Run all tests in the suite*/
	test_suite_run(&spi_test_suite);

	while (true) {
		/* Intentionally left empty */
	}
}

/**
 * \brief Run ADC unit tests
 *
 * Initializes the system and serial output, then sets up the
 * ADC unit test suite and runs it.
 */
int main(void)
{
	system_init();
	delay_init();
	cdc_uart_init();
	test_dac_init();

	/* Define Test Cases */
	DEFINE_TEST_CASE(adc_init_test,
			NULL,
			run_adc_init_test,
			NULL,
			"Testing ADC Initialization");

	DEFINE_TEST_CASE(adc_polled_mode_test,
			NULL,
			run_adc_polled_mode_test,
			NULL,
			"Testing ADC single ended mode by polling");

	DEFINE_TEST_CASE(adc_callback_mode_test,
			setup_adc_callback_mode_test,
			run_adc_callback_mode_test,
			cleanup_adc_callback_mode_test,
			"Testing ADC single ended mode by interrupt");

	DEFINE_TEST_CASE(adc_average_mode_test,
			setup_adc_average_mode_test,
			run_adc_average_mode_test,
			NULL,
			"Testing ADC average mode");

	DEFINE_TEST_CASE(adc_window_mode_test,
			setup_adc_window_mode_test,
			run_adc_window_mode_test,
			cleanup_adc_window_mode_test,
			"Testing ADC window mode");

	/* Put test case addresses in an array */
	DEFINE_TEST_ARRAY(adc_tests) = {
		&adc_init_test,
		&adc_polled_mode_test,
		&adc_callback_mode_test,
		&adc_average_mode_test,
		&adc_window_mode_test,
	};

	/* Define the test suite */
	DEFINE_TEST_SUITE(adc_test_suite, adc_tests,
			"SAM ADC driver test suite");

	/* Run all tests in the suite*/
	test_suite_run(&adc_test_suite);

	while (true) {
		/* Intentionally left empty */
	}
}

/**
 * \brief Run AFEC driver unit tests.
 */
int main(void)
{
	const usart_serial_options_t usart_serial_options = {
		.baudrate   = CONF_TEST_BAUDRATE,
		.paritytype = CONF_TEST_PARITY
	};

	/* Initialize the system clock and board */
	sysclk_init();
	board_init();

	sysclk_enable_peripheral_clock(CONSOLE_UART_ID);
	stdio_serial_init(CONF_TEST_USART, &usart_serial_options);

	afec_enable(AFEC0);

	struct afec_config afec_cfg;

	afec_get_config_defaults(&afec_cfg);
	afec_init(AFEC0, &afec_cfg);

	/*
	 * Because the internal ADC offset is 0x800, it should cancel it and shift
	 * down to 0.
	 */
	afec_channel_set_analog_offset(AFEC0, AFEC_CHANNEL_1, 0x800);

	afec_channel_enable(AFEC0, AFEC_CHANNEL_1);

#if defined(__GNUC__)
	setbuf(stdout, NULL);
#endif

	/* Define all the test cases */
	DEFINE_TEST_CASE(afec_tc_trig_test, NULL, run_afec_tc_trig_test, NULL,
			"AFEC TC Trig test");
	DEFINE_TEST_CASE(afec_comp_test, NULL, run_afec_comp_test,
			NULL, "AFEC Comparison Window test");

	/* Put test case addresses in an array */
	DEFINE_TEST_ARRAY(afec_tests) = {
		&afec_tc_trig_test,
		&afec_comp_test,
	};

	/* Define the test suite */
	DEFINE_TEST_SUITE(afec_suite, afec_tests,
			"SAM AFEC driver test suite");

	/* Run all tests in the test suite */
	test_suite_run(&afec_suite);

	while (1) {
		/* Busy-wait forever. */
	}
}

/**
 * \brief Run WDT unit tests
 *
 * Initializes the system and serial output, then sets up the
 * WDT unit test suite and runs it.
 */
int main(void)
{
	/* Check whether reset cause was Watchdog */
#if (SAML21)
	wdr_flag = (system_get_reset_cause() & RSTC_RCAUSE_WDT);
#else
	wdr_flag = (system_get_reset_cause() & PM_RCAUSE_WDT);
#endif
	system_init();

	/* Reset the Watchdog count */
	wdt_reset_count();

	struct wdt_conf config_wdt;
	/* Get the Watchdog default configuration */
	wdt_get_config_defaults(&config_wdt);
	if(wdr_flag) {
		config_wdt.enable = false;
	}
	/* Set the desired configuration */
#if !(SAML21)
	config_wdt.clock_source         = CONF_WDT_GCLK_GEN;
#endif
	config_wdt.timeout_period       = CONF_WDT_TIMEOUT_PERIOD;
	config_wdt.early_warning_period = CONF_WDT_EARLY_WARNING_PERIOD;
	wdt_set_config(&config_wdt);

	cdc_uart_init();

	DEFINE_TEST_CASE(wdt_early_warning_test, NULL,
			run_wdt_early_warning_test, wait_for_wdt_reset,
			"WDT Early Warning Test");

	DEFINE_TEST_CASE(reset_cause_test, NULL,
			run_reset_cause_test, NULL,
			"Confirming Watchdog Reset");

	/* Put test case addresses in an array */
	DEFINE_TEST_ARRAY(wdt_tests) = {
			&wdt_early_warning_test,
			&reset_cause_test,
			};

	/* Define the test suite */
	DEFINE_TEST_SUITE(wdt_suite, wdt_tests,
			"SAM WDT driver test suite");

	/* Run all tests in the suite*/
	test_suite_run(&wdt_suite);

	while (1) {
		/* Intentionally left empty */
	}

}

/**
 * \brief Run spinner widget unit tests
 */
int main (void)
{
	const usart_serial_options_t usart_serial_options = {
		.baudrate   = CONF_TEST_BAUDRATE,
		.charlength = CONF_TEST_CHARLENGTH,
		.paritytype = CONF_TEST_PARITY,
		.stopbits   = CONF_TEST_STOPBITS,
	};

	sysclk_init();
	board_init();
	gfx_mono_init();

	stdio_serial_init(CONF_TEST_USART, &usart_serial_options);


	// Define all the test cases
	DEFINE_TEST_CASE(single_spinner_spincollection_test, NULL,
			run_single_spinner_spincollection_test, NULL,
			"Single spinners in spincollection test");
	DEFINE_TEST_CASE(two_spinners_spincollection_test, NULL,
			run_two_spinners_spincollection_test, NULL,
			"Two spinners in spincollection test");
	DEFINE_TEST_CASE(three_spinners_spincollection_test, NULL,
			run_three_spinners_spincollection_test, NULL,
			"Three spinners in spincollection test");
	DEFINE_TEST_CASE(cancel_spinner_spincollection_test, NULL,
			run_cancel_spinner_spincollection_test, NULL,
			"Cancel spinner choice test");
	DEFINE_TEST_CASE(event_back_spincollection_test, NULL,
			run_event_back_spincollection_test, NULL,
			"Event back spincollection test");

	// Put test case addresses in an array
	DEFINE_TEST_ARRAY(spinctrl_tests) = {
		&single_spinner_spincollection_test,
		&two_spinners_spincollection_test,
		&three_spinners_spincollection_test,
		&event_back_spincollection_test,
		&cancel_spinner_spincollection_test,
	};

	// Define the test suite
	DEFINE_TEST_SUITE(spinctrl_suite, spinctrl_tests,
			"Spinner widget with test suite");

	// Set up the test data pointer and run all tests in the suite
	test_suite_run(&spinctrl_suite);

	while (1) {
		/* Intentionally left empty. */
	}
}

int main(void)
{
	system_init();
	cdc_uart_init();
	test_at25dfx_init();

	DEFINE_TEST_CASE(check_presence_test, NULL,
			run_check_presence_test, NULL,
			"Testing presence checking");

	DEFINE_TEST_CASE(read_write_buffer_test, NULL,
			run_read_write_buffer_test, NULL,
			"Testing read and write");

	DEFINE_TEST_CASE(erase_test, NULL,
			run_erase_test, NULL,
			"Testing chip erase");

	DEFINE_TEST_CASE(erase_block_test, NULL,
			run_erase_block_test, NULL,
			"Testing block erase");

	DEFINE_TEST_CASE(global_sector_protect_test, NULL,
			run_global_sector_protect_test, NULL,
			"Testing global sector protect setting");

	DEFINE_TEST_CASE(set_get_sector_protect_test, NULL,
			run_set_get_sector_protect_test, NULL,
			"Testing sector protect setting and getting");

	DEFINE_TEST_CASE(sleep_wake_test, NULL,
			run_sleep_wake_test, NULL,
			"Testing sleep and wake");

	DEFINE_TEST_ARRAY(at25dfx_tests) = {
		&check_presence_test,
		&read_write_buffer_test,
		&erase_test,
		&erase_block_test,
		&global_sector_protect_test,
		&set_get_sector_protect_test,
		&sleep_wake_test,
	};

	DEFINE_TEST_SUITE(at25dfx_test_suite, at25dfx_tests,
			"AT25DFx driver test suite");

	test_suite_run(&at25dfx_test_suite);

	while (true) {
		/* Intentionally left empty */
	}
}