test_m2mfirmware.cpp

00001 /*
00002  * Copyright (c) 2015 ARM Limited. All rights reserved.
00003  * SPDX-License-Identifier: Apache-2.0
00004  * Licensed under the Apache License, Version 2.0 (the License); you may
00005  * not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  * http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
00012  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 #include "CppUTest/TestHarness.h"
00017 #include "test_m2mfirmware.h"
00018 #include "m2mobject_stub.h"
00019 #include "m2mobjectinstance_stub.h"
00020 #include "m2mresource_stub.h"
00021 #include "m2mresourceinstance_stub.h"
00022 #include "m2mbase_stub.h"
00023 
00024 class Callback : public M2MObjectCallback {
00025 
00026 public:
00027 
00028     Callback(){}
00029     ~Callback(){}
00030     void notification_update(uint16_t obj_instance_id) {
00031         visited = true;
00032     }
00033 
00034     void clear() {visited = false;}
00035     bool visited;
00036 };
00037 
00038 
00039 Test_M2MFirmware::Test_M2MFirmware()
00040 {
00041     callback = new Callback();
00042     m2mobject_stub::inst = new M2MObjectInstance("name",*callback);
00043     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,"name","type",M2MResourceInstance::STRING,M2MBase::Dynamic);
00044     m2mobjectinstance_stub::create_resource_instance= new M2MResourceInstance("name","type",M2MResourceInstance::STRING,*m2mobject_stub::inst);
00045     m2mresource_stub::bool_value = true;
00046     m2mobjectinstance_stub::create_resource = new M2MResource(*m2mobject_stub::inst,"name","type",M2MResourceInstance::STRING,M2MBase::Dynamic);
00047     firmware = M2MFirmware::get_instance();
00048 
00049     delete m2mobjectinstance_stub::create_resource;
00050     m2mobjectinstance_stub::create_resource = NULL;
00051 
00052     delete m2mobjectinstance_stub::resource;
00053     m2mobjectinstance_stub::resource = NULL;
00054 
00055     delete m2mobjectinstance_stub::create_resource_instance;
00056     m2mobjectinstance_stub::create_resource_instance = NULL;
00057 }
00058 
00059 Test_M2MFirmware::~Test_M2MFirmware()
00060 {
00061     delete m2mobject_stub::inst;
00062     m2mobject_stub::inst = NULL;
00063 
00064     M2MFirmware::delete_instance();
00065     firmware = NULL;
00066     delete callback;
00067 }
00068 
00069 void Test_M2MFirmware::test_create_resource_string()
00070 {
00071     CHECK(firmware->create_resource(M2MFirmware::Package, "test") == NULL);
00072     CHECK(firmware->create_resource(M2MFirmware::Update, "test") == NULL);
00073     CHECK(firmware->create_resource(M2MFirmware::State, "test") == NULL);
00074 
00075     m2mobjectinstance_stub::create_resource = new M2MResource(*m2mobject_stub::inst,
00076                                                               "name",
00077                                                               "type",
00078                                                               M2MResourceInstance::STRING,
00079                                                               M2MBase::Dynamic);
00080 
00081     CHECK(firmware->create_resource(M2MFirmware::PackageName,"test") != NULL);
00082     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00083     CHECK(firmware->create_resource(M2MFirmware::PackageName,"") != NULL);
00084 
00085     // Check size limit
00086     String test = "";
00087     for (int i = 0; i <= 255; i++) {
00088         test.append("a", 1);
00089     }
00090     // 255 + null-termination
00091     CHECK(firmware->create_resource(M2MFirmware::PackageVersion,test) == NULL);
00092 
00093     test = "";
00094     for (int i = 0; i <= 254; i++) {
00095         test.append("a", 1);
00096     }
00097     // 254 + null-termination
00098     CHECK(firmware->create_resource(M2MFirmware::PackageVersion,test) != NULL);
00099     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00100 
00101 
00102     CHECK(firmware->create_resource(M2MFirmware::Package,"test") == NULL);
00103     CHECK(firmware->create_resource(M2MFirmware::Update,"test") == NULL);
00104     CHECK(firmware->create_resource(M2MFirmware::State,"test") == NULL);
00105     CHECK(firmware->create_resource(M2MFirmware::UpdateSupportedObjects,"test") == NULL);
00106     CHECK(firmware->create_resource(M2MFirmware::UpdateResult,"test") == NULL);
00107 
00108     delete m2mobjectinstance_stub::create_resource;
00109     m2mobjectinstance_stub::create_resource = NULL;
00110 }
00111 
00112 void Test_M2MFirmware::test_create_resource_int()
00113 {
00114     m2mobjectinstance_stub::create_resource = new M2MResource(*m2mobject_stub::inst,
00115                                                               "name",
00116                                                               "type",
00117                                                               M2MResourceInstance::INTEGER,
00118                                                               M2MBase::Dynamic);
00119 
00120     CHECK(firmware->create_resource(M2MFirmware::PackageVersion,10) == NULL);
00121     CHECK(firmware->create_resource(M2MFirmware::PackageName,10) == NULL);
00122     CHECK(firmware->create_resource(M2MFirmware::Package,10) == NULL);
00123     CHECK(firmware->create_resource(M2MFirmware::Update,10) == NULL);
00124 
00125     m2mbase_stub::void_value = malloc(20);
00126 
00127     CHECK(firmware->create_resource(M2MFirmware::UpdateSupportedObjects,false) != NULL);
00128     CHECK(firmware->create_resource(M2MFirmware::UpdateSupportedObjects,true) != NULL);
00129     CHECK(firmware->create_resource(M2MFirmware::UpdateSupportedObjects,5) == NULL);
00130     CHECK(M2MBase::GET_PUT_ALLOWED == m2mbase_stub::operation);
00131 
00132     CHECK(firmware->create_resource(M2MFirmware::Update,10) == NULL);
00133 
00134     free(m2mbase_stub::void_value);
00135     delete m2mobjectinstance_stub::create_resource;
00136     m2mobjectinstance_stub::create_resource = NULL;
00137 }
00138 
00139 
00140 void Test_M2MFirmware::test_delete_resource()
00141 {
00142     m2mobjectinstance_stub::bool_value = true;
00143 
00144     CHECK(firmware->delete_resource(M2MFirmware::PackageName) == true);
00145     CHECK(firmware->delete_resource(M2MFirmware::PackageVersion) == true);
00146     CHECK(firmware->delete_resource(M2MFirmware::UpdateSupportedObjects) == true);
00147 
00148     CHECK(firmware->delete_resource(M2MFirmware::Package) == false);
00149     CHECK(firmware->delete_resource(M2MFirmware::PackageUri) == false);
00150     CHECK(firmware->delete_resource(M2MFirmware::State) == false);
00151     CHECK(firmware->delete_resource(M2MFirmware::UpdateResult) == false);
00152     CHECK(firmware->delete_resource(M2MFirmware::Update) == false);
00153 }
00154 
00155 void Test_M2MFirmware::test_set_resource_value_string()
00156 {
00157     m2mresourceinstance_stub::value = NULL;
00158     m2mbase_stub::bool_value = true;
00159     m2mresourceinstance_stub::bool_value = true;
00160 
00161     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00162                                                        "name",
00163                                                        "type",
00164                                                        M2MResourceInstance::STRING,M2MBase::Dynamic);
00165     m2mresource_stub::bool_value = false;
00166 
00167     m2mbase_stub::void_value = malloc(20);
00168 
00169     CHECK(firmware->set_resource_value(M2MFirmware::PackageName,"test") == true);
00170     CHECK(firmware->set_resource_value(M2MFirmware::PackageVersion,"test") == true);
00171     CHECK(firmware->set_resource_value(M2MFirmware::PackageUri,"test") == true);
00172     CHECK(firmware->set_resource_value(M2MFirmware::PackageUri,"") == true);
00173 
00174     // Check size limit
00175     String test = "";
00176     for (int i = 0; i <= 255; i++) {
00177         test.append("a", 1);
00178     }
00179     CHECK(firmware->set_resource_value(M2MFirmware::PackageUri,test) == false);
00180 
00181     CHECK(firmware->set_resource_value(M2MFirmware::Package,"test") == false);
00182     CHECK(firmware->set_resource_value(M2MFirmware::State,"test") == false);
00183     CHECK(firmware->set_resource_value(M2MFirmware::UpdateResult,"test") == false);
00184     CHECK(firmware->set_resource_value(M2MFirmware::UpdateSupportedObjects,"test") == false);
00185     CHECK(firmware->set_resource_value(M2MFirmware::Update,"test") == false);
00186 
00187     free(m2mbase_stub::void_value);
00188     delete m2mobjectinstance_stub::resource;
00189     m2mobjectinstance_stub::resource = NULL;
00190 }
00191 
00192 void Test_M2MFirmware::test_set_resource_value_int()
00193 {
00194     m2mresourceinstance_stub::bool_value = true;
00195 
00196     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00197                                                        "name",
00198                                                        "type",
00199                                                        M2MResourceInstance::INTEGER,
00200                                                        M2MBase::Dynamic);
00201     m2mresource_stub::bool_value = false;
00202 
00203     m2mbase_stub::void_value = malloc(20);
00204 
00205     CHECK(firmware->set_resource_value(M2MFirmware::PackageName,10) == false);
00206     CHECK(firmware->set_resource_value(M2MFirmware::PackageVersion,10) == false);
00207     CHECK(firmware->set_resource_value(M2MFirmware::PackageUri,10) == false);
00208 
00209     CHECK(firmware->set_resource_value(M2MFirmware::Package,10) == false);
00210     CHECK(firmware->set_resource_value(M2MFirmware::State,2) == true);
00211     CHECK(firmware->set_resource_value(M2MFirmware::State,1) == true);
00212     CHECK(firmware->set_resource_value(M2MFirmware::State,3) == true);
00213     CHECK(firmware->set_resource_value(M2MFirmware::State,4) == false);
00214     CHECK(firmware->set_resource_value(M2MFirmware::State,0) == true);
00215     CHECK(firmware->set_resource_value(M2MFirmware::UpdateResult,2) == true);
00216     CHECK(firmware->set_resource_value(M2MFirmware::UpdateResult,20) == false);
00217     CHECK(firmware->set_resource_value(M2MFirmware::UpdateSupportedObjects,true) == true);
00218     CHECK(firmware->set_resource_value(M2MFirmware::Update,10) == false);
00219     CHECK(firmware->check_value_range(M2MFirmware::Update,10) == false);
00220 
00221     free(m2mbase_stub::void_value);
00222     delete m2mobjectinstance_stub::resource;
00223     m2mobjectinstance_stub::resource = NULL;
00224 }
00225 
00226 
00227 void Test_M2MFirmware::test_resource_value_int()
00228 {
00229     uint8_t value[] = {"10"};
00230     uint8_t* ptr = (uint8_t*)malloc((uint32_t)sizeof(value));
00231     m2mresourceinstance_stub::value = ptr;
00232     memset(m2mresourceinstance_stub::value,0,(uint32_t)sizeof(value));
00233     memcpy(m2mresourceinstance_stub::value, value,sizeof(value));
00234     m2mresourceinstance_stub::int_value = (uint32_t)sizeof(value);
00235 
00236     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00237                                                        "name",
00238                                                        "type",
00239                                                        M2MResourceInstance::INTEGER,
00240                                                        M2MBase::Dynamic);
00241 
00242     m2mresourceinstance_stub::bool_value = true;
00243     m2mresource_stub::bool_value = false;
00244     m2mbase_stub::void_value = malloc(20);
00245 
00246     CHECK(firmware->resource_value_int(M2MFirmware::State) == 10);
00247     CHECK(firmware->resource_value_int(M2MFirmware::UpdateResult) == 10);
00248     CHECK(firmware->resource_value_int(M2MFirmware::UpdateSupportedObjects) == 10);
00249     CHECK(firmware->resource_value_int(M2MFirmware::PackageName) == -1);
00250     CHECK(firmware->resource_value_int(M2MFirmware::Package) == -1);
00251     CHECK(firmware->resource_value_int(M2MFirmware::PackageUri) == -1);
00252     CHECK(firmware->resource_value_int(M2MFirmware::PackageVersion) == -1);
00253     CHECK(firmware->resource_value_int(M2MFirmware::Update) == -1);
00254 
00255     free(m2mbase_stub::void_value);
00256     delete m2mobjectinstance_stub::resource;
00257     m2mobjectinstance_stub::resource = NULL;
00258 
00259     free(ptr);
00260 }
00261 
00262 void Test_M2MFirmware::test_resource_value_string()
00263 {
00264     String test = "string";
00265     uint8_t value[] = {"string"};
00266     m2mresourceinstance_stub::value = (uint8_t*)malloc((uint32_t)sizeof(value));
00267     memset(m2mresourceinstance_stub::value,0,(uint32_t)sizeof(value));
00268     memcpy(m2mresourceinstance_stub::value,value,sizeof(value));
00269     m2mresourceinstance_stub::int_value = (uint32_t)sizeof(value);
00270 
00271     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00272                                                        "name",
00273                                                        "type",
00274                                                        M2MResourceInstance::STRING,
00275                                                        M2MBase::Dynamic);
00276 
00277     m2mresourceinstance_stub::bool_value = true;
00278     m2mresource_stub::bool_value = false;
00279     m2mbase_stub::void_value = malloc(20);
00280 
00281     CHECK(firmware->resource_value_string(M2MFirmware::PackageUri) == test);
00282     CHECK(firmware->resource_value_string(M2MFirmware::PackageName) == test);
00283     CHECK(firmware->resource_value_string(M2MFirmware::PackageVersion) == test);
00284     CHECK(firmware->resource_value_string(M2MFirmware::Package) == "");
00285     CHECK(firmware->resource_value_string(M2MFirmware::Update) == "");
00286     CHECK(firmware->resource_value_string(M2MFirmware::UpdateResult) == "");
00287     CHECK(firmware->resource_value_string(M2MFirmware::UpdateSupportedObjects) == "");
00288     CHECK(firmware->resource_value_string(M2MFirmware::State) == "");
00289 
00290     free(m2mbase_stub::void_value);
00291 
00292     delete m2mobjectinstance_stub::resource;
00293     m2mobjectinstance_stub::resource = NULL;
00294 
00295     free(m2mresourceinstance_stub::value);
00296     m2mresourceinstance_stub::value = NULL;
00297 }
00298 
00299 void Test_M2MFirmware::test_is_resource_present()
00300 {
00301     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00302                                                        "name",
00303                                                        "type",
00304                                                        M2MResourceInstance::STRING,
00305                                                        M2MBase::Dynamic);
00306     m2mresource_stub::bool_value = false;
00307     CHECK(firmware->is_resource_present(M2MFirmware::PackageUri) == true);
00308 
00309     delete m2mobjectinstance_stub::resource;
00310     m2mobjectinstance_stub::resource = NULL;
00311 
00312     CHECK(firmware->is_resource_present(M2MFirmware::PackageName) == false);
00313     CHECK(firmware->is_resource_present(M2MFirmware::PackageVersion) == false);
00314 }
00315 
00316 void Test_M2MFirmware::test_per_resource_count()
00317 {
00318     m2mobjectinstance_stub::int_value = 1;
00319     CHECK(firmware->per_resource_count(M2MFirmware::Package) == 1);
00320 
00321     m2mobjectinstance_stub::int_value = 0;
00322 
00323     CHECK(firmware->per_resource_count(M2MFirmware::PackageVersion) == 0);
00324 }
00325 
00326 
00327 
00328 void Test_M2MFirmware::test_total_resource_count()
00329 {
00330     M2MResource res(*m2mobject_stub::inst,
00331                     "test",
00332                     "test",
00333                     M2MResourceInstance::STRING,
00334                     M2MBase::Dynamic);
00335 
00336     m2mobjectinstance_stub::resource_list.push_back(&res);
00337     M2MResource res2(*m2mobject_stub::inst,
00338                      "test",
00339                      "test",
00340                      M2MResourceInstance::STRING,
00341                      M2MBase::Dynamic);
00342 
00343     m2mobjectinstance_stub::resource_list.push_back(&res2);
00344 
00345     CHECK(firmware->total_resource_count() == 2);
00346 
00347     m2mobjectinstance_stub::resource_list.clear();
00348 }
00349 
00350 void Test_M2MFirmware::test_resource_value_buffer()
00351 {
00352     m2mresourceinstance_stub::bool_value = true;
00353 
00354     uint8_t value[] = {"buffer"};
00355     uint8_t *out_value = NULL;
00356 
00357     m2mresourceinstance_stub::value = (uint8_t*)malloc((uint32_t)sizeof(value));
00358     memset(m2mresourceinstance_stub::value,0,(uint32_t)sizeof(value));
00359     memcpy(m2mresourceinstance_stub::value,value,sizeof(value));
00360     m2mresourceinstance_stub::int_value = (uint16_t)sizeof(value);
00361 
00362     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00363                                                        "name",
00364                                                        "type",
00365                                                        M2MResourceInstance::STRING,
00366                                                        M2MBase::Dynamic);
00367 
00368     CHECK(firmware->resource_value_buffer(M2MFirmware::Package,out_value) != 0);
00369 
00370     CHECK(firmware->resource_value_buffer(M2MFirmware::PackageName,out_value) == 0);
00371     CHECK(firmware->resource_value_buffer(M2MFirmware::PackageUri,out_value) == 0);
00372     CHECK(firmware->resource_value_buffer(M2MFirmware::PackageVersion,out_value) == 0);
00373     CHECK(firmware->resource_value_buffer(M2MFirmware::Update,out_value) == 0);
00374     CHECK(firmware->resource_value_buffer(M2MFirmware::State,out_value) == 0);
00375     CHECK(firmware->resource_value_buffer(M2MFirmware::UpdateResult,out_value) == 0);
00376     CHECK(firmware->resource_value_buffer(M2MFirmware::UpdateSupportedObjects,out_value) == 0);
00377 
00378 
00379     free(out_value);
00380     out_value = NULL;
00381 
00382     delete m2mobjectinstance_stub::resource;
00383     m2mobjectinstance_stub::resource = NULL;
00384 
00385     free(m2mresourceinstance_stub::value);
00386     m2mresourceinstance_stub::value = NULL;
00387 }
00388 
00389 void Test_M2MFirmware::test_set_resource_value_buffer()
00390 {
00391     m2mresourceinstance_stub::bool_value = true;
00392 
00393     uint8_t value[] = {"value"};
00394     uint16_t length = (uint16_t)sizeof(value);
00395 
00396     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00397                                                        "name",
00398                                                        "type",
00399                                                        M2MResourceInstance::STRING,
00400                                                        M2MBase::Dynamic);
00401 
00402     CHECK(firmware->set_resource_value(M2MFirmware::Package,value,length) == true);
00403     CHECK(firmware->set_resource_value(M2MFirmware::PackageName,value,length) == false);
00404     CHECK(firmware->set_resource_value(M2MFirmware::PackageUri,value,length) == false);
00405     CHECK(firmware->set_resource_value(M2MFirmware::PackageVersion,value,length) == false);
00406     CHECK(firmware->set_resource_value(M2MFirmware::State,value,length) == false);
00407     CHECK(firmware->set_resource_value(M2MFirmware::Update,value,length) == false);
00408     CHECK(firmware->set_resource_value(M2MFirmware::UpdateResult,value,length) == false);
00409     CHECK(firmware->set_resource_value(M2MFirmware::UpdateSupportedObjects,value,length) == false);
00410 
00411     delete m2mobjectinstance_stub::resource;
00412     m2mobjectinstance_stub::resource = NULL;
00413 }
00414 
00415 void Test_M2MFirmware::test_resource_name()
00416 {
00417     CHECK(firmware->resource_name(M2MFirmware::Package) == "0");
00418     CHECK(firmware->resource_name(M2MFirmware::PackageUri) == "1");
00419     CHECK(firmware->resource_name(M2MFirmware::Update) == "2");
00420     CHECK(firmware->resource_name(M2MFirmware::State) == "3");
00421     CHECK(firmware->resource_name(M2MFirmware::UpdateSupportedObjects) == "4");
00422     CHECK(firmware->resource_name(M2MFirmware::UpdateResult) == "5");
00423     CHECK(firmware->resource_name(M2MFirmware::PackageName) == "6");
00424     CHECK(firmware->resource_name(M2MFirmware::PackageVersion) == "7");
00425 }