change net test order

diff --git a/tests/kds_s2000w_net_tests.c b/tests/kds_s2000w_net_tests.c
index e7134c3ad0231f7282dbcbac162005bcc3ab5960..6d8641956811bc286a3bc75e85c2eea805dc5095 100644 (file)
--- a/tests/kds_s2000w_net_tests.c
+++ b/tests/kds_s2000w_net_tests.c
@@ -7,6 +7,19 @@
 #include "../src/kds_s2000w_net.h"
 #include "../src/kds_s2000w_handler.h"
 
+void kds_s2000w_net_init_test()
+{
+       SANE_Int* version = malloc(sizeof(SANE_Int));
+
+       SANE_Status status = sane_kds_s2000w_net_init(version, NULL);
+
+       assert_int_equal(*version, SANE_VERSION_CODE(1, 0, 28));
+       assert_int_equal(status, SANE_STATUS_GOOD);
+
+       free(version);
+       version = NULL;
+}
+
 void kds_s2000w_net_get_devices_test()
 {
        SANE_Device*** device_list = malloc(sizeof(SANE_Device**));
@@ -22,19 +35,6 @@ void kds_s2000w_net_get_devices_test()
        device_list = NULL;
 }
 
-void kds_s2000w_net_init_test()
-{
-       SANE_Int* version = malloc(sizeof(SANE_Int));
-
-       SANE_Status status = sane_kds_s2000w_net_init(version, NULL);
-
-       assert_int_equal(*version, SANE_VERSION_CODE(1, 0, 28));
-       assert_int_equal(status, SANE_STATUS_GOOD);
-
-       free(version);
-       version = NULL;
-}
-
 void kds_s2000w_net_get_devices_only_remote_test()
 {
        SANE_Device*** device_list = malloc(sizeof(SANE_Device**));
@@ -47,31 +47,161 @@ void kds_s2000w_net_get_devices_only_remote_test()
        device_list = NULL;
 }
 
-void kds_s2000w_net_set_io_mode_test()
+void sane_kds_s2000w_net_get_parameter_color_test()
 {
-       SANE_Status result = sane_kds_s2000w_net_set_io_mode(NULL, SANE_FALSE);
+       handler* h = kds_s2000w_handler_init();
+       const char* config = "{\"Configuration\":{\"ColorMode\":\"Color\"}}";
+       h->current_scanner_config = json_tokener_parse(config);
+       h->image->size = 17;
+       h->image->data = malloc(sizeof(char) * 17);
+       char* image_data = (char*) h->image->data;
+       image_data[0] = 0x50;
+       image_data[1] = 0x36;
+       image_data[2] = 0x0a;
+       image_data[3] = 0x32;
+       image_data[4] = 0x20;
+       image_data[5] = 0x31;
+       image_data[6] = 0x0a;
+       image_data[7] = 0x32;
+       image_data[8] = 0x35;
+       image_data[9] = 0x35;
+       image_data[10] = 0x0a;
+       for (int i = 11; i < 17; i++) {
+               image_data[i] = 0xff;
+       }
 
-       assert_int_equal(result, SANE_STATUS_UNSUPPORTED);
+       SANE_Parameters* params = malloc(sizeof(SANE_Parameters));
+
+       SANE_Status status = sane_kds_s2000w_net_get_parameters(h, params);
+
+       assert_int_equal(status, SANE_STATUS_GOOD);
+       assert_int_equal(params->format, 1);
+       assert_int_equal(params->last_frame, 1);
+       assert_int_equal(params->bytes_per_line, 6);
+       assert_int_equal(params->pixels_per_line, 2);
+       assert_int_equal(params->lines, 1);
+       assert_int_equal(params->depth, 8);
+       assert_int_equal(h->read_info->read_size, 11);
+
+       kds_s2000w_handler_free(h);
+       h = NULL;
+       free(params);
+       params = NULL;
 }
 
