Align fint* names to protobuf like fixed*

src/generator/templates.cpp

@@ -167,14 +167,14 @@ const std::unordered_map<::google::protobuf::FieldDescriptor::Type, std::string>
     {::google::protobuf::FieldDescriptor::TYPE_INT64, "int64"},     //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
     {::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"},
+    {::google::protobuf::FieldDescriptor::TYPE_FIXED64, "fixed64"},  //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
+    {::google::protobuf::FieldDescriptor::TYPE_FIXED32, "fixed32"},
     {::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"},
-    {::google::protobuf::FieldDescriptor::TYPE_SFIXED64, "sfint64"}, //Limited usage see https://doc.qt.io/qt-5/qtqml-typesystem-basictypes.html
+    {::google::protobuf::FieldDescriptor::TYPE_SFIXED32, "sfixed32"},
+    {::google::protobuf::FieldDescriptor::TYPE_SFIXED64, "sfixed64"}, //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/protobuf/qprotobufobject_p.cpp

@@ -39,10 +39,10 @@ void ProtobufObjectPrivate::registerSerializers()
     wrapSerializer<uint64>(ProtobufObjectPrivate::serializeBasic<uint64>, ProtobufObjectPrivate::deserializeBasic<uint64>, Varint);
     wrapSerializer<sint32>(ProtobufObjectPrivate::serializeBasic<sint32>, ProtobufObjectPrivate::deserializeBasic<sint32>, Varint);
     wrapSerializer<sint64>(ProtobufObjectPrivate::serializeBasic<sint64>, ProtobufObjectPrivate::deserializeBasic<sint64>, Varint);
-    wrapSerializer<fint32>(ProtobufObjectPrivate::serializeBasic<fint32>, ProtobufObjectPrivate::deserializeBasic<fint32>, Fixed32);
-    wrapSerializer<fint64>(ProtobufObjectPrivate::serializeBasic<fint64>, ProtobufObjectPrivate::deserializeBasic<fint64>, Fixed64);
-    wrapSerializer<sfint32>(ProtobufObjectPrivate::serializeBasic<sfint32>, ProtobufObjectPrivate::deserializeBasic<sfint32>, Fixed32);
-    wrapSerializer<sfint64>(ProtobufObjectPrivate::serializeBasic<sfint64>, ProtobufObjectPrivate::deserializeBasic<sfint64>, Fixed64);
+    wrapSerializer<fixed32>(ProtobufObjectPrivate::serializeBasic<fixed32>, ProtobufObjectPrivate::deserializeBasic<fixed32>, Fixed32);
+    wrapSerializer<fixed64>(ProtobufObjectPrivate::serializeBasic<fixed64>, ProtobufObjectPrivate::deserializeBasic<fixed64>, Fixed64);
+    wrapSerializer<sfixed32>(ProtobufObjectPrivate::serializeBasic<sfixed32>, ProtobufObjectPrivate::deserializeBasic<sfixed32>, Fixed32);
+    wrapSerializer<sfixed64>(ProtobufObjectPrivate::serializeBasic<sfixed64>, ProtobufObjectPrivate::deserializeBasic<sfixed64>, Fixed64);
     wrapSerializer<bool>(ProtobufObjectPrivate::serializeBasic<uint32>, ProtobufObjectPrivate::deserializeBasic<uint32>, Varint);
 
     wrapSerializer<QString>([](const QString &data, int &/*fieldIndex*/) {
@@ -57,10 +57,10 @@ void ProtobufObjectPrivate::registerSerializers()
 
     wrapSerializer<FloatList>(ProtobufObjectPrivate::serializeListType<float>, ProtobufObjectPrivate::deserializeList<float>, LengthDelimited);
     wrapSerializer<DoubleList>(ProtobufObjectPrivate::serializeListType<double>, ProtobufObjectPrivate::deserializeList<double>, LengthDelimited);
-    wrapSerializer<fint32List>(ProtobufObjectPrivate::serializeListType<fint32>, ProtobufObjectPrivate::deserializeList<fint32>, LengthDelimited);
-    wrapSerializer<fint64List>(ProtobufObjectPrivate::serializeListType<fint64>, ProtobufObjectPrivate::deserializeList<fint64>, LengthDelimited);
-    wrapSerializer<sfint32List>(ProtobufObjectPrivate::serializeListType<sfint32>, ProtobufObjectPrivate::deserializeList<sfint32>, LengthDelimited);
-    wrapSerializer<sfint64List>(ProtobufObjectPrivate::serializeListType<sfint64>, ProtobufObjectPrivate::deserializeList<sfint64>, LengthDelimited);
+    wrapSerializer<fixed32List>(ProtobufObjectPrivate::serializeListType<fixed32>, ProtobufObjectPrivate::deserializeList<fixed32>, LengthDelimited);
+    wrapSerializer<fixed64List>(ProtobufObjectPrivate::serializeListType<fixed64>, ProtobufObjectPrivate::deserializeList<fixed64>, LengthDelimited);
+    wrapSerializer<sfixed32List>(ProtobufObjectPrivate::serializeListType<sfixed32>, ProtobufObjectPrivate::deserializeList<sfixed32>, LengthDelimited);
+    wrapSerializer<sfixed64List>(ProtobufObjectPrivate::serializeListType<sfixed64>, ProtobufObjectPrivate::deserializeList<sfixed64>, LengthDelimited);
     wrapSerializer<int32List>(ProtobufObjectPrivate::serializeListType<int32>, ProtobufObjectPrivate::deserializeList<int32>, LengthDelimited);
     wrapSerializer<int64List>(ProtobufObjectPrivate::serializeListType<int64>, ProtobufObjectPrivate::deserializeList<int64>, LengthDelimited);
     wrapSerializer<sint32List>(ProtobufObjectPrivate::serializeListType<sint32>, ProtobufObjectPrivate::deserializeList<sint32>, LengthDelimited);

src/protobuf/qprotobufobject_p.h

@@ -118,10 +118,10 @@ public:
     //----------------Serialize basic integral and floating point----------------
     template <typename V,
               typename std::enable_if_t<std::is_floating_point<V>::value
-                                        || std::is_same<V, fint32>::value
-                                        || std::is_same<V, fint64>::value
-                                        || std::is_same<V, sfint32>::value
-                                        || std::is_same<V, sfint64>::value, int> = 0>
+                                        || std::is_same<V, fixed32>::value
+                                        || std::is_same<V, fixed64>::value
+                                        || std::is_same<V, sfixed32>::value
+                                        || std::is_same<V, sfixed64>::value, int> = 0>
     static QByteArray serializeBasic(V value, int &/*outFieldIndex*/) {
         qProtoDebug() << __func__ << "value" << value;
 
@@ -300,10 +300,10 @@ public:
     //###########################################################################
     template <typename V,
               typename std::enable_if_t<std::is_floating_point<V>::value
-                                        || std::is_same<V, sfint32>::value
-                                        || std::is_same<V, sfint64>::value
-                                        || std::is_same<V, fint32>::value
-                                        || std::is_same<V, fint64>::value, int> = 0>
+                                        || std::is_same<V, sfixed32>::value
+                                        || std::is_same<V, sfixed64>::value
+                                        || std::is_same<V, fixed32>::value
+                                        || std::is_same<V, fixed64>::value, int> = 0>
     static uint32 getRepeatedFieldCount(QByteArray::const_iterator &it) {
         return deserializeBasic<uint32>(it).value<uint32>() / sizeof(V);
     }
@@ -319,10 +319,10 @@ public:
     //---------------Deserialize basic integral and floating point---------------
     template <typename V,
               typename std::enable_if_t<std::is_floating_point<V>::value
-                                        || std::is_same<V, fint32>::value
-                                        || std::is_same<V, fint64>::value
-                                        || std::is_same<V, sfint32>::value
-                                        || std::is_same<V, sfint64>::value, int> = 0>
+                                        || std::is_same<V, fixed32>::value
+                                        || std::is_same<V, fixed64>::value
+                                        || std::is_same<V, sfixed32>::value
+                                        || std::is_same<V, sfixed64>::value, int> = 0>
     static QVariant deserializeBasic(QByteArray::const_iterator &it) {
         qProtoDebug() << __func__ << "currentByte:" << QString::number((*it), 16);
 

src/protobuf/qtprotobuf.cpp

@@ -23,4 +23,4 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#include <qtprotobuf.h>
+#include "qtprotobuf.h"

src/protobuf/qtprotobuf.h

@@ -45,10 +45,10 @@ public:
             registerProtobufType(uint64);
             registerProtobufType(sint32);
             registerProtobufType(sint64);
-            registerProtobufType(fint32);
-            registerProtobufType(fint64);
-            registerProtobufType(sfint32);
-            registerProtobufType(sfint64);
+            registerProtobufType(fixed32);
+            registerProtobufType(fixed64);
+            registerProtobufType(sfixed32);
+            registerProtobufType(sfixed64);
 
             registerProtobufType(int32List);
             registerProtobufType(int64List);
@@ -56,10 +56,10 @@ public:
             registerProtobufType(uint64List);
             registerProtobufType(sint32List);
             registerProtobufType(sint64List);
-            registerProtobufType(fint32List);
-            registerProtobufType(fint64List);
-            registerProtobufType(sfint32List);
-            registerProtobufType(sfint64List);
+            registerProtobufType(fixed32List);
+            registerProtobufType(fixed64List);
+            registerProtobufType(sfixed32List);
+            registerProtobufType(sfixed64List);
 
             registerProtobufType(DoubleList);
             registerProtobufType(FloatList);

src/protobuf/qtprotobuftypes.h

@@ -54,10 +54,10 @@ using uint32 = uint32_t;
 using uint64 = uint64_t;
 using sint32 = transparent<int32_t>;
 using sint64 = transparent<int64_t>;
-using fint32 = transparent<uint32_t, 1>;
-using fint64 = transparent<uint64_t, 1>;
-using sfint32 = transparent<int32_t, 1>;
-using sfint64 = transparent<int64_t, 1>;
+using fixed32 = transparent<uint32_t, 1>;
+using fixed64 = transparent<uint64_t, 1>;
+using sfixed32 = transparent<int32_t, 1>;
+using sfixed64 = transparent<int64_t, 1>;
 
 using int32List = QList<int32>;
 using int64List = QList<int64>;
@@ -65,10 +65,10 @@ using uint32List = QList<uint32>;
 using uint64List = QList<uint64>;
 using sint32List = QList<sint32>;
 using sint64List = QList<sint64>;
-using fint32List = QList<fint32>;
-using fint64List = QList<fint64>;
-using sfint32List = QList<sfint32>;
-using sfint64List = QList<sfint64>;
+using fixed32List = QList<fixed32>;
+using fixed64List = QList<fixed64>;
+using sfixed32List = QList<sfixed32>;
+using sfixed64List = QList<sfixed64>;
 
 using FloatList = QList<float>;
 using DoubleList = QList<double>;
@@ -80,10 +80,10 @@ Q_DECLARE_METATYPE(qtprotobuf::sint32)
 Q_DECLARE_METATYPE(qtprotobuf::sint64)
 Q_DECLARE_METATYPE(qtprotobuf::uint32)
 Q_DECLARE_METATYPE(qtprotobuf::uint64)
-Q_DECLARE_METATYPE(qtprotobuf::fint32)
-Q_DECLARE_METATYPE(qtprotobuf::fint64)
-Q_DECLARE_METATYPE(qtprotobuf::sfint32)
-Q_DECLARE_METATYPE(qtprotobuf::sfint64)
+Q_DECLARE_METATYPE(qtprotobuf::fixed32)
+Q_DECLARE_METATYPE(qtprotobuf::fixed64)
+Q_DECLARE_METATYPE(qtprotobuf::sfixed32)
+Q_DECLARE_METATYPE(qtprotobuf::sfixed64)
 
 Q_DECLARE_METATYPE(qtprotobuf::int32List)
 Q_DECLARE_METATYPE(qtprotobuf::int64List)
@@ -91,10 +91,10 @@ Q_DECLARE_METATYPE(qtprotobuf::sint32List)
 Q_DECLARE_METATYPE(qtprotobuf::sint64List)
 Q_DECLARE_METATYPE(qtprotobuf::uint32List)
 Q_DECLARE_METATYPE(qtprotobuf::uint64List)
-Q_DECLARE_METATYPE(qtprotobuf::fint32List)
-Q_DECLARE_METATYPE(qtprotobuf::fint64List)
-Q_DECLARE_METATYPE(qtprotobuf::sfint32List)
-Q_DECLARE_METATYPE(qtprotobuf::sfint64List)
+Q_DECLARE_METATYPE(qtprotobuf::fixed32List)
+Q_DECLARE_METATYPE(qtprotobuf::fixed64List)
+Q_DECLARE_METATYPE(qtprotobuf::sfixed32List)
+Q_DECLARE_METATYPE(qtprotobuf::sfixed64List)
 
 Q_DECLARE_METATYPE(qtprotobuf::FloatList)
 Q_DECLARE_METATYPE(qtprotobuf::DoubleList)

tests/deserializationtest.cpp

@@ -499,7 +499,7 @@ TEST_F(DeserializationTest, RepeatedFixedIntMessageTest)
     RepeatedFixedIntMessage test;
     test.deserialize(QByteArray::fromHex("0a180100000041010000cf010100ab0ebc000300000003000000"));
     ASSERT_EQ(6, test.testRepeatedInt().count());
-    ASSERT_TRUE(test.testRepeatedInt() == fint32List({1, 321, 65999, 12324523, 3, 3}));
+    ASSERT_TRUE(test.testRepeatedInt() == fixed32List({1, 321, 65999, 12324523, 3, 3}));
 }
 
 TEST_F(DeserializationTest, RepeatedSFixedIntMessageTest)
@@ -507,7 +507,7 @@ TEST_F(DeserializationTest, RepeatedSFixedIntMessageTest)
     RepeatedSFixedIntMessage test;
     test.deserialize(QByteArray::fromHex("0a18010000004101000031fefeffab0ebc00fdffffff03000000"));
     ASSERT_EQ(6, test.testRepeatedInt().count());
-    ASSERT_TRUE(test.testRepeatedInt() == sfint32List({1, 321, -65999, 12324523, -3, 3}));
+    ASSERT_TRUE(test.testRepeatedInt() == sfixed32List({1, 321, -65999, 12324523, -3, 3}));
 }
 
 TEST_F(DeserializationTest, RepeatedFixedInt64MessageTest)
@@ -515,7 +515,7 @@ TEST_F(DeserializationTest, RepeatedFixedInt64MessageTest)
     RepeatedFixedInt64Message test;
     test.deserialize(QByteArray::fromHex("0a3001000000000000004101000000000000cf01010000000000d2c5472bf8dab50103000000000000000300000000000000"));
     ASSERT_EQ(6, test.testRepeatedInt().count());
-    ASSERT_TRUE(test.testRepeatedInt() == fint64List({1, 321, 65999, 123245324235425234, 3, 3}));
+    ASSERT_TRUE(test.testRepeatedInt() == fixed64List({1, 321, 65999, 123245324235425234, 3, 3}));
 }
 
 TEST_F(DeserializationTest, RepeatedSFixedInt64MessageTest)
@@ -523,7 +523,7 @@ TEST_F(DeserializationTest, RepeatedSFixedInt64MessageTest)
     RepeatedSFixedInt64Message test;
     test.deserialize(QByteArray::fromHex("0a300100000000000000410100000000000031fefeffffffffffd2c5472bf8dab501fdffffffffffffff0300000000000000"));
     ASSERT_EQ(6, test.testRepeatedInt().count());
-    ASSERT_TRUE(test.testRepeatedInt() == sfint64List({1, 321, -65999, 123245324235425234, -3, 3}));
+    ASSERT_TRUE(test.testRepeatedInt() == sfixed64List({1, 321, -65999, 123245324235425234, -3, 3}));
 }
 
 TEST_F(DeserializationTest, RepeatedComplexMessageTest)

tests/serializationtest.cpp

@@ -1501,7 +1501,7 @@ TEST_F(SerializationTest, RepeatedFixedIntMessageTest)
     QByteArray result = test.serialize();
     //qDebug() << "result " << result.toHex();
     ASSERT_TRUE(result == QByteArray::fromHex("0a180100000041010000cf010100ab0ebc000300000003000000"));
-    test.setTestRepeatedInt(fint32List());
+    test.setTestRepeatedInt(fixed32List());
     result = test.serialize();
     ASSERT_TRUE(result.isEmpty());
 }
@@ -1514,7 +1514,7 @@ TEST_F(SerializationTest, RepeatedSFixedIntMessageTest)
     //qDebug() << "result " << result.toHex();
     ASSERT_TRUE(result == QByteArray::fromHex("0a18010000004101000031fefeffab0ebc00fdffffff03000000"));
 
-    test.setTestRepeatedInt(sfint32List());
+    test.setTestRepeatedInt(sfixed32List());
     result = test.serialize();
     ASSERT_TRUE(result.isEmpty());
 }
