Swap int and sint types implementation

- Swap int and sint types implemntation since sint is more likely for protobuf
  It's required to prio support in QML.
- Update tests
TODO: it's required to make protobuf int and fixed types compatible with QML

src/protobuf/qprotobufobject_p.cpp

@@ -33,7 +33,7 @@ void ProtobufObjectPrivate::registerSerializers()
 {
     wrapSerializer<float>(ProtobufObjectPrivate::serializeBasic<float>, ProtobufObjectPrivate::deserializeBasic<float>, Fixed32);
     wrapSerializer<double>(ProtobufObjectPrivate::serializeBasic<double>, ProtobufObjectPrivate::deserializeBasic<double>, Fixed64);
-    wrapSerializer<int32>(ProtobufObjectPrivate::serializeBasic<int64>, ProtobufObjectPrivate::deserializeBasic<int64>, Varint);
+    wrapSerializer<int32>(ProtobufObjectPrivate::serializeBasic<int32>, ProtobufObjectPrivate::deserializeBasic<int32>, Varint);
     wrapSerializer<int64>(ProtobufObjectPrivate::serializeBasic<int64>, ProtobufObjectPrivate::deserializeBasic<int64>, Varint);
     wrapSerializer<uint32>(ProtobufObjectPrivate::serializeBasic<uint32>, ProtobufObjectPrivate::deserializeBasic<uint32>, Varint);
     wrapSerializer<uint64>(ProtobufObjectPrivate::serializeBasic<uint64>, ProtobufObjectPrivate::deserializeBasic<uint64>, Varint);
@@ -81,7 +81,7 @@ QByteArray ProtobufObjectPrivate::serializeValue(const QVariant &propertyValue,
 
     if (metaProperty.isEnumType()) {
         type = Varint;
-        result.append(serializeBasic(propertyValue.toLongLong(), fieldIndex));
+        result.append(serializeBasic(int64(propertyValue.value<int32_t>()), fieldIndex));
     } else {
         result.append(serializeUserType(propertyValue, fieldIndex, type));
     }
@@ -127,7 +127,7 @@ void ProtobufObjectPrivate::deserializeProperty(QObject *object, WireTypes wireT
         return;
     default:
         if (metaProperty.isEnumType()) {
-            newPropertyValue = deserializeBasic<int32>(it);
+            newPropertyValue = QVariant::fromValue(int32_t(deserializeBasic<int64>(it).value<int64>()._t));
         } else {
             newPropertyValue = metaProperty.read(object);
             deserializeUserType(metaProperty, it, newPropertyValue);

src/protobuf/qprotobufobject_p.h

@@ -44,10 +44,10 @@ template<typename V>
 struct make_unsigned { typedef typename std::make_unsigned<V>::type type; };
 
 template<>
-struct make_unsigned<sint32> { typedef typename std::make_unsigned<decltype(sint32::_t)>::type type; };
+struct make_unsigned<int32> { typedef typename std::make_unsigned<decltype(int32::_t)>::type type; };
 
 template<>
-struct make_unsigned<sint64> { typedef typename std::make_unsigned<decltype(sint64::_t)>::type type; };
+struct make_unsigned<int64> { typedef typename std::make_unsigned<decltype(int64::_t)>::type type; };
 
 class ProtobufObjectPrivate
 {
@@ -132,8 +132,8 @@ public:
     }
 
     template <typename V,
-              typename std::enable_if_t<std::is_same<V, sint32>::value
-                                        || std::is_same<V, sint64>::value, int> = 0>
+              typename std::enable_if_t<std::is_integral<V>::value
+                                        && std::is_signed<V>::value, int> = 0>
     static QByteArray serializeBasic(V value, int &outFieldIndex) {
         qProtoDebug() << __func__ << "value" << value;
         using UV = typename qtprotobuf::make_unsigned<V>::type;
@@ -146,8 +146,8 @@ public:
     }
 
     template <typename V,
-              typename std::enable_if_t<std::is_integral<V>::value
-                                        && std::is_signed<V>::value, int> = 0>
+              typename std::enable_if_t<std::is_same<V, int32>::value
+                                        || std::is_same<V, int64>::value, int> = 0>
     static QByteArray serializeBasic(V value, int &outFieldIndex) {
         qProtoDebug() << __func__ << "value" << value;
         using UV = typename qtprotobuf::make_unsigned<V>::type;
@@ -341,8 +341,8 @@ public:
     }
 
     template <typename V,
-              typename std::enable_if_t<std::is_same<sint32, V>::value
-                                        || std::is_same<sint64, V>::value,int> = 0>
+              typename std::enable_if_t<std::is_integral<V>::value
+                                        && std::is_signed<V>::value,int> = 0>
     static QVariant deserializeBasic(QByteArray::const_iterator &it) {
         qProtoDebug() << __func__ << "currentByte:" << QString::number((*it), 16);
         using  UV = typename qtprotobuf::make_unsigned<V>::type;
@@ -352,8 +352,8 @@ public:
     }
 
     template <typename V,
-              typename std::enable_if_t<std::is_integral<V>::value
-                                        && std::is_signed<V>::value, int> = 0>
+              typename std::enable_if_t<std::is_same<int32, V>::value
+                                        || std::is_same<int64, V>::value, int> = 0>
     static QVariant deserializeBasic(QByteArray::const_iterator &it) {
         qProtoDebug() << __func__ << "currentByte:" << QString::number((*it), 16);
         using  UV = typename qtprotobuf::make_unsigned<V>::type;

src/protobuf/qtprotobuftypes.h

@@ -48,12 +48,12 @@ struct transparent {
     operator T() const { return _t; }
 };
 
-using int32 = int32_t;
-using int64 = int64_t;
+using int32 = transparent<int32_t>;
+using int64 = transparent<int64_t>;
 using uint32 = uint32_t;
 using uint64 = uint64_t;
-using sint32 = transparent<int32_t>;
-using sint64 = transparent<int64_t>;
+using sint32 = int32_t;
+using sint64 = int64_t;
 using fixed32 = transparent<uint32_t, 1>;
 using fixed64 = transparent<uint64_t, 1>;
 using sfixed32 = transparent<int32_t, 1>;
@@ -98,3 +98,4 @@ Q_DECLARE_METATYPE(qtprotobuf::sfixed64List)
 
 Q_DECLARE_METATYPE(qtprotobuf::FloatList)
 Q_DECLARE_METATYPE(qtprotobuf::DoubleList)
+

tests/serializationcomplexmessagemap.cpp

@@ -71,7 +71,7 @@ TEST_F(SerializationTest, SimpleInt32ComplexMapSerializeTest)
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
-                "1a2f08d6ffffffffffffffff011222121e321c6d696e757320666f757274792074776f2074656e207369787465656e080a1a15080a1211120d320b74656e207369787465656e08101a1008938004120a120632045755543f080a");
+                "1a2a08d6ffffff0f1222121e321c6d696e757320666f757274792074776f2074656e207369787465656e080a1a15080a1211120d320b74656e207369787465656e08101a1008938004120a120632045755543f080a");
 }
 
 TEST_F(SerializationTest, SimpleSInt32ComplexMapSerializeTest)

tests/serializationtest.cpp

@@ -151,123 +151,35 @@ TEST_F(SerializationTest, IntMessageSerializeTest)
 
     test.setTestFieldInt(-1);
     result = test.serialize();
-    ASSERT_EQ(result.size(), 11);
-    ASSERT_EQ(result.at(0), 0x08);
-    ASSERT_EQ(result.at(1), '\xff');
-    ASSERT_EQ(result.at(2), '\xff');
-    ASSERT_EQ(result.at(3), '\xff');
-    ASSERT_EQ(result.at(4), '\xff');
-    ASSERT_EQ(result.at(5), '\xff');
-    ASSERT_EQ(result.at(6), '\xff');
-    ASSERT_EQ(result.at(7), '\xff');
-    ASSERT_EQ(result.at(8), '\xff');
-    ASSERT_EQ(result.at(9), '\xff');
-    ASSERT_EQ(result.at(10), '\x01');
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "08ffffffff0f");
 
     test.setTestFieldInt(-462);
     result = test.serialize();
-    ASSERT_EQ(result.size(), 11);
-    ASSERT_EQ(result.at(0), 0x08);
-    ASSERT_EQ(result.at(1), '\xb2');
-    ASSERT_EQ(result.at(2), '\xfc');
-    ASSERT_EQ(result.at(3), '\xff');
-    ASSERT_EQ(result.at(4), '\xff');
-    ASSERT_EQ(result.at(5), '\xff');
-    ASSERT_EQ(result.at(6), '\xff');
-    ASSERT_EQ(result.at(7), '\xff');
-    ASSERT_EQ(result.at(8), '\xff');
-    ASSERT_EQ(result.at(9), '\xff');
-    ASSERT_EQ(result.at(10), '\x01');
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "08b2fcffff0f");
 
     test.setTestFieldInt(-63585);
     result = test.serialize();
