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