@@ -1527,7 +1527,7 @@ TEST_F(SerializationTest, RepeatedFixedInt64MessageTest)
     //qDebug() << "result " << result.toHex();
     ASSERT_TRUE(result == QByteArray::fromHex("0a3001000000000000004101000000000000cf01010000000000d2c5472bf8dab50103000000000000000300000000000000"));
 
-    test.setTestRepeatedInt(fint64List());
+    test.setTestRepeatedInt(fixed64List());
     result = test.serialize();
     ASSERT_TRUE(result.isEmpty());
 }
@@ -1540,7 +1540,7 @@ TEST_F(SerializationTest, RepeatedSFixedInt64MessageTest)
     //qDebug() << "result " << result.toHex();
     ASSERT_TRUE(result == QByteArray::fromHex("0a300100000000000000410100000000000031fefeffffffffffd2c5472bf8dab501fdffffffffffffff0300000000000000"));
 
-    test.setTestRepeatedInt(sfint64List());
+    test.setTestRepeatedInt(sfixed64List());
     result = test.serialize();
     ASSERT_TRUE(result.isEmpty());
 }

tests/simpletest.cpp

@@ -177,11 +177,11 @@ TEST_F(SimpleTest, SimpleFixedInt32MessageTest)
     const char* propertyName = "testFieldFixedInt32";
     SimpleFixedInt32Message test;
     int propertyNumber = SimpleFixedInt32Message::propertyOrdering.at(1); //See simpletest.proto