-    ASSERT_EQ(result.size(), 11);
-    ASSERT_EQ(result.at(0), 0x08);
-    ASSERT_EQ(result.at(1), '\x9f');
-    ASSERT_EQ(result.at(2), '\x8f');
-    ASSERT_EQ(result.at(3), '\xfc');
-    ASSERT_EQ(result.at(4), '\xff');
-    ASSERT_EQ(result.at(5), '\xff');
-    ASSERT_EQ(result.at(6), '\xff');
-    ASSERT_EQ(result.at(7), '\xff');
-    ASSERT_EQ(result.at(8), '\xff');
-    ASSERT_EQ(result.at(9), '\xff');
-    ASSERT_EQ(result.at(10), '\x01');
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "089f8ffcff0f");
 
     test.setTestFieldInt(INT8_MIN);
     result = test.serialize();
-    ASSERT_EQ(result.size(), 11);
-    ASSERT_EQ(result.at(0), 0x08);
-    ASSERT_EQ(result.at(1), '\x80');
-    ASSERT_EQ(result.at(2), '\xff');
-    ASSERT_EQ(result.at(3), '\xff');
-    ASSERT_EQ(result.at(4), '\xff');
-    ASSERT_EQ(result.at(5), '\xff');
-    ASSERT_EQ(result.at(6), '\xff');
-    ASSERT_EQ(result.at(7), '\xff');
-    ASSERT_EQ(result.at(8), '\xff');
-    ASSERT_EQ(result.at(9), '\xff');
-    ASSERT_EQ(result.at(10), '\x01');
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "0880ffffff0f");
 
     test.setTestFieldInt(INT16_MIN);
     result = test.serialize();