-void kds_s2000w_net_get_select_fd_test()
+void sane_kds_s2000w_net_get_parameter_bw_test()
 {
-       SANE_Status result = sane_kds_s2000w_net_get_select_fd(NULL, NULL);
+       handler* h = kds_s2000w_handler_init();
+       const char* config = "{\"Configuration\":{\"ColorMode\":\"Color\"}}";
+       h->current_scanner_config = json_tokener_parse(config);
+       h->image->size = 17;
+       h->image->data = malloc(sizeof(char) * 17);
+       char* image_data = (char*) h->image->data;
+       image_data[0] = 0x50;
+       image_data[1] = 0x34;
+       image_data[2] = 0x0a;
+       image_data[3] = 0x32;
+       image_data[4] = 0x20;
+       image_data[5] = 0x31;
+       image_data[6] = 0x0a;
+       for (int i = 7; i < 17; i++) {
+               image_data[i] = 0xff;
+       }
 
-       assert_int_equal(result, SANE_STATUS_UNSUPPORTED);
+       SANE_Parameters* params = malloc(sizeof(SANE_Parameters));
+
+       SANE_Status status = sane_kds_s2000w_net_get_parameters(h, params);
+
+       assert_int_equal(status, SANE_STATUS_GOOD);
+       assert_int_equal(params->format, 1);
+       assert_int_equal(params->last_frame, 1);
+       assert_int_equal(params->bytes_per_line, 3);
+       assert_int_equal(params->pixels_per_line, 2);
+       assert_int_equal(params->lines, 1);
+       assert_int_equal(params->depth, 1);
+       assert_int_equal(h->read_info->read_size, 7);
+
+       kds_s2000w_handler_free(h);
+       h = NULL;
+       free(params);
+       params = NULL;
 }
 
-void sane_kds_s2000w_net_start_cancel_test()
+void sane_kds_s2000w_net_open_test()
 {
-       handler* h = kds_s2000w_handler_init();
-       h->read_info->cancel = 1;
+       response* resp = kds_s2000w_client_response_init();
+       resp->data = realloc(resp->data, 28);
+       const char* responsedata = "{\"SessionId\":\"1251877821\"}\0";
+       memcpy(resp->data, responsedata, 28);
+       resp->code = 200;
+       resp->size = 28;
+       will_return(mock_response, resp);
+       will_return(__wrap_kds_s2000w_client_open_session, 0);
+       expect_function_call(__wrap_kds_s2000w_client_open_session);
+       void** hlist = malloc(sizeof(void*));
 
-       SANE_Status status = sane_kds_s2000w_net_start(h);
+       SANE_Status status = sane_kds_s2000w_net_open("kds_s2000w_net", hlist);
+       handler* h = (handler*) *hlist;
 
-       assert_int_equal(status, SANE_STATUS_CANCELLED);
+       assert_int_equal(h->sessionid, 1251877821);
+       assert_int_equal(status, SANE_STATUS_GOOD);
 
        kds_s2000w_handler_free(h);
        h = NULL;
+       kds_s2000w_client_response_free(resp);
+       resp = NULL;
+       free(hlist);
+       hlist = NULL;
+}
+
+void sane_kds_s2000w_net_open_busy_device_test()
+{
+       response* resp = kds_s2000w_client_response_init();
+       resp->code = 423;
+       will_return(mock_response, resp);
+       will_return(__wrap_kds_s2000w_client_open_session, 0);
+       expect_function_call(__wrap_kds_s2000w_client_open_session);
+       void** hlist = malloc(sizeof(void*));
+
+       SANE_Status status = sane_kds_s2000w_net_open("kds_s2000w_net", hlist);
+
+       assert_int_equal(status, SANE_STATUS_DEVICE_BUSY);
+
+       kds_s2000w_client_response_free(resp);
+       resp = NULL;
+       free(hlist);
+       hlist = NULL;
+}
+
+void sane_kds_s2000w_net_open_invalid_test()
+{
+       void** hlist = malloc(sizeof(void*));
+
+       SANE_Status status = sane_kds_s2000w_net_open("wrong_device_name", hlist);
+
+       assert_int_equal(status, SANE_STATUS_INVAL);
+
+       free(hlist);
+       hlist = NULL;
+}
+
+void sane_kds_s2000w_net_open_not_connected_test()
+{
+       response* resp = kds_s2000w_client_response_init();
+       resp->code = 0;
+       will_return(mock_response, resp);
+       will_return(__wrap_kds_s2000w_client_open_session, 1);
+       expect_function_call(__wrap_kds_s2000w_client_open_session);
+       void** hlist = malloc(sizeof(void*));
+
+       SANE_Status status = sane_kds_s2000w_net_open("kds_s2000w_net", hlist);
+
+       assert_int_equal(status, SANE_STATUS_IO_ERROR);
+
+       kds_s2000w_client_response_free(resp);
+       resp = NULL;
+       free(hlist);
+       hlist = NULL;
 }
 
 void sane_kds_s2000w_net_start_test(void** state)
