tests/core/test_serialization.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /*
  17  * @file        test_address.cpp
  18  * @author      Tomasz Swierczek (t.swierczek@samsung.com)
  19  * @version     1.0
  20  * @brief       This file is the implementation file of serialization tests
  21  */
  22
  23 #include <vector>
  24 #include <string>
  25 #include <list>
  26 #include <map>
  27
  28 #include <dpl/test/test_runner.h>
  29 #include <dpl/serialization.h>
  30
  31 RUNNER_TEST_GROUP_INIT(DPL)
  32
  33 // test stream class
  34 class BinaryStream : public DPL::IStream {
  35   public:
  36     virtual void Read(size_t num, void * bytes)
  37     {
  38         for (unsigned i = 0; i < num; ++i) {
  39             ((unsigned char*)bytes)[i] = data[i + readPosition];
  40         }
  41         readPosition += num;
  42     }
  43     virtual void Write(size_t num, const void * bytes)
  44     {
  45         for (unsigned i = 0; i < num; ++i) {
  46             data.push_back(((unsigned char*)bytes)[i]);
  47         }
  48     }
  49     BinaryStream()
  50     {
  51         readPosition = 0;
  52     }
  53     virtual ~BinaryStream(){};
  54
  55   private:
  56     std::vector<unsigned char> data;
  57     unsigned readPosition;
  58 };
  59
  60 //test ISerializable class
  61 class TestClass : public DPL::ISerializable {
  62   public:
  63     TestClass(int val, std::string str1, std::string str2)
  64     {
  65         a = val;
  66         b = str1;
  67         c.push_back(str1);
  68         c.push_back(str2);
  69         c.push_back(str1 + str2);
  70     };
  71     TestClass(DPL::IStream& stream)
  72     {
  73         DPL::Deserialization::Deserialize(stream,a);
  74         DPL::Deserialization::Deserialize(stream,b);
  75         DPL::Deserialization::Deserialize(stream,c);
  76     };
  77     virtual void Serialize(DPL::IStream& stream) const
  78     {
  79         DPL::Serialization::Serialize(stream,a);
  80         DPL::Serialization::Serialize(stream,b);
  81         DPL::Serialization::Serialize(stream,c);
  82     }
  83     virtual ~TestClass(){}
  84     virtual bool operator==(const TestClass& other)
  85     {
  86         return (a == other.a &&
  87                 b == other.b &&
  88                 c.size() == other.c.size() &&
  89                 c[0] == other.c[0] &&
  90                 c[1] == other.c[1] &&
  91                 c[2] == other.c[2]);
  92     }
  93   private:
  94     int a;
  95     std::string b;
  96     std::vector<std::string> c;
  97 };
  98
  99 RUNNER_TEST(Serialize_primitives)
 100 {
 101     int a = 1;
 102     bool b = true;
 103     unsigned c = 23;
 104     BinaryStream stream;
 105     DPL::Serialization::Serialize(stream,a);
 106     DPL::Serialization::Serialize(stream,b);
 107     DPL::Serialization::Serialize(stream,c);
 108     int test_int;
 109     DPL::Deserialization::Deserialize(stream,test_int);
 110     RUNNER_ASSERT(test_int == a);
 111     bool test_bool;
 112     DPL::Deserialization::Deserialize(stream,test_bool);
 113     RUNNER_ASSERT(test_bool == b);
 114     unsigned test_unsigned;
 115     DPL::Deserialization::Deserialize(stream,test_unsigned);
 116     RUNNER_ASSERT(test_unsigned == c);
 117 }
 118
 119 RUNNER_TEST(Serialize_primitive_pointers)
 120 {
 121     int a = 1;
 122     bool b = true;
 123     unsigned c = 23;
 124     BinaryStream stream;
 125     DPL::Serialization::Serialize(stream,&a);
 126     DPL::Serialization::Serialize(stream,&b);
 127     DPL::Serialization::Serialize(stream,&c);
 128     int* test_int;
 129     DPL::Deserialization::Deserialize(stream,test_int);
 130     RUNNER_ASSERT(test_int != NULL && *test_int == a);
 131     bool* test_bool;
 132     DPL::Deserialization::Deserialize(stream,test_bool);
 133     RUNNER_ASSERT(test_bool != NULL && *test_bool == b);
 134     unsigned* test_unsigned;
 135     DPL::Deserialization::Deserialize(stream,test_unsigned);
 136     RUNNER_ASSERT(test_unsigned != NULL && *test_unsigned == c);
 137     delete test_int;
 138     delete test_bool;
 139     delete test_unsigned;
 140 }
 141
 142 RUNNER_TEST(Serialize_strings)
 143 {
 144     std::string str1 = "ALA MA KOTA";
 145     std::string str2 = "MULTILINE\nTEST";
 146     BinaryStream stream;
 147     DPL::Serialization::Serialize(stream,str1);
 148     DPL::Serialization::Serialize(stream,str2);
 149     std::string test_str1;
 150     DPL::Deserialization::Deserialize(stream,test_str1);
 151     RUNNER_ASSERT(test_str1 == str1);
 152     std::string test_str2;
 153     DPL::Deserialization::Deserialize(stream,test_str2);
 154     RUNNER_ASSERT(test_str2 == str2);
 155 }
 156
 157 RUNNER_TEST(Serialize_string_pointers)
 158 {
 159     std::string str1 = "ALA MA KOTA";
 160     std::string str2 = "MULTILINE\nTEST";
 161     BinaryStream stream;
 162     DPL::Serialization::Serialize(stream,&str1);
 163     DPL::Serialization::Serialize(stream,&str2);
 164     std::string* test_str1;
 165     DPL::Deserialization::Deserialize(stream,test_str1);
 166     RUNNER_ASSERT(test_str1 != NULL && *test_str1 == str1);
 167     std::string* test_str2;
 168     DPL::Deserialization::Deserialize(stream,test_str2);
 169     RUNNER_ASSERT(test_str2 != NULL && *test_str2 == str2);
 170     delete test_str1;
 171     delete test_str2;
 172 }
 173
 174 RUNNER_TEST(Serialize_containers)
 175 {
 176     std::vector<int> vec;
 177     vec.push_back(134);
 178     vec.push_back(265);
 179     std::list<bool> list;
 180     list.push_back(true);
 181     list.push_back(false);
 182     std::pair<int,unsigned> pair;
 183     pair.first = -23;
 184     pair.second = 1234;
 185     std::map<int,std::string> map;
 186     map.insert(std::pair<int,std::string>(45,  "ALA MA CZARNEGO KOTA"));
 187     map.insert(std::pair<int,std::string>(-78, "...A MOZE\nMA\nWIELE LINIJEK"));
 188     BinaryStream stream;
 189     DPL::Serialization::Serialize(stream,vec);
 190     DPL::Serialization::Serialize(stream,list);
 191     DPL::Serialization::Serialize(stream,pair);
 192     DPL::Serialization::Serialize(stream,map);
 193     std::vector<int> test_vec;
 194     DPL::Deserialization::Deserialize(stream,test_vec);
 195     RUNNER_ASSERT(test_vec.size() == vec.size() &&
 196                   test_vec[0] == vec[0] && test_vec[1] == vec[1]);
 197     std::list<bool> test_list;
 198     DPL::Deserialization::Deserialize(stream,test_list);
 199     RUNNER_ASSERT(test_list.size() == list.size() &&
 200                   test_list.front() == list.front() &&
 201                   test_list.back() == test_list.back());
 202     std::pair<int,unsigned> test_pair;
 203     DPL::Deserialization::Deserialize(stream,test_pair);
 204     RUNNER_ASSERT(test_pair.first == pair.first &&
 205                   test_pair.second == pair.second);
 206     std::map<int,std::string> test_map;
 207     DPL::Deserialization::Deserialize(stream,test_map);
 208     RUNNER_ASSERT(test_map.size() == map.size() &&
 209                   test_map.at(45) == map.at(45) &&
 210                   test_map.at(-78) == map.at(-78));
 211 }
 212
 213 RUNNER_TEST(Serialize_objects)
 214 {
 215     TestClass a(123,"ASDGHUADB\n\n5679b^^()*","TEST_STRING"),
 216             b(679,"HUSPIDNSAHDPA","\nASDSADASD\naDSADASD8");
 217     BinaryStream stream;
 218     DPL::Serialization::Serialize(stream,a);
 219     DPL::Serialization::Serialize(stream,b);
 220     TestClass test_a(0,"",""), test_b(0,"","");
 221     DPL::Deserialization::Deserialize(stream, test_a);
 222     RUNNER_ASSERT(test_a == a);
 223     DPL::Deserialization::Deserialize(stream, test_b);
 224     RUNNER_ASSERT(test_b == b);
 225 }
 226
 227 RUNNER_TEST(Serialize_all)
 228 {
 229     std::map<std::string, std::vector<TestClass*> > map;
 230     std::vector<TestClass*> vec;
 231     vec.push_back(new TestClass(123,"ASDGHUADB\n\n5679b^^()*","TEST_STRING"));
 232     vec.push_back(new TestClass(679,"HUSPIDNSAHDPA","\nASDSADASD\naDSADASD8"));
 233     map.insert(std::pair<std::string,std::vector<TestClass*> >("KEY1",vec));
 234     map.insert(std::pair<std::string,std::vector<TestClass*> >("KEY2",vec));
 235     BinaryStream stream;
 236
 237     DPL::Serialization::Serialize(stream, map);
 238
 239     std::map<std::string, std::vector<TestClass*> > test_map;
 240     DPL::Deserialization::Deserialize(stream,test_map);
 241     RUNNER_ASSERT(map.size() == test_map.size());
 242     std::vector<TestClass*> test_vec1,test_vec2;
 243     test_vec1 = map.at("KEY1");
 244     test_vec2 = test_map.at("KEY1");
 245     RUNNER_ASSERT(test_vec1.size() == test_vec2.size());
 246     unsigned i;
 247     for (i = 0; i < test_vec1.size(); ++i)
 248     {
 249         RUNNER_ASSERT((*test_vec1[i]) == (*test_vec2[i]));
 250     }
 251     test_vec1 = map.at("KEY2");
 252     test_vec2 = test_map.at("KEY2");
 253     RUNNER_ASSERT(test_vec1.size() == test_vec2.size());
 254     for (i = 0; i < test_vec1.size(); ++i)
 255     {
 256         RUNNER_ASSERT((*test_vec1[i]) == (*test_vec2[i]));
 257     }
 258 }
 259