-    ASSERT_EQ(SimpleFixedInt32Message::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<fint32>());
-    ASSERT_STREQ(SimpleFixedInt32Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::fint32");
+    ASSERT_EQ(SimpleFixedInt32Message::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<fixed32>());
+    ASSERT_STREQ(SimpleFixedInt32Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::fixed32");
     ASSERT_STREQ(SimpleFixedInt32Message::staticMetaObject.property(propertyNumber).name(), propertyName);
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<fint32>(1)));
-    ASSERT_EQ(test.property(propertyName).value<fint32>(), 1);
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<fixed32>(1)));
+    ASSERT_EQ(test.property(propertyName).value<fixed32>(), 1);
     ASSERT_EQ(test.testFieldFixedInt32(), 1);
 }
 
@@ -190,11 +190,11 @@ TEST_F(SimpleTest, SimpleFixedInt64MessageTest)
     const char* propertyName = "testFieldFixedInt64";
     SimpleFixedInt64Message test;
     int propertyNumber = SimpleFixedInt64Message::propertyOrdering.at(1); //See simpletest.proto
-    ASSERT_EQ(SimpleFixedInt64Message::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<fint64>());
-    ASSERT_STREQ(SimpleFixedInt64Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::fint64");
+    ASSERT_EQ(SimpleFixedInt64Message::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<fixed64>());
+    ASSERT_STREQ(SimpleFixedInt64Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::fixed64");
     ASSERT_STREQ(SimpleFixedInt64Message::staticMetaObject.property(propertyNumber).name(), propertyName);
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<fint64>(1)));
-    ASSERT_EQ(test.property(propertyName).value<fint64>(), 1);
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<fixed64>(1)));
+    ASSERT_EQ(test.property(propertyName).value<fixed64>(), 1);
     ASSERT_EQ(test.testFieldFixedInt64(), 1);
 }
 