@@ -297,86 +427,6 @@ void sane_kds_s2000w_net_start_two_pages_per_feeder_test(void** state)
        h = NULL;
 }
 
-void sane_kds_s2000w_net_get_parameter_color_test()
-{
-       handler* h = kds_s2000w_handler_init();
-       const char* config = "{\"Configuration\":{\"ColorMode\":\"Color\"}}";
-       h->current_scanner_config = json_tokener_parse(config);
-       h->image->size = 17;
-       h->image->data = malloc(sizeof(char) * 17);
-       char* image_data = (char*) h->image->data;
-       image_data[0] = 0x50;
-       image_data[1] = 0x36;
-       image_data[2] = 0x0a;
-       image_data[3] = 0x32;
-       image_data[4] = 0x20;
-       image_data[5] = 0x31;
-       image_data[6] = 0x0a;
-       image_data[7] = 0x32;
-       image_data[8] = 0x35;
-       image_data[9] = 0x35;
-       image_data[10] = 0x0a;
-       for (int i = 11; i < 17; i++) {
-               image_data[i] = 0xff;
-       }
-
-       SANE_Parameters* params = malloc(sizeof(SANE_Parameters));
-
-       SANE_Status status = sane_kds_s2000w_net_get_parameters(h, params);
-
-       assert_int_equal(status, SANE_STATUS_GOOD);
-       assert_int_equal(params->format, 1);
-       assert_int_equal(params->last_frame, 1);
-       assert_int_equal(params->bytes_per_line, 6);
-       assert_int_equal(params->pixels_per_line, 2);
-       assert_int_equal(params->lines, 1);
-       assert_int_equal(params->depth, 8);
-       assert_int_equal(h->read_info->read_size, 11);
-
-       kds_s2000w_handler_free(h);
-       h = NULL;
-       free(params);
-       params = NULL;
-}
-
-void sane_kds_s2000w_net_get_parameter_bw_test()
-{
-       handler* h = kds_s2000w_handler_init();
-       const char* config = "{\"Configuration\":{\"ColorMode\":\"Color\"}}";
-       h->current_scanner_config = json_tokener_parse(config);
-       h->image->size = 17;
-       h->image->data = malloc(sizeof(char) * 17);
-       char* image_data = (char*) h->image->data;
-       image_data[0] = 0x50;
-       image_data[1] = 0x34;
-       image_data[2] = 0x0a;
-       image_data[3] = 0x32;
-       image_data[4] = 0x20;
-       image_data[5] = 0x31;
-       image_data[6] = 0x0a;
-       for (int i = 7; i < 17; i++) {
-               image_data[i] = 0xff;
-       }
-
-       SANE_Parameters* params = malloc(sizeof(SANE_Parameters));
-
-       SANE_Status status = sane_kds_s2000w_net_get_parameters(h, params);
-
-       assert_int_equal(status, SANE_STATUS_GOOD);
-       assert_int_equal(params->format, 1);
-       assert_int_equal(params->last_frame, 1);
-       assert_int_equal(params->bytes_per_line, 3);
-       assert_int_equal(params->pixels_per_line, 2);
-       assert_int_equal(params->lines, 1);
-       assert_int_equal(params->depth, 1);
-       assert_int_equal(h->read_info->read_size, 7);
-
-       kds_s2000w_handler_free(h);
-       h = NULL;
-       free(params);
-       params = NULL;
-}
-
 void sane_kds_s2000w_net_cancel_test()
 {
        response* resp_status = kds_s2000w_client_response_init();
@@ -418,6 +468,19 @@ void sane_kds_s2000w_net_cancel_test()
        h = NULL;
 }
 
