Added enum instead of int for QDnsHeader and QDnsQuery and associated tests

src/modules/dns-base/includes/dns-base/QDnsHeader.h

 #include <qplatformdefs.h>
 #include <QByteArray>
 #include <QDataStream>
+#include "QDnsBase.h"
 
 namespace QDns
 {
 
             void setIsQuery(bool isQuery);
 
-            quint8 getOpcode() const;
+            HeaderOpcode getOpcode() const;
 
-            void setOpcode(quint8 opcode);
+            void setOpcode(HeaderOpcode opcode);
 
             bool isAuthoritative() const;
 
 
             void setNonAuthenticatedAcceptable(bool isNonAuthenticatedAcceptable);
 
-            quint8 getReplyCode() const;
+            HeaderReplyCode getReplyCode() const;
 
-            void setReplyCode(quint8 replyCode);
+            void setReplyCode(HeaderReplyCode replyCode);
 
 
             quint16 getQueryCount() const;

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

 
 #include <qplatformdefs.h>
 #include <QString>
+#include "dns-base/QDnsBase.h"
 
 namespace QDns
 {
 
             void setName(const QString &name);
 
-            quint16 getType() const;
+            RecordType getType() const;
 
-            void setType(quint16 type);
+            void setType(RecordType type);
 
-            quint16 getClass() const;
+            RecordClass getClass() const;
 
-            void setClass(quint16 aClass);
+            void setClass(RecordClass aClass);
 
         private:
             void parse(const QByteArray &packetData, QDataStream &dataStream);

src/modules/dns-base/src/QDnsHeader.cpp

             setFlagBits(0, (quint8) !isQuery, 1);
         }
 
-        quint8 QDnsHeader::getOpcode() const
+        HeaderOpcode QDnsHeader::getOpcode() const
         {
-            return (quint8) getFlagBits(4, 4);
+            return (HeaderOpcode) getFlagBits(4, 4);
         }
 
-        void QDnsHeader::setOpcode(quint8 opcode)
+        void QDnsHeader::setOpcode(HeaderOpcode opcode)
         {
-            setFlagBits(4, opcode, 4);
+            setFlagBits(4, (quint8) opcode, 4);
         }
 
         bool QDnsHeader::isAuthoritative() const
             setFlagBits(11, (quint8) isNonAuthenticatedAcceptable, 1);
         }
 
-        quint8 QDnsHeader::getReplyCode() const
+        HeaderReplyCode QDnsHeader::getReplyCode() const
         {
-            return (quint8) getFlagBits(15, 4);
+            return (HeaderReplyCode) getFlagBits(15, 4);
         }
 
-        void QDnsHeader::setReplyCode(quint8 replyCode)
+        void QDnsHeader::setReplyCode(HeaderReplyCode replyCode)
         {
             setFlagBits(15, (quint8) replyCode, 4);
         }

src/modules/dns-base/src/QDnsQuery.cpp

     {
         QDnsQuery::QDnsQuery()
                 : m_isValid(true)
-                  , m_type(0)
-                  , m_class(0)
+                  , m_type(RecordType::A)
+                  , m_class(RecordClass::IN)
         {
         }
 
             m_name = name;
         }
 
-        quint16 QDnsQuery::getType() const
+        RecordType QDnsQuery::getType() const
         {
-            return m_type;
+            return (RecordType) m_type;
         }
 
-        void QDnsQuery::setType(quint16 type)
+        void QDnsQuery::setType(RecordType type)
         {
             m_type = type;
         }
 
-        quint16 QDnsQuery::getClass() const
+        RecordClass QDnsQuery::getClass() const
         {
-            return m_class;
+            return (RecordClass) m_class;
         }
 
-        void QDnsQuery::setClass(quint16 aClass)
+        void QDnsQuery::setClass(RecordClass aClass)
         {
             m_class = aClass;
         }

src/modules/dns-base/tests/DnsHeader.cpp

 
     quint16 flags;
     bool flagQuery;
-    quint8 flagOpcode;
+    QDns::Base::HeaderOpcode flagOpcode;
     bool flagAuthoritative;
     bool flagTruncated;
     bool flagRecursionDesired;
     bool flagReserved0;
     bool flagAnswerAuthenticated;
     bool flagNonAuthenticatedAcceptable;
-    quint8 flagReplyCode;
+    QDns::Base::HeaderReplyCode flagReplyCode;
 
     quint16 queryCount;
     quint16 answerCount;
 
                                                      0x0100,
                                                      true,
-                                                     0,
+                                                     QDns::Base::HeaderOpcode::Query,
                                                      false,
                                                      false,
                                                      true,
                                                      false,
                                                      false,
                                                      false,
-                                                     0,
+                                                     QDns::Base::HeaderReplyCode::NoError,
 
                                                      1,
                                                      0,
                                                      0x3cdc,
                                                      0x8180,
                                                      false,
-                                                     0,
+                                                     QDns::Base::HeaderOpcode::Query,
                                                      false,
                                                      false,
                                                      true,
                                                      false,
                                                      false,
                                                      false,
-                                                     0,
+                                                     QDns::Base::HeaderReplyCode::NoError,
 
                                                      1,
                                                      1,
                                                      0x3cdc,
                                                      0xaaaa,
                                                      false,
-                                                     5,
+                                                     QDns::Base::HeaderOpcode::Update,
                                                      false,
                                                      true,
                                                      false,
                                                      false,
                                                      true,
                                                      false,
-                                                     10,
+                                                     QDns::Base::HeaderReplyCode::NotZone,
 
                                                      43690,
                                                      21845,
                                                      0x3cdc,
                                                      0x5555,
                                                      true,
-                                                     10,
+                                                     (QDns::Base::HeaderOpcode) 10,
                                                      true,
                                                      false,
                                                      true,
                                                      true,
                                                      false,
                                                      true,
-                                                     5,
+                                                     QDns::Base::HeaderReplyCode::Refused,
 
                                                      22015,
                                                      43690,

src/modules/dns-base/tests/DnsQuery.cpp

     const char* hexData;
 
     const char* name;
-    quint16 type;
-    quint16 clazz;
+    QDns::Base::RecordType type;
+    QDns::Base::RecordClass clazz;
 };
 
 class DnsQuerySerializeTest : public ::testing::TestWithParam<DnsQuerySerializeTestParams>
 INSTANTIATE_TEST_CASE_P(DnsQuerySerializeTestInst,
                         DnsQuerySerializeTest,
                         ::testing::Values(
-                                DnsQuerySerializeTestParams {"0266720000020008",
+                                DnsQuerySerializeTestParams {"0266720000020004",
                                                              "fr",
-                                                             2,
-                                                             8
+                                                             QDns::Base::RecordType::NS,
+                                                             QDns::Base::RecordClass::HS
                                 },
                                 DnsQuerySerializeTestParams {"06676f6f676c650266720000010001",
                                                              "google.fr",
-                                                             1,
-                                                             1
+                                                             QDns::Base::RecordType::A,
+                                                             QDns::Base::RecordClass::IN
                                 },
                                 DnsQuerySerializeTestParams {"03777777067274686f6e6903636f6d0000010001",
                                                              "www.rthoni.com",
-                                                             1,
-                                                             1
+                                                             QDns::Base::RecordType::A,
+                                                             QDns::Base::RecordClass::IN
                                 }
                         ));