[prev in list] [next in list] [prev in thread] [next in thread] 

List:       kde-commits
Subject:    [dferry] tests/serialization: Add tests for copied Reader and Writer instances.
From:       Andreas Hartmetz <ahartmetz () gmail ! com>
Date:       2016-10-12 0:57:08
Message-ID: E1bu7r2-0007PZ-3v () code ! kde ! org
[Download RAW message or body]

Git commit 18136f5a5150aecd731e8a4edb25723241a18a6d by Andreas Hartmetz.
Committed on 12/10/2016 at 00:53.
Pushed by ahartmetz into branch 'master'.

Add tests for copied Reader and Writer instances.

No bugs found! (The tests work, I've injected an error to check)
Supporting changes:
- Extract the code to check things after a roundtrip
- Decrease the lowest dataIncrement value from 1 to 0. Seems like a
  good idea to include this corner case in all the tests.

M  +101  -21   tests/serialization/tst_arguments.cpp

http://commits.kde.org/dferry/18136f5a5150aecd731e8a4edb25723241a18a6d

diff --git a/tests/serialization/tst_arguments.cpp b/tests/serialization/tst_arguments.cpp
index cd22da4..5dc354c 100644
--- a/tests/serialization/tst_arguments.cpp
+++ b/tests/serialization/tst_arguments.cpp
@@ -394,7 +394,33 @@ static void defaultReadToWrite(Arguments::Reader *reader, Arguments::Writer *wri
     }
 }
 
-static void doRoundtripForReal(const Arguments &original, uint32 dataIncrement, bool debugPrint)
+static void verifyAfterRoundtrip(const Arguments &original, const Arguments::Reader &originalReader,
+                                 const Arguments &copy, const Arguments::Writer &copyWriter,
+                                 bool debugPrint)
+{
+    TEST(originalReader.state() == Arguments::Finished);
+    TEST(copyWriter.state() == Arguments::Finished);
+    cstring originalSignature = original.signature();
+    cstring copySignature = copy.signature();
+    if (originalSignature.length) {
+        TEST(Arguments::isSignatureValid(copySignature));
+        TEST(stringsEqual(originalSignature, copySignature));
+    } else {
+        TEST(copySignature.length == 0);
+    }
+
+    chunk originalData = original.data();
+
+    chunk copyData = copy.data();
+    TEST(originalData.length == copyData.length);
+    if (debugPrint && !chunksEqual(originalData, copyData)) {
+        printChunk(originalData);
+        printChunk(copyData);
+    }
+    TEST(chunksEqual(originalData, copyData));
+}
+
+static void doRoundtripWithShortReads(const Arguments &original, uint32 dataIncrement, bool debugPrint)
 {
     Arguments::Reader reader(original);
     Arguments::Writer writer;
@@ -440,31 +466,85 @@ static void doRoundtripForReal(const Arguments &original, uint32 dataIncrement,
     }
 
     Arguments copy = writer.finish();
-    TEST(reader.state() == Arguments::Finished);
-    TEST(writer.state() == Arguments::Finished);
-    cstring originalSignature = original.signature();
-    cstring copySignature = copy.signature();
-    if (originalSignature.length) {
-        TEST(Arguments::isSignatureValid(copySignature));
-        TEST(stringsEqual(originalSignature, copySignature));
-    } else {
-        TEST(copySignature.length == 0);
+    verifyAfterRoundtrip(original, reader, copy, writer, debugPrint);
+    if (shortData.ptr) {
+        free(shortData.ptr);
     }
+}
 
-    // TODO when it's wired up between Reader and Arguments: chunk originalData = arg.data();
-    chunk originalData = original.data();
+static void doRoundtripWithReaderCopy(const Arguments &original, uint32 dataIncrement, bool debugPrint)
+{
+    Arguments::Reader *reader = new Arguments::Reader(original);
+    Arguments::Writer writer;
 
-    chunk copyData = copy.data();
-    TEST(originalData.length == copyData.length);
-    if (debugPrint && !chunksEqual(originalData, copyData)) {
-        printChunk(originalData);
-        printChunk(copyData);
+    bool isDone = false;
+    uint32 emptyNesting = 0;
+    uint32 i = 0;
+
+    while (!isDone) {
+        TEST(writer.state() != Arguments::InvalidData);
+        if (i++ == dataIncrement) {
+            Arguments::Reader *copy = new Arguments::Reader(*reader);
+            delete reader;
+            reader = copy;
+        }
+        if (debugPrint) {
+            std::cout << "Reader state: " << reader->stateString().ptr << '\n';
+        }
+        switch(reader->state()) {
+        case Arguments::Finished:
+            isDone = true;
+            break;
+        default:
+            defaultReadToWrite(reader, &writer, &emptyNesting);
+            break;
+        }
     }
-    TEST(chunksEqual(originalData, copyData));
 
-    if (shortData.ptr) {
-        free(shortData.ptr);
+    Arguments copy = writer.finish();
+    verifyAfterRoundtrip(original, *reader, copy, writer, debugPrint);
+    delete reader;
+}
+
+static void doRoundtripWithWriterCopy(const Arguments &original, uint32 dataIncrement, bool debugPrint)
+{
+    Arguments::Reader reader(original);
+    Arguments::Writer *writer = new Arguments::Writer;
+
+    bool isDone = false;
+    uint32 emptyNesting = 0;
+    uint32 i = 0;
+
+    while (!isDone) {
+        TEST(writer->state() != Arguments::InvalidData);
+        if (i++ == dataIncrement) {
+            Arguments::Writer *copy = new Arguments::Writer(*writer);
+            delete writer;
+            writer = copy;
+        }
+        if (debugPrint) {
+            std::cout << "Reader state: " << reader.stateString().ptr << '\n';
+        }
+        switch(reader.state()) {
+        case Arguments::Finished:
+            isDone = true;
+            break;
+        default:
+            defaultReadToWrite(&reader, writer, &emptyNesting);
+            break;
+        }
     }
+
+    Arguments copy = writer->finish();
+    verifyAfterRoundtrip(original, reader, copy, *writer, debugPrint);
+    delete writer;
+}
+
+static void doRoundtripForReal(const Arguments &original, uint32 dataIncrement, bool debugPrint)
+{
+    doRoundtripWithShortReads(original, dataIncrement, debugPrint);
+    doRoundtripWithReaderCopy(original, dataIncrement, debugPrint);
+    doRoundtripWithWriterCopy(original, dataIncrement, debugPrint);
 }
 
 // not returning by value to avoid the move constructor or assignment operator -
@@ -539,7 +619,7 @@ static void doRoundtripWithCopyAssignEtc(const Arguments &arg_in, uint32 dataInc
 static void doRoundtrip(const Arguments &arg, bool debugPrint = false)
 {
     const uint32 maxIncrement = arg.data().length;
-    for (uint32 i = 1; i <= maxIncrement; i++) {
+    for (uint32 i = 0; i <= maxIncrement; i++) {
         doRoundtripWithCopyAssignEtc(arg, i, debugPrint);
     }
 
[prev in list] [next in list] [prev in thread] [next in thread]