Complete sfixed types serialization

- Implement and update tests

src/generator/templates.cpp

@@ -133,13 +133,13 @@ const std::unordered_map<::google::protobuf::FieldDescriptor::Type, std::string>
     {::google::protobuf::FieldDescriptor::TYPE_UINT64,"uint64"},    //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
     {::google::protobuf::FieldDescriptor::TYPE_INT32, "int32"},
     {::google::protobuf::FieldDescriptor::TYPE_FIXED64, "fint64"},  //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
-    {::google::protobuf::FieldDescriptor::TYPE_FIXED32, "fint32"},  //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
+    {::google::protobuf::FieldDescriptor::TYPE_FIXED32, "fint32"},
     {::google::protobuf::FieldDescriptor::TYPE_BOOL, "bool"},
     {::google::protobuf::FieldDescriptor::TYPE_STRING, "QString"},
     {::google::protobuf::FieldDescriptor::TYPE_BYTES, "QByteArray"},
     {::google::protobuf::FieldDescriptor::TYPE_UINT32, "uint32"},    //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
-    {::google::protobuf::FieldDescriptor::TYPE_SFIXED32, "sfint32"}, //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
+    {::google::protobuf::FieldDescriptor::TYPE_SFIXED32, "sfint32"},
     {::google::protobuf::FieldDescriptor::TYPE_SFIXED64, "sfint64"}, //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
-    {::google::protobuf::FieldDescriptor::TYPE_SINT32, "sint32"},    //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
+    {::google::protobuf::FieldDescriptor::TYPE_SINT32, "sint32"},
     {::google::protobuf::FieldDescriptor::TYPE_SINT64, "sint64"}     //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
 };

src/lib/protobufobject.h

