test.cpp

00001 /////////////////////////////////////////////////////////////
00002 // APP 3                                                   //
00003 //                                                         //
00004 // Université de Sherbrooke                                //
00005 // Génie informatique                                      //
00006 // Session 5, Hiver 2017                                   //
00007 //                                                         //
00008 // Date:    14 février 2017                                //
00009 //                                                         //
00010 // Auteurs: Maxime Dupuis,       dupm2216                  //
00011 //          Bruno Allaire-Lemay, allb2701                  //
00012 /////////////////////////////////////////////////////////////
00013 
00014 #include <cassert>
00015 #include <algorithm>
00016 #include "test.h"
00017 #include "xbee.h"
00018 
00019 void run_all_tests()
00020 {
00021     vectors_are_equal_test();
00022     generate_transmit_request_test();
00023     generate_led_high_command_test();
00024     generate_led_low_command_test();
00025     parse_receive_packet_test();
00026     parse_frame_parses_receive_packet_test();
00027     parse_frame_parses_transmit_status_test();
00028     parse_frame_parses_at_command_response_test();
00029     parse_frame_parses_remote_command_response_test();
00030     handle_frame_adds_parsed_frame_to_mailbox_test();
00031     
00032     test_create_vector_by_copy_test();
00033     
00034     string_to_data_test();
00035     hexa_char_to_dec_test();
00036 }
00037 
00038 void vectors_are_equal_test()
00039 {
00040     vector<char> v1;    
00041     v1.push_back(1);
00042     v1.push_back(2);
00043     
00044     vector<char> v2;
00045     v2.push_back(1);
00046     v2.push_back(2);
00047     
00048     vector<char> v3;
00049     v3.push_back(1);
00050     v3.push_back(2);
00051     v3.push_back(3);
00052     
00053     vector<char> v4;
00054     v4.push_back(1);
00055     v4.push_back(1);
00056     
00057     assert(vectors_are_equal(v1, v2));
00058     
00059     assert(!vectors_are_equal(v1, v3));
00060     assert(!vectors_are_equal(v1, v4));
00061 }
00062 
00063 bool vectors_are_equal(const vector<char> v1, const vector<char> v2)
00064 {
00065     if(v1.size() != v2.size()) return false;
00066     
00067     const bool all_elements_are_equal = equal(v1.begin(), v1.end(), v2.begin());
00068     return all_elements_are_equal;
00069 }
00070 
00071 vector<char> construct_vector(const char* content, int length)
00072 {
00073     vector<char> constructed_vector;
00074     for(int i = 0; i < length; ++i)
00075     {
00076         constructed_vector.push_back(content[i]);
00077     }
00078     return constructed_vector;
00079 }
00080 
00081 int some_function_that_returns_int_forty_two()
00082 {
00083     return 42;   
00084 }
00085 
00086 void test_create_vector_by_copy_test()
00087 {
00088     const vector<char> original(2, 3);
00089     vector<char> *copy_vector = new vector<char>();
00090     *copy_vector = original;
00091     
00092     assert(vectors_are_equal(original, *copy_vector));
00093     
00094     delete copy_vector;
00095     
00096     assert(original.at(0) == 3);
00097     assert(original.at(1) == 3);
00098 }
00099 
00100 void generate_transmit_request_test()
00101 {
00102     const char expected_array[] = {0x7E, 0x00, 0x12, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x54, 0x65, 0x73, 0x74, 0x53};
00103     vector<char> expected_request = construct_vector(expected_array, 22);
00104     
00105     int address[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF};
00106     
00107     vector<char> actual_request = generate_transmit_request("Test", 4, address);
00108         
00109     assert(vectors_are_equal(actual_request, expected_request));
00110 }
00111 
00112 void generate_led_high_command_test()
00113 {
00114     const char expected_array[] = {0x7E, 0x00, 0x10, 0x17, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFE, 0x02, 0x50, 0x32, 0x05, 0x63};
00115     vector<char> expected_request = construct_vector(expected_array, 20);
00116     
00117     vector<char> actual_request = generate_led_command(true);
00118         
00119     assert(vectors_are_equal(actual_request, expected_request));
00120 }
00121 
00122 void generate_led_low_command_test()
00123 {
00124     const char expected_array[] = {0x7E, 0x00, 0x10, 0x17, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFE, 0x02, 0x50, 0x32, 0x04, 0x64};
00125     vector<char> expected_request = construct_vector(expected_array, 20);
00126     
00127     vector<char> actual_request = generate_led_command(false);
00128         
00129     assert(vectors_are_equal(actual_request, expected_request));
00130 }
00131 
00132 void parse_receive_packet_test()
00133 {
00134     const char receive_packet_array[] = {0x7E, 0x00, 0x10, 0x90, 0x00, 0x13, 0xA2, 0x00, 0x40, 0x86, 0xDA, 0x0E, 0x90, 0x1D, 0x01, 0x54, 0x65, 0x73, 0x74, 0xBE};
00135     vector<char> receive_packet = construct_vector(receive_packet_array, 20);
00136     
00137     const char expected_message_array[] = {0x54, 0x65, 0x73, 0x74};
00138     vector<char> expected_message = construct_vector(expected_message_array, 4);
00139     
00140     vector<char> actual_message = parse_receive_packet(receive_packet);
00141     
00142     assert(vectors_are_equal(actual_message, expected_message));
00143 }
00144 
00145 void parse_frame_parses_receive_packet_test()
00146 {
00147     const char frame_to_parse_array[] = {0x7E, 0x00, 0x10, 0x90, 0x00, 0x13, 0xA2, 0x00, 0x40, 0x86, 0xDA, 0x0E, 0x90, 0x1D, 0x01, 0x54, 0x65, 0x73, 0x74, 0xBE};
00148     const vector<char> frame_to_parse = construct_vector(frame_to_parse_array, 20);
00149     
00150     const char expected_parsed_frame_array[] = {FRAME_TYPE_RECEIVE_PACKET, 'T', 'e', 's', 't'};
00151     const vector<char> expected_parsed_frame = construct_vector(expected_parsed_frame_array, 5);
00152     
00153     const vector<char> actual_parsed_frame = parse_frame(frame_to_parse);
00154     
00155     assert(vectors_are_equal(expected_parsed_frame, actual_parsed_frame));
00156 }
00157 
00158 void parse_frame_parses_transmit_status_test()
00159 {    
00160     const char frame_to_parse_array[] = {0x7E, 0x00, 0x07, 0x8B, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73};
00161     const vector<char> frame_to_parse = construct_vector(frame_to_parse_array, 11);
00162     
00163     const char expected_parsed_frame_array[] = {FRAME_TYPE_TRANSMIT_STATUS, TRANSMIT_STATUS_SUCCESS};
00164     const vector<char> expected_parsed_frame = construct_vector(expected_parsed_frame_array, 2);
00165     
00166     const vector<char> actual_parsed_frame = parse_frame(frame_to_parse);
00167     
00168     assert(vectors_are_equal(expected_parsed_frame, actual_parsed_frame));
00169 }
00170 
00171 void parse_frame_parses_at_command_response_test()
00172 {
00173     const char frame_to_parse_array[] = {0x7E, 0x00, 0x05, 0x88, 0x01, 0x4E, 0x4A, 0x00, 0xDE};
00174     const vector<char> frame_to_parse = construct_vector(frame_to_parse_array, 9);
00175     
00176     const char expected_parsed_frame_array[] = {FRAME_TYPE_AT_COMMAND_RESPONSE, AT_COMMAND_RESPONSE_STATUS_OK};
00177     const vector<char> expected_parsed_frame = construct_vector(expected_parsed_frame_array, 2);
00178     
00179     const vector<char> actual_parsed_frame = parse_frame(frame_to_parse);
00180     
00181     assert(vectors_are_equal(expected_parsed_frame, actual_parsed_frame));
00182 }
00183 
00184 void parse_frame_parses_remote_command_response_test()
00185 {
00186     const char frame_to_parse_array[] = {0x7E, 0x00, 0x0F, 0x97, 0x01, 0x00, 0x13, 0xA2, 0x00, 0x40, 0x86, 0xDA, 0x0E, 0x90, 0x1D, 0x50, 0x32, 0x00, 0xD5};
00187     const vector<char> frame_to_parse = construct_vector(frame_to_parse_array, 19);
00188     
00189     const char expected_parsed_frame_array[] = {FRAME_TYPE_REMOTE_COMMAND_RESPONSE, REMOTE_COMMAND_RESPONSE_COMMAND_STATUS_OK};
00190     const vector<char> expected_parsed_frame = construct_vector(expected_parsed_frame_array, 2);
00191     
00192     const vector<char> actual_parsed_frame = parse_frame(frame_to_parse);
00193     
00194     assert(vectors_are_equal(expected_parsed_frame, actual_parsed_frame));
00195 }
00196 
00197 void handle_frame_adds_parsed_frame_to_mailbox_test()
00198 {
00199     const char frame_to_handle_array[] = {0x7E, 0x00, 0x05, 0x88, 0x01, 0x4E, 0x4A, 0x00, 0xDE};
00200     const vector<char> frame_to_handle = construct_vector(frame_to_handle_array, 9);
00201     
00202     const char expected_parsed_frame_array[] = {FRAME_TYPE_AT_COMMAND_RESPONSE, AT_COMMAND_RESPONSE_STATUS_OK};
00203     const vector<char> expected_parsed_frame = construct_vector(expected_parsed_frame_array, 2);
00204     
00205     handle_frame(frame_to_handle);
00206     
00207     //Read parsed frame from the mailbox
00208     osEvent event = parsed_frames.get();
00209     assert(event.status == osEventMail);
00210     ingoing_value_t *parsed_frame = (ingoing_value_t*)event.value.p;    
00211     
00212     assert(vectors_are_equal(expected_parsed_frame, ingoing_value_to_vector(*parsed_frame))); 
00213    
00214     parsed_frames.free(parsed_frame);   
00215 }
00216 
00217 void string_to_data_test()
00218 {
00219     vector<char> result;
00220     
00221     result = string_to_data("0000");
00222     assert(result.at(0) == 0);
00223     assert(result.at(1) == 0);
00224     
00225     result = string_to_data("EEEEEE");
00226     assert(result.at(0) == 0xEE);
00227     assert(result.at(1) == 0xEE);
00228 }
00229 
00230 void hexa_char_to_dec_test()
00231 {    
00232     assert(hexa_char_to_dec('0') == 0);
00233     assert(hexa_char_to_dec('1') == 1);
00234     assert(hexa_char_to_dec('A') == 10);
00235     assert(hexa_char_to_dec('F') == 15);
00236     
00237     assert(hexa_char_to_dec('a') == 10);
00238     assert(hexa_char_to_dec('f') == 15);
00239 }