Add tests for ProtocolSerialization

Change-Id: I9afce8b2635e81c3ffaae45804c1d4b93251b314

diff --git a/test/common/protocols/ProtocolSerialization.cpp b/test/common/protocols/ProtocolSerialization.cpp
index f42f5a19a9d1beeeace11667a2f662781fc8c816..b906ae70cd7ec6b98176db5bb9e8b40eda74733d 100644 (file)
--- a/test/common/protocols/ProtocolSerialization.cpp
+++ b/test/common/protocols/ProtocolSerialization.cpp
@@ -47,7 +47,7 @@ ACTION_P(AssignUInt16, param) {
 }
 ACTION_P(AssignString, param) { strcpy(static_cast<char*>(arg1), param); }
 
-TEST(Serialization, maxString) {
+TEST(Serialization, maxStringPositive) {
     using ::testing::_;
 
     FakeIStream stream;
@@ -59,7 +59,7 @@ TEST(Serialization, maxString) {
     EXPECT_NO_THROW(Cynara::ProtocolSerialization::serialize(stream, string));
 }
 
-TEST(Serialization, maxVector) {
+TEST(Serialization, maxVectorPositive) {
     using ::testing::_;
     FakeIStream stream;
     std::vector<char> vector;
@@ -70,7 +70,7 @@ TEST(Serialization, maxVector) {
     EXPECT_NO_THROW(Cynara::ProtocolSerialization::serialize(stream, vector));
 }
 
-TEST(Serialization, vectorWithOverMaxString) {
+TEST(Serialization, vectorWithOverMaxStringNegative) {
     using ::testing::_;
     FakeIStream stream;
     std::string string;
@@ -82,7 +82,7 @@ TEST(Serialization, vectorWithOverMaxString) {
                  Cynara::InvalidProtocolException);
 }
 
-TEST(Serialization, overMaxVector) {
+TEST(Serialization, overMaxVectorNegative) {
     FakeIStream stream;
     std::vector<char> vector;
 
@@ -92,7 +92,7 @@ TEST(Serialization, overMaxVector) {
                  Cynara::InvalidProtocolException);
 }
 
-TEST(Serialization, overMaxString) {
+TEST(Serialization, overMaxStringNegative) {
     FakeIStream stream;
     std::string string;
 
@@ -102,7 +102,71 @@ TEST(Serialization, overMaxString) {
                  Cynara::InvalidProtocolException);
 }
 
-TEST(Deserialization, overMaxString) {
+TEST(Serialization, overMaxMapNegative) {
+    FakeIStream stream;
+    std::map<int, int> map;
+
+    for (int i = 0; i <= CYNARA_MAX_VECTOR_SIZE; i++) {
+        map[i] = i;
+    }
+
+    EXPECT_THROW(Cynara::ProtocolSerialization::serialize(stream, map),
+                 Cynara::InvalidProtocolException);
+}
+
+TEST(Serialization, maxMapPositive) {
+    using ::testing::_;
+    FakeIStream stream;
+    std::map<int, int> map;
+
+    for (int i = 0; i < CYNARA_MAX_VECTOR_SIZE; i++) {
+        map[i] = i;
+    }
+
+    EXPECT_CALL(stream, write(_, _)).Times(2 * CYNARA_MAX_VECTOR_SIZE + 1);
+    EXPECT_NO_THROW(Cynara::ProtocolSerialization::serialize(stream, map));
+}
+
+TEST(Serialization, mapWithOverMaxKeyNegative) {
+    using ::testing::_;
+    FakeIStream stream;
+    std::map<std::string, int> map;
+
+    std::string key(CYNARA_MAX_ID_LENGTH + 1, 'c');
+    map[key] = 42;
+
+    EXPECT_CALL(stream, write(_, _)).Times(1);
+    EXPECT_THROW(Cynara::ProtocolSerialization::serialize(stream, map),
+                 Cynara::InvalidProtocolException);
+}
+
+TEST(Serialization, mapWithOverMaxValueNegative) {
+    using ::testing::_;
+    FakeIStream stream;
+    std::map<int, std::string> map;
+
+    std::string value(CYNARA_MAX_ID_LENGTH + 1, 'c');
+    map[42] = value;
+
+    EXPECT_CALL(stream, write(_, _)).Times(2);
+    EXPECT_THROW(Cynara::ProtocolSerialization::serialize(stream, map),
+                 Cynara::InvalidProtocolException);
+}
+
+TEST(Serialization, mapWithOverMaxValueVectorNegative) {
+    using ::testing::_;
+    FakeIStream stream;
+    std::map<int, std::vector<char>> map;
+
+    std::vector<char> value(CYNARA_MAX_ID_LENGTH + 1, 'c');
+    map[42] = value;
+
+    EXPECT_CALL(stream, write(_, _)).Times(2);
+    EXPECT_THROW(Cynara::ProtocolSerialization::serialize(stream, map),
+                 Cynara::InvalidProtocolException);
+}
+
+TEST(Deserialization, overMaxStringNegative) {
     using ::testing::_;
 
     FakeIStream stream;
@@ -113,7 +177,7 @@ TEST(Deserialization, overMaxString) {
                  Cynara::InvalidProtocolException);
 }
 
-TEST(Deserialization, overMaxStringWithLength) {
+TEST(Deserialization, overMaxStringWithLengthNegative) {
     using ::testing::_;
 
     FakeIStream stream;
@@ -124,7 +188,7 @@ TEST(Deserialization, overMaxStringWithLength) {
                  Cynara::InvalidProtocolException);
 }
 
-TEST(Deserialization, maxString) {
+TEST(Deserialization, maxStringPositive) {
     using ::testing::_;
 
     FakeIStream stream;
@@ -137,7 +201,7 @@ TEST(Deserialization, maxString) {
     EXPECT_NO_THROW(Cynara::ProtocolDeserialization::deserialize(stream, string));
 }
 
-TEST(Deserialization, maxStringWithLength) {
+TEST(Deserialization, maxStringWithLengthPositive) {
     using ::testing::_;
 
     FakeIStream stream;
@@ -151,18 +215,18 @@ TEST(Deserialization, maxStringWithLength) {
                                                                  string));
 }
 
-TEST(Deserialization, overMaxVector) {
+TEST(Deserialization, overMaxVectorNegative) {
     using ::testing::_;
 
     FakeIStream stream;
     std::vector<std::string> vector;
 
-    EXPECT_CALL(stream, read(_, _)).WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH + 1));
+    EXPECT_CALL(stream, read(_, _)).WillOnce(AssignUInt16(CYNARA_MAX_VECTOR_SIZE + 1));
     EXPECT_THROW(Cynara::ProtocolDeserialization::deserialize(stream, vector),
                  Cynara::InvalidProtocolException);
 }
 
-TEST(Deserialization, maxVector) {
+TEST(Deserialization, maxVectorPositive) {
     using ::testing::_;
     using ::testing::Sequence;
     Sequence sequence;
@@ -171,7 +235,6 @@ TEST(Deserialization, maxVector) {
     std::string stringInput;
     std::vector<std::string> vector;
     stringInput.resize(CYNARA_MAX_ID_LENGTH, ' ');
-    vector.resize(CYNARA_MAX_VECTOR_SIZE);
 
     EXPECT_CALL(stream, read(_, _)).InSequence(sequence)
             .WillOnce(AssignUInt16(CYNARA_MAX_VECTOR_SIZE));
@@ -185,7 +248,7 @@ TEST(Deserialization, maxVector) {
     EXPECT_NO_THROW(Cynara::ProtocolDeserialization::deserialize(stream, vector));
 }
 
-TEST(Deserialization, vectorWithOverMaxString) {
+TEST(Deserialization, vectorWithOverMaxStringNegative) {
     using ::testing::_;
 
     FakeIStream stream;
@@ -196,3 +259,110 @@ TEST(Deserialization, vectorWithOverMaxString) {
     EXPECT_THROW(Cynara::ProtocolDeserialization::deserialize(stream, vector),
                  Cynara::InvalidProtocolException);
 }
+
+TEST(Deserialization, overMaxMapNegative) {
+    using ::testing::_;
+
+    FakeIStream stream;
+    std::map<std::string, std::string> map;
+
+    EXPECT_CALL(stream, read(_, _)).WillOnce(AssignUInt16(CYNARA_MAX_VECTOR_SIZE + 1));
+    EXPECT_THROW(Cynara::ProtocolDeserialization::deserialize(stream, map),
+                 Cynara::InvalidProtocolException);
+}
+
+TEST(Deserialization, maxMapPositive) {
+    using ::testing::_;
+    using ::testing::Sequence;
+    Sequence sequence;
+
+    FakeIStream stream;
+    std::string stringInput;
+    std::map<std::string, std::string> map;
+    stringInput.resize(CYNARA_MAX_ID_LENGTH, ' ');
+
+    EXPECT_CALL(stream, read(_, _)).InSequence(sequence)
+            .WillOnce(AssignUInt16(CYNARA_MAX_VECTOR_SIZE));
+
+    for (int i = 0; i < CYNARA_MAX_VECTOR_SIZE; i++) {
+        EXPECT_CALL(stream, read(_, _)).InSequence(sequence)
+                .WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH))
+                .WillOnce(AssignString(stringInput.c_str()))
+                .WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH))
+                .WillOnce(AssignString(stringInput.c_str()));
+    }
+
+    EXPECT_NO_THROW(Cynara::ProtocolDeserialization::deserialize(stream, map));
+}
+
+TEST(Deserialization, maxMapOfVectorsPositive) {
+    using ::testing::_;
+    using ::testing::Sequence;
+    Sequence sequence;
+
+    FakeIStream stream;
+    std::string stringInput;
+    std::map<std::string, std::string> map;
+    stringInput.resize(CYNARA_MAX_ID_LENGTH, ' ');
+
+    EXPECT_CALL(stream, read(_, _)).InSequence(sequence)
+            .WillOnce(AssignUInt16(CYNARA_MAX_VECTOR_SIZE));
+
+    for (int i = 0; i < CYNARA_MAX_VECTOR_SIZE; i++) {
+        EXPECT_CALL(stream, read(_, _)).InSequence(sequence)
+                .WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH))
+                .WillOnce(AssignString(stringInput.c_str()))
+                .WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH))
+                .WillOnce(AssignString(stringInput.c_str()));
+    }
+
+    EXPECT_NO_THROW(Cynara::ProtocolDeserialization::deserialize(stream, map));
+}
+
+TEST(Deserialization, mapWithOverMaxKeyNegative) {
+    using ::testing::_;
+    using ::testing::Sequence;
+    Sequence sequence;
+
+    FakeIStream stream;
+    std::map<std::string, std::string> map;
+
+    EXPECT_CALL(stream, read(_, _)).WillOnce(AssignUInt16(1))
+            .WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH + 1));
+    EXPECT_THROW(Cynara::ProtocolDeserialization::deserialize(stream, map),
+                 Cynara::InvalidProtocolException);
+}
+
+TEST(Deserialization, mapWithOverMaxValueNegative) {
+    using ::testing::_;
+    using ::testing::Sequence;
+    Sequence sequence;
+    std::string stringInput("a");
+    FakeIStream stream;
+    std::map<std::string, std::string> map;
+
+    EXPECT_CALL(stream, read(_, _))
+            .WillOnce(AssignUInt16(1))
+            .WillOnce(AssignUInt16(1))
+            .WillOnce(AssignString(stringInput.c_str()))
+            .WillOnce(AssignUInt16(CYNARA_MAX_ID_LENGTH + 1));
+    EXPECT_THROW(Cynara::ProtocolDeserialization::deserialize(stream, map),
+                 Cynara::InvalidProtocolException);
+}
+
+TEST(Deserialization, mapWithOverMaxValueVectorNegative) {
+    using ::testing::_;
+    using ::testing::Sequence;
+    Sequence sequence;
+    std::string stringInput("a");
+    FakeIStream stream;
+    std::map<std::string, std::vector<int>> map;
+
+    EXPECT_CALL(stream, read(_, _))
+            .WillOnce(AssignUInt16(1))
+            .WillOnce(AssignUInt16(1))
+            .WillOnce(AssignString(stringInput.c_str()))
+            .WillOnce(AssignUInt16(CYNARA_MAX_VECTOR_SIZE + 1));
+    EXPECT_THROW(Cynara::ProtocolDeserialization::deserialize(stream, map),
+                 Cynara::InvalidProtocolException);
+}