@@ -203,11 +203,11 @@ 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).userType(), qMetaTypeId<sfint32>());
-    ASSERT_STREQ(SimpleSFixedInt32Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::sfint32");
+    ASSERT_EQ(SimpleSFixedInt32Message::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<sfixed32>());
+    ASSERT_STREQ(SimpleSFixedInt32Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::sfixed32");
     ASSERT_STREQ(SimpleSFixedInt32Message::staticMetaObject.property(propertyNumber).name(), propertyName);
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<sfint32>(1)));
-    ASSERT_EQ(test.property(propertyName).value<sfint32>(), 1);
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<sfixed32>(1)));
+    ASSERT_EQ(test.property(propertyName).value<sfixed32>(), 1);
     ASSERT_EQ(test.testFieldFixedInt32(), 1);
 }
 
@@ -216,11 +216,11 @@ 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).userType(), qMetaTypeId<sfint64>());
-    ASSERT_STREQ(SimpleSFixedInt64Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::sfint64");
+    ASSERT_EQ(SimpleSFixedInt64Message::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<sfixed64>());
+    ASSERT_STREQ(SimpleSFixedInt64Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::sfixed64");
     ASSERT_STREQ(SimpleSFixedInt64Message::staticMetaObject.property(propertyNumber).name(), propertyName);
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<sfint64>(1)));
-    ASSERT_EQ(test.property(propertyName).value<sfint64>(), 1);
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<sfixed64>(1)));
+    ASSERT_EQ(test.property(propertyName).value<sfixed64>(), 1);
     ASSERT_EQ(test.testFieldFixedInt64(), 1);
 }
 