@@ -99,9 +99,13 @@ public:
         switch (static_cast<QMetaType::Type>(propertyValue.type())) {
         case QMetaType::Int:
             type = Varint;
-            if (typeName == "sint32"
-                    || typeName == "qtprotobuf::sint32") {
+            if (typeName == "qtprotobuf::sint32"
+                    || typeName == "sint32") {
                 result.append(serializeVarintZigZag(propertyValue.toInt()));
+            } else if (typeName == "qtprotobuf::sfint32"
+                       || typeName == "sfint32") {
+                type = Fixed32;
+                result.append(serializeFixed(propertyValue.toInt()));
             } else {
                 result.append(serializeVarint(propertyValue.toLongLong()));
             }
@@ -111,9 +115,13 @@ public:
             break;
         case QMetaType::LongLong:
             type = Varint;
-            if (typeName == "sint64"
-                    || typeName == "qtprotobuf::sint64") {
+            if (typeName == "qtprotobuf::sint64"
+                    || typeName == "sint64") {
                 result.append(serializeVarintZigZag(propertyValue.toLongLong()));
+            } else if (typeName == "qtprotobuf::sfint64"
+                       || typeName == "sfint64") {
+                type = Fixed64;
+                result.append(serializeFixed(propertyValue.toLongLong()));
             } else {
                 result.append(serializeVarint(propertyValue.toLongLong()));
             }
@@ -150,8 +158,8 @@ public:
             result.append(serializeUserType(propertyValue, fieldIndex));
             break;
         case QMetaType::UInt:
-            if (typeName == "fint32"
-                    || typeName == "qtprotobuf::fint32") {
+            if (typeName == "qtprotobuf::fint32"
+                    || typeName == "fint32") {
                 type = Fixed32;
                 result.append(serializeFixed(propertyValue.toUInt()));
             } else {
@@ -163,8 +171,8 @@ public:
             }
             break;
         case QMetaType::ULongLong:
-            if (typeName == "fint64"
-                    || typeName == "qtprotobuf::fint64") {
+            if (typeName == "qtprotobuf::fint64"
+                    || typeName == "fint64") {
                 type = Fixed64;
                 result.append(serializeFixed(propertyValue.toULongLong()));
             } else {
@@ -303,7 +311,9 @@ public:
     template <typename V,
               typename std::enable_if_t<std::is_floating_point<V>::value
                                         || std::is_same<V, unsigned int>::value
-                                        || std::is_same<V, qulonglong>::value, int> = 0>
+                                        || std::is_same<V, qulonglong>::value
+                                        || std::is_same<V, int>::value
+                                        || std::is_same<V, qlonglong>::value, int> = 0>
     QByteArray serializeFixed(V value) const {
         qProtoDebug() << __func__ << "value" << value;
         //Reserve required amount of bytes

tests/serializationtest.cpp

@@ -33,6 +33,8 @@
 #include "simplesint64message.h"
 #include "simplefixedint32message.h"
 #include "simplefixedint64message.h"
+#include "simplesfixedint32message.h"
+#include "simplesfixedint64message.h"
 #include "simplefloatmessage.h"
 #include "simpledoublemessage.h"
 #include "simplestringmessage.h"
@@ -1057,6 +1059,171 @@ TEST_F(SerializationTest, FixedInt64MessageSerializeTest)
     ASSERT_TRUE(result == QByteArray::fromHex("09ffffffffffffffff"));
 }
 
+TEST_F(SerializationTest, SFixedInt32MessageSerializeTest)
+{
+    constexpr int Fixed32MessageSize = 5;
+    SimpleSFixedInt32Message test;
+    test.setTestFieldFixedInt32(15);
+    QByteArray result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d0f000000"));
+
+    test.setTestFieldFixedInt32(300);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d2c010000"));
+
+    test.setTestFieldFixedInt32(65545);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d09000100"));
+
+    test.setTestFieldFixedInt32(0);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d00000000"));
+
+    test.setTestFieldFixedInt32(INT8_MAX + 1);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d80000000"));
+
+    test.setTestFieldFixedInt32(INT16_MAX + 1);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d00800000"));
+
+    test.setTestFieldFixedInt32(INT8_MAX);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d7f000000"));
+
+    test.setTestFieldFixedInt32(INT16_MAX);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0dff7f0000"));
+
+    test.setTestFieldFixedInt32(INT8_MIN - 1);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d7fffffff"));
+
+    test.setTestFieldFixedInt32(INT16_MIN - 1);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0dff7fffff"));
+
+    test.setTestFieldFixedInt32(INT8_MIN);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d80ffffff"));
+
+    test.setTestFieldFixedInt32(INT16_MIN);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d0080ffff"));
+
+    test.setTestFieldFixedInt32(INT32_MIN);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed32MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0d00000080"));
+}
+
+TEST_F(SerializationTest, SFixedInt64MessageSerializeTest)
+{
+    constexpr int Fixed64MessageSize = 9;
+    SimpleSFixedInt64Message test;
+    test.setTestFieldFixedInt64(15);
+    QByteArray result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("090f00000000000000"));
+
+    test.setTestFieldFixedInt64(300);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("092c01000000000000"));
+
+    test.setTestFieldFixedInt64(65545);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("090900010000000000"));
+
+    test.setTestFieldFixedInt64(0);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("090000000000000000"));
+
+    test.setTestFieldFixedInt64(INT8_MAX + 1);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("098000000000000000"));
+
+    test.setTestFieldFixedInt64(INT16_MAX + 1);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("090080000000000000"));
+
+    test.setTestFieldFixedInt64((unsigned long long)(INT32_MAX) + 1);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("090000008000000000"));
+
+    test.setTestFieldFixedInt64(INT8_MAX);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("097f00000000000000"));
+
+    test.setTestFieldFixedInt64(INT16_MAX);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("09ff7f000000000000"));
+
+    test.setTestFieldFixedInt64(INT32_MAX);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("09ffffff7f00000000"));
+
+    test.setTestFieldFixedInt64(INT64_MAX);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("09ffffffffffffff7f"));
+
+    test.setTestFieldFixedInt64(INT8_MIN - 1);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("097fffffffffffffff"));
+
+    test.setTestFieldFixedInt64(INT16_MIN - 1);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("09ff7fffffffffffff"));
+
+    test.setTestFieldFixedInt64((qlonglong)INT32_MIN - 1);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("09ffffff7fffffffff"));
+
+    test.setTestFieldFixedInt64(INT8_MIN);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0980ffffffffffffff"));
+
+    test.setTestFieldFixedInt64(INT16_MIN);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("090080ffffffffffff"));
+
+    test.setTestFieldFixedInt64(INT32_MIN);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("0900000080ffffffff"));
+
+    test.setTestFieldFixedInt64(INT64_MIN);
+    result = test.serialize();
+    ASSERT_EQ(result.size(), Fixed64MessageSize);
+    ASSERT_TRUE(result == QByteArray::fromHex("090000000000000080"));
+}
+
 TEST_F(SerializationTest, FloatMessageSerializeTest)
 {
     constexpr int FloatMessageSize = 5;

tests/simpletest.cpp

@@ -33,6 +33,8 @@
 #include "simpleuint64message.h"
 #include "simplefixedint32message.h"
 #include "simplefixedint64message.h"
+#include "simplesfixedint32message.h"
+#include "simplesfixedint64message.h"
 #include "simplestringmessage.h"
 #include "simplefloatmessage.h"
 #include "simpledoublemessage.h"
@@ -139,6 +141,7 @@ TEST_F(SimpleTest, SimpleFixedInt32MessageTest)
     SimpleFixedInt32Message test;
     int propertyNumber = SimpleFixedInt32Message::propertyOrdering.at(1); //See simpletest.proto
     ASSERT_EQ(SimpleFixedInt32Message::staticMetaObject.property(propertyNumber).type(), qMetaTypeId<fint32>());
+    ASSERT_STREQ(SimpleFixedInt32Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::fint32");
     ASSERT_STREQ(SimpleFixedInt32Message::staticMetaObject.property(propertyNumber).name(), propertyName);
     ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue(1)));
     ASSERT_EQ(test.property(propertyName).value<fint32>(), 1);