-    ASSERT_EQ(result.size(), 11);
-    ASSERT_EQ(result.at(0), 0x08);
-    ASSERT_EQ(result.at(1), '\x80');
-    ASSERT_EQ(result.at(2), '\x80');
-    ASSERT_EQ(result.at(3), '\xfe');
-    ASSERT_EQ(result.at(4), '\xff');
-    ASSERT_EQ(result.at(5), '\xff');
-    ASSERT_EQ(result.at(6), '\xff');
-    ASSERT_EQ(result.at(7), '\xff');
-    ASSERT_EQ(result.at(8), '\xff');
-    ASSERT_EQ(result.at(9), '\xff');
-    ASSERT_EQ(result.at(10), '\x01');
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "088080feff0f");
 
     test.setTestFieldInt(INT32_MIN);
     result = test.serialize();
-    ASSERT_EQ(result.size(), 11);
-    ASSERT_EQ(result.at(0), 0x08);
-    ASSERT_EQ(result.at(1), '\x80');
-    ASSERT_EQ(result.at(2), '\x80');
-    ASSERT_EQ(result.at(3), '\x80');
-    ASSERT_EQ(result.at(4), '\x80');
-    ASSERT_EQ(result.at(5), '\xf8');
-    ASSERT_EQ(result.at(6), '\xff');
-    ASSERT_EQ(result.at(7), '\xff');
-    ASSERT_EQ(result.at(8), '\xff');
-    ASSERT_EQ(result.at(9), '\xff');
-    ASSERT_EQ(result.at(10), '\x01');
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "088080808008");
 
     test.setTestFieldInt(INT8_MIN - 1);
     result = test.serialize();
