test_m2mdevice.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_m2mdevice.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 Test_M2MDevice::Test_M2MDevice()
00025 {
00026     M2MObject* obj = new M2MObject("name", "name");
00027     m2mobject_stub::inst = new M2MObjectInstance(*obj,
00028                                                  "name",
00029                                                  "","");
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     device = M2MDevice::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 
00062     delete obj;
00063 }
00064 
00065 Test_M2MDevice::~Test_M2MDevice()
00066 {
00067     delete m2mobject_stub::inst;
00068     m2mobject_stub::inst = NULL;
00069 
00070     M2MDevice::delete_instance();
00071     device = NULL;
00072 }
00073 
00074 void Test_M2MDevice::test_create_resource_instance()
00075 {
00076     m2mobjectinstance_stub::create_resource_instance = new M2MResourceInstance(*m2mobjectinstance_stub::resource,
00077                                                                              "name",
00078                                                                              "type",
00079                                                                              M2MResourceInstance::STRING,
00080                                                                              0,
00081                                                                              "name",
00082                                                                              false);
00083 
00084     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00085                                                        "name",
00086                                                        "type",
00087                                                        M2MResourceInstance::STRING,
00088                                                        false,
00089                                                        "name");
00090 
00091     CHECK(device->create_resource_instance(M2MDevice::ErrorCode,5,1) != NULL);
00092     CHECK(device->create_resource_instance(M2MDevice::ErrorCode,-1,1) == NULL);
00093     CHECK(device->create_resource_instance(M2MDevice::ErrorCode,9,1) == NULL);
00094 
00095     m2mbase_stub::void_value = malloc(20);
00096 
00097     CHECK(device->create_resource_instance(M2MDevice::AvailablePowerSources,-1,0) == NULL);
00098     CHECK(device->create_resource_instance(M2MDevice::AvailablePowerSources,8,0) == NULL);
00099     CHECK(device->create_resource_instance(M2MDevice::AvailablePowerSources,7,0) != NULL);
00100     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00101 
00102     CHECK(device->create_resource_instance(M2MDevice::PowerSourceVoltage,10,0) != NULL);
00103     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00104 
00105     CHECK(device->create_resource_instance(M2MDevice::PowerSourceCurrent,10,0) != NULL);
00106     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00107 
00108     free(m2mbase_stub::void_value);
00109     delete m2mobjectinstance_stub::create_resource_instance;
00110     m2mobjectinstance_stub::create_resource_instance = NULL;
00111 
00112     delete m2mobjectinstance_stub::resource;
00113     m2mobjectinstance_stub::resource  = NULL;
00114 }
00115 
00116 void Test_M2MDevice::test_create_resource_string()
00117 {
00118     m2mresourceinstance_stub::value = NULL;
00119     CHECK(device->create_resource(M2MDevice::Reboot,"test") == NULL);
00120     CHECK(device->create_resource(M2MDevice::ErrorCode,"test") == NULL);
00121     CHECK(device->create_resource(M2MDevice::SupportedBindingMode,"test") == NULL);
00122     // Length 65, should fail
00123     String max_lenght = "65656565656565656565656565656565656565656565656565656565656565656";
00124     m2mobjectinstance_stub::create_resource = new M2MResource(*m2mobject_stub::inst,
00125                                                               "name",
00126                                                               "type",
00127                                                               M2MResourceInstance::STRING,
00128                                                               false,
00129                                                               "name");
00130 
00131     CHECK(device->create_resource(M2MDevice::Manufacturer,"test") != NULL);
00132     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00133 
00134     CHECK(device->create_resource(M2MDevice::Manufacturer,max_lenght) == NULL);
00135     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00136 
00137     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00138                                                        "name",
00139                                                        "type",
00140                                                        M2MResourceInstance::STRING,
00141                                                        false,
00142                                                        "name");
00143     m2mresource_stub::bool_value = false;
00144     //Duplicate resource
00145     CHECK(device->create_resource(M2MDevice::Manufacturer,"test") == NULL);
00146 
00147     delete m2mobjectinstance_stub::resource;
00148     m2mobjectinstance_stub::resource = NULL;
00149 
00150     CHECK(device->create_resource(M2MDevice::DeviceType,"test") != NULL);
00151     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00152     CHECK(device->create_resource(M2MDevice::DeviceType,"") != NULL);
00153     CHECK(device->create_resource(M2MDevice::DeviceType,max_lenght) == NULL);
00154 
00155     CHECK(device->create_resource(M2MDevice::ModelNumber,"test") != NULL);
00156     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00157     CHECK(device->create_resource(M2MDevice::ModelNumber,max_lenght) == NULL);
00158 
00159 
00160     CHECK(device->create_resource(M2MDevice::SerialNumber,"test") != NULL);
00161     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00162     CHECK(device->create_resource(M2MDevice::SerialNumber,max_lenght) == NULL);
00163 
00164 
00165     CHECK(device->create_resource(M2MDevice::HardwareVersion,"test") != NULL);
00166     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00167     CHECK(device->create_resource(M2MDevice::HardwareVersion,max_lenght) == NULL);
00168 
00169 
00170     CHECK(device->create_resource(M2MDevice::FirmwareVersion,"test") != NULL);
00171     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00172     CHECK(device->create_resource(M2MDevice::FirmwareVersion,max_lenght) == NULL);
00173 
00174 
00175     CHECK(device->create_resource(M2MDevice::SoftwareVersion,"test") != NULL);
00176     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00177     CHECK(device->create_resource(M2MDevice::SoftwareVersion,max_lenght) == NULL);
00178 
00179 
00180     CHECK(device->create_resource(M2MDevice::UTCOffset,"test") != NULL);
00181     CHECK(M2MBase::GET_PUT_ALLOWED == m2mbase_stub::operation);
00182     CHECK(device->create_resource(M2MDevice::UTCOffset,max_lenght) == NULL);
00183 
00184 
00185     CHECK(device->create_resource(M2MDevice::Timezone,"test") != NULL);
00186     CHECK(M2MBase::GET_PUT_ALLOWED == m2mbase_stub::operation);
00187     CHECK(device->create_resource(M2MDevice::Timezone,max_lenght) == NULL);
00188 
00189     CHECK(device->create_resource(M2MDevice::BatteryLevel,"test") == NULL);
00190     CHECK(device->create_resource(M2MDevice::BatteryStatus,"test") == NULL);
00191     CHECK(device->create_resource(M2MDevice::MemoryFree,"test") == NULL);
00192     CHECK(device->create_resource(M2MDevice::MemoryTotal,"test") == NULL);
00193     CHECK(device->create_resource(M2MDevice::ResetErrorCode,"test") == NULL);
00194     CHECK(device->create_resource(M2MDevice::CurrentTime,"test") == NULL);
00195     CHECK(device->create_resource(M2MDevice::AvailablePowerSources,"test") == NULL);
00196     CHECK(device->create_resource(M2MDevice::PowerSourceVoltage,"test") == NULL);
00197     CHECK(device->create_resource(M2MDevice::PowerSourceCurrent,"test") == NULL);
00198     CHECK(device->create_resource(M2MDevice::FactoryReset,"test") == NULL);
00199 
00200     delete m2mobjectinstance_stub::create_resource;
00201     m2mobjectinstance_stub::create_resource = NULL;
00202 }
00203 
00204 void Test_M2MDevice::test_create_resource_int()
00205 {
00206     m2mobjectinstance_stub::create_resource = new M2MResource(*m2mobject_stub::inst,
00207                                                               "name",
00208                                                               "type",
00209                                                               M2MResourceInstance::STRING,
00210                                                               false,
00211                                                               "name");
00212 
00213     CHECK(device->create_resource(M2MDevice::Reboot,10) == NULL);
00214     CHECK(device->create_resource(M2MDevice::SupportedBindingMode,10) == NULL);
00215 
00216     CHECK(device->create_resource(M2MDevice::Manufacturer,10) == NULL);
00217     CHECK(device->create_resource(M2MDevice::DeviceType,10) == NULL);
00218     CHECK(device->create_resource(M2MDevice::ModelNumber,10) == NULL);
00219     CHECK(device->create_resource(M2MDevice::SerialNumber,10) == NULL);
00220     CHECK(device->create_resource(M2MDevice::HardwareVersion,10) == NULL);
00221     CHECK(device->create_resource(M2MDevice::FirmwareVersion,10) == NULL);
00222     CHECK(device->create_resource(M2MDevice::SoftwareVersion,10) == NULL);
00223     CHECK(device->create_resource(M2MDevice::UTCOffset,10) == NULL);
00224     CHECK(device->create_resource(M2MDevice::Timezone,10) == NULL);
00225     CHECK(device->create_resource(M2MDevice::FactoryReset,10) == NULL);
00226 
00227     m2mbase_stub::void_value = malloc(20);
00228 
00229     CHECK(device->create_resource(M2MDevice::BatteryLevel,10) != NULL);
00230     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00231 
00232     // Range is above 100
00233     CHECK(device->create_resource(M2MDevice::BatteryLevel,101) == NULL);
00234 
00235     CHECK(device->create_resource(M2MDevice::BatteryStatus,4) != NULL);
00236     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00237 
00238     // Range is above 6
00239     CHECK(device->create_resource(M2MDevice::BatteryStatus,10) == NULL);
00240 
00241     CHECK(device->create_resource(M2MDevice::MemoryFree,10) != NULL);
00242     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00243 
00244     CHECK(device->create_resource(M2MDevice::MemoryTotal,10) != NULL);
00245     CHECK(M2MBase::GET_ALLOWED == m2mbase_stub::operation);
00246 
00247     CHECK(device->create_resource(M2MDevice::CurrentTime,10) != NULL);
00248     CHECK(M2MBase::GET_PUT_ALLOWED == m2mbase_stub::operation);
00249 
00250     free(m2mbase_stub::void_value);
00251     delete m2mobjectinstance_stub::create_resource;
00252     m2mobjectinstance_stub::create_resource = NULL;
00253 }
00254 
00255 void Test_M2MDevice::test_create_resource_no_param()
00256 {
00257     m2mobjectinstance_stub::create_resource = new M2MResource(*m2mobject_stub::inst,
00258                                                               "name",
00259                                                               "type",
00260                                                               M2MResourceInstance::STRING,
00261                                                               false,
00262                                                               "name");
00263 
00264 
00265     CHECK(device->create_resource(M2MDevice::Reboot) == NULL);
00266     CHECK(device->create_resource(M2MDevice::ErrorCode) == NULL);
00267     CHECK(device->create_resource(M2MDevice::SupportedBindingMode) == NULL);
00268 
00269     CHECK(device->create_resource(M2MDevice::Manufacturer) == NULL);
00270     CHECK(device->create_resource(M2MDevice::DeviceType) == NULL);
00271     CHECK(device->create_resource(M2MDevice::ModelNumber) == NULL);
00272     CHECK(device->create_resource(M2MDevice::SerialNumber) == NULL);
00273     CHECK(device->create_resource(M2MDevice::HardwareVersion) == NULL);
00274     CHECK(device->create_resource(M2MDevice::FirmwareVersion) == NULL);
00275     CHECK(device->create_resource(M2MDevice::SoftwareVersion) == NULL);
00276     CHECK(device->create_resource(M2MDevice::UTCOffset) == NULL);
00277     CHECK(device->create_resource(M2MDevice::Timezone) == NULL);
00278 
00279     CHECK(device->create_resource(M2MDevice::BatteryLevel) == NULL);
00280     CHECK(device->create_resource(M2MDevice::BatteryStatus) == NULL);
00281     CHECK(device->create_resource(M2MDevice::MemoryFree) == NULL);
00282     CHECK(device->create_resource(M2MDevice::MemoryTotal) == NULL);
00283     CHECK(device->create_resource(M2MDevice::CurrentTime) == NULL);
00284     CHECK(device->create_resource(M2MDevice::AvailablePowerSources) == NULL);
00285     CHECK(device->create_resource(M2MDevice::PowerSourceVoltage) == NULL);
00286     CHECK(device->create_resource(M2MDevice::PowerSourceCurrent) == NULL);
00287 
00288     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00289                                                        "name",
00290                                                        "type",
00291                                                        M2MResourceInstance::STRING,
00292                                                        false,
00293                                                        "name");
00294 
00295     CHECK(device->create_resource(M2MDevice::ResetErrorCode) != NULL);
00296 
00297     CHECK(device->create_resource(M2MDevice::FactoryReset) != NULL);
00298 
00299     delete m2mobjectinstance_stub::resource;
00300     m2mobjectinstance_stub::resource = NULL;
00301 
00302     CHECK(M2MBase::POST_ALLOWED == m2mbase_stub::operation);
00303 
00304     delete m2mobjectinstance_stub::create_resource;
00305     m2mobjectinstance_stub::create_resource = NULL;
00306 
00307 
00308 }
00309 
00310 void Test_M2MDevice::test_delete_resource()
00311 {
00312     m2mobjectinstance_stub::bool_value = true;
00313 
00314     CHECK(device->delete_resource(M2MDevice::Reboot) == false);
00315     CHECK(device->delete_resource(M2MDevice::ErrorCode) == false);
00316     CHECK(device->delete_resource(M2MDevice::SupportedBindingMode) == false);
00317 
00318     CHECK(device->delete_resource(M2MDevice::Manufacturer) == true);
00319     CHECK(device->delete_resource(M2MDevice::BatteryLevel) == true);
00320     CHECK(device->delete_resource(M2MDevice::FactoryReset) == true);
00321 }
00322 
00323 void Test_M2MDevice::test_delete_resource_instance()
00324 {
00325     m2mobjectinstance_stub::bool_value = true;
00326 
00327     CHECK(device->delete_resource_instance(M2MDevice::Reboot,0) == false);
00328     CHECK(device->delete_resource_instance(M2MDevice::ErrorCode,0) == false);
00329     CHECK(device->delete_resource_instance(M2MDevice::SupportedBindingMode,0) == false);
00330 
00331     CHECK(device->delete_resource_instance(M2MDevice::AvailablePowerSources,0) == true);
00332     CHECK(device->delete_resource_instance(M2MDevice::PowerSourceVoltage,0) == true);
00333     CHECK(device->delete_resource_instance(M2MDevice::PowerSourceCurrent,0) == true);
00334 }
00335 
00336 void Test_M2MDevice::test_set_resource_value_string()
00337 {
00338     // Length 65, should fail
00339     m2mresourceinstance_stub::value = NULL;
00340     String max_lenght = "65656565656565656565656565656565656565656565656565656565656565656";
00341     m2mbase_stub::bool_value = true;
00342     m2mresourceinstance_stub::bool_value = true;
00343 
00344     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00345                                                        "name",
00346                                                        "type",
00347                                                        M2MResourceInstance::STRING,
00348                                                        false,
00349                                                        "name");
00350     m2mresource_stub::bool_value = false;
00351 
00352     m2mbase_stub::void_value = malloc(20);
00353 
00354     CHECK(device->set_resource_value(M2MDevice::Reboot,"test") == false);
00355     CHECK(device->set_resource_value(M2MDevice::ErrorCode,"test") == false);
00356     CHECK(device->set_resource_value(M2MDevice::SupportedBindingMode,"test") == false);
00357 
00358     CHECK(device->set_resource_value(M2MDevice::Manufacturer,"test") == true);
00359     CHECK(device->set_resource_value(M2MDevice::Manufacturer,"") == true);
00360     CHECK(device->set_resource_value(M2MDevice::Manufacturer,max_lenght) == false);
00361     CHECK(device->set_resource_value(M2MDevice::DeviceType,"test") == true);
00362     CHECK(device->set_resource_value(M2MDevice::DeviceType,max_lenght) == false);
00363     CHECK(device->set_resource_value(M2MDevice::ModelNumber,"test") == true);
00364     CHECK(device->set_resource_value(M2MDevice::ModelNumber,max_lenght) == false);
00365     CHECK(device->set_resource_value(M2MDevice::SerialNumber,"test") == true);
00366     CHECK(device->set_resource_value(M2MDevice::SerialNumber,max_lenght) == false);
00367     CHECK(device->set_resource_value(M2MDevice::HardwareVersion,"test") == true);
00368     CHECK(device->set_resource_value(M2MDevice::HardwareVersion,max_lenght) == false);
00369     CHECK(device->set_resource_value(M2MDevice::FirmwareVersion,"test") == true);
00370     CHECK(device->set_resource_value(M2MDevice::FirmwareVersion,max_lenght) == false);
00371     CHECK(device->set_resource_value(M2MDevice::SoftwareVersion,"test") == true);
00372     CHECK(device->set_resource_value(M2MDevice::SoftwareVersion,max_lenght) == false);
00373     CHECK(device->set_resource_value(M2MDevice::UTCOffset,"test") == true);
00374     CHECK(device->set_resource_value(M2MDevice::UTCOffset,max_lenght) == false);
00375     CHECK(device->set_resource_value(M2MDevice::Timezone,"test") == true);
00376     CHECK(device->set_resource_value(M2MDevice::Timezone,max_lenght) == false);
00377     CHECK(device->set_resource_value(M2MDevice::Timezone,"") == true);
00378 
00379     CHECK(device->set_resource_value(M2MDevice::BatteryLevel,"test") == false);
00380     CHECK(device->set_resource_value(M2MDevice::BatteryStatus,"test") == false);
00381     CHECK(device->set_resource_value(M2MDevice::MemoryFree,"test") == false);
00382     CHECK(device->set_resource_value(M2MDevice::MemoryTotal,"test") == false);
00383     CHECK(device->set_resource_value(M2MDevice::ResetErrorCode,"test") == false);
00384     CHECK(device->set_resource_value(M2MDevice::CurrentTime,"test") == false);
00385     CHECK(device->set_resource_value(M2MDevice::AvailablePowerSources,"test") == false);
00386     CHECK(device->set_resource_value(M2MDevice::PowerSourceVoltage,"test") == false);
00387     CHECK(device->set_resource_value(M2MDevice::PowerSourceCurrent,"test") == false);
00388     CHECK(device->set_resource_value(M2MDevice::FactoryReset,"test") == false);
00389 
00390     free(m2mbase_stub::void_value);
00391     delete m2mobjectinstance_stub::resource;
00392     m2mobjectinstance_stub::resource = NULL;
00393 }
00394 
00395 void Test_M2MDevice::test_set_resource_value_int()
00396 {
00397     m2mresourceinstance_stub::bool_value = true;
00398 
00399     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00400                                                        "name",
00401                                                        "type",
00402                                                        M2MResourceInstance::STRING,
00403                                                        false,
00404                                                        "name");
00405     m2mresource_stub::bool_value = false;
00406 
00407     m2mbase_stub::void_value = malloc(20);
00408 
00409     CHECK(device->set_resource_value(M2MDevice::Reboot,10) == false);
00410     CHECK(device->set_resource_value(M2MDevice::SupportedBindingMode,10) == false);
00411 
00412     CHECK(device->set_resource_value(M2MDevice::Manufacturer,10) == false);
00413     CHECK(device->set_resource_value(M2MDevice::DeviceType,10) == false);
00414     CHECK(device->set_resource_value(M2MDevice::ModelNumber,10) == false);
00415     CHECK(device->set_resource_value(M2MDevice::SerialNumber,10) == false);
00416     CHECK(device->set_resource_value(M2MDevice::HardwareVersion,10) == false);
00417     CHECK(device->set_resource_value(M2MDevice::FirmwareVersion,10) == false);
00418     CHECK(device->set_resource_value(M2MDevice::SoftwareVersion,10) == false);
00419     CHECK(device->set_resource_value(M2MDevice::UTCOffset,10) == false);
00420     CHECK(device->set_resource_value(M2MDevice::Timezone,10) == false);
00421 
00422     CHECK(device->set_resource_value(M2MDevice::BatteryLevel,-1) == false);
00423     CHECK(device->set_resource_value(M2MDevice::BatteryLevel,10) == true);
00424     CHECK(device->set_resource_value(M2MDevice::BatteryLevel,101) == false);
00425     CHECK(device->set_resource_value(M2MDevice::BatteryStatus,6) == true);
00426     CHECK(device->set_resource_value(M2MDevice::BatteryStatus,-1) == false);
00427     CHECK(device->set_resource_value(M2MDevice::BatteryStatus,7) == false);
00428     CHECK(device->set_resource_value(M2MDevice::MemoryFree,10) == true);
00429     CHECK(device->set_resource_value(M2MDevice::MemoryTotal,10) == true);
00430     CHECK(device->set_resource_value(M2MDevice::CurrentTime,10) == true);
00431     CHECK(device->set_resource_value(M2MDevice::FactoryReset,10) == false);
00432 
00433     free(m2mbase_stub::void_value);
00434     delete m2mobjectinstance_stub::resource;
00435     m2mobjectinstance_stub::resource = NULL;
00436 }
00437 
00438 void Test_M2MDevice::test_resource_value_int()
00439 {
00440     uint8_t value[] = {"10"};
00441     uint8_t* ptr = (uint8_t*)malloc((uint32_t)sizeof(value));
00442     m2mresourceinstance_stub::value = ptr;
00443     memset(m2mresourceinstance_stub::value,0,(uint32_t)sizeof(value));
00444     memcpy(m2mresourceinstance_stub::value,value,sizeof(value));
00445     m2mresourceinstance_stub::int_value = (uint32_t)sizeof(value);
00446 
00447     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00448                                                        "name",
00449                                                        "type",
00450                                                        M2MResourceInstance::STRING,
00451                                                        false,
00452                                                        "name");
00453 
00454     m2mresourceinstance_stub::bool_value = true;
00455     m2mresource_stub::bool_value = false;
00456     m2mbase_stub::void_value = malloc(20);
00457 
00458     CHECK(device->resource_value_int(M2MDevice::BatteryLevel) == 10);
00459     CHECK(device->resource_value_int(M2MDevice::BatteryStatus) == 10);
00460     CHECK(device->resource_value_int(M2MDevice::MemoryFree) == 10);
00461     CHECK(device->resource_value_int(M2MDevice::MemoryTotal) == 10);
00462     CHECK(device->resource_value_int(M2MDevice::ErrorCode) == 10);
00463     CHECK(device->resource_value_int(M2MDevice::CurrentTime) == 10);
00464     CHECK(device->resource_value_int(M2MDevice::AvailablePowerSources) == 10);
00465     CHECK(device->resource_value_int(M2MDevice::PowerSourceVoltage) == 10);
00466     CHECK(device->resource_value_int(M2MDevice::PowerSourceCurrent) == 10);
00467     CHECK(device->resource_value_int(M2MDevice::Manufacturer) == -1);
00468 
00469     m2mresource_stub::instance= new M2MResourceInstance(*m2mobjectinstance_stub::resource,
00470                                                         "name",
00471                                                         "type",
00472                                                         M2MResourceInstance::STRING,
00473                                                         0,
00474                                                         "name",
00475                                                         false);
00476     m2mresource_stub::bool_value = true;
00477     CHECK(device->resource_value_int(M2MDevice::AvailablePowerSources,1) == 10);
00478 
00479     free(m2mbase_stub::void_value);
00480 
00481     delete m2mresource_stub::instance;
00482     m2mresource_stub::instance = NULL;
00483 
00484     delete m2mobjectinstance_stub::resource;
00485     m2mobjectinstance_stub::resource = NULL;
00486 
00487     free(ptr);
00488 }
00489 
00490 void Test_M2MDevice::test_resource_value_string()
00491 {
00492     String test = "string";
00493     uint8_t value[] = {"string"};
00494     m2mresourceinstance_stub::value = (uint8_t*)malloc((uint32_t)sizeof(value));
00495     memset(m2mresourceinstance_stub::value,0,(uint32_t)sizeof(value));
00496     memcpy(m2mresourceinstance_stub::value,value,sizeof(value));
00497     m2mresourceinstance_stub::int_value = (uint32_t)sizeof(value);
00498 
00499     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00500                                                        "name",
00501                                                        "type",
00502                                                        M2MResourceInstance::STRING,
00503                                                        false,
00504                                                        "name");
00505 
00506     m2mresourceinstance_stub::bool_value = true;
00507     m2mresource_stub::bool_value = false;
00508     m2mbase_stub::void_value = malloc(20);
00509 
00510     CHECK(device->resource_value_string(M2MDevice::Manufacturer) == test);
00511     CHECK(device->resource_value_string(M2MDevice::DeviceType) == test);
00512     CHECK(device->resource_value_string(M2MDevice::ModelNumber) == test);
00513     CHECK(device->resource_value_string(M2MDevice::SerialNumber) == test);
00514     CHECK(device->resource_value_string(M2MDevice::HardwareVersion) == test);
00515     CHECK(device->resource_value_string(M2MDevice::FirmwareVersion) == test);
00516     CHECK(device->resource_value_string(M2MDevice::SoftwareVersion) == test);
00517     CHECK(device->resource_value_string(M2MDevice::UTCOffset) == test);
00518     CHECK(device->resource_value_string(M2MDevice::Timezone) == test);
00519     CHECK(device->resource_value_string(M2MDevice::BatteryLevel) == "");
00520 
00521     free(m2mbase_stub::void_value);
00522 
00523     delete m2mobjectinstance_stub::resource;
00524     m2mobjectinstance_stub::resource = NULL;
00525 
00526     free(m2mresourceinstance_stub::value);
00527     m2mresourceinstance_stub::value = NULL;
00528 }
00529 
00530 void Test_M2MDevice::test_is_resource_present()
00531 {
00532     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00533                                                        "name",
00534                                                        "type",
00535                                                        M2MResourceInstance::STRING,
00536                                                        false,
00537                                                        "name");
00538     m2mresource_stub::bool_value = false;
00539     CHECK(device->is_resource_present(M2MDevice::Reboot) == true);
00540 
00541     delete m2mobjectinstance_stub::resource;
00542     m2mobjectinstance_stub::resource = NULL;
00543 
00544     CHECK(device->is_resource_present(M2MDevice::Manufacturer) == false);
00545     CHECK(device->is_resource_present(M2MDevice::DeviceType) == false);
00546 }
00547 
00548 void Test_M2MDevice::test_per_resource_count()
00549 {
00550     m2mobjectinstance_stub::int_value = 1;
00551     CHECK(device->per_resource_count(M2MDevice::Reboot) == 1);
00552 
00553     m2mobjectinstance_stub::int_value = 0;
00554 
00555     CHECK(device->per_resource_count(M2MDevice::Manufacturer) == 0);
00556 }
00557 
00558 void Test_M2MDevice::test_total_resource_count()
00559 {
00560     M2MResource res(*m2mobject_stub::inst,"test","test",M2MResourceInstance::STRING,false, "test");
00561 
00562     m2mobjectinstance_stub::resource_list.push_back(&res);
00563     M2MResource res2(*m2mobject_stub::inst,"test","test",M2MResourceInstance::STRING,false, "test");
00564 
00565     m2mobjectinstance_stub::resource_list.push_back(&res2);
00566 
00567     CHECK(device->total_resource_count() == 2);
00568 
00569     m2mobjectinstance_stub::resource_list.clear();
00570 }
00571