@@ -151,12 +154,39 @@ TEST_F(SimpleTest, SimpleFixedInt64MessageTest)
     SimpleFixedInt64Message test;
     int propertyNumber = SimpleFixedInt64Message::propertyOrdering.at(1); //See simpletest.proto
     ASSERT_EQ(SimpleFixedInt64Message::staticMetaObject.property(propertyNumber).type(), qMetaTypeId<fint64>());
+    ASSERT_STREQ(SimpleFixedInt64Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::fint64");
     ASSERT_STREQ(SimpleFixedInt64Message::staticMetaObject.property(propertyNumber).name(), propertyName);
     ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue(1)));
     ASSERT_EQ(test.property(propertyName).value<fint64>(), 1);
     ASSERT_EQ(test.testFieldFixedInt64(), 1);
 }
 
+TEST_F(SimpleTest, SimpleSFixedInt32MessageTest)
+{
+    const char* propertyName = "testFieldFixedInt32";
+    SimpleSFixedInt32Message test;
+    int propertyNumber = SimpleSFixedInt32Message::propertyOrdering.at(1); //See simpletest.proto
+    ASSERT_EQ(SimpleSFixedInt32Message::staticMetaObject.property(propertyNumber).type(), qMetaTypeId<sfint32>());
+    ASSERT_STREQ(SimpleSFixedInt32Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::sfint32");
+    ASSERT_STREQ(SimpleSFixedInt32Message::staticMetaObject.property(propertyNumber).name(), propertyName);
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue(1)));
+    ASSERT_EQ(test.property(propertyName).value<fint32>(), 1);
+    ASSERT_EQ(test.testFieldFixedInt32(), 1);
+}
+
+TEST_F(SimpleTest, SimpleSFixedInt64MessageTest)
+{
+    const char* propertyName = "testFieldFixedInt64";
+    SimpleSFixedInt64Message test;
+    int propertyNumber = SimpleSFixedInt64Message::propertyOrdering.at(1); //See simpletest.proto
+    ASSERT_EQ(SimpleSFixedInt64Message::staticMetaObject.property(propertyNumber).type(), qMetaTypeId<sfint64>());
+    ASSERT_STREQ(SimpleSFixedInt64Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::sfint64");
+    ASSERT_STREQ(SimpleSFixedInt64Message::staticMetaObject.property(propertyNumber).name(), propertyName);
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue(1)));
+    ASSERT_EQ(test.property(propertyName).value<fint64>(), 1);
+    ASSERT_EQ(test.testFieldFixedInt64(), 1);
+}
+
 TEST_F(SimpleTest, SimpleStringMessageTest)
 {
     const char* propertyName = "testFieldString";