+void sane_kds_s2000w_net_cancel_start_test()
+{
+       handler* h = kds_s2000w_handler_init();
+       h->read_info->cancel = 1;
+
+       SANE_Status status = sane_kds_s2000w_net_start(h);
+
+       assert_int_equal(status, SANE_STATUS_CANCELLED);
+
+       kds_s2000w_handler_free(h);
+       h = NULL;
+}
+
 void sane_kds_s2000w_net_cancel_canceled_test()
 {
        response* resp_status = kds_s2000w_client_response_init();
@@ -539,79 +602,16 @@ void sane_kds_s2000w_net_cancel_completed_scan_flatbed_test()
        h = NULL;
 }
 
-void sane_kds_s2000w_net_open_test()
-{
-       response* resp = kds_s2000w_client_response_init();
-       resp->data = realloc(resp->data, 28);
-       const char* responsedata = "{\"SessionId\":\"1251877821\"}\0";
-       memcpy(resp->data, responsedata, 28);
-       resp->code = 200;
-       resp->size = 28;
-       will_return(mock_response, resp);
-       will_return(__wrap_kds_s2000w_client_open_session, 0);
-       expect_function_call(__wrap_kds_s2000w_client_open_session);
-       void** hlist = malloc(sizeof(void*));
-
-       SANE_Status status = sane_kds_s2000w_net_open("kds_s2000w_net", hlist);
-       handler* h = (handler*) *hlist;
-
-       assert_int_equal(h->sessionid, 1251877821);
-       assert_int_equal(status, SANE_STATUS_GOOD);
-
-       kds_s2000w_handler_free(h);
-       h = NULL;
-       kds_s2000w_client_response_free(resp);
-       resp = NULL;
-       free(hlist);
-       hlist = NULL;
-}
-
-void sane_kds_s2000w_net_open_busy_device_test()
-{
-       response* resp = kds_s2000w_client_response_init();
-       resp->code = 423;
-       will_return(mock_response, resp);
-       will_return(__wrap_kds_s2000w_client_open_session, 0);
-       expect_function_call(__wrap_kds_s2000w_client_open_session);
-       void** hlist = malloc(sizeof(void*));
-
-       SANE_Status status = sane_kds_s2000w_net_open("kds_s2000w_net", hlist);
-
-       assert_int_equal(status, SANE_STATUS_DEVICE_BUSY);
-
-       kds_s2000w_client_response_free(resp);
-       resp = NULL;
-       free(hlist);
-       hlist = NULL;
-}
-
-void sane_kds_s2000w_net_open_invalid_test()
+void kds_s2000w_net_set_io_mode_test()
 {
-       void** hlist = malloc(sizeof(void*));
-
-       SANE_Status status = sane_kds_s2000w_net_open("wrong_device_name", hlist);
-
-       assert_int_equal(status, SANE_STATUS_INVAL);
+       SANE_Status result = sane_kds_s2000w_net_set_io_mode(NULL, SANE_FALSE);
 
-       free(hlist);
-       hlist = NULL;
+       assert_int_equal(result, SANE_STATUS_UNSUPPORTED);
 }
 
