Test_LoRaWANStack.cpp

00001 /*
00002  * Copyright (c) 2018, Arm Limited and affiliates
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License");
00006  * you may not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  *     http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS,
00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 
00018 #include "gtest/gtest.h"
00019 #include "LoRaWANStack.h"
00020 #include "EventQueue.h"
00021 
00022 #include "LoRaPHY_stub.h"
00023 #include "LoRaMac_stub.h"
00024 #include "equeue_stub.h"
00025 #include "lorawan_data_structures.h"
00026 
00027 static uint8_t batt_level = 0;
00028 
00029 using namespace events;
00030 
00031 class my_LoRaPHY : public LoRaPHY
00032 {
00033 public:
00034     my_LoRaPHY(){};
00035 
00036     virtual ~my_LoRaPHY(){};
00037 };
00038 
00039 uint8_t my_cb()
00040 {
00041     return 1;
00042 }
00043 
00044 class my_radio : public LoRaRadio
00045 {
00046 public:
00047     radio_events_t *_ev;
00048 
00049     virtual void init_radio(radio_events_t *events){_ev = events;};
00050 
00051     virtual void radio_reset(){};
00052 
00053     virtual void sleep(void){};
00054 
00055     virtual void standby(void){};
00056 
00057     virtual void set_rx_config (radio_modems_t modem, uint32_t bandwidth,
00058                                    uint32_t datarate, uint8_t coderate,
00059                                    uint32_t bandwidth_afc, uint16_t preamble_len,
00060                                    uint16_t symb_timeout, bool fix_len,
00061                                    uint8_t payload_len,
00062                                    bool crc_on, bool freq_hop_on, uint8_t hop_period,
00063                                    bool iq_inverted, bool rx_continuous){};
00064 
00065     virtual void set_tx_config(radio_modems_t modem, int8_t power, uint32_t fdev,
00066                                   uint32_t bandwidth, uint32_t datarate,
00067                                   uint8_t coderate, uint16_t preamble_len,
00068                                   bool fix_len, bool crc_on, bool freq_hop_on,
00069                                   uint8_t hop_period, bool iq_inverted, uint32_t timeout){};
00070 
00071     virtual void send(uint8_t *buffer, uint8_t size){};
00072 
00073     virtual void receive(void){};
00074 
00075     virtual void set_channel(uint32_t freq){};
00076 
00077     virtual uint32_t random(void){};
00078 
00079     virtual uint8_t get_status(void){return uint8_value;};
00080 
00081     virtual void set_max_payload_length(radio_modems_t modem, uint8_t max){};
00082 
00083     virtual void set_public_network(bool enable){};
00084 
00085     virtual uint32_t time_on_air(radio_modems_t modem, uint8_t pkt_len){};
00086 
00087     virtual bool perform_carrier_sense(radio_modems_t modem,
00088                                            uint32_t freq,
00089                                            int16_t rssi_threshold,
00090                                            uint32_t max_carrier_sense_time){ return bool_value;};
00091 
00092     virtual void start_cad(void){};
00093 
00094     virtual bool check_rf_frequency(uint32_t frequency){ return bool_value; };
00095 
00096     virtual void set_tx_continuous_wave(uint32_t freq, int8_t power, uint16_t time){};
00097 
00098     virtual void lock(void){};
00099 
00100     virtual void unlock(void){};
00101 
00102     bool bool_value;
00103     uint8_t uint8_value;
00104 };
00105 
00106 
00107 
00108 class Test_LoRaWANStack : public testing::Test {
00109 protected:
00110     LoRaWANStack *object;
00111 
00112     virtual void SetUp()
00113     {
00114         LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00115         object = new LoRaWANStack();
00116     }
00117 
00118     virtual void TearDown()
00119     {
00120         delete object;
00121     }
00122 };
00123 
00124 TEST_F(Test_LoRaWANStack, constructor)
00125 {
00126     EXPECT_TRUE(object);
00127 }
00128 
00129 TEST_F(Test_LoRaWANStack, bind_phy_and_radio_driver)
00130 {
00131     my_radio radio;
00132     my_LoRaPHY phy;
00133     object->bind_phy_and_radio_driver(radio, phy);
00134 }
00135 
00136 TEST_F(Test_LoRaWANStack, initialize_mac_layer)
00137 {
00138     EXPECT_TRUE(LORAWAN_STATUS_PARAMETER_INVALID == object->initialize_mac_layer(NULL));
00139 
00140     EventQueue queue;
00141     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00142     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00143 
00144     //Visit callback
00145     if (LoRaMac_stub::_scheduling_failure_handler) {
00146         LoRaMac_stub::_scheduling_failure_handler.call();
00147     }
00148 }
00149 
00150 void events_cb(lorawan_event_t ev)
00151 {
00152 
00153 }
00154 
00155 void lc_resp(uint8_t a, uint8_t b)
00156 {
00157 
00158 }
00159 
00160 uint8_t batt_lvl()
00161 {
00162     return batt_level;
00163 }
00164 
00165 TEST_F(Test_LoRaWANStack, set_lora_callbacks)
00166 {
00167     lorawan_app_callbacks_t cb;
00168     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->set_lora_callbacks(&cb));
00169 
00170     EventQueue queue;
00171     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00172 
00173     EXPECT_TRUE(LORAWAN_STATUS_PARAMETER_INVALID == object->set_lora_callbacks(NULL));
00174 
00175     cb.events = NULL;
00176     EXPECT_TRUE(LORAWAN_STATUS_PARAMETER_INVALID == object->set_lora_callbacks(&cb));
00177 
00178     cb.events = events_cb;
00179     cb.link_check_resp = lc_resp;
00180     cb.battery_level = batt_lvl;
00181     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_lora_callbacks(&cb));
00182 }
00183 
00184 TEST_F(Test_LoRaWANStack, connect)
00185 {
00186     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->connect());
00187 
00188     EventQueue queue;
00189     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00190 
00191     LoRaMac_stub::status_value = LORAWAN_STATUS_BUSY;
00192     EXPECT_TRUE(LORAWAN_STATUS_BUSY == object->connect());
00193 
00194     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00195     EXPECT_TRUE(LORAWAN_STATUS_OK == object->connect());
00196 
00197     //_ctrl_flags & CONN_IN_PROGRESS_FLAG
00198     EXPECT_TRUE(LORAWAN_STATUS_BUSY == object->connect());
00199 
00200     my_radio radio;
00201     my_LoRaPHY phy;
00202     object->bind_phy_and_radio_driver(radio, phy);
00203 
00204     struct equeue_event ptr;
00205     equeue_stub.void_ptr = &ptr;
00206     equeue_stub.call_cb_immediately = true;
00207     loramac_mcps_confirm_t  conf;
00208     LoRaMac_stub::mcps_conf_ptr = &conf;
00209     radio._ev->tx_done();
00210 
00211     loramac_mcps_indication_t  ind;
00212     LoRaMac_stub::mcps_ind_ptr = &ind;
00213 
00214     loramac_mlme_confirm_t  mlme;
00215     LoRaMac_stub::mlme_conf_ptr = &mlme;
00216     mlme.pending  = true;
00217     mlme.req_type  = MLME_JOIN ;
00218     mlme.status  = LORAMAC_EVENT_INFO_STATUS_OK ;
00219     LoRaMac_stub::bool_value = false;
00220     radio._ev->rx_done(NULL, 0, 0, 0);
00221 
00222     //_ctrl_flags & CONNECTED_FLAG
00223     EXPECT_TRUE(LORAWAN_STATUS_ALREADY_CONNECTED == object->connect());
00224 
00225     //Visit rx_interrupt_handler's first if
00226     radio._ev->rx_done(NULL, 65535, 0, 0);
00227 }
00228 
00229 TEST_F(Test_LoRaWANStack, connect_args)
00230 {
00231     lorawan_connect_t conn;
00232     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->connect(conn));
00233 
00234     EventQueue queue;
00235     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00236 
00237     conn.connect_type = lorawan_connect_type_t(8);
00238     EXPECT_TRUE(LORAWAN_STATUS_PARAMETER_INVALID == object->connect(conn));
00239 
00240     LoRaMac_stub::status_value = LORAWAN_STATUS_BUSY;
00241     conn.connect_type = LORAWAN_CONNECTION_OTAA;
00242     EXPECT_TRUE(LORAWAN_STATUS_BUSY == object->connect(conn));
00243 
00244     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00245     EXPECT_TRUE(LORAWAN_STATUS_OK == object->connect(conn));
00246 
00247     //_ctrl_flags & CONN_IN_PROGRESS_FLAG
00248     EXPECT_TRUE(LORAWAN_STATUS_BUSY == object->connect(conn));
00249 
00250     object->shutdown();
00251     conn.connect_type = LORAWAN_CONNECTION_ABP;
00252     EXPECT_TRUE(LORAWAN_STATUS_OK == object->connect(conn));
00253 
00254     //_ctrl_flags & CONNECTED_FLAG
00255     EXPECT_TRUE(LORAWAN_STATUS_ALREADY_CONNECTED == object->connect(conn));
00256 }
00257 
00258 TEST_F(Test_LoRaWANStack, add_channels)
00259 {
00260     lorawan_channelplan_t plan;
00261     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->add_channels(plan));
00262 
00263     EventQueue queue;
00264     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00265 
00266     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00267     EXPECT_TRUE(LORAWAN_STATUS_OK == object->add_channels(plan));
00268 }
00269 
00270 TEST_F(Test_LoRaWANStack, remove_a_channel)
00271 {
00272     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->remove_a_channel(1));
00273 
00274     EventQueue queue;
00275     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00276 
00277     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00278     EXPECT_TRUE(LORAWAN_STATUS_OK == object->remove_a_channel(1));
00279 }
00280 
00281 TEST_F(Test_LoRaWANStack, drop_channel_list)
00282 {
00283     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->drop_channel_list());
00284 
00285     EventQueue queue;
00286     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00287 
00288     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00289     EXPECT_TRUE(LORAWAN_STATUS_OK == object->drop_channel_list());
00290 }
00291 
00292 TEST_F(Test_LoRaWANStack, get_enabled_channels)
00293 {
00294     lorawan_channelplan_t plan;
00295     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->get_enabled_channels(plan));
00296 
00297     EventQueue queue;
00298     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00299 
00300     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00301     EXPECT_TRUE(LORAWAN_STATUS_OK == object->get_enabled_channels(plan));
00302 }
00303 
00304 TEST_F(Test_LoRaWANStack, set_confirmed_msg_retry)
00305 {
00306     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->set_confirmed_msg_retry(1));
00307 
00308     EventQueue queue;
00309     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00310 
00311     EXPECT_TRUE(LORAWAN_STATUS_PARAMETER_INVALID == object->set_confirmed_msg_retry(255));
00312 
00313     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00314     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_confirmed_msg_retry(1));
00315 }
00316 
00317 TEST_F(Test_LoRaWANStack, set_channel_data_rate)
00318 {
00319     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->set_channel_data_rate(4));
00320 
00321     EventQueue queue;
00322     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00323 
00324     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00325     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_channel_data_rate(4));
00326 }
00327 
00328 TEST_F(Test_LoRaWANStack, enable_adaptive_datarate)
00329 {
00330     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->enable_adaptive_datarate(false));
00331 
00332     EventQueue queue;
00333     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00334 
00335     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00336     EXPECT_TRUE(LORAWAN_STATUS_OK == object->enable_adaptive_datarate(false));
00337 }
00338 
00339 TEST_F(Test_LoRaWANStack, handle_tx)
00340 {
00341     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->handle_tx(0, NULL, 0, 0, true, false));
00342 
00343     EventQueue queue;
00344     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00345 
00346     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00347     EXPECT_TRUE(LORAWAN_STATUS_PARAMETER_INVALID == object->handle_tx(0, NULL, 0, 0, false, false));
00348 
00349     lorawan_app_callbacks_t cb;
00350     cb.events = events_cb;
00351     cb.link_check_resp = lc_resp;
00352     cb.battery_level = batt_lvl;
00353     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_lora_callbacks(&cb));
00354     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_link_check_request());
00355 
00356     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00357     EXPECT_TRUE(LORAWAN_STATUS_NO_ACTIVE_SESSIONS == object->handle_tx(0, NULL, 0, 0, true, false));
00358 
00359     lorawan_connect_t conn;
00360     conn.connect_type = LORAWAN_CONNECTION_ABP;
00361     EXPECT_TRUE(LORAWAN_STATUS_OK == object->connect(conn));
00362 
00363     LoRaMac_stub::bool_value = false;
00364     EXPECT_TRUE(LORAWAN_STATUS_NO_NETWORK_JOINED == object->handle_tx(0, NULL, 0, 0, true, false));
00365 
00366     LoRaMac_stub::bool_value = true;
00367     EXPECT_TRUE(LORAWAN_STATUS_WOULD_BLOCK == object->handle_tx(0, NULL, 0, 0, true, false));
00368 
00369     LoRaMac_stub::bool_false_counter = 1;
00370     LoRaMac_stub::bool_value = true;
00371     //set_application_port fails
00372     EXPECT_TRUE(LORAWAN_STATUS_PORT_INVALID == object->handle_tx(0, NULL, 0, 0, true, false));
00373 
00374     LoRaMac_stub::bool_false_counter = 1;
00375     LoRaMac_stub::bool_value = true;
00376     //Wrong flags -> LORAWAN_STATUS_PARAMETER_INVALID
00377     EXPECT_TRUE(LORAWAN_STATUS_PARAMETER_INVALID == object->handle_tx(1, NULL, 0, 0x04, true, false));
00378 
00379     LoRaMac_stub::bool_false_counter = 1;
00380     //Actual sending
00381     EXPECT_TRUE(LORAWAN_STATUS_OK == object->handle_tx(1, NULL, 0, 0x08, true, false));
00382 
00383 }
00384 
00385 TEST_F(Test_LoRaWANStack, handle_rx)
00386 {
00387     uint8_t port;
00388     int flags;
00389     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->handle_rx(NULL, 0, port, flags, false));
00390 
00391     EventQueue queue;
00392     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00393 
00394     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00395     EXPECT_TRUE(LORAWAN_STATUS_NO_ACTIVE_SESSIONS == object->handle_rx(NULL, 0, port, flags, false));
00396 
00397     lorawan_connect_t conn;
00398     conn.connect_type = LORAWAN_CONNECTION_ABP;
00399     EXPECT_TRUE(LORAWAN_STATUS_OK == object->connect(conn));
00400     EXPECT_TRUE(LORAWAN_STATUS_WOULD_BLOCK == object->handle_rx(NULL, 0, port, flags, false));
00401 
00402     //Prepare ready for receive state
00403     lorawan_app_callbacks_t cb;
00404     cb.events = events_cb;
00405     cb.link_check_resp = lc_resp;
00406     cb.battery_level = batt_lvl;
00407     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_lora_callbacks(&cb));
00408 
00409     my_radio radio;
00410     my_LoRaPHY phy;
00411     object->bind_phy_and_radio_driver(radio, phy);
00412 
00413     struct equeue_event ptr;
00414     equeue_stub.void_ptr = &ptr;
00415     equeue_stub.call_cb_immediately = true;
00416     loramac_mcps_confirm_t  conf;
00417     LoRaMac_stub::mcps_conf_ptr = &conf;
00418     radio._ev->tx_done();
00419 
00420     loramac_mcps_indication_t  ind;
00421     LoRaMac_stub::mcps_ind_ptr = &ind;
00422 
00423     loramac_mlme_confirm_t  mlme;
00424     LoRaMac_stub::mlme_conf_ptr = &mlme;
00425     mlme.pending  = false;
00426     mlme.req_type  = MLME_JOIN ;
00427     mlme.status  = LORAMAC_EVENT_INFO_STATUS_OK ;
00428     LoRaMac_stub::bool_value = true;
00429     conf.req_type  = MCPS_PROPRIETARY ;
00430 
00431     ind.pending  = true;
00432     LoRaMac_stub::dev_class_value = CLASS_C;
00433 
00434     loramac_mlme_indication_t  mlme_ind;
00435     mlme_ind.pending = false;
00436     LoRaMac_stub::mlme_ind_ptr = &mlme_ind;
00437 
00438     uint8_t ind_buf[150];
00439     for (int i= 0; i < 110; i++) {
00440         ind_buf[i] = i;
00441     }
00442     ind.buffer  = ind_buf;
00443     ind.buffer_size  = 150;
00444     ind.type  = MCPS_UNCONFIRMED ;
00445     radio._ev->rx_done(NULL, 0, 0, 0);
00446 
00447     //data == NULL || LENGTH == 0 (2 cases)
00448     EXPECT_TRUE(LORAWAN_STATUS_PARAMETER_INVALID == object->handle_rx(NULL, 0, port, flags, false));
00449     uint8_t data[50];
00450     EXPECT_TRUE(LORAWAN_STATUS_PARAMETER_INVALID == object->handle_rx(data, 0, port, flags, false));
00451 
00452     //validate_params returns Would block
00453     port = 43;
00454     EXPECT_TRUE(LORAWAN_STATUS_WOULD_BLOCK == object->handle_rx(data, 50, port, flags, true));
00455 
00456     ind.type  = MCPS_CONFIRMED ;
00457     radio._ev->rx_done(NULL, 0, 0, 0);
00458     EXPECT_TRUE(LORAWAN_STATUS_WOULD_BLOCK == object->handle_rx(data, 50, port, flags, true));
00459     //Call again to visit send_automatic_uplink_message error case
00460     LoRaMac_stub::bool_true_counter = 1;
00461     ind.type  = MCPS_CONFIRMED ;
00462     ind.status  = LORAMAC_EVENT_INFO_STATUS_ERROR ;
00463     LoRaMac_stub::bool_value = false;
00464     radio._ev->rx_done(NULL, 0, 0, 0);
00465 
00466     ind.status  = LORAMAC_EVENT_INFO_STATUS_OK ;
00467 
00468     LoRaMac_stub::bool_value = true;
00469     //convert_to_msg_flag cases
00470     ind.fpending_status  = true;
00471     ind.type  = MCPS_PROPRIETARY ;
00472     radio._ev->rx_done(NULL, 0, 0, 0);
00473     EXPECT_TRUE(LORAWAN_STATUS_WOULD_BLOCK == object->handle_rx(data, 50, port, flags, true));
00474 
00475     ind.type  = MCPS_MULTICAST ;
00476     radio._ev->rx_done(NULL, 0, 0, 0);
00477     EXPECT_TRUE(LORAWAN_STATUS_WOULD_BLOCK == object->handle_rx(data, 50, port, flags, true));
00478 
00479     ind.type  = MCPS_UNCONFIRMED ;
00480     radio._ev->rx_done(NULL, 0, 0, 0);
00481 
00482     //read not complete
00483     EXPECT_TRUE(50 == object->handle_rx(data, 50, port, flags, false));
00484     EXPECT_EQ(10, data[10]);
00485 
00486     EXPECT_TRUE(50 == object->handle_rx(data, 50, port, flags, false));
00487     EXPECT_EQ(60, data[10]);
00488 
00489     //read complete
00490     EXPECT_TRUE(50 == object->handle_rx(data, 50, port, flags, false));
00491     EXPECT_EQ(100, data[0]);
00492 
00493     //read can fit the buffer
00494     for (int i= 0; i < 110; i++) {
00495         ind_buf[i] = i;
00496     }
00497     ind.buffer  = ind_buf;
00498     ind.buffer_size  = 50;
00499     ind.type  = mcps_type_t(66);
00500     radio._ev->rx_done(NULL, 0, 0, 0);
00501     EXPECT_TRUE(50 == object->handle_rx(data, 50, port, flags, false));
00502     EXPECT_EQ(10, data[10]);
00503 }
00504 
00505 TEST_F(Test_LoRaWANStack, set_link_check_request)
00506 {
00507     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->set_link_check_request());
00508 
00509     EventQueue queue;
00510     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00511 
00512     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00513     EXPECT_TRUE(LORAWAN_STATUS_PARAMETER_INVALID == object->set_link_check_request());
00514 
00515     lorawan_app_callbacks_t cb;
00516     cb.events = events_cb;
00517     cb.link_check_resp = lc_resp;
00518     cb.battery_level = batt_lvl;
00519     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_lora_callbacks(&cb));
00520     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_link_check_request());
00521 }
00522 
00523 TEST_F(Test_LoRaWANStack, remove_link_check_request)
00524 {
00525     object->remove_link_check_request();
00526 }
00527 
00528 TEST_F(Test_LoRaWANStack, shutdown)
00529 {
00530     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->shutdown());
00531 
00532     EventQueue queue;
00533     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00534 
00535     EXPECT_TRUE(LORAWAN_STATUS_DEVICE_OFF == object->shutdown());
00536 }
00537 
00538 TEST_F(Test_LoRaWANStack, set_device_class)
00539 {
00540     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->set_device_class(CLASS_A));
00541 
00542     EventQueue queue;
00543     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00544 
00545     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00546     EXPECT_TRUE(LORAWAN_STATUS_UNSUPPORTED == object->set_device_class(CLASS_B));
00547 
00548     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_device_class(CLASS_A));
00549 
00550     //Visit callback
00551     if (LoRaMac_stub::_ack_expiry_handler_for_class_c) {
00552         LoRaMac_stub::_ack_expiry_handler_for_class_c.call();
00553     }
00554 }
00555 
00556 TEST_F(Test_LoRaWANStack, acquire_tx_metadata)
00557 {
00558     lorawan_tx_metadata data;
00559     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->acquire_tx_metadata(data));
00560 
00561     EventQueue queue;
00562     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00563 
00564     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00565     // stale = true;
00566     EXPECT_TRUE(LORAWAN_STATUS_METADATA_NOT_AVAILABLE == object->acquire_tx_metadata(data));
00567 
00568     // stale = false;
00569     my_radio radio;
00570     my_LoRaPHY phy;
00571     object->bind_phy_and_radio_driver(radio, phy);
00572 
00573     struct equeue_event ptr;
00574     equeue_stub.void_ptr = &ptr;
00575     equeue_stub.call_cb_immediately = true;
00576     loramac_mcps_confirm_t  conf;
00577     LoRaMac_stub::mcps_conf_ptr = &conf;
00578     radio._ev->tx_done();
00579 
00580     EXPECT_TRUE(LORAWAN_STATUS_OK == object->acquire_tx_metadata(data));
00581 }
00582 
00583 TEST_F(Test_LoRaWANStack, acquire_rx_metadata)
00584 {
00585     lorawan_rx_metadata data;
00586     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->acquire_rx_metadata(data));
00587 
00588     EventQueue queue;
00589     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00590 
00591     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00592     // stale = true;
00593     EXPECT_TRUE(LORAWAN_STATUS_METADATA_NOT_AVAILABLE == object->acquire_rx_metadata(data));
00594 
00595     // stale = false;
00596     my_radio radio;
00597     my_LoRaPHY phy;
00598     object->bind_phy_and_radio_driver(radio, phy);
00599 
00600     struct equeue_event ptr;
00601     equeue_stub.void_ptr = &ptr;
00602     equeue_stub.call_cb_immediately = true;
00603     loramac_mcps_confirm_t  conf;
00604     LoRaMac_stub::mcps_conf_ptr = &conf;
00605     radio._ev->tx_done();
00606 
00607     loramac_mcps_indication_t  ind;
00608     LoRaMac_stub::mcps_ind_ptr = &ind;
00609 
00610     loramac_mlme_confirm_t  mlme;
00611     LoRaMac_stub::mlme_conf_ptr = &mlme;
00612     mlme.pending  = true;
00613     mlme.req_type  = MLME_JOIN ;
00614 
00615     //Visit mlme_confirm_handler here also
00616     mlme.status  = LORAMAC_EVENT_INFO_STATUS_CRYPTO_FAIL ;
00617     LoRaMac_stub::bool_value = false;
00618     radio._ev->rx_done(NULL, 0, 0, 0);
00619 
00620     mlme.status  = LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT ;
00621     radio._ev->rx_done(NULL, 0, 0, 0);
00622 
00623     mlme.status  = LORAMAC_EVENT_INFO_STATUS_RX1_TIMEOUT ;
00624     LoRaMac_stub::slot_value = RX_SLOT_WIN_2 ;
00625     radio._ev->rx_done(NULL, 0, 0, 0);
00626 
00627     lorawan_app_callbacks_t cb;
00628     cb.events = events_cb;
00629     cb.link_check_resp = lc_resp;
00630     cb.battery_level = batt_lvl;
00631     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_lora_callbacks(&cb));
00632     mlme.req_type  = MLME_LINK_CHECK ;
00633     mlme.status  = LORAMAC_EVENT_INFO_STATUS_OK ;
00634     radio._ev->rx_done(NULL, 0, 0, 0);
00635 
00636     EXPECT_TRUE(LORAWAN_STATUS_OK == object->acquire_rx_metadata(data));
00637 }
00638 
00639 TEST_F(Test_LoRaWANStack, acquire_backoff_metadata)
00640 {
00641     int b;
00642     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->acquire_backoff_metadata(b));
00643 
00644     EventQueue queue;
00645     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00646 
00647     LoRaMac_stub::int_value = 2;
00648     EXPECT_TRUE(LORAWAN_STATUS_OK == object->acquire_backoff_metadata(b));
00649 
00650     LoRaMac_stub::int_value = 0;
00651     EXPECT_TRUE(LORAWAN_STATUS_METADATA_NOT_AVAILABLE == object->acquire_backoff_metadata(b));
00652 }
00653 
00654 TEST_F(Test_LoRaWANStack, stop_sending)
00655 {
00656     EXPECT_TRUE(LORAWAN_STATUS_NOT_INITIALIZED == object->stop_sending());
00657 
00658     EventQueue queue;
00659     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00660 
00661     LoRaMac_stub::status_value = LORAWAN_STATUS_DEVICE_OFF;
00662     EXPECT_TRUE(LORAWAN_STATUS_BUSY == object->stop_sending());
00663 
00664     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00665     EXPECT_TRUE(LORAWAN_STATUS_OK == object->stop_sending());
00666 }
00667 
00668 TEST_F(Test_LoRaWANStack, lock)
00669 {
00670     object->lock();
00671 }
00672 
00673 TEST_F(Test_LoRaWANStack, unlock)
00674 {
00675     object->unlock();
00676 }
00677 
00678 TEST_F(Test_LoRaWANStack, interrupt_functions)
00679 {
00680     lorawan_connect_t conn;
00681     EventQueue queue;
00682     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00683 
00684     my_radio radio;
00685     my_LoRaPHY phy;
00686     object->bind_phy_and_radio_driver(radio, phy);
00687 
00688     struct equeue_event ptr;
00689     equeue_stub.void_ptr = &ptr;
00690     equeue_stub.call_cb_immediately = true;
00691     loramac_mcps_confirm_t  conf;
00692     LoRaMac_stub::mcps_conf_ptr = &conf;
00693     radio._ev->tx_done();
00694 
00695     loramac_mcps_indication_t  ind;
00696     LoRaMac_stub::mcps_ind_ptr = &ind;
00697 
00698     loramac_mlme_confirm_t  mlme;
00699     LoRaMac_stub::mlme_conf_ptr = &mlme;
00700     mlme.pending  = true;
00701     mlme.req_type  = MLME_JOIN ;
00702     mlme.status  = LORAMAC_EVENT_INFO_STATUS_OK ;
00703     LoRaMac_stub::bool_value = false;
00704     radio._ev->rx_done(NULL, 0, 0, 0);
00705 
00706     radio._ev->rx_done(NULL, 0, 0, 0);
00707 
00708     radio._ev->rx_error();
00709     LoRaMac_stub::slot_value = RX_SLOT_WIN_2 ;
00710     radio._ev->rx_error();
00711 
00712     conf.req_type  = MCPS_UNCONFIRMED ;
00713     LoRaMac_stub::bool_value = true;
00714     radio._ev->rx_error();
00715 
00716     conf.req_type  = MCPS_CONFIRMED ;
00717     radio._ev->rx_error();
00718 
00719     LoRaMac_stub::bool_value = false;
00720 
00721     LoRaMac_stub::slot_value = RX_SLOT_WIN_1 ;
00722     radio._ev->rx_timeout();
00723 
00724     radio._ev->tx_timeout();
00725 
00726     object->shutdown();
00727     conn.connect_type = LORAWAN_CONNECTION_OTAA;
00728     object->connect(conn);
00729     LoRaMac_stub::status_value = LORAWAN_STATUS_OK;
00730     object->connect(conn);
00731     radio._ev->tx_timeout();
00732 }
00733 
00734 TEST_F(Test_LoRaWANStack, process_transmission)
00735 {
00736     EventQueue queue;
00737     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00738 
00739     lorawan_app_callbacks_t cb;
00740     cb.events = events_cb;
00741     cb.link_check_resp = lc_resp;
00742     cb.battery_level = batt_lvl;
00743     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_lora_callbacks(&cb));
00744 
00745     my_radio radio;
00746     my_LoRaPHY phy;
00747     object->bind_phy_and_radio_driver(radio, phy);
00748 
00749     object->connect();
00750 
00751     struct equeue_event ptr;
00752     equeue_stub.void_ptr = &ptr;
00753     equeue_stub.call_cb_immediately = true;
00754     loramac_mcps_confirm_t  conf;
00755     LoRaMac_stub::mcps_conf_ptr = &conf;
00756     radio._ev->tx_done();
00757 
00758     loramac_mcps_indication_t  ind;
00759     LoRaMac_stub::mcps_ind_ptr = &ind;
00760 
00761     loramac_mlme_confirm_t  mlme;
00762     LoRaMac_stub::mlme_conf_ptr = &mlme;
00763     mlme.pending  = true;
00764     mlme.req_type  = MLME_JOIN ;
00765     mlme.status  = LORAMAC_EVENT_INFO_STATUS_OK ;
00766     LoRaMac_stub::bool_value = false;
00767     radio._ev->rx_done(NULL, 0, 0, 0);
00768 
00769     LoRaMac_stub::bool_value = true;
00770     conf.req_type  = MCPS_PROPRIETARY ;
00771     LoRaMac_stub::bool_false_counter = 1;
00772     LoRaMac_stub::dev_class_value = CLASS_A;
00773     object->handle_tx(1, NULL, 0, MSG_UNCONFIRMED_FLAG, true, false);
00774     radio._ev->tx_done();
00775 
00776     LoRaMac_stub::bool_false_counter = 1;
00777     LoRaMac_stub::dev_class_value = CLASS_A;
00778     object->handle_tx(1, NULL, 0, MSG_UNCONFIRMED_FLAG, true, false);
00779     radio._ev->tx_done();
00780 
00781     LoRaMac_stub::bool_false_counter = 1;
00782     LoRaMac_stub::dev_class_value = CLASS_C;
00783     object->handle_tx(1, NULL, 0, MSG_UNCONFIRMED_FLAG, true, false);
00784     radio._ev->tx_done();
00785 
00786     LoRaMac_stub::bool_false_counter = 1;
00787     conf.req_type  = MCPS_CONFIRMED ;
00788     object->handle_tx(1, NULL, 0, MSG_UNCONFIRMED_FLAG, true, false);
00789     radio._ev->tx_done();
00790 }
00791 
00792 TEST_F(Test_LoRaWANStack, process_reception)
00793 {
00794     EventQueue queue;
00795     EXPECT_TRUE(LORAWAN_STATUS_OK == object->initialize_mac_layer(&queue));
00796 
00797     //Prepare ready for receive state
00798     lorawan_app_callbacks_t cb;
00799     cb.events = events_cb;
00800     cb.link_check_resp = lc_resp;
00801     cb.battery_level = batt_lvl;
00802     EXPECT_TRUE(LORAWAN_STATUS_OK == object->set_lora_callbacks(&cb));
00803 
00804     my_radio radio;
00805     my_LoRaPHY phy;
00806     object->bind_phy_and_radio_driver(radio, phy);
00807 
00808     struct equeue_event ptr;
00809     equeue_stub.void_ptr = &ptr;
00810     equeue_stub.call_cb_immediately = true;
00811     loramac_mcps_confirm_t  conf;
00812     LoRaMac_stub::mcps_conf_ptr = &conf;
00813     radio._ev->tx_done();
00814 
00815     loramac_mcps_indication_t  ind;
00816     LoRaMac_stub::mcps_ind_ptr = &ind;
00817 
00818     loramac_mlme_confirm_t  mlme;
00819     LoRaMac_stub::mlme_conf_ptr = &mlme;
00820     mlme.pending  = false;
00821     mlme.req_type  = MLME_JOIN ;
00822     mlme.status  = LORAMAC_EVENT_INFO_STATUS_OK ;
00823     LoRaMac_stub::bool_value = true;
00824     conf.req_type  = MCPS_PROPRIETARY ;
00825 
00826     ind.pending  = true;
00827     LoRaMac_stub::dev_class_value = CLASS_C;
00828 
00829     loramac_mlme_indication_t  mlme_ind;
00830     mlme_ind.pending = false;
00831     LoRaMac_stub::mlme_ind_ptr = &mlme_ind;
00832 
00833     uint8_t ind_buf[150];
00834     for (int i= 0; i < 110; i++) {
00835         ind_buf[i] = i;
00836     }
00837     ind.buffer  = ind_buf;
00838     ind.buffer_size  = 150;
00839 
00840     //_loramac.get_mcps_confirmation()->req_type == MCPS_CONFIRMED
00841     conf.req_type  = MCPS_CONFIRMED ;
00842     conf.status  = LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT ;
00843     radio._ev->rx_done(NULL, 0, 0, 0);
00844 
00845     ind.is_ack_recvd  = false;
00846     LoRaMac_stub::bool_true_counter = 1;
00847     LoRaMac_stub::bool_value = false;
00848     LoRaMac_stub::slot_value = RX_SLOT_WIN_2 ;
00849     conf.status  = LORAMAC_EVENT_INFO_STATUS_TX_DR_PAYLOAD_SIZE_ERROR ;
00850     radio._ev->rx_done(NULL, 0, 0, 0);
00851 
00852     conf.req_type  = MCPS_UNCONFIRMED ;
00853     LoRaMac_stub::dev_class_value = CLASS_A;
00854     LoRaMac_stub::bool_value = true;
00855     mlme_ind.pending = true;
00856     mlme_ind.indication_type  = MLME_SCHEDULE_UPLINK ;
00857     conf.status  = LORAMAC_EVENT_INFO_STATUS_ERROR ;
00858     radio._ev->rx_done(NULL, 0, 0, 0);
00859 
00860     ind.is_ack_recvd  = true;
00861     conf.req_type  = MCPS_CONFIRMED ;
00862     conf.status  = LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT ;
00863     radio._ev->rx_done(NULL, 0, 0, 0);
00864 }
00865