| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2007-2009 Google Inc. | |
| 2 // | |
| 3 // Licensed under the Apache License, Version 2.0 (the "License"); | |
| 4 // you may not use this file except in compliance with the License. | |
| 5 // You may obtain a copy of the License at | |
| 6 // | |
| 7 // http://www.apache.org/licenses/LICENSE-2.0 | |
| 8 // | |
| 9 // Unless required by applicable law or agreed to in writing, software | |
| 10 // distributed under the License is distributed on an "AS IS" BASIS, | |
| 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 12 // See the License for the specific language governing permissions and | |
| 13 // limitations under the License. | |
| 14 // ======================================================================== | |
| 15 | |
| 16 #include "omaha/base/serializable_object.h" | |
| 17 #include "omaha/testing/unit_test.h" | |
| 18 | |
| 19 namespace omaha { | |
| 20 | |
| 21 // Template test function to round-trip an object through its serialized form. | |
| 22 // Requires the object to implement SetTestValues() and VerifyTestValues(). | |
| 23 template <class T> | |
| 24 void TestSerializeRoundTrip() { | |
| 25 T in; | |
| 26 T out; | |
| 27 std::vector<byte> data; | |
| 28 | |
| 29 in.SetTestValues(); | |
| 30 in.VerifyTestValues(); // sanity check to catch broken tests | |
| 31 EXPECT_TRUE(in.Serialize(&data)); | |
| 32 EXPECT_TRUE(out.Deserialize(&data[0], data.size())); | |
| 33 out.VerifyTestValues(); | |
| 34 } | |
| 35 | |
| 36 | |
| 37 // Ordinary values. | |
| 38 class SimpleValues : public SerializableObject { | |
| 39 public: | |
| 40 SimpleValues() { | |
| 41 AddSerializableMember(&value1_); | |
| 42 AddSerializableMember(&value2_); | |
| 43 AddSerializableMember(&value3_); | |
| 44 AddSerializableMember(&value4_); | |
| 45 } | |
| 46 | |
| 47 virtual void SetTestValues() { | |
| 48 value1_ = 452; | |
| 49 value2_ = 'Z'; | |
| 50 value3_ = false; | |
| 51 value4_ = 9276554; | |
| 52 } | |
| 53 | |
| 54 virtual void VerifyTestValues() { | |
| 55 EXPECT_EQ(452, value1_); | |
| 56 EXPECT_EQ('Z', value2_); | |
| 57 EXPECT_EQ(false, value3_); | |
| 58 EXPECT_EQ(9276554, value4_); | |
| 59 } | |
| 60 | |
| 61 private: | |
| 62 int value1_; | |
| 63 char value2_; | |
| 64 bool value3_; | |
| 65 int value4_; | |
| 66 }; | |
| 67 | |
| 68 TEST(SerializableObjectTest, SimpleValues) { | |
| 69 TestSerializeRoundTrip<SimpleValues>(); | |
| 70 } | |
| 71 | |
| 72 | |
| 73 // Strings. | |
| 74 const TCHAR kString1[] = _T("an example\tvalue\n"); | |
| 75 const TCHAR kString2[] = _T(""); | |
| 76 const TCHAR kString3[] = _T("and the mome raths outgrabe"); | |
| 77 | |
| 78 class StringValues : public SerializableObject { | |
| 79 public: | |
| 80 StringValues() { | |
| 81 AddSerializableMember(&string1_); | |
| 82 AddSerializableMember(&string2_); | |
| 83 AddSerializableMember(&string3_); | |
| 84 } | |
| 85 | |
| 86 virtual void SetTestValues() { | |
| 87 string1_ = kString1; | |
| 88 string2_ = kString2; | |
| 89 string3_ = kString3; | |
| 90 } | |
| 91 | |
| 92 virtual void VerifyTestValues() { | |
| 93 EXPECT_STREQ(kString1, string1_); | |
| 94 EXPECT_STREQ(kString2, string2_); | |
| 95 EXPECT_STREQ(kString3, string3_); | |
| 96 } | |
| 97 | |
| 98 private: | |
| 99 CString string1_; | |
| 100 CString string2_; | |
| 101 CString string3_; | |
| 102 }; | |
| 103 | |
| 104 TEST(SerializableObjectTest, StringValues) { | |
| 105 TestSerializeRoundTrip<StringValues>(); | |
| 106 } | |
| 107 | |
| 108 | |
| 109 // Nested objects. | |
| 110 class NestedObjects : public SerializableObject { | |
| 111 public: | |
| 112 NestedObjects() { | |
| 113 AddSerializableMember(&simple_values_); | |
| 114 AddSerializableMember(&string_values_); | |
| 115 } | |
| 116 | |
| 117 virtual void SetTestValues() { | |
| 118 simple_values_.SetTestValues(); | |
| 119 string_values_.SetTestValues(); | |
| 120 } | |
| 121 | |
| 122 virtual void VerifyTestValues() { | |
| 123 simple_values_.VerifyTestValues(); | |
| 124 string_values_.VerifyTestValues(); | |
| 125 } | |
| 126 | |
| 127 private: | |
| 128 SimpleValues simple_values_; | |
| 129 StringValues string_values_; | |
| 130 }; | |
| 131 | |
| 132 TEST(SerializableObjectTest, NestedObjects) { | |
| 133 TestSerializeRoundTrip<NestedObjects>(); | |
| 134 } | |
| 135 | |
| 136 | |
| 137 // Vector of values. | |
| 138 class ValueVector : public SerializableObject { | |
| 139 public: | |
| 140 ValueVector() { | |
| 141 AddSerializableMember(&vector_); | |
| 142 AddSerializableMember(&empty_vector_); | |
| 143 } | |
| 144 | |
| 145 virtual void SetTestValues() { | |
| 146 vector_.push_back(5); | |
| 147 vector_.push_back(8); | |
| 148 vector_.push_back(13); | |
| 149 } | |
| 150 | |
| 151 virtual void VerifyTestValues() { | |
| 152 EXPECT_EQ(0, empty_vector_.size()); | |
| 153 EXPECT_EQ(3, vector_.size()); | |
| 154 EXPECT_EQ(5, vector_[0]); | |
| 155 EXPECT_EQ(8, vector_[1]); | |
| 156 EXPECT_EQ(13, vector_[2]); | |
| 157 } | |
| 158 | |
| 159 private: | |
| 160 std::vector<int> vector_; | |
| 161 std::vector<int> empty_vector_; | |
| 162 }; | |
| 163 | |
| 164 TEST(SerializableObjectTest, ValueVector) { | |
| 165 TestSerializeRoundTrip<ValueVector>(); | |
| 166 } | |
| 167 | |
| 168 | |
| 169 // Vector of objects. | |
| 170 class InnerObject : public SerializableObject { | |
| 171 public: | |
| 172 InnerObject() : value_(-1) { | |
| 173 AddSerializableMember(&value_); | |
| 174 } | |
| 175 | |
| 176 explicit InnerObject(int i) : value_(i) { | |
| 177 AddSerializableMember(&value_); | |
| 178 } | |
| 179 | |
| 180 InnerObject(const InnerObject& other) { | |
| 181 AddSerializableMember(&value_); | |
| 182 value_ = other.value_; | |
| 183 } | |
| 184 | |
| 185 InnerObject& operator=(const InnerObject& other) { | |
| 186 value_ = other.value_; | |
| 187 return *this; | |
| 188 } | |
| 189 | |
| 190 int value() { | |
| 191 return value_; | |
| 192 } | |
| 193 | |
| 194 private: | |
| 195 int value_; | |
| 196 }; | |
| 197 | |
| 198 class ObjectVector : public SerializableObject { | |
| 199 public: | |
| 200 ObjectVector() { | |
| 201 AddSerializableMember(&vector_); | |
| 202 } | |
| 203 | |
| 204 virtual void SetTestValues() { | |
| 205 vector_.push_back(InnerObject(21)); | |
| 206 vector_.push_back(InnerObject(34)); | |
| 207 vector_.push_back(InnerObject(55)); | |
| 208 } | |
| 209 | |
| 210 virtual void VerifyTestValues() { | |
| 211 EXPECT_EQ(3, vector_.size()); | |
| 212 EXPECT_EQ(21, vector_[0].value()); | |
| 213 EXPECT_EQ(34, vector_[1].value()); | |
| 214 EXPECT_EQ(55, vector_[2].value()); | |
| 215 } | |
| 216 | |
| 217 virtual bool SerializeVectorNestedObject(std::vector<byte>* data, | |
| 218 const byte* ptr) const { | |
| 219 EXPECT_TRUE(data); | |
| 220 EXPECT_TRUE(ptr); | |
| 221 if (ptr == reinterpret_cast<const byte*>(&vector_)) | |
| 222 return SerializeVectorNestedObjectHelper(data, &vector_); | |
| 223 return false; | |
| 224 } | |
| 225 | |
| 226 virtual bool DeserializeVectorNestedObject(byte** data, | |
| 227 int size, | |
| 228 byte* ptr, | |
| 229 uint32 version) { | |
| 230 EXPECT_TRUE(data); | |
| 231 EXPECT_TRUE(ptr); | |
| 232 if (ptr == reinterpret_cast<byte*>(&vector_)) { | |
| 233 return DeserializeVectorNestedObjectHelper(data, size, | |
| 234 &vector_, version); | |
| 235 } | |
| 236 return false; | |
| 237 } | |
| 238 | |
| 239 private: | |
| 240 std::vector<InnerObject> vector_; | |
| 241 }; | |
| 242 | |
| 243 TEST(SerializableObjectTest, ObjectVector) { | |
| 244 TestSerializeRoundTrip<ObjectVector>(); | |
| 245 } | |
| 246 | |
| 247 } // namespace omaha | |
| 248 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 624713003:
Keep only base/extractor.[cc|h]. (Closed)
Base URL: https://chromium.googlesource.com/external/omaha.git@master