-void sane_kds_s2000w_net_open_not_connected_test()
+void kds_s2000w_net_get_select_fd_test()
 {
-       response* resp = kds_s2000w_client_response_init();
-       resp->code = 0;
-       will_return(mock_response, resp);
-       will_return(__wrap_kds_s2000w_client_open_session, 1);
-       expect_function_call(__wrap_kds_s2000w_client_open_session);
-       void** hlist = malloc(sizeof(void*));
-
-       SANE_Status status = sane_kds_s2000w_net_open("kds_s2000w_net", hlist);
-
-       assert_int_equal(status, SANE_STATUS_IO_ERROR);
+       SANE_Status result = sane_kds_s2000w_net_get_select_fd(NULL, NULL);
 
-       kds_s2000w_client_response_free(resp);
-       resp = NULL;
-       free(hlist);
-       hlist = NULL;
+       assert_int_equal(result, SANE_STATUS_UNSUPPORTED);
 }
\ No newline at end of file

diff --git a/tests/kds_s2000w_net_tests.h b/tests/kds_s2000w_net_tests.h
index be16ce9881eb12eeb72e091da4aace0f0fb81742..9dd6b66367e90ceab6acb1a819311fbf74755e58 100644 (file)
--- a/tests/kds_s2000w_net_tests.h
+++ b/tests/kds_s2000w_net_tests.h
@@ -6,25 +6,31 @@
 #include <setjmp.h>
 #include <cmocka.h>
 
-void kds_s2000w_net_get_devices_test();
 void kds_s2000w_net_init_test();
+
+void kds_s2000w_net_get_devices_test();
 void kds_s2000w_net_get_devices_only_remote_test();
-void kds_s2000w_net_set_io_mode_test();
-void kds_s2000w_net_get_select_fd_test();
-void sane_kds_s2000w_net_start_cancel_test();
-void sane_kds_s2000w_net_cancel_canceled_test();
-void sane_kds_s2000w_net_cancel_completed_scan_flatbed_test();
-void sane_kds_s2000w_net_start_test(void** state);
-void sane_kds_s2000w_net_start_one_page_per_flatscan_test(void** state);
-void sane_kds_s2000w_net_start_one_page_per_feeder_test(void** state);
-void sane_kds_s2000w_net_start_two_pages_per_feeder_test(void** state);
+
 void sane_kds_s2000w_net_get_parameter_color_test();
 void sane_kds_s2000w_net_get_parameter_bw_test();
-void sane_kds_s2000w_net_cancel_test();
-void sane_kds_s2000w_net_cancel_completed_scan_feeder_test();
+
 void sane_kds_s2000w_net_open_test();
 void sane_kds_s2000w_net_open_busy_device_test();
 void sane_kds_s2000w_net_open_invalid_test();
 void sane_kds_s2000w_net_open_not_connected_test();
 
+void sane_kds_s2000w_net_start_test(void** state);
+void sane_kds_s2000w_net_start_one_page_per_flatscan_test(void** state);
+void sane_kds_s2000w_net_start_one_page_per_feeder_test(void** state);
+void sane_kds_s2000w_net_start_two_pages_per_feeder_test(void** state);
+
+void sane_kds_s2000w_net_cancel_test();
+void sane_kds_s2000w_net_cancel_start_test();
+void sane_kds_s2000w_net_cancel_canceled_test();
+void sane_kds_s2000w_net_cancel_completed_scan_flatbed_test();
+void sane_kds_s2000w_net_cancel_completed_scan_feeder_test();
+
+void kds_s2000w_net_set_io_mode_test();
+void kds_s2000w_net_get_select_fd_test();
+
 #endif
\ No newline at end of file

diff --git a/tests/kds_s2000w_net_tests_run.c b/tests/kds_s2000w_net_tests_run.c
index 34d9a0775e7651cd506ef6fa692ecb9662ec141f..665bcf382c6b5afb22e578e7bb6f52631576cf8a 100644 (file)
--- a/tests/kds_s2000w_net_tests_run.c
+++ b/tests/kds_s2000w_net_tests_run.c
@@ -3,7 +3,7 @@
 #include "kds_s2000w_net_tests.h"
 #include "../src/kds_s2000w_client.h"
 
