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