Unit testing

- Major changes to unit-test-master/slave to add 4 tests
- Use new functions to manipulate bits
- Reduce memory usage (allocate only the required space and use
  uint[8|16]_t pointers)

tests/unit-test-master.c

@@ -24,49 +24,122 @@
 
 #include <modbus/modbus.h>
 
+#include "unit-test.h"
+
 /* Tests based on PI-MBUS-300 documentation */
 #define SLAVE    0x11
-#define FIELDS   500
 
 int main(void)
 {
-        int *tab_rq;
-        int *tab_rq_bits;
-        int *tab_rp;
+        uint8_t *tab_rp_status;
+        uint16_t *tab_rp_registers;
         modbus_param_t mb_param;
+        int i;
+        uint8_t value;
+        uint16_t address;
+        uint16_t nb_points;
 
         /* RTU parity : none, even, odd */
 /*      modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, "none", 8, 1); */
 
         /* TCP */
         modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
-        modbus_set_debug(&mb_param, TRUE);
       
         modbus_connect(&mb_param);
 
-        /* Allocate and initialize the different memory spaces */
-        tab_rq = (int *) malloc(FIELDS * sizeof(int));
-        memset(tab_rq, 0, FIELDS * sizeof(int));
+        /* Allocate and initialize the memory to store the status */
+        nb_points = (UT_COIL_STATUS_NB_POINTS > UT_INPUT_STATUS_NB_POINTS) ?
+                UT_COIL_STATUS_NB_POINTS : UT_INPUT_STATUS_NB_POINTS;
+        tab_rp_status = (uint8_t *) malloc(nb_points * sizeof(uint8_t));
+        memset(tab_rp_status, 0, nb_points * sizeof(uint8_t));
+        
+        /* Allocate and initialize the memory to store the registers */
+        nb_points = (UT_HOLDING_REGISTERS_NB_POINTS > UT_INPUT_REGISTERS_NB_POINTS) ?
+                UT_HOLDING_REGISTERS_NB_POINTS : UT_INPUT_REGISTERS_NB_POINTS;
+        tab_rp_registers = (uint16_t *) malloc(nb_points * sizeof(uint16_t));
+        memset(tab_rp_registers, 0, nb_points * sizeof(uint16_t));
 
-        tab_rq_bits = (int *) malloc(FIELDS * sizeof(int));
-        memset(tab_rq_bits, 0, FIELDS * sizeof(int));
+        printf("Unit testing\n");
+
+        /** COIL STATUS **/
+        read_coil_status(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS,
+                         UT_COIL_STATUS_NB_POINTS, tab_rp_status);
+
+        i = 0;
+        address = UT_COIL_STATUS_ADDRESS;
+        nb_points = UT_COIL_STATUS_NB_POINTS;
+        while (nb_points > 0) {
+                int nb_bits = (nb_points > 8) ? 8 : nb_points;
+
+                value = get_byte_from_bits(tab_rp_status, i*8, nb_bits);
+                if (value != UT_COIL_STATUS_TAB[i]) {
+                        printf("Coil status: FAILED (%0X != %0X)\n",
+                               value, UT_COIL_STATUS_TAB[i]);
+                        goto close;
+                }
+
+                nb_points -= nb_bits;
+                i++;
+        }
+        printf("Coil status: OK\n");
 
-        tab_rp = (int *) malloc(FIELDS * sizeof(int));
-        memset(tab_rp, 0, FIELDS * sizeof(int));
-        
-        read_coil_status(&mb_param, SLAVE, 0x13, 0x25, tab_rp);
-        read_input_status(&mb_param, SLAVE, 0xC4, 0x16, tab_rp);
-        read_holding_registers(&mb_param, SLAVE, 0x6B, 3, tab_rp);
-        read_input_registers(&mb_param, SLAVE, 0x8, 1, tab_rp);
-        force_single_coil(&mb_param, SLAVE, 0xAC, ON);
 
+        /** INPUT STATUS **/
+        read_input_status(&mb_param, SLAVE, UT_INPUT_STATUS_ADDRESS,
+                          UT_INPUT_STATUS_NB_POINTS, tab_rp_status);
+
+        i = 0;
+        address = UT_INPUT_STATUS_ADDRESS;
+        nb_points = UT_INPUT_STATUS_NB_POINTS;
+        while (nb_points > 0) {
+                int nb_bits = (nb_points > 8) ? 8 : nb_points;
+
+                value = get_byte_from_bits(tab_rp_status, i*8, nb_bits);
+                if (value != UT_INPUT_STATUS_TAB[i]) {
+                        printf("Input status: FAILED (%0X != %0X)\n",
+                               value, UT_INPUT_STATUS_TAB[i]);
+                        goto close;
+                }
+
+                nb_points -= nb_bits;
+                i++;
+        }
+        printf("Input status: OK\n");
+
+        /** HOLDING REGISTERS **/
+        read_holding_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS,
+                               UT_HOLDING_REGISTERS_NB_POINTS, tab_rp_registers);
+        for (i=0; i < UT_HOLDING_REGISTERS_NB_POINTS; i++) {
+                if (tab_rp_registers[i] != UT_HOLDING_REGISTERS_TAB[i]) {
+                        printf("Holding registers: FAILED (%0X != %0X)\n",
+                               tab_rp_registers[i], UT_HOLDING_REGISTERS_TAB[i]);
+                        goto close;
+                }
+        }
+        printf("Holding registers: OK\n");
+
+        /** INPUT REGISTERS **/
+        read_input_registers(&mb_param, SLAVE, UT_INPUT_REGISTERS_ADDRESS,
+                               UT_INPUT_REGISTERS_NB_POINTS, tab_rp_registers);
+        for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) {
+                if (tab_rp_registers[i] != UT_INPUT_REGISTERS_TAB[i]) {
+                        printf("Input registers: FAILED (%0X != %0X)\n",
+                               tab_rp_registers[i], UT_INPUT_REGISTERS_TAB[i]);
+                        goto close;
+                }
+        }
+        printf("Input registers: OK\n");
+        
+close:
         /* Free the memory */