-int setup_net_start(void** state)
+int setup(void** state)
 {
        response** response_list = malloc(sizeof(response*) * 4);
        response_list[0] = kds_s2000w_client_response_init();
@@ -46,7 +46,7 @@ int setup_net_start(void** state)
        return 0;
 }
 
-int teardown_net_start(void** state)
+int teardown(void** state)
 {
        response** respons_list = (response**) *state;
        for (int i = 0; respons_list[i] != NULL; i++) {
@@ -63,26 +63,26 @@ int teardown_net_start(void** state)
 int main()
 {
        const struct CMUnitTest net_tests[] = {
-               cmocka_unit_test(kds_s2000w_net_get_devices_test),
                cmocka_unit_test(kds_s2000w_net_init_test),
+               cmocka_unit_test(kds_s2000w_net_get_devices_test),
                cmocka_unit_test(kds_s2000w_net_get_devices_only_remote_test),
-               cmocka_unit_test(kds_s2000w_net_set_io_mode_test),
-               cmocka_unit_test(kds_s2000w_net_get_select_fd_test),
-               cmocka_unit_test(sane_kds_s2000w_net_start_cancel_test),
-               cmocka_unit_test(sane_kds_s2000w_net_cancel_canceled_test),
-               cmocka_unit_test(sane_kds_s2000w_net_cancel_test),
-               cmocka_unit_test(sane_kds_s2000w_net_cancel_completed_scan_feeder_test),
-               cmocka_unit_test(sane_kds_s2000w_net_cancel_completed_scan_flatbed_test),
+               cmocka_unit_test(sane_kds_s2000w_net_get_parameter_color_test),
+               cmocka_unit_test(sane_kds_s2000w_net_get_parameter_bw_test),
                cmocka_unit_test(sane_kds_s2000w_net_open_test),
                cmocka_unit_test(sane_kds_s2000w_net_open_busy_device_test),
                cmocka_unit_test(sane_kds_s2000w_net_open_invalid_test),
                cmocka_unit_test(sane_kds_s2000w_net_open_not_connected_test),
-               cmocka_unit_test(sane_kds_s2000w_net_get_parameter_color_test),
-               cmocka_unit_test(sane_kds_s2000w_net_get_parameter_bw_test),
-               cmocka_unit_test_setup_teardown(sane_kds_s2000w_net_start_test, setup_net_start, teardown_net_start),
-               cmocka_unit_test_setup_teardown(sane_kds_s2000w_net_start_one_page_per_flatscan_test, setup_net_start, teardown_net_start),
-               cmocka_unit_test_setup_teardown(sane_kds_s2000w_net_start_one_page_per_feeder_test, setup_net_start, teardown_net_start),
-               cmocka_unit_test_setup_teardown(sane_kds_s2000w_net_start_two_pages_per_feeder_test, setup_net_start, teardown_net_start),
+               cmocka_unit_test_setup_teardown(sane_kds_s2000w_net_start_test, setup, teardown),
+               cmocka_unit_test_setup_teardown(sane_kds_s2000w_net_start_one_page_per_flatscan_test, setup, teardown),
+               cmocka_unit_test_setup_teardown(sane_kds_s2000w_net_start_one_page_per_feeder_test, setup, teardown),
+               cmocka_unit_test_setup_teardown(sane_kds_s2000w_net_start_two_pages_per_feeder_test, setup, teardown),
+               cmocka_unit_test(sane_kds_s2000w_net_cancel_test),
+               cmocka_unit_test(sane_kds_s2000w_net_cancel_start_test),
+               cmocka_unit_test(sane_kds_s2000w_net_cancel_canceled_test),
+               cmocka_unit_test(sane_kds_s2000w_net_cancel_completed_scan_feeder_test),
+               cmocka_unit_test(sane_kds_s2000w_net_cancel_completed_scan_flatbed_test),
+               cmocka_unit_test(kds_s2000w_net_set_io_mode_test),
+               cmocka_unit_test(kds_s2000w_net_get_select_fd_test)
        };
 
        return cmocka_run_group_tests(net_tests, NULL, NULL);