test_m2mtlvdeserializer.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_m2mtlvdeserializer.h"
00018 #include "m2mtlvserializer.h"
00019 #include "m2mobject_stub.h"
00020 #include "m2mobjectinstance_stub.h"
00021 #include "m2mresource_stub.h"
00022 #include "m2mresourceinstance_stub.h"
00023 #include "m2mbase_stub.h"
00024 
00025 
00026 Test_M2MTLVDeserializer::Test_M2MTLVDeserializer()
00027 {
00028     deserializer = new M2MTLVDeserializer();
00029 }
00030 
00031 Test_M2MTLVDeserializer::~Test_M2MTLVDeserializer()
00032 {
00033     delete deserializer;
00034     m2mbase_stub::clear();
00035     m2mresourceinstance_stub::clear();
00036     m2mobjectinstance_stub::clear();
00037     m2mobject_stub::clear();
00038     m2mresource_stub::clear();
00039 }
00040 
00041 void Test_M2MTLVDeserializer::test_is_object_instance()
00042 {
00043     uint8_t data_resource[] = {0xC3,0x0};
00044     uint8_t data_object[] = {0x08,0x0};
00045 
00046     CHECK(deserializer->is_object_instance(data_resource) == false);
00047     CHECK(deserializer->is_object_instance(data_object) == true);
00048 }
00049 
00050 void Test_M2MTLVDeserializer::test_is_resource()
00051 {
00052     uint8_t data_resource[] = {0xC3,0x0};
00053     uint8_t data_object[] = {0x08,0x0};
00054 
00055     CHECK(deserializer->is_resource(data_resource) == true);
00056     CHECK(deserializer->is_resource(data_object) == false);
00057 
00058 }
00059 
00060 void Test_M2MTLVDeserializer::test_is_multiple_resource()
00061 {
00062     uint8_t data_resource[] = {0xC3,0x0};
00063     uint8_t data_object[] = {0x88,0x0};
00064 
00065     CHECK(deserializer->is_multiple_resource(data_resource) == false);
00066     CHECK(deserializer->is_multiple_resource(data_object) == true);
00067 }
00068 
00069 void Test_M2MTLVDeserializer::test_is_resource_instance()
00070 {
00071     uint8_t data_resource[] = {0xC3,0x0};
00072     uint8_t data_object[] = {0x44,0x0};
00073 
00074     CHECK(deserializer->is_resource_instance(data_object) == true);
00075     CHECK(deserializer->is_resource_instance(data_resource) == false);
00076 }
00077 
00078 void Test_M2MTLVDeserializer::test_deserialise_object_instances()
00079 {
00080     uint32_t size = 0;
00081     uint8_t *data = 0;
00082 
00083 
00084     M2MObject *object = new M2MObject("1", "1");
00085     M2MObjectInstance* instance = new M2MObjectInstance(*object,"1", "type", "1");
00086 
00087     M2MObjectInstance* instance_1 = new M2MObjectInstance(*object,"2", "type", "2");
00088 
00089 
00090     m2mobject_stub::instance_list.push_back(instance);
00091 
00092     M2MResource* resource = new M2MResource(*instance,
00093                                             "1",
00094                                             "type",
00095                                             M2MResourceInstance::INTEGER,
00096                                             false,
00097                                             "1");
00098 
00099     M2MResource* resource_1 = new M2MResource(*instance,
00100                                               "2",
00101                                               "type",
00102                                               M2MResourceInstance::INTEGER,
00103                                               false,
00104                                               "2");
00105 
00106     m2mobjectinstance_stub::resource_list.push_back(resource);
00107     m2mobjectinstance_stub::resource_list.push_back(resource_1);
00108 
00109     m2mbase_stub::name_id_value = 0;
00110     m2mbase_stub::operation = M2MBase::GET_PUT_POST_ALLOWED;
00111 
00112     M2MTLVSerializer *serializer = new M2MTLVSerializer();
00113 
00114     data = serializer->serialize( m2mobject_stub::instance_list,size);
00115 
00116     CHECK(M2MTLVDeserializer::None == deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Post));
00117 
00118     size = 0;
00119 
00120     if(data) {
00121         free(data);
00122         data = 0;
00123     }
00124 
00125     m2mbase_stub::operation = M2MBase::GET_ALLOWED;
00126 
00127     data = serializer->serialize( m2mobject_stub::instance_list,size);
00128 
00129     CHECK(M2MTLVDeserializer::NotAllowed == deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Post));
00130 
00131     size = 0;
00132 
00133     if(data) {
00134         free(data);
00135         data = 0;
00136     }
00137 
00138     m2mbase_stub::operation = M2MBase::GET_PUT_POST_ALLOWED;
00139 
00140     u_int8_t value[] = {"value"};
00141     m2mresourceinstance_stub::value = value;
00142     m2mresourceinstance_stub::int_value = sizeof(value);
00143 
00144     data = serializer->serialize( m2mobject_stub::instance_list,size);
00145 
00146     delete serializer;
00147 
00148     CHECK(M2MTLVDeserializer::None == deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Post));
00149     CHECK(M2MTLVDeserializer::None == deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Put));
00150 
00151     size = 0;
00152 
00153     if(data) {
00154         free(data);
00155         data = 0;
00156     }
00157 
00158     m2mobject_stub::instance_list.push_back(instance_1);
00159 
00160     m2mbase_stub::operation = M2MBase::NOT_ALLOWED;
00161     serializer = new M2MTLVSerializer();
00162 
00163     data = serializer->serialize( m2mobject_stub::instance_list,size);
00164 
00165     delete serializer;
00166 
00167     CHECK(M2MTLVDeserializer::None != deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Post));
00168     size = 0;
00169 
00170     if(data) {
00171         free(data);
00172         data = 0;
00173     }
00174 
00175     CHECK(M2MTLVDeserializer::NotValid == deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Post));
00176 
00177     M2MResourceInstance* res_instance = new M2MResourceInstance(*resource,
00178                                                                 "1",
00179                                                                 "type",
00180                                                                 M2MResourceInstance::INTEGER,
00181                                                                 0,
00182                                                                 "1",
00183                                                                 false);
00184 
00185 
00186     M2MResourceInstance* res_instance_1 = new M2MResourceInstance(*resource,
00187                                                                  "2",
00188                                                                  "type",
00189                                                                  M2MResourceInstance::INTEGER,
00190                                                                  0,
00191                                                                  "1",
00192                                                                  false);
00193 
00194     m2mresource_stub::bool_value = true;
00195     m2mresource_stub::list.push_back(res_instance);
00196     m2mresource_stub::list.push_back(res_instance_1);
00197 
00198     m2mobject_stub::instance_list.pop_back();
00199 
00200     serializer = new M2MTLVSerializer();
00201     data = serializer->serialize( m2mobject_stub::instance_list,size);
00202     delete serializer;
00203 
00204     m2mbase_stub::operation = M2MBase::GET_PUT_POST_ALLOWED;
00205 
00206     m2mbase_stub::string_value = "name";
00207     m2mobjectinstance_stub::create_resource_instance = new M2MResource(*instance,
00208                                                                        "1",
00209                                                                        "type",
00210                                                                        M2MResourceInstance::INTEGER,
00211                                                                        false,
00212                                                                        "1");
00213 
00214     deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Post);
00215 
00216     deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Put);
00217 
00218     size = 0;
00219     if(data) {
00220         free(data);
00221         data = 0;
00222     }
00223 
00224     m2mbase_stub::name_id_value = 300;
00225 
00226     m2mresourceinstance_stub::int_value = 6;
00227     m2mresourceinstance_stub::value = (uint8_t*) malloc(m2mresourceinstance_stub::int_value);
00228     serializer = new M2MTLVSerializer();
00229     data = serializer->serialize( m2mobject_stub::instance_list,size);
00230     delete serializer;
00231 
00232     deserializer->deserialise_object_instances(data,size,*object, M2MTLVDeserializer::Post);
00233     deserializer->deserialise_object_instances(data,size,*object, M2MTLVDeserializer::Put);
00234     size = 0;
00235 
00236     if(data) {
00237         free(data);
00238         data = 0;
00239     }
00240     free(m2mresourceinstance_stub::value);
00241     m2mresourceinstance_stub::value = NULL;
00242 
00243     m2mresourceinstance_stub::int_value = 256;
00244     m2mresourceinstance_stub::value = (uint8_t*) malloc(m2mresourceinstance_stub::int_value);
00245     serializer = new M2MTLVSerializer();
00246     data = serializer->serialize( m2mobject_stub::instance_list,size);
00247     delete serializer;
00248 
00249     deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Post);
00250     deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Put);
00251     size = 0;
00252 
00253     if(data) {
00254         free(data);
00255         data = 0;
00256     }
00257     free(m2mresourceinstance_stub::value);
00258     m2mresourceinstance_stub::value = NULL;
00259 
00260     m2mresourceinstance_stub::int_value = 65536;
00261     m2mresourceinstance_stub::value = (uint8_t*) malloc(m2mresourceinstance_stub::int_value);
00262     serializer = new M2MTLVSerializer();
00263     data = serializer->serialize( m2mobject_stub::instance_list,size);
00264     delete serializer;
00265 
00266    deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Post);
00267    deserializer->deserialise_object_instances(data,size,*object,M2MTLVDeserializer::Put);
00268     size = 0;
00269 
00270     if(data) {
00271         free(data);
00272         data = 0;
00273     }
00274 
00275     free(m2mresourceinstance_stub::value);
00276     m2mresourceinstance_stub::value = NULL;
00277 
00278     delete m2mobjectinstance_stub::create_resource_instance;
00279     m2mobjectinstance_stub::create_resource_instance = NULL;
00280 
00281     delete res_instance;
00282     delete res_instance_1;
00283     delete resource;
00284     delete resource_1;
00285     delete instance;
00286     delete instance_1;
00287     delete object;
00288 }
00289 
00290 void Test_M2MTLVDeserializer::test_deserialize_resources()
00291 {
00292     uint8_t data_resource[] = {0xC3,0x0,'A','R','M'};
00293 
00294     M2MObject *object = new M2MObject("1","1");
00295     M2MObjectInstance* instance = new M2MObjectInstance(*object,"1","type", "1");
00296 
00297     m2mobject_stub::instance_list.push_back(instance);
00298 
00299     M2MResource* resource = new M2MResource(*instance,
00300                                             "1",
00301                                             "type",
00302                                             M2MResourceInstance::INTEGER,
00303                                             false,
00304                                             "1");
00305 
00306 
00307     m2mobjectinstance_stub::resource_list.push_back(resource);
00308 
00309     CHECK(deserializer->is_resource(data_resource) == true);
00310 
00311     uint8_t invalid_data_resource[] = {0x65,0x0,'A','R','M'};
00312 
00313     CHECK( M2MTLVDeserializer::NotValid == deserializer->deserialize_resources(invalid_data_resource,
00314                                                                                sizeof(invalid_data_resource),
00315                                                                                *instance,M2MTLVDeserializer::Post));
00316 
00317     m2mbase_stub::operation = M2MBase::GET_PUT_POST_ALLOWED;
00318 
00319     m2mobjectinstance_stub::create_resource = new M2MResource(*instance,
00320                                                               "1",
00321                                                               "type",
00322                                                               M2MResourceInstance::INTEGER,
00323                                                               false,
00324                                                               "1");
00325 
00326     CHECK( M2MTLVDeserializer::None == deserializer->deserialize_resources(data_resource,sizeof(data_resource),*instance,M2MTLVDeserializer::Post));
00327 
00328     delete m2mobjectinstance_stub::create_resource;
00329     m2mobjectinstance_stub::create_resource = NULL;
00330 
00331     CHECK( M2MTLVDeserializer::NotFound == deserializer->deserialize_resources(data_resource,sizeof(data_resource),*instance,M2MTLVDeserializer::Put));
00332 
00333     m2mbase_stub::operation = M2MBase::NOT_ALLOWED;
00334 
00335     deserializer->deserialize_resources(data_resource,sizeof(data_resource),*instance,M2MTLVDeserializer::Post);
00336 
00337 
00338     M2MResourceInstance* res_instance = new M2MResourceInstance(*resource,
00339                                                                 "1",
00340                                                                 "type",
00341                                                                 M2MResourceInstance::INTEGER,
00342                                                                 0,
00343                                                                 "1",
00344                                                                 false);
00345 
00346 
00347     m2mresource_stub::bool_value = true;
00348     m2mresource_stub::list.push_back(res_instance);
00349 
00350 //    M2MResourceInstance* res_instance_1 = new M2MResourceInstance("2",
00351 //                                                                *name,
00352 //                                                                M2MResourceInstance::INTEGER,
00353 //                                                                *instance);
00354 
00355 //    m2mresource_stub::list.push_back(res_instance_1);
00356     m2mbase_stub::string_value = "1";
00357     uint8_t data_multiple_resource[] = {0x86,0x6, 0x81,0x0, 0x01, 0x41, 0x01, 0x05};
00358     CHECK(deserializer->is_multiple_resource(data_multiple_resource) == true);
00359     deserializer->deserialize_resources(data_multiple_resource,sizeof(data_multiple_resource),*instance,M2MTLVDeserializer::Post);
00360 
00361     M2MTLVSerializer *serializer = new M2MTLVSerializer();
00362 
00363     m2mbase_stub::name_id_value = 1;
00364     uint32_t size = 0;
00365     uint8_t* data = serializer->serialize(resource,size);
00366 
00367     delete serializer;
00368 
00369     m2mbase_stub::operation = M2MBase::GET_PUT_POST_ALLOWED;
00370 
00371     deserializer->deserialize_resources(data,size,*instance,M2MTLVDeserializer::Post);
00372 
00373     free(data);
00374 
00375     delete res_instance;
00376 //    delete res_instance_1;
00377     delete resource;
00378     delete instance;
00379     delete object;
00380 
00381     m2mresourceinstance_stub::clear();
00382     m2mresource_stub::clear();
00383     m2mobjectinstance_stub::clear();
00384     m2mobject_stub::clear();
00385 }
00386 
00387 void Test_M2MTLVDeserializer::test_deserialize_resource_instance_1()
00388 {
00389     uint8_t data_resource[] = {0xC3,0x0,'A','R','M'};
00390 
00391     m2mbase_stub::name_id_value = 1;
00392 
00393     M2MObject *object = new M2MObject("1","1");
00394     M2MObjectInstance* instance = new M2MObjectInstance(*object,"1","type", "1");
00395 
00396     m2mobject_stub::instance_list.push_back(instance);
00397 
00398     M2MResource* resource = new M2MResource(*instance,
00399                                             "1",
00400                                             "type",
00401                                             M2MResourceInstance::INTEGER,
00402                                             false,
00403                                             "1");
00404 
00405     m2mobjectinstance_stub::resource_list.push_back(resource);
00406 
00407     CHECK(deserializer->is_resource(data_resource) == true);
00408 
00409     m2mbase_stub::operation = M2MBase::GET_PUT_POST_ALLOWED;
00410 
00411     deserializer->deserialize_resource_instances(data_resource,sizeof(data_resource),
00412                                                  *resource,M2MTLVDeserializer::Put);
00413 
00414     M2MResourceInstance* res_instance = new M2MResourceInstance(*resource,
00415                                                                 "1",
00416                                                                 "type",
00417                                                                 M2MResourceInstance::INTEGER,
00418                                                                 0,
00419                                                                 "1",
00420                                                                 false);
00421 
00422     m2mresource_stub::bool_value = true;
00423     m2mresource_stub::list.push_back(res_instance);
00424 
00425     M2MResourceInstance* res_instance_1 = new M2MResourceInstance(*resource,
00426                                                                  "2",
00427                                                                  "type",
00428                                                                  M2MResourceInstance::INTEGER,
00429                                                                  0,
00430                                                                  "2",
00431                                                                  false);
00432 
00433     m2mresource_stub::list.push_back(res_instance_1);
00434 
00435     M2MTLVSerializer *serializer = new M2MTLVSerializer();
00436 
00437     uint32_t size = 0;
00438     uint8_t* data = serializer->serialize( resource,size);
00439 
00440     delete serializer;
00441 
00442     deserializer->deserialize_resource_instances(data,size,
00443                                                 *resource,M2MTLVDeserializer::Put);
00444 
00445 
00446     free(data);
00447 
00448     delete res_instance;
00449     delete res_instance_1;
00450     delete resource;
00451     delete instance;
00452     delete object;
00453 
00454     m2mresourceinstance_stub::clear();
00455     m2mresource_stub::clear();
00456     m2mobjectinstance_stub::clear();
00457     m2mobject_stub::clear();
00458 }
00459 
00460 
00461 void Test_M2MTLVDeserializer::test_deserialize_resource_instance()
00462 {
00463     uint32_t size = 0;
00464     uint8_t *data = 0;
00465 
00466     M2MObject *object = new M2MObject("1","1");
00467     M2MObjectInstance* instance = new M2MObjectInstance(*object,"1","type", "1");
00468 
00469     M2MObjectInstance* instance_1 = new M2MObjectInstance(*object,"2","type", "1");
00470 
00471 
00472     m2mobject_stub::instance_list.push_back(instance);
00473     m2mobject_stub::instance_list.push_back(instance_1);
00474 
00475 
00476     M2MResource* resource = new M2MResource(*instance,
00477                                             "1",
00478                                             "type",
00479                                             M2MResourceInstance::INTEGER,
00480                                             false,
00481                                             "1");
00482 
00483     M2MResource* resource_1 = new M2MResource(*instance,
00484                                               "2",
00485                                               "type",
00486                                               M2MResourceInstance::INTEGER,
00487                                               false,
00488                                               "2");
00489 
00490     m2mobjectinstance_stub::resource_list.push_back(resource);
00491     m2mobjectinstance_stub::resource_list.push_back(resource_1);
00492 
00493     m2mbase_stub::name_id_value = 0;
00494 
00495     M2MTLVSerializer *serializer = new M2MTLVSerializer();
00496 
00497     data = serializer->serialize( resource,size);
00498 
00499     delete serializer;
00500 
00501     m2mbase_stub::operation = M2MBase::GET_PUT_POST_ALLOWED;
00502 
00503     deserializer->deserialize_resource_instances(data,size,*resource,M2MTLVDeserializer::Post);
00504     size = 0;
00505 
00506     if(data) {
00507         free(data);
00508         data = 0;
00509     }
00510 
00511     m2mbase_stub::operation = M2MBase::NOT_ALLOWED;
00512 
00513     deserializer->deserialize_resource_instances(data,size,*resource,M2MTLVDeserializer::Post);
00514     size = 0;
00515 
00516     if(data) {
00517         free(data);
00518         data = 0;
00519     }
00520 
00521     M2MResourceInstance* res_instance = new M2MResourceInstance(*resource,
00522                                                                 "1",
00523                                                                 "type",
00524                                                                 M2MResourceInstance::INTEGER,
00525                                                                 0,
00526                                                                 "1",
00527                                                                 false);
00528 
00529     M2MResourceInstance* res_instance_1 = new M2MResourceInstance(*resource,
00530                                                                   "2",
00531                                                                   "type",
00532                                                                   M2MResourceInstance::INTEGER,
00533                                                                   0,
00534                                                                   "2",
00535                                                                   false);
00536 
00537 
00538     m2mbase_stub::operation = M2MBase::GET_ALLOWED;
00539 
00540     m2mresource_stub::bool_value = true;
00541     m2mresource_stub::list.push_back(res_instance);
00542     m2mresource_stub::list.push_back(res_instance_1);
00543     serializer = new M2MTLVSerializer();
00544     data = serializer->serialize( resource,size);
00545     delete serializer;
00546 
00547     deserializer->deserialize_resource_instances(data,size,*resource,M2MTLVDeserializer::Post);
00548 
00549     m2mbase_stub::operation = M2MBase::GET_PUT_POST_ALLOWED;
00550     deserializer->deserialize_resource_instances(data,size,*resource,M2MTLVDeserializer::Post);
00551 
00552     m2mresource_stub::list.pop_back();
00553     m2mresource_stub::list.pop_back();
00554 
00555     CHECK(M2MTLVDeserializer::NotAllowed ==deserializer->deserialize_resource_instances(data,size,*resource,M2MTLVDeserializer::Post));
00556 
00557     CHECK(M2MTLVDeserializer::NotFound == deserializer->deserialize_resource_instances(data,size,*resource,M2MTLVDeserializer::Put));
00558 
00559     size = 0;
00560     if(data) {
00561         free(data);
00562         data = 0;
00563     }
00564 
00565     serializer = new M2MTLVSerializer();
00566     data = serializer->serialize( resource,size);
00567     delete serializer;
00568 
00569     deserializer->deserialize_resource_instances(data,size,*resource,M2MTLVDeserializer::Put);
00570     size = 0;
00571     if(data) {
00572         free(data);
00573         data = 0;
00574     }
00575 
00576     m2mresource_stub::list.push_back(res_instance);
00577     m2mresource_stub::list.push_back(res_instance_1);
00578 
00579     m2mbase_stub::name_id_value = 300;
00580 
00581     m2mresourceinstance_stub::int_value = 6;
00582     m2mresourceinstance_stub::value = (uint8_t*) malloc(m2mresourceinstance_stub::int_value);
00583     serializer = new M2MTLVSerializer();
00584     data = serializer->serialize( resource,size);
00585     delete serializer;
00586 
00587     deserializer->deserialize_resource_instances(data,size,*resource, M2MTLVDeserializer::Post);
00588     size = 0;
00589 
00590     if(data) {
00591         free(data);
00592         data = 0;
00593     }
00594     free(m2mresourceinstance_stub::value);
00595     m2mresourceinstance_stub::value = NULL;
00596 
00597     m2mresourceinstance_stub::int_value = 256;
00598     m2mresourceinstance_stub::value = (uint8_t*) malloc(m2mresourceinstance_stub::int_value);
00599     serializer = new M2MTLVSerializer();
00600     data = serializer->serialize( resource,size);
00601     delete serializer;
00602 
00603     deserializer->deserialize_resource_instances(data,size,*resource,M2MTLVDeserializer::Post);
00604     size = 0;
00605 
00606     if(data) {
00607         free(data);
00608         data = 0;
00609     }
00610     free(m2mresourceinstance_stub::value);
00611     m2mresourceinstance_stub::value = NULL;
00612 
00613     m2mresourceinstance_stub::int_value = 65536;
00614     m2mresourceinstance_stub::value = (uint8_t*) malloc(m2mresourceinstance_stub::int_value);
00615     serializer = new M2MTLVSerializer();
00616     data = serializer->serialize( resource,size);
00617     delete serializer;
00618 
00619     deserializer->deserialize_resource_instances(data,size,*resource,M2MTLVDeserializer::Post);
00620     size = 0;
00621 
00622     if(data) {
00623         free(data);
00624         data = 0;
00625     }
00626 
00627     free(m2mresourceinstance_stub::value);
00628     m2mresourceinstance_stub::value = NULL;
00629 
00630     delete res_instance;
00631     delete res_instance_1;
00632     delete resource;
00633     delete resource_1;
00634     delete instance;
00635     delete instance_1;
00636     delete object;
00637 }
00638 
00639 void Test_M2MTLVDeserializer::test_instance_id()
00640 {
00641     uint8_t data_resource[] = {0xC3,0x1};
00642     uint8_t data_object[] = {0x08,0x2};
00643 
00644     CHECK(deserializer->instance_id(data_resource) == 1);
00645     CHECK(deserializer->instance_id(data_object) == 2);
00646 }