@@ -553,12 +553,12 @@ TEST_F(SimpleTest, RepeatedFixedIntMessageTest)
     const char* propertyName = "testRepeatedInt";
     RepeatedFixedIntMessage test;
     int propertyNumber = RepeatedFixedIntMessage::propertyOrdering.at(1); //See simpletest.proto
-    ASSERT_STREQ(RepeatedFixedIntMessage::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::fint32List");
-    ASSERT_EQ(RepeatedFixedIntMessage::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<qtprotobuf::fint32List>());
+    ASSERT_STREQ(RepeatedFixedIntMessage::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::fixed32List");
+    ASSERT_EQ(RepeatedFixedIntMessage::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<qtprotobuf::fixed32List>());
     ASSERT_STREQ(RepeatedFixedIntMessage::staticMetaObject.property(propertyNumber).name(), propertyName);
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<fint32List>({1, 2, 3, 4, 5})));
-    ASSERT_TRUE(test.property(propertyName).value<fint32List>() == fint32List({1, 2, 3, 4, 5}));
-    ASSERT_TRUE(test.testRepeatedInt() == fint32List({1, 2, 3, 4, 5}));
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<fixed32List>({1, 2, 3, 4, 5})));
+    ASSERT_TRUE(test.property(propertyName).value<fixed32List>() == fixed32List({1, 2, 3, 4, 5}));
+    ASSERT_TRUE(test.testRepeatedInt() == fixed32List({1, 2, 3, 4, 5}));
 }
 
 TEST_F(SimpleTest, RepeatedFixedInt64MessageTest)
