Added DnsQuery serialize() method and associated tests; modified DnsQuery to use QDataStream

src/modules/dns/includes/dns/QDnsQuery.h

         QDnsQuery();
 
         static QDnsQuery parse(const QByteArray& packetData, quint32 pos);
-        QByteArray serialize(const QByteArray& data) const;
+        static QDnsQuery parse(const QByteArray& packetData, QDataStream& dataStream);
+        QByteArray serialize() const;
+        void serialize(QDataStream& dataStream) const;
 
         bool isValid() const;
 

src/modules/dns/src/QDnsQuery.cpp

 
     QDnsQuery QDnsQuery::parse(const QByteArray& packetData, quint32 pos)
     {
-        QDnsQuery query;
         QDataStream dataStream(packetData);
         dataStream.skipRawData(pos);
+        return parse(packetData, dataStream);
+    }
+
+    QDnsQuery QDnsQuery::parse(const QByteArray& packetData, QDataStream& dataStream)
+    {
+        QDnsQuery query;
 
         if (dataStream.device()->bytesAvailable() < 5)
         {
         return query;
     }
 
-    QByteArray QDnsQuery::serialize(const QByteArray& data) const // TODO
+    QByteArray QDnsQuery::serialize() const
     {
         QByteArray byteArray;
         QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
-
+        serialize(dataStream);
         return byteArray;
     }
 
+    void QDnsQuery::serialize(QDataStream& dataStream) const
+    {
+        auto label = QDnsLabel::serialize(m_name);
+        dataStream.writeRawData(label.constData(), label.length());
+        dataStream << m_type;
+        dataStream << m_class;
+    }
+
     bool QDnsQuery::isValid() const
     {
         return m_isValid;

tests/DnsQuery.cpp

 
 #include "dns/QDnsQuery.h"
 
-struct DnsQueryTestParams
+struct DnsQueryParseTestParams
 {
     bool isValid;
     const char* hexData;
     quint16 clazz;
 };
 
-class DnsQueryTest : public ::testing::TestWithParam<DnsQueryTestParams>
+class DnsQueryParseTest : public ::testing::TestWithParam<DnsQueryParseTestParams>
 {
 };
 
-TEST_P(DnsQueryTest, parse)
+TEST_P(DnsQueryParseTest, parse)
 {
     auto params = GetParam();
     auto data = QByteArray::fromHex(params.hexData);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(DnsQueryTestInst,
-                        DnsQueryTest,
+INSTANTIATE_TEST_CASE_P(DnsQueryParseTestInst,
+                        DnsQueryParseTest,
                         ::testing::Values(
-                                DnsQueryTestParams {false, "", 0},
-                                DnsQueryTestParams {false, "00", 0},
-                                DnsQueryTestParams {true,
+                                DnsQueryParseTestParams {false, "", 0},
+                                DnsQueryParseTestParams {false, "00", 0},
+                                DnsQueryParseTestParams {true,
                                                     "0377777706676f6f676c650266720000010001",
                                                     0,
                                                     "www.google.fr",
                                                     1,
                                                     1
                                 },
-                                DnsQueryTestParams {true,
+                                DnsQueryParseTestParams {true,
                                                     "03777777067274686f6e6903636f6d0000030008",
                                                     0,
                                                     "www.rthoni.com",
                                                     3,
                                                     8
                                 },
-                                DnsQueryTestParams {true,
+                                DnsQueryParseTestParams {true,
                                                     "0003777777067274686f6e6903636f6d0000030008",
                                                     1,
                                                     "www.rthoni.com",
                                                     8
                                 }
                         ));
+
+
+
+struct DnsQuerySerializeTestParams
+{
+    const char* hexData;
+
+    const char* name;
+    quint16 type;
+    quint16 clazz;
+};
+
+class DnsQuerySerializeTest : public ::testing::TestWithParam<DnsQuerySerializeTestParams>
+{
+};
+
+TEST_P(DnsQuerySerializeTest, serialize)
+{
+    auto params = GetParam();
+    auto data = QByteArray::fromHex(params.hexData);
+    QDns::QDnsQuery query;
+
+    query.setName(params.name);
+    query.setType(params.type);
+    query.setClass(params.clazz);
+
+    ASSERT_EQ(query.serialize().toHex(), QString(params.hexData).remove(" "));
+}
+
+INSTANTIATE_TEST_CASE_P(DnsQuerySerializeTestInst,
+                        DnsQuerySerializeTest,
+                        ::testing::Values(
+                                DnsQuerySerializeTestParams {"0266720000020008",
+                                                             "fr",
+                                                             2,
+                                                             8
+                                },
+                                DnsQuerySerializeTestParams {"06676f6f676c650266720000010001",
+                                                             "google.fr",
+                                                             1,
+                                                             1
+                                },
+                                DnsQuerySerializeTestParams {"03777777067274686f6e6903636f6d0000010001",
+                                                             "www.rthoni.com",
+                                                             1,
+                                                             1
+                                }
+                        ));