-        free(tab_rp);                                           
-        free(tab_rq);
-        free(tab_rq_bits);
+        free(tab_rp_status);                                           
+        free(tab_rp_registers);
 
         /* Close the connection */
         modbus_close(&mb_param);
         
         return 0;
+/*
+        force_single_coil(&mb_param, SLAVE, 0xAC, ON);
+*/
 }

tests/unit-test-slave.c

@@ -24,12 +24,10 @@
 
 #include <modbus/modbus.h>
 
+#include "unit-test.h"
+
 int main(void)
 {
-        const int nb_coil_status = 500;
-        const int nb_input_status = 500;
-        const int nb_input_registers = 500;
-        const int nb_holding_registers = 500;
         int socket;
         modbus_param_t mb_param;
         modbus_mapping_t mb_mapping;
@@ -37,59 +35,41 @@ int main(void)
         int i;
 
         modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
-        modbus_set_debug(&mb_param, TRUE);
 
-        modbus_mapping_new(&mb_mapping,
-                           nb_coil_status, nb_input_status,
-                           nb_input_registers, nb_holding_registers);
+        ret = modbus_mapping_new(&mb_mapping,
+                                 UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS,
+                                 UT_INPUT_STATUS_ADDRESS + UT_INPUT_STATUS_NB_POINTS,
+                                 UT_HOLDING_REGISTERS_ADDRESS + UT_HOLDING_REGISTERS_NB_POINTS,
+                                 UT_INPUT_STATUS_ADDRESS + UT_INPUT_REGISTERS_NB_POINTS);
+        if (ret == FALSE) {
+                printf("Memory allocation failed\n");
+                exit(1);
+        }
 
         /* Examples from PI_MODBUS_300.pdf */
 
-        /* Coil status */
-        mb_mapping.tab_coil_status[26] = ON;
-        mb_mapping.tab_coil_status[25] = ON;
-        mb_mapping.tab_coil_status[24] = OFF;
-        mb_mapping.tab_coil_status[23] = OFF;
-        mb_mapping.tab_coil_status[22] = ON;
-        mb_mapping.tab_coil_status[21] = ON;
-        mb_mapping.tab_coil_status[20] = OFF;
-        mb_mapping.tab_coil_status[19] = ON;
-
-        /* Input status */
-        mb_mapping.tab_input_status[203] = ON;
-        mb_mapping.tab_input_status[202] = OFF;
-        mb_mapping.tab_input_status[201] = ON;
-        mb_mapping.tab_input_status[200] = OFF;
-        mb_mapping.tab_input_status[199] = ON;
-        mb_mapping.tab_input_status[198] = ON;
-        mb_mapping.tab_input_status[197] = OFF;
-        mb_mapping.tab_input_status[196] = OFF;
+        /** COIL STATUS **/
+        set_bits_from_bytes(mb_mapping.tab_coil_status,
+                            UT_COIL_STATUS_ADDRESS, UT_COIL_STATUS_NB_POINTS,
+                            UT_COIL_STATUS_TAB);
 
-        mb_mapping.tab_input_status[211] = ON;
-        mb_mapping.tab_input_status[210] = ON;
-        mb_mapping.tab_input_status[209] = OFF;
-        mb_mapping.tab_input_status[208] = ON;
-        mb_mapping.tab_input_status[207] = ON;
-        mb_mapping.tab_input_status[206] = OFF;
-        mb_mapping.tab_input_status[205] = ON;
-        mb_mapping.tab_input_status[204] = ON;
+        /** INPUT STATUS **/
+        set_bits_from_bytes(mb_mapping.tab_input_status,
+                            UT_INPUT_STATUS_ADDRESS, UT_INPUT_STATUS_NB_POINTS,
+                            UT_INPUT_STATUS_TAB);
 
-        /* Incomplete byte */
-        mb_mapping.tab_input_status[217] = ON;
-        mb_mapping.tab_input_status[216] = ON;
-        mb_mapping.tab_input_status[215] = OFF;
-        mb_mapping.tab_input_status[214] = ON;
-        mb_mapping.tab_input_status[213] = OFF;
-        mb_mapping.tab_input_status[212] = ON;
+        /** HOLDING REGISTERS **/
+        for (i=0; i < UT_HOLDING_REGISTERS_NB_POINTS; i++) {
+                mb_mapping.tab_holding_registers[UT_HOLDING_REGISTERS_ADDRESS+i] =
+                        UT_HOLDING_REGISTERS_TAB[i];;
+        }
 
-        /* Holding registers */
-        mb_mapping.tab_holding_registers[107] = 0x022B;
-        mb_mapping.tab_holding_registers[108] = 0x0000;
-        mb_mapping.tab_holding_registers[109] = 0x0064;
+        /** INPUT REGISTERS **/
+        for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) {
+                mb_mapping.tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] =
+                        UT_INPUT_REGISTERS_TAB[i];;
+        }
 