@@ -566,12 +566,12 @@ TEST_F(SimpleTest, RepeatedFixedInt64MessageTest)
     const char* propertyName = "testRepeatedInt";
     RepeatedFixedInt64Message test;
     int propertyNumber = RepeatedFixedInt64Message::propertyOrdering.at(1); //See simpletest.proto
-    ASSERT_STREQ(RepeatedFixedInt64Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::fint64List");
-    ASSERT_EQ(RepeatedFixedInt64Message::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<qtprotobuf::fint64List>());
+    ASSERT_STREQ(RepeatedFixedInt64Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::fixed64List");
+    ASSERT_EQ(RepeatedFixedInt64Message::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<qtprotobuf::fixed64List>());
     ASSERT_STREQ(RepeatedFixedInt64Message::staticMetaObject.property(propertyNumber).name(), propertyName);
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<fint64List>({1, 2, 3, 4, 5})));
-    ASSERT_TRUE(test.property(propertyName).value<fint64List>() == fint64List({1, 2, 3, 4, 5}));
-    ASSERT_TRUE(test.testRepeatedInt() == fint64List({1, 2, 3, 4, 5}));
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<fixed64List>({1, 2, 3, 4, 5})));
+    ASSERT_TRUE(test.property(propertyName).value<fixed64List>() == fixed64List({1, 2, 3, 4, 5}));
+    ASSERT_TRUE(test.testRepeatedInt() == fixed64List({1, 2, 3, 4, 5}));
 }
 
 TEST_F(SimpleTest, RepeatedSFixedIntMessageTest)