-    ASSERT_EQ(result.size(), 11);
-    ASSERT_EQ(result.at(0), 0x08);
-    ASSERT_EQ(result.at(1), '\xff');
-    ASSERT_EQ(result.at(2), '\xfe');
-    ASSERT_EQ(result.at(3), '\xff');
-    ASSERT_EQ(result.at(4), '\xff');
-    ASSERT_EQ(result.at(5), '\xff');
-    ASSERT_EQ(result.at(6), '\xff');
-    ASSERT_EQ(result.at(7), '\xff');
-    ASSERT_EQ(result.at(8), '\xff');
-    ASSERT_EQ(result.at(9), '\xff');
-    ASSERT_EQ(result.at(10), '\x01');
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "08fffeffff0f");
 
     test.setTestFieldInt(INT16_MIN - 1);
     result = test.serialize();
-    ASSERT_EQ(result.size(), 11);
-    ASSERT_EQ(result.at(0), 0x08);
-    ASSERT_EQ(result.at(1), '\xff');
-    ASSERT_EQ(result.at(2), '\xff');
-    ASSERT_EQ(result.at(3), '\xfd');
-    ASSERT_EQ(result.at(4), '\xff');
-    ASSERT_EQ(result.at(5), '\xff');
-    ASSERT_EQ(result.at(6), '\xff');
-    ASSERT_EQ(result.at(7), '\xff');
-    ASSERT_EQ(result.at(8), '\xff');
-    ASSERT_EQ(result.at(9), '\xff');
-    ASSERT_EQ(result.at(10), '\x01');
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "08fffffdff0f");
 }
 
 TEST_F(SerializationTest, UIntMessageSerializeTest)
@@ -1411,10 +1323,10 @@ TEST_F(SerializationTest, ComplexTypeSerializeTest)
     test.setTestComplexField(stringMsg);
 
     result = test.serialize();
-    //qDebug() << "result" << result.toHex();
+//    qDebug() << "result" << result.toHex();
 
-    ASSERT_TRUE(result == QByteArray::fromHex("1208320671776572747908d3ffffffffffffffff01")
-                || result == QByteArray::fromHex("08d3ffffffffffffffff0112083206717765727479"));
+    ASSERT_TRUE(result == QByteArray::fromHex("1208320671776572747908d3ffffff0f")
+                || result == QByteArray::fromHex("08d3ffffff0f12083206717765727479"));
 }
 
 TEST_F(SerializationTest, RepeatedIntMessageTest)
@@ -1647,7 +1559,7 @@ TEST_F(SerializationTest, SimpleEnumMessageSerializeTest)
     test.setLocalEnum(SimpleEnumMessage::LOCAL_ENUM_VALUE2);
     QByteArray result = test.serialize();
     ASSERT_EQ(2, result.size());
-    ASSERT_TRUE(result == QByteArray::fromHex("0802"));
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "0802");
 }
 
 TEST_F(SerializationTest, SimpleFixed32StringMapSerializeTest)
@@ -1677,7 +1589,7 @@ TEST_F(SerializationTest, SimpleInt32StringMapSerializeTest)
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
-                "1a1608f6ffffffffffffffff0112096d696e75732074656e1a0b080f12076669667465656e1a0e082a120a666f757274792074776f");
+                "1a1108f6ffffff0f12096d696e75732074656e1a0b080f12076669667465656e1a0e082a120a666f757274792074776f");
 }
 
 TEST_F(SerializationTest, SimpleSInt32StringMapSerializeTest)