Exemple #1
0
/**
* @testcase         itc_systemio_iotbus_uart_write_read_flush_read_p
* @brief            perform write, read, flush, and read data operations over uart bus
* @scenario         perform write, read, flush, and read data operations over uart bus
* @apicovered       iotbus_uart_write, iotbus_uart_read, iotbus_uart_flush
* @precondition     initializes uart_context
* @postcondition    closes uart_context
*/
static void itc_systemio_iotbus_uart_write_read_flush_read_p(void)
{
	int ret = IOTBUS_ERROR_NONE;
	char sz_input_text[BUF_LEN] = "UART READ/WRITE ITC TESTING!";
	char sz_output_text[BUF_LEN];

	iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);

	ret = iotbus_uart_write(h_uart, sz_input_text, sizeof(sz_input_text));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_write", ret < 0, false, iotbus_uart_stop(h_uart));

	usleep(MICROSECOND);

	ret = iotbus_uart_read(h_uart, sz_output_text, sizeof(sz_output_text));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_read", ret < 0, false, iotbus_uart_stop(h_uart));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_read", strcmp(sz_input_text, sz_output_text), 0, iotbus_uart_stop(h_uart));

	ret = iotbus_uart_flush(h_uart);
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_flush", ret, IOTBUS_ERROR_NONE, iotbus_uart_stop(h_uart));

	ret = iotbus_uart_read(h_uart, sz_output_text, sizeof(sz_output_text));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_read", ret == 0, true, iotbus_uart_stop(h_uart));

	ret = iotbus_uart_stop(h_uart);
	TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);

	TC_SUCCESS_RESULT();
}
Exemple #2
0
/**
* @testcase         itc_systemio_iotbus_uart_set_mode_flush_write_read_p
* @brief            To check flush/write/read operation with different parity
* @scenario         uart flush/write/read operation with different parity
* @apicovered       iotbus_uart_set_mode, iotbus_uart_write, iotbus_uart_read, iotbus_uart_flush
* @precondition     initializes uart_context
* @postcondition    closes uart_context
*/
static void itc_systemio_iotbus_uart_set_mode_flush_write_read_p(void)
{
	int i_bytesize = 8;
	int i_stop_bits = 1;
	int ret = IOTBUS_ERROR_NONE;
	char sz_input_text[BUF_LEN] = "UART READ/WRITE ITC TESTING!";
	char sz_output_text[BUF_LEN];
	int mode[] = { IOTBUS_UART_PARITY_NONE, IOTBUS_UART_PARITY_EVEN, IOTBUS_UART_PARITY_ODD };
	char *mode_str[3] = { "IOTBUS_UART_PARITY_NONE", "IOTBUS_UART_PARITY_EVEN", "IOTBUS_UART_PARITY_ODD" };
	int i_modes = sizeof(mode) / sizeof(int);
	int index = 0;
	int count_fail_mode = 0;
	int count_fail_write = 0;
	int count_fail_read = 0;
	int count_fail_flush = 0;

	iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);

	for (index = 0; index < i_modes; index++) {
		ret = iotbus_uart_set_mode(h_uart, i_bytesize, mode[index], i_stop_bits);
		if ((ret != IOTBUS_ERROR_NONE)) {
			SYSIO_ITC_PRINT("iotbus_uart_set_mode failed with PARITY ::%s, stop_bits::%d\n", mode_str[index], i_stop_bits);
			count_fail_mode++;
			continue;
		}

		ret = iotbus_uart_flush(h_uart);
		if ((ret != IOTBUS_ERROR_NONE)) {
			SYSIO_ITC_PRINT("iotbus_uart_flush failed with PARITY ::%s, stop_bits::%d\n", mode_str[index], i_stop_bits);
			count_fail_flush++;
			continue;
		}

		ret = iotbus_uart_write(h_uart, sz_input_text, sizeof(sz_input_text));
		if ((ret < 0)) {
			SYSIO_ITC_PRINT("iotbus_uart_write failed with PARITY ::%s, stop_bits::%d\n", mode_str[index], i_stop_bits);
			count_fail_write++;
			continue;
		}

		usleep(MICROSECOND);

		ret = iotbus_uart_read(h_uart, sz_output_text, sizeof(sz_output_text));
		if ((ret < 0) || (strcmp(sz_input_text, sz_output_text) != 0)) {
			SYSIO_ITC_PRINT("iotbus_uart_read failed with PARITY ::%s, stop_bits::%d\n", mode_str[index], i_stop_bits);
			count_fail_read++;
		}
	}

	TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_mode failed count", count_fail_mode, 0, iotbus_uart_stop(h_uart));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_flush failed count", count_fail_flush, 0, iotbus_uart_stop(h_uart));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_write failed count", count_fail_write, 0, iotbus_uart_stop(h_uart));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_read failed count", count_fail_read, 0, iotbus_uart_stop(h_uart));

	ret = iotbus_uart_stop(h_uart);
	TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);

	TC_SUCCESS_RESULT();
}
Exemple #3
0
/**
* @testcase         itc_systemio_iotbus_uart_set_flow_write_flush_read_p
* @brief            flush, write, and read data over uart bus with set flow
* @scenario         flush, write, and read data over uart bus with set flow
* @apicovered       iotbus_uart_write, iotbus_uart_read, iotbus_uart_set_flowcontrol, iotbus_uart_flush
* @precondition     initializes uart_context
* @postcondition    closes uart_context
*/
static void itc_systemio_iotbus_uart_set_flow_flush_write_read_p(void)
{
	int i_size = 4;
	int ret = IOTBUS_ERROR_NONE;
	char sz_input_text[BUF_LEN] = "UART READ/WRITE ITC TESTING!";
	char sz_output_text[BUF_LEN];
	int rtscts[4][2] = { {1, 0}, {0, 1}, {1, 1}, {0, 0} };
	int index = 0;
	int count_fail_flowcontrol = 0;
	int count_fail_write = 0;
	int count_fail_read = 0;
	int count_fail_flush = 0;

	iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);

	for (index = 0; index < i_size; index++) {
		ret = iotbus_uart_set_flowcontrol(h_uart, rtscts[index][0], rtscts[index][1]);
		if (ret != IOTBUS_ERROR_NONE) {
			SYSIO_ITC_PRINT("iotbus_uart_set_flowcontrol failed with xonxoff ::%d, rtscts::%d\n", rtscts[index][0], rtscts[index][1]);
			count_fail_flowcontrol++;
			continue;
		}

		ret = iotbus_uart_flush(h_uart);
		if (ret != IOTBUS_ERROR_NONE) {
			SYSIO_ITC_PRINT("iotbus_uart_flush failed with xonxoff ::%d, rtscts::%d\n", rtscts[index][0], rtscts[index][1]);
			count_fail_flush++;
			continue;
		}

		ret = iotbus_uart_write(h_uart, sz_input_text, sizeof(sz_input_text));
		if (ret < 0) {
			SYSIO_ITC_PRINT("iotbus_uart_write failed with xonxoff ::%d, rtscts::%d\n", rtscts[index][0], rtscts[index][1]);
			count_fail_write++;
			continue;
		}

		usleep(MICROSECOND);

		ret = iotbus_uart_read(h_uart, sz_output_text, sizeof(sz_output_text));
		if ((ret < 0) || (strcmp(sz_input_text, sz_output_text) != 0)) {
			SYSIO_ITC_PRINT("iotbus_uart_read failed with xonxoff ::%d, rtscts::%d\n", rtscts[index][0], rtscts[index][1]);
			count_fail_read++;
		}
	}

	TC_ASSERT_EQ_CLEANUP("iotbus_uart_flush failed count", count_fail_flush, 0, iotbus_uart_stop(h_uart));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_write failed count", count_fail_write, 0, iotbus_uart_stop(h_uart));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_read failed count", count_fail_read, 0, iotbus_uart_stop(h_uart));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_flowcontrol failed count", count_fail_flowcontrol, 0, iotbus_uart_stop(h_uart));

	ret = iotbus_uart_stop(h_uart);
	TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);

	TC_SUCCESS_RESULT();
}
Exemple #4
0
/**
* @testcase         itc_systemio_iotbus_uart_init_stop_p
* @brief            initializes and closes uart_context
* @scenario         initializes and closes uart_context
* @apicovered       iotbus_uart_init, iotbus_uart_stop
* @precondition     none
* @postcondition    none
*/
void itc_systemio_iotbus_uart_init_stop_p(void)
{
	int ret = IOTBUS_ERROR_NONE;
	iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);

	ret = iotbus_uart_stop(h_uart);
	TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);

	TC_SUCCESS_RESULT();
}
Exemple #5
0
/**
* @testcase         itc_systemio_iotbus_uart_set_mode_p_all
* @brief            sets byte size, parity bit and stop bits (all combinations)
* @scenario         sets byte size, parity bit and stop bits (all combinations)
* @apicovered       iotbus_uart_set_mode
* @precondition     initializes uart_context
* @postcondition    closes uart_context
*/
static void itc_systemio_iotbus_uart_set_mode_p_all(void)
{
	int i_bytesize = 0;
	int i_max_bytesize = 10;
	int i_stop_bits = 0;
	int i_max_stop_bits = 4;
	int ret = IOTBUS_ERROR_NONE;
	int mode[] = { IOTBUS_UART_PARITY_NONE, IOTBUS_UART_PARITY_EVEN, IOTBUS_UART_PARITY_ODD };
	char mode_str[3][BUF_LEN] = { "IOTBUS_UART_PARITY_NONE", "IOTBUS_UART_PARITY_EVEN", "IOTBUS_UART_PARITY_ODD" };
	int i_modes = sizeof(mode) / sizeof(int);
	int index = 0;
	int count_bytesize_fail = 0;
	int count_stopbit_fail = 0;
	int count_fail = 0;

	iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);

	for (i_bytesize = 0; i_bytesize < i_max_bytesize; ++i_bytesize) {
		for (i_stop_bits = 0; i_stop_bits < i_max_stop_bits; ++i_stop_bits) {
			for (index = 0; index < i_modes; index++) {
				ret = iotbus_uart_set_mode(h_uart, i_bytesize, mode[index], i_stop_bits);
				if (i_stop_bits < 1 || i_stop_bits > 2) {
					//checking for invalid parameters (stopbits)
					if (ret != IOTBUS_ERROR_INVALID_PARAMETER) {
						SYSIO_ITC_PRINT("iotbus_uart_set_mode failed for stopbits ::%d\n", i_stop_bits);
						count_stopbit_fail++;
					}
				} else if (i_bytesize < 5 || i_bytesize > 8) {
					//checking with invalid parameters (bytessize)
					if (ret != IOTBUS_ERROR_INVALID_PARAMETER) {
						SYSIO_ITC_PRINT("iotbus_uart_set_mode failed for bytesize ::%d\n", i_bytesize);
						count_bytesize_fail++;
					}
				} else {
					//checking with valid parameters
					if (ret != IOTBUS_ERROR_NONE) {
						SYSIO_ITC_PRINT("iotbus_uart_set_mode failed UART_PARITY::%s, bytesize::%d, stopbits::%d \n", mode_str[index], i_bytesize, i_stop_bits);
						count_fail++;
					}
				}
			}
		}
	}
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_mode fail_count with bytesize", count_bytesize_fail, 0, iotbus_uart_stop(h_uart));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_mode fail_count with stopbit", count_stopbit_fail, 0, iotbus_uart_stop(h_uart));
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_mode fail_count", count_fail, 0, iotbus_uart_stop(h_uart));

	ret = iotbus_uart_stop(h_uart);
	TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);

	TC_SUCCESS_RESULT();
}
Exemple #6
0
/**
* @testcase         itc_systemio_iotbus_uart_init_stop_p_multi_handle
* @brief            initializes and closes uart_context
* @scenario         initializes and closes uart_context
* @apicovered       iotbus_uart_init, iotbus_uart_stop
* @precondition     none
* @postcondition    none
*/
static void itc_systemio_iotbus_uart_init_stop_p_multi_handle(void)
{
	int ret = IOTBUS_ERROR_NONE;

	iotbus_uart_context_h h_uart1 = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ("iotbus_uart_init1", h_uart1, NULL);

	iotbus_uart_context_h h_uart2 = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ_CLEANUP("iotbus_uart_init2", h_uart2, NULL, iotbus_uart_stop(h_uart1));

	iotbus_uart_context_h h_uart3 = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ_CLEANUP("iotbus_uart_init3", h_uart3, NULL, iotbus_uart_stop(h_uart2); iotbus_uart_stop(h_uart1));

	ret = iotbus_uart_stop(h_uart3);
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_stop3", ret, IOTBUS_ERROR_NONE, iotbus_uart_stop(h_uart2); iotbus_uart_stop(h_uart1));

	ret = iotbus_uart_stop(h_uart2);
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_stop2", ret, IOTBUS_ERROR_NONE, iotbus_uart_stop(h_uart1));

	ret = iotbus_uart_stop(h_uart1);
	TC_ASSERT_EQ("iotbus_uart_stop1", ret, IOTBUS_ERROR_NONE);

	TC_SUCCESS_RESULT();
}
Exemple #7
0
/**
* @testcase         itc_systemio_iotbus_uart_set_baudrate_p
* @brief            sets uart baud rate
* @scenario         sets uart baud rate
* @apicovered       iotbus_uart_set_baudrate
* @precondition     initializes uart_context
* @postcondition    closes uart_context
*/
void itc_systemio_iotbus_uart_set_baudrate_p(void)
{
	int i_baudrate = 115200;
	int ret = IOTBUS_ERROR_NONE;
	iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);

	ret = iotbus_uart_set_baudrate(h_uart, i_baudrate);
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_baudrate", ret, IOTBUS_ERROR_NONE, iotbus_uart_stop(h_uart));

	ret = iotbus_uart_stop(h_uart);
	TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);

	TC_SUCCESS_RESULT();;
}
Exemple #8
0
/**
* @testcase         itc_systemio_iotbus_uart_set_baudrate_n
* @brief            sets uart baud rate
* @scenario         sets uart baud rate
* @apicovered       iotbus_uart_set_baudrate
* @precondition     initializes uart_context
* @postcondition    closes uart_context
*/
static void itc_systemio_iotbus_uart_set_baudrate_n(void)
{
	int i_baudrate = -115200; // invalid baudrate
	int ret = IOTBUS_ERROR_NONE;

	iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);

	ret = iotbus_uart_set_baudrate(h_uart, i_baudrate);
	TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_baudrate", ret, IOTBUS_ERROR_INVALID_PARAMETER, iotbus_uart_stop(h_uart));

	ret = iotbus_uart_stop(h_uart);
	TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);

	TC_SUCCESS_RESULT();
}
Exemple #9
0
/**
* @testcase         itc_systemio_iotbus_uart_set_flowcontrol_p
* @brief            set flow control settings
* @scenario         set flow control settings
* @apicovered       iotbus_uart_set_flowcontrol
* @precondition     initializes uart_context
* @postcondition    closes uart_context
*/
void itc_systemio_iotbus_uart_set_flowcontrol_p(void)
{
	int i_size = 4;
	int ret = IOTBUS_ERROR_NONE;
	int rtscts[4][2] = { {1, 0}, {0, 1}, {1, 1}, {0, 0} };
	int index = 0;
	iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);

	for (index = 0; index < i_size; index++) {
		ret = iotbus_uart_set_flowcontrol(h_uart, rtscts[index][0], rtscts[index][1]);
		TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_flowcontrol", ret, IOTBUS_ERROR_NONE, iotbus_uart_stop(h_uart));
	}

	ret = iotbus_uart_stop(h_uart);
	TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);

	TC_SUCCESS_RESULT();
}
Exemple #10
0
/**
* @testcase         itc_systemio_iotbus_uart_set_mode_p
* @brief            sets byte size, parity bit and stop bits
* @scenario         sets byte size, parity bit and stop bits
* @apicovered       iotbus_uart_set_mode
* @precondition     initializes uart_context
* @postcondition    closes uart_context
*/
void itc_systemio_iotbus_uart_set_mode_p(void)
{
	int i_bytesize = 8;
	int i_stop_bits = 1;
	int ret = IOTBUS_ERROR_NONE;
	int mode[] = { IOTBUS_UART_PARITY_NONE, IOTBUS_UART_PARITY_EVEN, IOTBUS_UART_PARITY_ODD };
	int i_modes = sizeof(mode) / sizeof(int);
	int index = 0;
	iotbus_uart_context_h h_uart = iotbus_uart_init(DEVPATH);
	TC_ASSERT_NEQ("iotbus_uart_init", h_uart, NULL);

	for (index = 0; index < i_modes; index++) {
		ret = iotbus_uart_set_mode(h_uart, i_bytesize, mode[index], i_stop_bits);
		TC_ASSERT_EQ_CLEANUP("iotbus_uart_set_mode", ret, IOTBUS_ERROR_NONE, iotbus_uart_stop(h_uart));
	}

	ret = iotbus_uart_stop(h_uart);
	TC_ASSERT_EQ("iotbus_uart_stop", ret, IOTBUS_ERROR_NONE);

	TC_SUCCESS_RESULT();
}
Exemple #11
0
/******************************
     UART TEST
 ******************************/