-        /* Input registers */
-        mb_mapping.tab_input_registers[8] = 0x000A;
- 
         socket = modbus_init_listen_tcp(&mb_param);
         
         i = 0;
@@ -98,10 +78,15 @@ int main(void)
                 int query_size;
 
                 ret = modbus_listen(&mb_param, query, &query_size);
-                if (ret == 0)
+
+                if (ret == 0) {
                         manage_query(&mb_param, query, query_size, &mb_mapping);
-                else
+                } else if (ret == CONNECTION_CLOSED) {
+                        /* Connection closed by the client, end of server */
+                        break;
+                } else {
                         printf("Error in modbus_listen (%d)\n", ret);
+                }
         }
 
         close(socket);

tests/unit-test.h

@@ -0,0 +1,22 @@
+#ifndef _UNIT_TEST_H_
+#define _UNIT_TEST_H_
+
+#include <stdint.h>
+
+const uint16_t UT_COIL_STATUS_ADDRESS = 0x13;
+const uint16_t UT_COIL_STATUS_NB_POINTS = 0x25;
+const uint8_t UT_COIL_STATUS_TAB[] = { 0xCD, 0x6B, 0xB2, 0x0E, 0x1B }; 
+
+const uint16_t UT_INPUT_STATUS_ADDRESS = 0xC4;
+const uint16_t UT_INPUT_STATUS_NB_POINTS = 0x16;
+const uint8_t UT_INPUT_STATUS_TAB[] = { 0xAC, 0xDB, 0x35 };
+
+const uint16_t UT_HOLDING_REGISTERS_ADDRESS = 0x6B;
+const uint16_t UT_HOLDING_REGISTERS_NB_POINTS = 0x3;
+const uint16_t UT_HOLDING_REGISTERS_TAB[] = { 0x022B, 0x0000, 0x0064 };
+
+const uint16_t UT_INPUT_REGISTERS_ADDRESS = 0x08;
+const uint16_t UT_INPUT_REGISTERS_NB_POINTS = 0x1;
+const uint16_t UT_INPUT_REGISTERS_TAB[] = { 0x000A };
+
+#endif /* _UNIT_TEST_H_ */