@@ -579,12 +579,12 @@ TEST_F(SimpleTest, RepeatedSFixedIntMessageTest)
     const char* propertyName = "testRepeatedInt";
     RepeatedSFixedIntMessage test;
     int propertyNumber = RepeatedSFixedIntMessage::propertyOrdering.at(1); //See simpletest.proto
-    ASSERT_STREQ(RepeatedSFixedIntMessage::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::sfint32List");
-    ASSERT_EQ(RepeatedSFixedIntMessage::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<qtprotobuf::sfint32List>());
+    ASSERT_STREQ(RepeatedSFixedIntMessage::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::sfixed32List");
+    ASSERT_EQ(RepeatedSFixedIntMessage::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<qtprotobuf::sfixed32List>());
     ASSERT_STREQ(RepeatedSFixedIntMessage::staticMetaObject.property(propertyNumber).name(), propertyName);
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<sfint32List>({1, 2, 3, 4, 5})));
-    ASSERT_TRUE(test.property(propertyName).value<sfint32List>() == sfint32List({1, 2, 3, 4, 5}));
-    ASSERT_TRUE(test.testRepeatedInt() == sfint32List({1, 2, 3, 4, 5}));
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<sfixed32List>({1, 2, 3, 4, 5})));
+    ASSERT_TRUE(test.property(propertyName).value<sfixed32List>() == sfixed32List({1, 2, 3, 4, 5}));
+    ASSERT_TRUE(test.testRepeatedInt() == sfixed32List({1, 2, 3, 4, 5}));
 }
 
 TEST_F(SimpleTest, RepeatedSFixedInt64MessageTest)
@@ -592,12 +592,12 @@ TEST_F(SimpleTest, RepeatedSFixedInt64MessageTest)
     const char* propertyName = "testRepeatedInt";
     RepeatedSFixedInt64Message test;
     int propertyNumber = RepeatedSFixedInt64Message::propertyOrdering.at(1); //See simpletest.proto
-    ASSERT_STREQ(RepeatedSFixedInt64Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::sfint64List");
-    ASSERT_EQ(RepeatedSFixedInt64Message::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<qtprotobuf::sfint64List>());
+    ASSERT_STREQ(RepeatedSFixedInt64Message::staticMetaObject.property(propertyNumber).typeName(), "qtprotobuf::sfixed64List");
+    ASSERT_EQ(RepeatedSFixedInt64Message::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<qtprotobuf::sfixed64List>());
     ASSERT_STREQ(RepeatedSFixedInt64Message::staticMetaObject.property(propertyNumber).name(), propertyName);
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<sfint64List>({1, 2, 3, 4, 5})));
-    ASSERT_TRUE(test.property(propertyName).value<sfint64List>() == sfint64List({1, 2, 3, 4, 5}));
-    ASSERT_TRUE(test.testRepeatedInt() == sfint64List({1, 2, 3, 4, 5}));
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<sfixed64List>({1, 2, 3, 4, 5})));
+    ASSERT_TRUE(test.property(propertyName).value<sfixed64List>() == sfixed64List({1, 2, 3, 4, 5}));
+    ASSERT_TRUE(test.testRepeatedInt() == sfixed64List({1, 2, 3, 4, 5}));
 }
 
 TEST_F(SimpleTest, StepChildEnumMessageTest)