int systemio_test_uart(char *failstr)
{
	int result = SYSIO_RESULT_FAIL;
	int fail_flag = 0;
	iotbus_uart_context_h uart;
	int ret = -1;
	char *dev_path = "/dev/ttyS1";

	uart = iotbus_uart_init(dev_path);
	if (!uart) {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_init() fail \n");
		REGISTER_FAIL_REASON("iotbus_uart_init() fail", &fail_flag);
		goto errout_without_handle;
	} else {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_init() success \n");
	}

	unsigned int baudrate = 115200;
	ret = iotbus_uart_set_baudrate(uart, baudrate);
	if (ret < 0) {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_set_baudrate(baudrate=%d) fail \n", baudrate);
		REGISTER_FAIL_REASON("iotbus_uart_set_baudrate() fail", &fail_flag);
		goto errout_with_handle;
	} else {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_set_baudrate(baudrate=%d) success \n", baudrate);
	}

	ret = iotbus_uart_set_mode(uart, 8, IOTBUS_UART_PARITY_NONE, 1);
	if (ret < 0) {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_set_mode(mode=8N1) fail \n");
		REGISTER_FAIL_REASON("iotbus_uart_set_mode() fail", &fail_flag);
		goto errout_with_handle;
	} else {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_set_mode(mode=8N1) success \n");
	}

	ret = iotbus_uart_set_flowcontrol(uart, 1, 1);
	if (ret < 0) {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_set_flowcontrol(1,1) fail \n");
		REGISTER_FAIL_REASON("iotbus_uart_set_flowcontrol() fail", &fail_flag);
		goto errout_with_handle;
	} else {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_set_flowcontrol(1,1) success \n");
	}

#if 0
	char rbuf[20];
	ret = iotbus_uart_read(uart, rbuf, sizeof(rbuf));
	if (ret < 0) {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_read() fail \n");
		REGISTER_FAIL_REASON("iotbus_uart_read() fail", &fail_flag);
		//goto errout_with_handle;
	} else {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_read() success \n");
	}
#endif

	char tbuf[32] = "Go Bears!UART WRITE TEST OK!\n";
	ret = iotbus_uart_write(uart, tbuf, sizeof(tbuf));
	if (ret < 0) {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_write() fail \n");
		//      REGISTER_FAIL_REASON("iotbus_uart_write() fail", &fail_flag);
		//goto errout_with_handle;
	} else {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_write() success \n");
	}

	ret = iotbus_uart_flush(uart);
	if (ret < 0) {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_flush() fail \n");
		//      REGISTER_FAIL_REASON("iotbus_uart_flush() fail", &fail_flag);
		//goto errout_with_handle;
	} else {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_flush() success \n");
	}

errout_with_handle:
	ret = iotbus_uart_stop(uart);
	if (ret < 0) {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_stop() fail \n");
		REGISTER_FAIL_REASON("iotbus_uart_stop() fail", &fail_flag);
	} else {
		SYSIO_DEBUG("[IOTAPI] iotbus_uart_stop() success \n");
	}

errout_without_handle:
	/* check if succeed */
	if (fail_flag == 0) {
		result = SYSIO_RESULT_SUCCESS;
	}
	return result;
}