Browse Source

Migrate to pointers for QObject based class

- Refactor generator
- Refactor serializers/deserializers for QObject based classes
- Refactor serializers/deserializers for QObject based list
- Refactor serializers/deserializers for QObject based maps
- Add and update tests
TODO: potential memory leaks introduced
Alexey Edelev 6 years ago
parent
commit
ade2bb7a10
38 changed files with 12038 additions and 216 deletions
  1. 116 0
      src/generator/classgeneratorbase.cpp
  2. 13 2
      src/generator/classgeneratorbase.h
  3. 37 130
      src/generator/protobufclassgenerator.cpp
  4. 0 12
      src/generator/protobufclassgenerator.h
  5. 4 1
      src/generator/protobufsourcegenerator.cpp
  6. 29 11
      src/generator/templates.cpp
  7. 4 0
      src/generator/templates.h
  8. 6 6
      src/protobuf/qprotobufobject_p.cpp
  9. 134 21
      src/protobuf/qprotobufobject_p.h
  10. 45 20
      tests/deserializationtest.cpp
  11. 13 0
      tests/echoserver/CMakeLists.txt
  12. 29 0
      tests/echoserver/main.cpp
  13. 73 0
      tests/echoserver/testserver/.gitignore
  14. 23 0
      tests/echoserver/testserver/globalenums.grpc.pb.cc
  15. 36 0
      tests/echoserver/testserver/globalenums.grpc.pb.h
  16. 110 0
      tests/echoserver/testserver/globalenums.pb.cc
  17. 117 0
      tests/echoserver/testserver/globalenums.pb.h
  18. 11 0
      tests/echoserver/testserver/globalenums.proto
  19. 21 0
      tests/echoserver/testserver/globalenumssamenamespace.grpc.pb.cc
  20. 34 0
      tests/echoserver/testserver/globalenumssamenamespace.grpc.pb.h
  21. 106 0
      tests/echoserver/testserver/globalenumssamenamespace.pb.cc
  22. 113 0
      tests/echoserver/testserver/globalenumssamenamespace.pb.h
  23. 11 0
      tests/echoserver/testserver/globalenumssamenamespace.proto
  24. 31 0
      tests/echoserver/testserver/main.cpp
  25. 21 0
      tests/echoserver/testserver/simpletest.grpc.pb.cc
  26. 34 0
      tests/echoserver/testserver/simpletest.grpc.pb.h
  27. 6594 0
      tests/echoserver/testserver/simpletest.pb.cc
  28. 3696 0
      tests/echoserver/testserver/simpletest.pb.h
  29. 117 0
      tests/echoserver/testserver/simpletest.proto
  30. 45 0
      tests/echoserver/testserver/testserver.pro
  31. 66 0
      tests/echoserver/testserver/testservice.grpc.pb.cc
  32. 161 0
      tests/echoserver/testserver/testservice.grpc.pb.h
  33. 89 0
      tests/echoserver/testserver/testservice.pb.cc
  34. 77 0
      tests/echoserver/testserver/testservice.pb.h
  35. 9 0
      tests/echoserver/testserver/testservice.proto
  36. 11 11
      tests/serializationcomplexmessagemap.cpp
  37. 1 1
      tests/serializationtest.cpp
  38. 1 1
      tests/simpletest.cpp

+ 116 - 0
src/generator/classgeneratorbase.cpp

@@ -122,3 +122,119 @@ bool ClassGeneratorBase::isLocalMessageEnum(const google::protobuf::Descriptor *
     }
     return false;
 }
+
+std::string ClassGeneratorBase::getTypeName(const FieldDescriptor *field, const Descriptor *messageFor)
+{
+    assert(field != nullptr);
+    std::string typeName;
+    std::string namespaceQtProtoDefinition("qtprotobuf::");
+
+    std::string namespaceTypeName;
+    std::vector<std::string> typeNamespace;
+
+    if (field->type() == FieldDescriptor::TYPE_MESSAGE) {
+        const Descriptor *msg = field->message_type();
+        namespaceTypeName = getNamespacesList(msg, typeNamespace, mNamespacesColonDelimited);
+        typeName = namespaceTypeName.append(msg->name());
+
+        if (field->is_map()) {
+            return mClassName + "::" + field->message_type()->name();
+        }
+        if (field->is_repeated()) {
+            return namespaceTypeName.append("List");
+        }
+    } else if (field->type() == FieldDescriptor::TYPE_ENUM) {
+        const EnumDescriptor *enumType = field->enum_type();
+        namespaceTypeName = getNamespacesList(enumType, typeNamespace, mNamespacesColonDelimited);
+        EnumVisibility visibility = getEnumVisibility(field, messageFor);
+        if (visibility == LOCAL_ENUM) {
+            if(field->is_repeated()) {
+                typeName = typeName.append(mClassName + "::" + enumType->name());
+            } else {
+                typeName = typeName.append(enumType->name());
+            }
+        } else if (visibility == GLOBAL_ENUM) {
+            typeName = namespaceTypeName.append(Templates::GlobalEnumClassNameTemplate)
+                    .append("::").append(enumType->name());
+        } else {
+            typeName = namespaceTypeName.append(enumType->name());
+        }
+        if (field->is_repeated()) {
+            return typeName.append("List");
+        }
+    } else {
+        auto it = Templates::TypeReflection.find(field->type());
+        if (it != std::end(Templates::TypeReflection)) {
+            if (field->type() != FieldDescriptor::TYPE_STRING
+                    && field->type() != FieldDescriptor::TYPE_BYTES
+                    && field->type() != FieldDescriptor::TYPE_BOOL
+                    && field->type() != FieldDescriptor::TYPE_FLOAT
+                    && field->type() != FieldDescriptor::TYPE_DOUBLE) {
+                typeName = typeName.append(namespaceQtProtoDefinition.append(it->second));
+            } else {
+                typeName = typeName.append(it->second);
+            }
+            if (field->is_repeated()) {
+                if (field->type() == FieldDescriptor::TYPE_FLOAT
+                        || field->type() == FieldDescriptor::TYPE_DOUBLE) {
+                    typeName[0] = ::toupper(typeName[0]);
+                    typeName = namespaceQtProtoDefinition.append(typeName);
+                }
+                typeName.append("List");
+            }
+        }
+    }
+
+    return typeName;
+}
+
+template<typename T>
+std::string ClassGeneratorBase::getNamespacesList(const T *message, std::vector<std::string> &container, const std::string &localNamespace)
+{
+    std::string result;
+    utils::split(std::string(message->full_name()), container, '.');
+
+    if (container.size() > 1) {
+        //delete type name -> only namespace stays
+        container.pop_back();
+
+        for (size_t i = 0; i < container.size(); i++) {
+            if (i > 0) {
+                result = result.append("::");
+            }
+            result = result.append(container[i]);
+        }
+    }
+
+    if (container.size() > 0
+            && localNamespace != result) {
+        result = result.append("::");
+    } else {
+        result.clear();
+    }
+
+    return result;
+}
+
+ClassGeneratorBase::EnumVisibility ClassGeneratorBase::getEnumVisibility(const FieldDescriptor *field, const Descriptor *messageFor)
+{
+    assert(field->enum_type() != nullptr);
+
+    if (isLocalMessageEnum(messageFor, field)) {
+        return LOCAL_ENUM;
+    }
+
+    const EnumDescriptor *enumType = field->enum_type();
+    const FileDescriptor *enumFile = field->enum_type()->file();
+
+    for (int i = 0; i < enumFile->message_type_count(); i++) {
+        const Descriptor* msg = enumFile->message_type(i);
+        for (int j = 0; j < msg->enum_type_count(); j++) {
+            if (enumType->full_name() == msg->enum_type(j)->full_name()) {
+                return NEIGHBOUR_ENUM;
+            }
+        }
+    }
+
+    return GLOBAL_ENUM;
+}

+ 13 - 2
src/generator/classgeneratorbase.h

@@ -49,6 +49,12 @@ public:
     virtual ~ClassGeneratorBase() = default;
     virtual void run() = 0;
 protected:
+    enum EnumVisibility {
+        GLOBAL_ENUM,
+        LOCAL_ENUM,
+        NEIGHBOUR_ENUM
+    };
+
     std::unique_ptr<::google::protobuf::io::ZeroCopyOutputStream> mOutput;
     ::google::protobuf::io::Printer mPrinter;
     std::string mClassName;
@@ -65,8 +71,6 @@ protected:
     void printMetaTypeDeclaration();
     void encloseNamespaces();
     void encloseNamespaces(int count);
-    bool isLocalMessageEnum(const google::protobuf::Descriptor *message,
-                            const ::google::protobuf::FieldDescriptor *field);
 
     template<typename T>
     void printQEnums(const T *message) {
@@ -109,6 +113,13 @@ protected:
         mPrinter.Outdent();
         mPrinter.Outdent();
     }
+
+    std::string getTypeName(const ::google::protobuf::FieldDescriptor *field, const ::google::protobuf::Descriptor *messageFor);
+    static bool isLocalMessageEnum(const google::protobuf::Descriptor *message,
+                            const ::google::protobuf::FieldDescriptor *field);
+    template<typename T>
+    static std::string getNamespacesList(const T *message, std::vector<std::string> &container, const std::string &localNamespace);
+    static EnumVisibility getEnumVisibility(const ::google::protobuf::FieldDescriptor *field, const ::google::protobuf::Descriptor *messageFor);
 };
 
 } //namespace generator

+ 37 - 130
src/generator/protobufclassgenerator.cpp

@@ -191,7 +191,7 @@ void ProtobufClassGenerator::printInclude(const FieldDescriptor *field, std::set
         includeTemplate = Templates::ExternalIncludeTemplate;
         break;
     case FieldDescriptor::TYPE_ENUM: {
-        EnumVisibility enumVisibily = getEnumVisibility(field);
+        EnumVisibility enumVisibily = getEnumVisibility(field, mMessage);
         if (enumVisibily == GLOBAL_ENUM) {
             includeTemplate = Templates::GlobalEnumIncludeTemplate;
         } else if (enumVisibily == NEIGHBOUR_ENUM){
@@ -226,103 +226,10 @@ void ProtobufClassGenerator::printField(const FieldDescriptor *field, const char
     }
 }
 
-template<typename T>
-std::string ProtobufClassGenerator::getNamespacesList(const T *message, std::vector<std::string> &container)
-{
-    std::string result;
-    utils::split(std::string(message->full_name()), container, '.');
-
-    if (container.size() > 1) {
-        //delete type name -> only namespace stays
-        container.pop_back();
-
-        for (size_t i = 0; i < container.size(); i++) {
-            if (i > 0) {
-                result = result.append("::");
-            }
-            result = result.append(container[i]);
-        }
-    }
-
-    if (container.size() > 0
-            && mNamespacesColonDelimited != result) {
-        result = result.append("::");
-    } else {
-        result.clear();
-    }
-
-    return result;
-}
-
-std::string ProtobufClassGenerator::getTypeName(const FieldDescriptor *field)
-{
-    assert(field != nullptr);
-    std::string typeName;
-    std::string namespaceQtProtoDefinition("qtprotobuf::");
-
-    std::string namespaceTypeName;
-    std::vector<std::string> typeNamespace;
-
-    if (field->type() == FieldDescriptor::TYPE_MESSAGE) {
-        const Descriptor *msg = field->message_type();
-        namespaceTypeName = getNamespacesList(msg, typeNamespace);
-        typeName = namespaceTypeName.append(msg->name());
-
-        if (field->is_map()) {
-            return mClassName + "::" + field->message_type()->name();
-        }
-        if (field->is_repeated()) {
-            return namespaceTypeName.append("List");
-        }
-    } else if (field->type() == FieldDescriptor::TYPE_ENUM) {
-        const EnumDescriptor *enumType = field->enum_type();
-        namespaceTypeName = getNamespacesList(enumType, typeNamespace);
-        EnumVisibility visibility = getEnumVisibility(field);
-        if (visibility == LOCAL_ENUM) {
-            if(field->is_repeated()) {
-                typeName = typeName.append(mClassName + "::" + enumType->name());
-            } else {
-                typeName = typeName.append(enumType->name());
-            }
-        } else if (visibility == GLOBAL_ENUM) {
-            typeName = namespaceTypeName.append(Templates::GlobalEnumClassNameTemplate)
-                    .append("::").append(enumType->name());
-        } else {
-            typeName = namespaceTypeName.append(enumType->name());
-        }
-        if (field->is_repeated()) {
-            return typeName.append("List");
-        }
-    } else {
-        auto it = Templates::TypeReflection.find(field->type());
-        if (it != std::end(Templates::TypeReflection)) {
-            if (field->type() != FieldDescriptor::TYPE_STRING
-                    && field->type() != FieldDescriptor::TYPE_BYTES
-                    && field->type() != FieldDescriptor::TYPE_BOOL
-                    && field->type() != FieldDescriptor::TYPE_FLOAT
-                    && field->type() != FieldDescriptor::TYPE_DOUBLE) {
-                typeName = typeName.append(namespaceQtProtoDefinition.append(it->second));
-            } else {
-                typeName = typeName.append(it->second);
-            }
-            if (field->is_repeated()) {
-                if (field->type() == FieldDescriptor::TYPE_FLOAT
-                        || field->type() == FieldDescriptor::TYPE_DOUBLE) {
-                    typeName[0] = ::toupper(typeName[0]);
-                    typeName = namespaceQtProtoDefinition.append(typeName);
-                }
-                typeName.append("List");
-            }
-        }
-    }
-
-    return typeName;
-}
-
 bool ProtobufClassGenerator::producePropertyMap(const FieldDescriptor *field, PropertyMap &propertyMap)
 {
     assert(field != nullptr);
-    std::string typeName = getTypeName(field);
+    std::string typeName = getTypeName(field, mMessage);
 
     if (typeName.size() <= 0) {
         std::cerr << "Type "
@@ -366,7 +273,7 @@ void ProtobufClassGenerator::printConstructor()
     std::string parameterList;
     for (int i = 0; i < mMessage->field_count(); i++) {
         const FieldDescriptor* field = mMessage->field(i);
-        std::string fieldTypeName = getTypeName(field);
+        std::string fieldTypeName = getTypeName(field, mMessage);
         std::string fieldName = field->name();
         fieldName[0] = ::tolower(fieldName[0]);
         if (field->is_repeated() || field->is_map()) {
@@ -421,11 +328,17 @@ void ProtobufClassGenerator::printMaps()
         const FieldDescriptor* field = mMessage->field(i);
 
         if (field->is_map()) {
-            std::string keyType = getTypeName(field->message_type()->field(0));
-            std::string valueType = getTypeName(field->message_type()->field(1));
-             mPrinter.Print({{"classname",field->message_type()->name()},
-                             {"key", keyType},
-                             {"value", valueType}}, Templates::MapTypeUsingTemplate);
+            std::string keyType = getTypeName(field->message_type()->field(0), mMessage);
+            std::string valueType = getTypeName(field->message_type()->field(1), mMessage);
+            const char *mapTemplate = Templates::MapTypeUsingTemplate;
+
+            if(field->message_type()->field(1)->type() == FieldDescriptor::TYPE_MESSAGE) {
+                mapTemplate = Templates::MessageMapTypeUsingTemplate;
+            }
+
+            mPrinter.Print({{"classname",field->message_type()->name()},
+                            {"key", keyType},
+                            {"value", valueType}}, mapTemplate);
         }
     }
     Outdent();
@@ -464,8 +377,10 @@ void ProtobufClassGenerator::printProperties()
     Indent();
     for (int i = 0; i < mMessage->field_count(); i++) {
         const FieldDescriptor* field = mMessage->field(i);
-        const char* propertyTemplate = field->type() == FieldDescriptor::TYPE_MESSAGE ? Templates::MessagePropertyTemplate :
-                                                                                        Templates::PropertyTemplate;
+        const char* propertyTemplate = Templates::PropertyTemplate;
+        if (field->type() == FieldDescriptor::TYPE_MESSAGE && !field->is_map() && !field->is_repeated()) {
+            propertyTemplate = Templates::MessagePropertyTemplate;
+        }
         printField(field, propertyTemplate);
     }
 
@@ -485,15 +400,30 @@ void ProtobufClassGenerator::printProperties()
     printComparisonOperators();
 
     for (int i = 0; i < mMessage->field_count(); i++) {
-        printField(mMessage->field(i), Templates::GetterTemplate);
+        const FieldDescriptor* field = mMessage->field(i);
+        if (field->type() == FieldDescriptor::TYPE_MESSAGE) {
+            if (!field->is_map() && !field->is_repeated()) {
+                printField(field, Templates::GetterMessageTemplate);
+            }
+        }
+        printField(field, Templates::GetterTemplate);
     }
     for (int i = 0; i < mMessage->field_count(); i++) {
         auto field = mMessage->field(i);
-        if (field->type() == FieldDescriptor::TYPE_MESSAGE
-                || field->type() == FieldDescriptor::TYPE_STRING) {
+        switch (field->type()) {
+        case FieldDescriptor::TYPE_MESSAGE:
+            if(!field->is_map() && !field->is_repeated()) {
+                printField(field, Templates::SetterTemplateMessageType);
+            }
             printField(field, Templates::SetterTemplateComplexType);
-        } else {
+            break;
+        case FieldDescriptor::FieldDescriptor::TYPE_STRING:
+        case FieldDescriptor::FieldDescriptor::TYPE_BYTES:
+            printField(field, Templates::SetterTemplateComplexType);
+            break;
+        default:
             printField(field, Templates::SetterTemplateSimpleType);
+            break;
         }
     }
     Outdent();
@@ -527,29 +457,6 @@ void ProtobufClassGenerator::printFieldsOrderingDefinition()
     Outdent();
 }
 
-ProtobufClassGenerator::EnumVisibility ProtobufClassGenerator::getEnumVisibility(const FieldDescriptor *field)
-{
-    assert(field->enum_type() != nullptr);
-
-    if (isLocalMessageEnum(mMessage, field)) {
-        return LOCAL_ENUM;
-    }
-
-    const EnumDescriptor *enumType = field->enum_type();
-    const FileDescriptor *enumFile = field->enum_type()->file();
-
-    for (int i = 0; i < enumFile->message_type_count(); i++) {
-        const Descriptor* msg = enumFile->message_type(i);
-        for (int j = 0; j < msg->enum_type_count(); j++) {
-            if (enumType->full_name() == msg->enum_type(j)->full_name()) {
-                return NEIGHBOUR_ENUM;
-            }
-        }
-    }
-
-    return GLOBAL_ENUM;
-}
-
 void ProtobufClassGenerator::printClassMembers()
 {
     Indent();

+ 0 - 12
src/generator/protobufclassgenerator.h

@@ -46,11 +46,6 @@ using PropertyMap = std::map<std::string, std::string>;
 class ProtobufClassGenerator : public ClassGeneratorBase
 {
     const ::google::protobuf::Descriptor* mMessage;
-    enum EnumVisibility {
-        GLOBAL_ENUM,
-        LOCAL_ENUM,
-        NEIGHBOUR_ENUM
-    };
 public:
     ProtobufClassGenerator(const ::google::protobuf::Descriptor* message, std::unique_ptr<::google::protobuf::io::ZeroCopyOutputStream> out);
     virtual ~ProtobufClassGenerator() = default;
@@ -77,16 +72,9 @@ public:
     std::set<std::string> extractModels() const;
 
 private:
-    EnumVisibility getEnumVisibility(const ::google::protobuf::FieldDescriptor *field);
-
-
-    std::string getTypeName(const ::google::protobuf::FieldDescriptor *field);
     bool producePropertyMap(const ::google::protobuf::FieldDescriptor *field, PropertyMap &propertyMap);
     static bool isComplexType(const ::google::protobuf::FieldDescriptor *field);
     static bool isListType(const ::google::protobuf::FieldDescriptor *field);
-
-    template<typename T>
-    std::string getNamespacesList(const T *message, std::vector<std::string> &container);
 };
 
 }

+ 4 - 1
src/generator/protobufsourcegenerator.cpp

@@ -64,8 +64,11 @@ void ProtobufSourceGenerator::printRegisterBody()
             mPrinter.Print({{"type", field->message_type()->name()},
                             {"namespaces", mNamespacesColonDelimited + "::" + mClassName}},
                            Templates::RegisterMetaTypeTemplate);
+
             mPrinter.Print({{"classname", mClassName},
-                            {"type", field->message_type()->name()}},
+                            {"type", field->message_type()->name()},
+                            {"key_type", getTypeName(field->message_type()->field(0), mMessage)},
+                            {"value_type", getTypeName(field->message_type()->field(1), mMessage)}},
                              Templates::MapSerializationRegisterTemplate);
         }
     }

+ 29 - 11
src/generator/templates.cpp

@@ -30,7 +30,8 @@ using namespace qtprotobuf::generator;
 const char *Templates::DefaultProtobufIncludesTemplate = "#include <QMetaType>\n"
                                                          "#include <QList>\n"
                                                          "#include <qprotobufobject.h>\n"
-                                                         "#include <unordered_map>\n\n";
+                                                         "#include <unordered_map>\n"
+                                                         "#include <QPointer>\n\n";
 
 const char *Templates::GlobalEnumClassNameTemplate = "GlobalEnums";
 
@@ -52,8 +53,9 @@ const char *Templates::ComplexTypeRegistrationTemplate = "void $classname$::regi
                                                          "        qRegisterMetaType<$classname$>(\"$namespaces$::$classname$\");\n"
                                                          "        qRegisterMetaType<$classname$List>(\"$namespaces$::$classname$List\");\n"
                                                          "";
-const char *Templates::ComplexListTypeUsingTemplate = "using $classname$List = QList<$classname$>;\n";
+const char *Templates::ComplexListTypeUsingTemplate = "using $classname$List = QList<QPointer<$classname$>>;\n";
 const char *Templates::MapTypeUsingTemplate = "using $classname$ = QMap<$key$, $value$>;\n";
+const char *Templates::MessageMapTypeUsingTemplate = "using $classname$ = QMap<$key$, QPointer<$value$>>;\n";
 
 const char *Templates::EnumTypeUsingTemplate = "using $enum$List = QList<$enum$>;\n";
 
@@ -67,7 +69,7 @@ const char *Templates::ProtoClassDefinitionTemplate = "\nclass $classname$ final
                                                  "    Q_OBJECT\n";
 
 const char *Templates::PropertyTemplate = "Q_PROPERTY($type$ $property_name$ READ $property_name$ WRITE set$property_name_cap$ NOTIFY $property_name$Changed)\n";
-const char *Templates::MessagePropertyTemplate = "Q_PROPERTY($type$ $property_name$ READ $property_name$ WRITE set$property_name_cap$ NOTIFY $property_name$Changed)\n";
+const char *Templates::MessagePropertyTemplate = "Q_PROPERTY($type$ *$property_name$ READ $property_name$_p WRITE set$property_name_cap$_p NOTIFY $property_name$Changed)\n";
 const char *Templates::MemberTemplate = "$type$ m_$property_name$;\n";
 const char *Templates::EnumMemberTemplate = "::$type$ m_$property_name$;\n";
 const char *Templates::PublicBlockTemplate = "\npublic:\n";
@@ -92,16 +94,23 @@ const char *Templates::NotEqualOperatorTemplate = "bool operator !=(const $type$
                                                   "    return !this->operator ==(other);\n"
                                                   "}\n\n";
 
+const char *Templates::GetterMessageTemplate = "$type$ *$property_name$_p() const {\n" //formally const...
+                                        "    return const_cast<$type$*>(&m_$property_name$);\n"
+                                        "}\n\n";
+
 const char *Templates::GetterTemplate = "$type$ $property_name$() const {\n"
                                         "    return m_$property_name$;\n"
                                         "}\n\n";
 
-const char *Templates::SetterTemplateSimpleType = "void set$property_name_cap$($type$ $property_name$) {\n"
-                                                  "    if (m_$property_name$ != $property_name$) {\n"
-                                                  "        m_$property_name$ = $property_name$;\n"
-                                                  "        $property_name$Changed();\n"
-                                                  "    }\n"
-                                                  "}\n\n";
+const char *Templates::SetterTemplateMessageType = "void set$property_name_cap$_p($type$ *$property_name$) {\n"
+                                                   "    if ($property_name$ == nullptr) {\n"
+                                                   "        m_$property_name$ = {};\n"
+                                                   "    }\n"
+                                                   "    if (m_$property_name$ != *$property_name$) {\n"
+                                                   "        m_$property_name$ = *$property_name$;\n"
+                                                   "        $property_name$Changed();\n"
+                                                   "    }\n"
+                                                   "}\n\n";
 
 const char *Templates::SetterTemplateComplexType = "void set$property_name_cap$(const $type$ &$property_name$) {\n"
                                                    "    if (m_$property_name$ != $property_name$) {\n"
@@ -110,6 +119,13 @@ const char *Templates::SetterTemplateComplexType = "void set$property_name_cap$(
                                                    "    }\n"
                                                    "}\n\n";
 
+const char *Templates::SetterTemplateSimpleType = "void set$property_name_cap$(const $type$ &$property_name$) {\n"
+                                                   "    if (m_$property_name$ != $property_name$) {\n"
+                                                   "        m_$property_name$ = $property_name$;\n"
+                                                   "        $property_name$Changed();\n"
+                                                   "    }\n"
+                                                   "}\n\n";
+
 const char *Templates::SignalsBlockTemplate = "\nsignals:\n";
 const char *Templates::SignalTemplate = "void $property_name$Changed();\n";
 
@@ -127,6 +143,8 @@ const char *Templates::PropertyInitializerTemplate = "\n    ,m_$property_name$($
 const char *Templates::ConstructorContentTemplate = "\n{\n    registerTypes();\n}\n";
 
 const char *Templates::DeclareMetaTypeTemplate = "Q_DECLARE_METATYPE($namespaces$::$classname$)\n";
+const char *Templates::DeclareMessageMetaTypeTemplate = "Q_DECLARE_METATYPE($namespaces$::$classname$)\n"
+                                                        "Q_DECLARE_OPAQUE_POINTER($namespaces$::$classname$)\n";
 const char *Templates::DeclareComplexListTypeTemplate = "Q_DECLARE_METATYPE($namespaces$::$classname$List)\n";
 const char *Templates::RegisterMetaTypeDefaultTemplate = "qRegisterMetaType<$namespaces$::$type$>();\n";
 const char *Templates::RegisterMetaTypeTemplateNoNamespace = "qRegisterMetaType<$namespaces$::$type$>(\"$type$\");\n";
@@ -135,8 +153,8 @@ const char *Templates::RegisterMetaTypeTemplate = "qRegisterMetaType<$namespaces
 const char *Templates::QEnumTemplate = "Q_ENUM($type$)\n";
 
 const char *Templates::MapSerializationRegisterTemplate = "qtprotobuf::ProtobufObjectPrivate::wrapSerializer<$classname$::$type$>(\n"
-                                                          "qtprotobuf::ProtobufObjectPrivate::serializeMap<$classname$::$type$::key_type, $classname$::$type$::mapped_type>,\n"
-                                                          "qtprotobuf::ProtobufObjectPrivate::deserializeMap<$classname$::$type$::key_type, $classname$::$type$::mapped_type>\n"
+                                                          "qtprotobuf::ProtobufObjectPrivate::serializeMap<$key_type$, $value_type$>,\n"
+                                                          "qtprotobuf::ProtobufObjectPrivate::deserializeMap<$key_type$, $value_type$>\n"
                                                           ", qtprotobuf::LengthDelimited);\n";
 
 const char *Templates::ClassDefinitionTemplate = "\nclass $classname$ : public $parent_class$\n"

+ 4 - 0
src/generator/templates.h

@@ -45,6 +45,7 @@ public:
     static const char *ComplexTypeRegistrationTemplate;
     static const char *ComplexListTypeUsingTemplate;
     static const char *MapTypeUsingTemplate;
+    static const char *MessageMapTypeUsingTemplate;
     static const char *EnumTypeUsingTemplate;
     static const char *NamespaceTemplate;
     static const char *UsingNamespaceTemplate;
@@ -74,8 +75,10 @@ public:
     static const char *EqualOperatorPropertyTemplate;
     static const char *NotEqualOperatorTemplate;
     static const char *GetterTemplate;
+    static const char *GetterMessageTemplate;
     static const char *SetterTemplateSimpleType;
     static const char *SetterTemplateComplexType;
+    static const char *SetterTemplateMessageType;
     static const char *SignalsBlockTemplate;
     static const char *SignalTemplate;
     static const char *FieldsOrderingDefinitionContainerTemplate;
@@ -88,6 +91,7 @@ public:
     static const char *PropertyInitializerTemplate;
     static const char *ConstructorContentTemplate;
     static const char *DeclareMetaTypeTemplate;
+    static const char *DeclareMessageMetaTypeTemplate;
     static const char *DeclareComplexListTypeTemplate;
     static const char *RegisterMetaTypeDefaultTemplate;
     static const char *RegisterMetaTypeTemplate;

+ 6 - 6
src/protobuf/qprotobufobject_p.cpp

@@ -98,11 +98,11 @@ QByteArray ProtobufObjectPrivate::serializeUserType(const QVariant &propertyValu
     qProtoDebug() << __func__ << "propertyValue" << propertyValue << "fieldIndex" << fieldIndex;
 
     int userType = propertyValue.userType();
-    auto serializer = serializers[userType].serializer;
-    Q_ASSERT_X(serializer, "ProtobufObjectPrivate", "Serialization of unknown type is impossible. QtProtobuf::init() missed?");
+    auto serializer = serializers[userType];
+    Q_ASSERT_X(serializer.serializer, "ProtobufObjectPrivate", "Serialization of unknown type is impossible. QtProtobuf::init() missed?");
 
-    type = serializers[userType].type;
-    return serializer(propertyValue, fieldIndex);
+    type = serializer.type;
+    return serializer.serializer(propertyValue, fieldIndex);
 }
 
 void ProtobufObjectPrivate::deserializeProperty(QObject *object, WireTypes wireType, const QMetaProperty &metaProperty, QByteArray::const_iterator &it)
@@ -141,8 +141,8 @@ void ProtobufObjectPrivate::deserializeUserType(const QMetaProperty &metaType, Q
 {
     qProtoDebug() << __func__ << "userType" << metaType.userType() << "typeName" << metaType.typeName()
                   << "currentByte:" << QString::number((*it), 16);
-
-    auto deserializer = serializers[metaType.userType()].deserializer;
+    int userType = metaType.userType();
+    auto deserializer = serializers[userType].deserializer;
     Q_ASSERT_X(deserializer, "ProtobufObjectPrivate", "Deserialization of unknown type is impossible. QtProtobuf::init() missed?");
 
     deserializer(it, newValue);

+ 134 - 21
src/protobuf/qprotobufobject_p.h

@@ -26,6 +26,7 @@
 #pragma once
 
 #include <QObject>
+#include <QPointer>
 #include <QMetaProperty>
 
 #include <unordered_map>
@@ -66,7 +67,8 @@ public:
 
     static void registerSerializers();
 
-    template <typename T>
+    template <typename T,
+              typename std::enable_if_t<!std::is_base_of<QObject, T>::value, int> = 0>
     static void wrapSerializer(std::function<QByteArray(const T &, int &)> s, std::function<QVariant(QByteArray::const_iterator &)> d, WireTypes type)
     {
         serializers[qMetaTypeId<T>()] = {
@@ -80,7 +82,8 @@ public:
         };
     }
 
-    template <typename T>
+    template <typename T,
+              typename std::enable_if_t<!std::is_base_of<QObject, T>::value, int> = 0>
     static void wrapSerializer(std::function<QByteArray(const T &, int &)> s, std::function<void(QByteArray::const_iterator &it, QVariant & value)> d, WireTypes type)
     {
         serializers[qMetaTypeId<T>()] = {
@@ -92,6 +95,34 @@ public:
         };
     }
 
+    template <typename T,
+              typename std::enable_if_t<std::is_base_of<QObject, T>::value, int> = 0>
+    static void wrapSerializer(std::function<QByteArray(const T &, int &)> s, std::function<QVariant(QByteArray::const_iterator &)> d, WireTypes type)
+    {
+        serializers[qMetaTypeId<T*>()] = {
+            [s](const QVariant &value, int &fieldIndex) {
+                return s(*(value.value<T*>()), fieldIndex);
+            },
+            [d](QByteArray::const_iterator &it, QVariant &value){
+                value = d(it);
+            },
+            type
+        };
+    }
+
+    template <typename T,
+              typename std::enable_if_t<std::is_base_of<QObject, T>::value, int> = 0>
+    static void wrapSerializer(std::function<QByteArray(const T &, int &)> s, std::function<void(QByteArray::const_iterator &it, QVariant &value)> d, WireTypes type)
+    {
+        serializers[qMetaTypeId<T*>()] = {
+            [s](const QVariant &value, int &fieldIndex) {
+                return s(*(value.value<T*>()), fieldIndex);
+            },
+            d,
+            type
+        };
+    }
+
     static unsigned char encodeHeaderByte(int fieldIndex, WireTypes wireType);
     static bool decodeHeaderByte(unsigned char typeByte, int &fieldIndex, WireTypes &wireType);
 
@@ -245,7 +276,7 @@ public:
 
     template<typename V,
              typename std::enable_if_t<std::is_base_of<QObject, V>::value, int> = 0>
-    static QByteArray serializeListType(const QList<V> &listValue, int &outFieldIndex) {
+    static QByteArray serializeListType(const QList<QPointer<V>> &listValue, int &outFieldIndex) {
         qProtoDebug() << __func__ << "listValue.count" << listValue.count() << "outFiledIndex" << outFieldIndex;
 
         if (listValue.count() <= 0) {
@@ -255,7 +286,7 @@ public:
 
         QByteArray serializedList;
         for (auto &value : listValue) {
-            QByteArray serializedValue = serializeLengthDelimited(value.serialize());
+            QByteArray serializedValue = serializeLengthDelimited(value->serialize());
             serializedValue.prepend(encodeHeaderByte(outFieldIndex, LengthDelimited));
             serializedList.append(serializedValue);
         }
@@ -266,7 +297,8 @@ public:
     }
 
     //-------------------------Serialize maps of any type------------------------
-    template<typename K, typename V>
+    template<typename K, typename V,
+             typename std::enable_if_t<!std::is_base_of<QObject, V>::value, int> = 0>
     static QByteArray serializeMap(const QMap<K,V> &mapValue, int &outFieldIndex) {
         using ItType = typename QMap<K,V>::const_iterator;
         QByteArray mapResult;
@@ -284,7 +316,31 @@ public:
         return mapResult;
     }
 
-    template <typename V, int num>
+    template<typename K, typename V,
+             typename std::enable_if_t<std::is_base_of<QObject, V>::value, int> = 0>
+    static QByteArray serializeMap(const QMap<K, QPointer<V>> &mapValue, int &outFieldIndex) {
+        using ItType = typename QMap<K, QPointer<V>>::const_iterator;
+        QByteArray mapResult;
+        auto kSerializer = serializers[qMetaTypeId<K>()];
+        auto vSerializer = serializers[qMetaTypeId<V*>()];
+
+        for ( ItType it = mapValue.constBegin(); it != mapValue.constEnd(); it++) {
+            QByteArray result;
+            if (it.value().isNull()) {
+                qProtoWarning() << __func__ << "Trying to serialize map value that contains nullptr";
+                continue;
+            }
+            result = mapSerializeHelper<K, 1>(it.key(), kSerializer) + mapSerializeHelper<V, 2>(it.value().data(), vSerializer);
+            prependLengthDelimitedSize(result);
+            result.prepend(encodeHeaderByte(outFieldIndex, LengthDelimited));
+            mapResult.append(result);
+        }
+        outFieldIndex = NotUsedFieldIndex;
+        return mapResult;
+    }
+
+    template <typename V, int num,
+              typename std::enable_if_t<!std::is_base_of<QObject, V>::value, int> = 0>
     static QByteArray mapSerializeHelper(const V &value, const SerializationHandlers &handlers) {
         int mapIndex = num;
         QByteArray result = handlers.serializer(QVariant::fromValue<V>(value), mapIndex);
@@ -295,6 +351,18 @@ public:
         return result;
     }
 
+    template <typename V, int num,
+              typename std::enable_if_t<std::is_base_of<QObject, V>::value, int> = 0>
+    static QByteArray mapSerializeHelper(V *value, const SerializationHandlers &handlers) {
+        int mapIndex = num;
+        QByteArray result = handlers.serializer(QVariant::fromValue<V*>(value), mapIndex);
+        if (mapIndex != NotUsedFieldIndex
+                && handlers.type != UnknownWireType) {
+            result.prepend(encodeHeaderByte(mapIndex, handlers.type));
+        }
+        return result;
+    }
+
     //###########################################################################
     //                           Deserialization helpers
     //###########################################################################
@@ -387,7 +455,7 @@ public:
     static QByteArray deserializeLengthDelimited(QByteArray::const_iterator &it) {
         qProtoDebug() << __func__ << "currentByte:" << QString::number((*it), 16);
 
-        unsigned int length = deserializeBasic<unsigned int>(it).toUInt();
+        unsigned int length = deserializeBasic<uint32>(it).toUInt();
         QByteArray result(it, length);
         it += length;
         return result;
@@ -408,7 +476,7 @@ public:
     static QVariant deserializeList(QByteArray::const_iterator &it) {
         qProtoDebug() << __func__ << "currentByte:" << QString::number((*it), 16);
         QVariant newValue;
-        serializers[qMetaTypeId<V>()].deserializer(it, newValue);
+        serializers[qMetaTypeId<V*>()].deserializer(it, newValue);
         return newValue;
     }
 
@@ -430,7 +498,8 @@ public:
     }
 
     //-----------------------Deserialize maps of any type------------------------
-    template <typename K, typename V>
+    template <typename K, typename V,
+              typename std::enable_if_t<!std::is_base_of<QObject, V>::value, int> = 0>
     static void deserializeMap(QByteArray::const_iterator &it, QVariant &previous) {
         qProtoDebug() << __func__ << "currentByte:" << QString::number((*it), 16);
         QMap<K,V> out = previous.value<QMap<K,V>>();
@@ -458,44 +527,88 @@ public:
         previous = QVariant::fromValue<QMap<K,V>>(out);
     }
 
-    template <typename T>
+    template <typename K, typename V,
+              typename std::enable_if_t<std::is_base_of<QObject, V>::value, int> = 0>
+    static void deserializeMap(QByteArray::const_iterator &it, QVariant &previous) {
+        qProtoDebug() << __func__ << "currentByte:" << QString::number((*it), 16);
+        auto out = previous.value<QMap<K, QPointer<V>>>();
+
+        int mapIndex = 0;
+        WireTypes type = WireTypes::UnknownWireType;
+
+        K key;
+        V* value;
+
+        unsigned int count = deserializeBasic<uint32>(it).toUInt();
+        qProtoDebug() << __func__ << "count:" << count;
+        QByteArray::const_iterator last = it + count;
+        while (it != last) {
+            decodeHeaderByte(*it, mapIndex, type);
+            ++it;
+            if(mapIndex == 1) {
+                key = deserializeMapHelper<K>(it);
+            } else {
+                value = deserializeMapHelper<V>(it);
+            }
+        }
+
+        out[key] = value;
+        previous = QVariant::fromValue<QMap<K,QPointer<V>>>(out);
+    }
+
+    template <typename T,
+              typename std::enable_if_t<std::is_base_of<QObject, T>::value, int> = 0>
+    static T *deserializeMapHelper(QByteArray::const_iterator &it) {
+        auto serializer = serializers[qMetaTypeId<T *>()];
+        QVariant value;
+        serializer.deserializer(it, value);
+        return value.value<T *>();
+    }
+
+    template <typename T,
+              typename std::enable_if_t<!std::is_base_of<QObject, T>::value, int> = 0>
     static T deserializeMapHelper(QByteArray::const_iterator &it) {
         auto serializer = serializers[qMetaTypeId<T>()];
         QVariant value;
         serializer.deserializer(it, value);
         return value.value<T>();
     }
+
     //-----------------------Functions to work with objects------------------------
     template<typename T>
     static void registerSerializers() {
         ProtobufObjectPrivate::wrapSerializer<T>(serializeComplexType<T>, deserializeComplexType<T>, LengthDelimited);
-        ProtobufObjectPrivate::serializers[qMetaTypeId<QList<T>>()] = {ProtobufObjectPrivate::Serializer(serializeComplexListType<T>),
+        ProtobufObjectPrivate::serializers[qMetaTypeId<QList<QPointer<T>>>()] = {ProtobufObjectPrivate::Serializer(serializeComplexListType<T>),
                 ProtobufObjectPrivate::Deserializer(deserializeComplexListType<T>), LengthDelimited};
     }
 
-    template<typename T>
+    template <typename T,
+              typename std::enable_if_t<std::is_base_of<QObject, T>::value, int> = 0>
     static QByteArray serializeComplexType(const T &value, int &/*outFieldIndex*/) {
         return ProtobufObjectPrivate::serializeLengthDelimited(value.serialize());
     }
 
-    template<typename T>
+    template <typename T,
+              typename std::enable_if_t<std::is_base_of<QObject, T>::value, int> = 0>
     static QVariant deserializeComplexType(QByteArray::const_iterator &it) {
-        T value;
-        value.deserialize(ProtobufObjectPrivate::deserializeLengthDelimited(it));
-        return QVariant::fromValue<T>(value);
+        T *value = new T;
+        value->deserialize(ProtobufObjectPrivate::deserializeLengthDelimited(it));
+        return QVariant::fromValue<T*>(value);
     }
 
-    template<typename T>
+    template <typename T,
+              typename std::enable_if_t<std::is_base_of<QObject, T>::value, int> = 0>
     static QByteArray serializeComplexListType(const QVariant &listValue, int &outFieldIndex) {
-        QList<T> list = listValue.value<QList<T>>();
+        QList<QPointer<T>> list = listValue.value<QList<QPointer<T>>>();
         return ProtobufObjectPrivate::serializeListType(list, outFieldIndex);
     }
 
-    template<typename T>
+    template <typename T,
+              typename std::enable_if_t<std::is_base_of<QObject, T>::value, int> = 0>
     static void deserializeComplexListType(QByteArray::const_iterator &it, QVariant &previous) {
-        QList<T> previousList = previous.value<QList<T>>();
+        QList<QPointer<T>> previousList = previous.value<QList<QPointer<T>>>();
         QVariant newMember = ProtobufObjectPrivate::deserializeList<T>(it);
-        previousList.append(newMember.value<T>());
+        previousList.append(newMember.value<T*>());
         previous.setValue(previousList);
     }
 

+ 45 - 20
tests/deserializationtest.cpp

@@ -378,7 +378,7 @@ TEST_F(DeserializationTest, ComplexTypeDeserializeTest)
 {
     ComplexMessage test;
 
-    qRegisterMetaType<SimpleStringMessage>("SimpleStringMessage");
+    SimpleEnumMessage::registerTypes();
 
     test.deserialize(QByteArray::fromHex("1208320671776572747908d3ffffffffffffffff01"));
     ASSERT_EQ(-45, test.testFieldInt());
@@ -529,22 +529,23 @@ TEST_F(DeserializationTest, RepeatedSFixedInt64MessageTest)
 TEST_F(DeserializationTest, RepeatedComplexMessageTest)
 {
     ComplexMessage::registerTypes();
+    SimpleStringMessage::registerTypes();
     RepeatedComplexMessage test;
     test.deserialize(QByteArray::fromHex("0a0c0819120832067177657274790a0c0819120832067177657274790a0c081912083206717765727479"));
     ASSERT_EQ(3, test.testRepeatedComplex().count());
-    ASSERT_EQ(25, test.testRepeatedComplex().at(0).testFieldInt());
-    ASSERT_TRUE(test.testRepeatedComplex().at(0).testComplexField().testFieldString() == QString("qwerty"));
-    ASSERT_EQ(25, test.testRepeatedComplex().at(1).testFieldInt());
-    ASSERT_TRUE(test.testRepeatedComplex().at(1).testComplexField().testFieldString() == QString("qwerty"));
-    ASSERT_EQ(25, test.testRepeatedComplex().at(2).testFieldInt());
-    ASSERT_TRUE(test.testRepeatedComplex().at(2).testComplexField().testFieldString() == QString("qwerty"));
+    ASSERT_EQ(25, test.testRepeatedComplex().at(0)->testFieldInt());
+    ASSERT_TRUE(test.testRepeatedComplex().at(0)->testComplexField().testFieldString() == QString("qwerty"));
+    ASSERT_EQ(25, test.testRepeatedComplex().at(1)->testFieldInt());
+    ASSERT_TRUE(test.testRepeatedComplex().at(1)->testComplexField().testFieldString() == QString("qwerty"));
+    ASSERT_EQ(25, test.testRepeatedComplex().at(2)->testFieldInt());
+    ASSERT_TRUE(test.testRepeatedComplex().at(2)->testComplexField().testFieldString() == QString("qwerty"));
 
     //FIXME: This setter should not be called in this test. See bug#69
     test.setTestRepeatedComplex({});
     test.deserialize(QByteArray::fromHex("0a1508d3feffffffffffffff0112083206717765727479"));
     ASSERT_LT(0, test.testRepeatedComplex().count());
-    ASSERT_EQ(-173, test.testRepeatedComplex().at(0).testFieldInt());
-    ASSERT_TRUE(test.testRepeatedComplex().at(0).testComplexField().testFieldString() == QString("qwerty"));
+    ASSERT_EQ(-173, test.testRepeatedComplex().at(0)->testFieldInt());
+    ASSERT_TRUE(test.testRepeatedComplex().at(0)->testComplexField().testFieldString() == QString("qwerty"));
 }
 
 TEST_F(DeserializationTest, SIntMessageDeserializeTest)
@@ -736,75 +737,99 @@ TEST_F(DeserializationTest, SimpleFixed32ComplexMapDeserializeTest)
 {
     SimpleFixed32ComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("3a180d0a0000001211120d320b74656e207369787465656e08103a230d2a000000121c12183216666f757274792074776f2074656e207369787465656e080a3a110d13000100120a120632045755543f080a"));
-    ASSERT_TRUE(test.mapField() == SimpleFixed32ComplexMessageMapMessage::MapFieldEntry({{10, {16, {"ten sixteen"}}}, {42, {10, {"fourty two ten sixteen"}}}, {65555, {10, {"WUT?"}}}}));
+    ASSERT_TRUE(*test.mapField()[10].data() == ComplexMessage({16, {"ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[42].data() == ComplexMessage({10, {"fourty two ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[65555].data() == ComplexMessage({10, {"WUT?"}}));
 }
 
 TEST_F(DeserializationTest, SimpleSFixed32ComplexMapDeserializeTest)
 {
     SimpleSFixed32ComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("4a290dd6ffffff1222121e321c6d696e757320666f757274792074776f2074656e207369787465656e080a4a180d0a0000001211120d320b74656e207369787465656e08104a110d13000100120a120632045755543f080a"));
-    ASSERT_TRUE(test.mapField() == SimpleSFixed32ComplexMessageMapMessage::MapFieldEntry({{10, {16 , {"ten sixteen"}}}, {-42, {10 , {"minus fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}}));
+
+    ASSERT_TRUE(*test.mapField()[10] == ComplexMessage({16 , {"ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[-42] == ComplexMessage({10 , {"minus fourty two ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[65555] == ComplexMessage({10 , {"WUT?"}}));
 }
 
 TEST_F(DeserializationTest, SimpleInt32ComplexMapDeserializeTest)
 {
     SimpleInt32ComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("1a2f08d6ffffffffffffffff011222121e321c6d696e757320666f757274792074776f2074656e207369787465656e080a1a15080a1211120d320b74656e207369787465656e08101a1008938004120a120632045755543f080a"));
-    ASSERT_TRUE(test.mapField() == SimpleInt32ComplexMessageMapMessage::MapFieldEntry({{10, {16 , {"ten sixteen"}}}, {-42, {10 , {"minus fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}}));
+    ASSERT_TRUE(*test.mapField()[10] == ComplexMessage({16 , {"ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[-42] == ComplexMessage({10 , {"minus fourty two ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[65555] == ComplexMessage({10 , {"WUT?"}}));
 }
 
 TEST_F(DeserializationTest, SimpleSInt32ComplexMapDeserializeTest)
 {
     SimpleSInt32ComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("0a1608a580081210120c320a6d696e7573205755543f080a0a1508141211120d320b74656e207369787465656e08100a200854121c12183216666f757274792074776f2074656e207369787465656e080a"));
-    ASSERT_TRUE(test.mapField() == SimpleSInt32ComplexMessageMapMessage::MapFieldEntry({{10, {16 , {"ten sixteen"}}}, {42, {10 , {"fourty two ten sixteen"}}}, {-65555, {10 , {"minus WUT?"}}}}));
+    ASSERT_TRUE(*test.mapField()[10] == ComplexMessage({16 , {"ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[42] == ComplexMessage({10 , {"fourty two ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[-65555] == ComplexMessage({10 , {"minus WUT?"}}));
 }
 
 TEST_F(DeserializationTest, SimpleUInt32ComplexMapDeserializeTest)
 {
     SimpleUInt32ComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("2a15080a1211120d320b74656e207369787465656e08102a20082a121c12183216666f757274792074776f2074656e207369787465656e080a2a1008938004120a120632045755543f080a"));
-    ASSERT_TRUE(test.mapField() == SimpleUInt32ComplexMessageMapMessage::MapFieldEntry({{10, {16 , {"ten sixteen"}}}, {42, {10 , {"fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}}));
+    ASSERT_TRUE(*test.mapField()[10] == ComplexMessage({16 , {"ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[42] == ComplexMessage({10 , {"fourty two ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[65555] == ComplexMessage({10 , {"WUT?"}}));
 }
 
 TEST_F(DeserializationTest, SimpleFixed64ComplexMapDeserializeTest)
 {
     SimpleFixed64ComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("421c090a000000000000001211120d320b74656e207369787465656e08104215091300010000000000120a120632045755543f080a422b09ffffffffffffffff1220121c321a6d696e757320666f757274792074776f2074656e204d41414158082a"));
-    ASSERT_TRUE(test.mapField() == SimpleFixed64ComplexMessageMapMessage::MapFieldEntry({{10, {16 , {"ten sixteen"}}}, {UINT64_MAX, {42 , {"minus fourty two ten MAAAX"}}}, {65555, {10 , {"WUT?"}}}}));
+
+    ASSERT_TRUE(*test.mapField()[10] == ComplexMessage({16 , {"ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[UINT64_MAX] == ComplexMessage({42 , {"minus fourty two ten MAAAX"}}));
+    ASSERT_TRUE(*test.mapField()[65555] == ComplexMessage({10 , {"WUT?"}}));
 }
 
 TEST_F(DeserializationTest, SimpleSFixed64ComplexMapDeserializeTest)
 {
     SimpleSFixed64ComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("522d09d6ffffffffffffff1222121e321c6d696e757320666f757274792074776f2074656e207369787465656e080a521c090a000000000000001211120d320b74656e207369787465656e08105215091300010000000000120a120632045755543f080a"));
-    ASSERT_TRUE(test.mapField() == SimpleSFixed64ComplexMessageMapMessage::MapFieldEntry({{10, {16 , {"ten sixteen"}}}, {-42, {10 , {"minus fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}}));
+    ASSERT_TRUE(*test.mapField()[10] == ComplexMessage({16 , {"ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[-42] == ComplexMessage({10 , {"minus fourty two ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[65555] == ComplexMessage({10 , {"WUT?"}}));
 }
 
 TEST_F(DeserializationTest, SimpleInt64ComplexMapDeserializeTest)
 {
     SimpleInt64ComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("222f08d6ffffffffffffffff011222121e321c6d696e757320666f757274792074776f2074656e207369787465656e080a2215080a1211120d320b74656e207369787465656e0810221008938004120a120632045755543f080a"));
-    ASSERT_TRUE(test.mapField() == SimpleInt64ComplexMessageMapMessage::MapFieldEntry({{10, {16 , {"ten sixteen"}}}, {-42, {10 , {"minus fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}}));
+    ASSERT_TRUE(*test.mapField()[10] == ComplexMessage({16 , {"ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[-42] == ComplexMessage({10 , {"minus fourty two ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[65555] == ComplexMessage({10 , {"WUT?"}}));
 }
 
 TEST_F(DeserializationTest, SimpleSInt64ComplexMapDeserializeTest)
 {
     SimpleSInt64ComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("122608531222121e321c6d696e757320666f757274792074776f2074656e207369787465656e080a121508141211120d320b74656e207369787465656e0810121008a68008120a120632045755543f080a"));
-    ASSERT_TRUE(test.mapField() == SimpleSInt64ComplexMessageMapMessage::MapFieldEntry({{10, {16 , {"ten sixteen"}}}, {-42, {10 , {"minus fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}}));
+    ASSERT_TRUE(*test.mapField()[10] == ComplexMessage({16 , {"ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[-42] == ComplexMessage({10 , {"minus fourty two ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[65555] == ComplexMessage({10 , {"WUT?"}}));
 }
 
 TEST_F(DeserializationTest, SimpleUInt64ComplexMapDeserializeTest)
 {
     SimpleUInt64ComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("3214080a1210120c320a74656e20656c6576656e080b3220082a121c12183216666f757274792074776f2074656e207369787465656e080a321008938004120a120632045755543f080a"));
-    ASSERT_TRUE(test.mapField() == SimpleUInt64ComplexMessageMapMessage::MapFieldEntry({{10, {11 , {"ten eleven"}}}, {42, {10 , {"fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}}));
+    ASSERT_TRUE(*test.mapField()[10] == ComplexMessage({11 , {"ten eleven"}}));
+    ASSERT_TRUE(*test.mapField()[42] == ComplexMessage({10 , {"fourty two ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()[65555] == ComplexMessage({10 , {"WUT?"}}));
 }
 
 TEST_F(DeserializationTest, SimpleStringComplexMapDeserializeTest)
 {
     SimpleStringComplexMessageMapMessage test;
     test.deserialize(QByteArray::fromHex("6a140a055755543f3f120b120732053f5755543f080a6a170a0362656e1210120c320a74656e20656c6576656e080b6a350a157768657265206973206d792063617220647564653f121c12183216666f757274792074776f2074656e207369787465656e080a"));
-    ASSERT_TRUE(test.mapField() == SimpleStringComplexMessageMapMessage::MapFieldEntry({{"ben", {11 , {"ten eleven"}}}, {"where is my car dude?", {10 , {"fourty two ten sixteen"}}}, {"WUT??", {10 , {"?WUT?"}}}}));
+    ASSERT_TRUE(*test.mapField()["ben"] == ComplexMessage({11 , {"ten eleven"}}));
+    ASSERT_TRUE(*test.mapField()["where is my car dude?"] == ComplexMessage({10 , {"fourty two ten sixteen"}}));
+    ASSERT_TRUE(*test.mapField()["WUT??"] == ComplexMessage({10 , {"?WUT?"}}));
 }

+ 13 - 0
tests/echoserver/CMakeLists.txt

@@ -0,0 +1,13 @@
+file(GLOB HEADERS ${TESTS_OUT_DIR}/*.h)
+file(GLOB SOURCES main.cpp)
+file(GLOB GENERATED_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/*.cpp)
+
+set(${ECHO_SERVER} "echoserver")
+
+add_executable(${ECHO_SERVER} ${SOURCES} ${GENERATED_SOURCES})
+add_custom_command(TARGET ${ECHO_SERVER} PRE_BUILD
+    COMMAND ${Protobuf_PROTOC_EXECUTABLE} --plugin=protoc-gen-${PROJECT_NAME}=${CMAKE_BINARY_DIR}/qtprotobuf --qtprotobuf_out=${CMAKE_CURRENT_BINARY_DIR}/tests
+    ${PROTO_FILES}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests/proto/
+    DEPENDS ${PROJECT_NAME} ${PROTO_FILES}
+    COMMENT "Generating test headers")

+ 29 - 0
tests/echoserver/main.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+#include <grpc++/grpc++.h>
+#include <testservice.pb.h>
+#include <testservice.grpc.pb.h>
+#include <simpletest.pb.h>
+#include <simpletest.grpc.pb.h>
+
+class SimpleTestImpl final : public qtprotobufnamespace::tests::TestService::Service {
+public:
+    ::grpc::Status testMethod(grpc::ServerContext *context, const qtprotobufnamespace::tests::SimpleStringMessage *request, qtprotobufnamespace::tests::SimpleStringMessage *response)
+    {
+        std::cerr << "testMethod called" << std::endl << request->testfieldstring() << std::endl;
+        response->set_testfieldstring(request->testfieldstring());
+        return ::grpc::Status();
+    }
+};
+
+int main(int argc, char *argv[])
+{
+    std::string server_address("localhost:50051");
+    SimpleTestImpl service;
+
+    grpc::ServerBuilder builder;
+    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
+    builder.RegisterService(&service);
+    std::unique_ptr<grpc::Server> server(builder.BuildAndStart());
+    std::cout << "Server listening on " << server_address << std::endl;
+    server->Wait();
+}

+ 73 - 0
tests/echoserver/testserver/.gitignore

@@ -0,0 +1,73 @@
+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+

+ 23 - 0
tests/echoserver/testserver/globalenums.grpc.pb.cc

@@ -0,0 +1,23 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: globalenums.proto
+
+#include "globalenums.pb.h"
+#include "globalenums.grpc.pb.h"
+
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace qtprotobufnamespace {
+namespace tests {
+namespace globalenums {
+
+}  // namespace qtprotobufnamespace
+}  // namespace tests
+}  // namespace globalenums
+

+ 36 - 0
tests/echoserver/testserver/globalenums.grpc.pb.h

@@ -0,0 +1,36 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: globalenums.proto
+#ifndef GRPC_globalenums_2eproto__INCLUDED
+#define GRPC_globalenums_2eproto__INCLUDED
+
+#include "globalenums.pb.h"
+
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace grpc {
+class CompletionQueue;
+class Channel;
+class ServerCompletionQueue;
+class ServerContext;
+}  // namespace grpc
+
+namespace qtprotobufnamespace {
+namespace tests {
+namespace globalenums {
+
+}  // namespace globalenums
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+
+
+#endif  // GRPC_globalenums_2eproto__INCLUDED

+ 110 - 0
tests/echoserver/testserver/globalenums.pb.cc

@@ -0,0 +1,110 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: globalenums.proto
+
+#include "globalenums.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// This is a temporary google only hack
+#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+#include "third_party/protobuf/version.h"
+#endif
+// @@protoc_insertion_point(includes)
+
+namespace qtprotobufnamespace {
+namespace tests {
+namespace globalenums {
+}  // namespace globalenums
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace protobuf_globalenums_2eproto {
+void InitDefaults() {
+}
+
+const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[1];
+const ::google::protobuf::uint32 TableStruct::offsets[1] = {};
+static const ::google::protobuf::internal::MigrationSchema* schemas = NULL;
+static const ::google::protobuf::Message* const* file_default_instances = NULL;
+
+void protobuf_AssignDescriptors() {
+  AddDescriptors();
+  AssignDescriptors(
+      "globalenums.proto", schemas, file_default_instances, TableStruct::offsets,
+      NULL, file_level_enum_descriptors, NULL);
+}
+
+void protobuf_AssignDescriptorsOnce() {
+  static ::google::protobuf::internal::once_flag once;
+  ::google::protobuf::internal::call_once(once, protobuf_AssignDescriptors);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+}
+
+void AddDescriptorsImpl() {
+  InitDefaults();
+  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+      "\n\021globalenums.proto\022%qtprotobufnamespace"
+      ".tests.globalenums*x\n\010TestEnum\022\024\n\020TEST_E"
+      "NUM_VALUE0\020\000\022\024\n\020TEST_ENUM_VALUE1\020\001\022\024\n\020TE"
+      "ST_ENUM_VALUE2\020\002\022\024\n\020TEST_ENUM_VALUE3\020\004\022\024"
+      "\n\020TEST_ENUM_VALUE4\020\003b\006proto3"
+  };
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+      descriptor, 188);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "globalenums.proto", &protobuf_RegisterTypes);
+}
+
+void AddDescriptors() {
+  static ::google::protobuf::internal::once_flag once;
+  ::google::protobuf::internal::call_once(once, AddDescriptorsImpl);
+}
+// Force AddDescriptors() to be called at dynamic initialization time.
+struct StaticDescriptorInitializer {
+  StaticDescriptorInitializer() {
+    AddDescriptors();
+  }
+} static_descriptor_initializer;
+}  // namespace protobuf_globalenums_2eproto
+namespace qtprotobufnamespace {
+namespace tests {
+namespace globalenums {
+const ::google::protobuf::EnumDescriptor* TestEnum_descriptor() {
+  protobuf_globalenums_2eproto::protobuf_AssignDescriptorsOnce();
+  return protobuf_globalenums_2eproto::file_level_enum_descriptors[0];
+}
+bool TestEnum_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace globalenums
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace google {
+namespace protobuf {
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)

+ 117 - 0
tests/echoserver/testserver/globalenums.pb.h

@@ -0,0 +1,117 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: globalenums.proto
+
+#ifndef PROTOBUF_INCLUDED_globalenums_2eproto
+#define PROTOBUF_INCLUDED_globalenums_2eproto
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3006001
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/inlined_string_field.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+// @@protoc_insertion_point(includes)
+#define PROTOBUF_INTERNAL_EXPORT_protobuf_globalenums_2eproto 
+
+namespace protobuf_globalenums_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+}  // namespace protobuf_globalenums_2eproto
+namespace qtprotobufnamespace {
+namespace tests {
+namespace globalenums {
+}  // namespace globalenums
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace qtprotobufnamespace {
+namespace tests {
+namespace globalenums {
+
+enum TestEnum {
+  TEST_ENUM_VALUE0 = 0,
+  TEST_ENUM_VALUE1 = 1,
+  TEST_ENUM_VALUE2 = 2,
+  TEST_ENUM_VALUE3 = 4,
+  TEST_ENUM_VALUE4 = 3,
+  TestEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  TestEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool TestEnum_IsValid(int value);
+const TestEnum TestEnum_MIN = TEST_ENUM_VALUE0;
+const TestEnum TestEnum_MAX = TEST_ENUM_VALUE3;
+const int TestEnum_ARRAYSIZE = TestEnum_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* TestEnum_descriptor();
+inline const ::std::string& TestEnum_Name(TestEnum value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    TestEnum_descriptor(), value);
+}
+inline bool TestEnum_Parse(
+    const ::std::string& name, TestEnum* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<TestEnum>(
+    TestEnum_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace globalenums
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::qtprotobufnamespace::tests::globalenums::TestEnum> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::qtprotobufnamespace::tests::globalenums::TestEnum>() {
+  return ::qtprotobufnamespace::tests::globalenums::TestEnum_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_INCLUDED_globalenums_2eproto

+ 11 - 0
tests/echoserver/testserver/globalenums.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package qtprotobufnamespace.tests.globalenums;
+
+enum TestEnum {
+    TEST_ENUM_VALUE0 = 0;
+    TEST_ENUM_VALUE1 = 1;
+    TEST_ENUM_VALUE2 = 2;
+    TEST_ENUM_VALUE3 = 4;
+    TEST_ENUM_VALUE4 = 3;
+}

+ 21 - 0
tests/echoserver/testserver/globalenumssamenamespace.grpc.pb.cc

@@ -0,0 +1,21 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: globalenumssamenamespace.proto
+
+#include "globalenumssamenamespace.pb.h"
+#include "globalenumssamenamespace.grpc.pb.h"
+
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace qtprotobufnamespace {
+namespace tests {
+
+}  // namespace qtprotobufnamespace
+}  // namespace tests
+

+ 34 - 0
tests/echoserver/testserver/globalenumssamenamespace.grpc.pb.h

@@ -0,0 +1,34 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: globalenumssamenamespace.proto
+#ifndef GRPC_globalenumssamenamespace_2eproto__INCLUDED
+#define GRPC_globalenumssamenamespace_2eproto__INCLUDED
+
+#include "globalenumssamenamespace.pb.h"
+
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace grpc {
+class CompletionQueue;
+class Channel;
+class ServerCompletionQueue;
+class ServerContext;
+}  // namespace grpc
+
+namespace qtprotobufnamespace {
+namespace tests {
+
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+
+
+#endif  // GRPC_globalenumssamenamespace_2eproto__INCLUDED

+ 106 - 0
tests/echoserver/testserver/globalenumssamenamespace.pb.cc

@@ -0,0 +1,106 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: globalenumssamenamespace.proto
+
+#include "globalenumssamenamespace.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// This is a temporary google only hack
+#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+#include "third_party/protobuf/version.h"
+#endif
+// @@protoc_insertion_point(includes)
+
+namespace qtprotobufnamespace {
+namespace tests {
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace protobuf_globalenumssamenamespace_2eproto {
+void InitDefaults() {
+}
+
+const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[1];
+const ::google::protobuf::uint32 TableStruct::offsets[1] = {};
+static const ::google::protobuf::internal::MigrationSchema* schemas = NULL;
+static const ::google::protobuf::Message* const* file_default_instances = NULL;
+
+void protobuf_AssignDescriptors() {
+  AddDescriptors();
+  AssignDescriptors(
+      "globalenumssamenamespace.proto", schemas, file_default_instances, TableStruct::offsets,
+      NULL, file_level_enum_descriptors, NULL);
+}
+
+void protobuf_AssignDescriptorsOnce() {
+  static ::google::protobuf::internal::once_flag once;
+  ::google::protobuf::internal::call_once(once, protobuf_AssignDescriptors);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+}
+
+void AddDescriptorsImpl() {
+  InitDefaults();
+  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+      "\n\036globalenumssamenamespace.proto\022\031qtprot"
+      "obufnamespace.tests*~\n\tTestEnum2\022\025\n\021TEST"
+      "_ENUM2_VALUE0\020\000\022\025\n\021TEST_ENUM2_VALUE1\020\001\022\025"
+      "\n\021TEST_ENUM2_VALUE2\020\002\022\025\n\021TEST_ENUM2_VALU"
+      "E3\020\004\022\025\n\021TEST_ENUM2_VALUE4\020\003b\006proto3"
+  };
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+      descriptor, 195);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "globalenumssamenamespace.proto", &protobuf_RegisterTypes);
+}
+
+void AddDescriptors() {
+  static ::google::protobuf::internal::once_flag once;
+  ::google::protobuf::internal::call_once(once, AddDescriptorsImpl);
+}
+// Force AddDescriptors() to be called at dynamic initialization time.
+struct StaticDescriptorInitializer {
+  StaticDescriptorInitializer() {
+    AddDescriptors();
+  }
+} static_descriptor_initializer;
+}  // namespace protobuf_globalenumssamenamespace_2eproto
+namespace qtprotobufnamespace {
+namespace tests {
+const ::google::protobuf::EnumDescriptor* TestEnum2_descriptor() {
+  protobuf_globalenumssamenamespace_2eproto::protobuf_AssignDescriptorsOnce();
+  return protobuf_globalenumssamenamespace_2eproto::file_level_enum_descriptors[0];
+}
+bool TestEnum2_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace google {
+namespace protobuf {
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)

+ 113 - 0
tests/echoserver/testserver/globalenumssamenamespace.pb.h

@@ -0,0 +1,113 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: globalenumssamenamespace.proto
+
+#ifndef PROTOBUF_INCLUDED_globalenumssamenamespace_2eproto
+#define PROTOBUF_INCLUDED_globalenumssamenamespace_2eproto
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3006001
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/inlined_string_field.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+// @@protoc_insertion_point(includes)
+#define PROTOBUF_INTERNAL_EXPORT_protobuf_globalenumssamenamespace_2eproto 
+
+namespace protobuf_globalenumssamenamespace_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+}  // namespace protobuf_globalenumssamenamespace_2eproto
+namespace qtprotobufnamespace {
+namespace tests {
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace qtprotobufnamespace {
+namespace tests {
+
+enum TestEnum2 {
+  TEST_ENUM2_VALUE0 = 0,
+  TEST_ENUM2_VALUE1 = 1,
+  TEST_ENUM2_VALUE2 = 2,
+  TEST_ENUM2_VALUE3 = 4,
+  TEST_ENUM2_VALUE4 = 3,
+  TestEnum2_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  TestEnum2_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool TestEnum2_IsValid(int value);
+const TestEnum2 TestEnum2_MIN = TEST_ENUM2_VALUE0;
+const TestEnum2 TestEnum2_MAX = TEST_ENUM2_VALUE3;
+const int TestEnum2_ARRAYSIZE = TestEnum2_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* TestEnum2_descriptor();
+inline const ::std::string& TestEnum2_Name(TestEnum2 value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    TestEnum2_descriptor(), value);
+}
+inline bool TestEnum2_Parse(
+    const ::std::string& name, TestEnum2* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<TestEnum2>(
+    TestEnum2_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::qtprotobufnamespace::tests::TestEnum2> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::qtprotobufnamespace::tests::TestEnum2>() {
+  return ::qtprotobufnamespace::tests::TestEnum2_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_INCLUDED_globalenumssamenamespace_2eproto

+ 11 - 0
tests/echoserver/testserver/globalenumssamenamespace.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package qtprotobufnamespace.tests;
+
+enum TestEnum2 {
+    TEST_ENUM2_VALUE0 = 0;
+    TEST_ENUM2_VALUE1 = 1;
+    TEST_ENUM2_VALUE2 = 2;
+    TEST_ENUM2_VALUE3 = 4;
+    TEST_ENUM2_VALUE4 = 3;
+}

+ 31 - 0
tests/echoserver/testserver/main.cpp

@@ -0,0 +1,31 @@
+#include <QCoreApplication>
+
+#include <iostream>
+#include <grpc++/grpc++.h>
+#include <testservice.pb.h>
+#include <testservice.grpc.pb.h>
+#include <simpletest.pb.h>
+#include <simpletest.grpc.pb.h>
+
+class SimpleTestImpl final : public qtprotobufnamespace::tests::TestService::Service {
+public:
+    ::grpc::Status testMethod(grpc::ServerContext *context, const qtprotobufnamespace::tests::SimpleStringMessage *request, qtprotobufnamespace::tests::SimpleStringMessage *response)
+    {
+        std::cerr << "testMethod called" << std::endl << request->testfieldstring() << std::endl;
+        response->set_testfieldstring(request->testfieldstring());
+        return ::grpc::Status();
+    }
+};
+
+int main(int argc, char *argv[])
+{
+    std::string server_address("localhost:50051");
+    SimpleTestImpl service;
+
+    grpc::ServerBuilder builder;
+    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
+    builder.RegisterService(&service);
+    std::unique_ptr<grpc::Server> server(builder.BuildAndStart());
+    std::cout << "Server listening on " << server_address << std::endl;
+    server->Wait();
+}

+ 21 - 0
tests/echoserver/testserver/simpletest.grpc.pb.cc

@@ -0,0 +1,21 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: simpletest.proto
+
+#include "simpletest.pb.h"
+#include "simpletest.grpc.pb.h"
+
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace qtprotobufnamespace {
+namespace tests {
+
+}  // namespace qtprotobufnamespace
+}  // namespace tests
+

+ 34 - 0
tests/echoserver/testserver/simpletest.grpc.pb.h

@@ -0,0 +1,34 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: simpletest.proto
+#ifndef GRPC_simpletest_2eproto__INCLUDED
+#define GRPC_simpletest_2eproto__INCLUDED
+
+#include "simpletest.pb.h"
+
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace grpc {
+class CompletionQueue;
+class Channel;
+class ServerCompletionQueue;
+class ServerContext;
+}  // namespace grpc
+
+namespace qtprotobufnamespace {
+namespace tests {
+
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+
+
+#endif  // GRPC_simpletest_2eproto__INCLUDED

+ 6594 - 0
tests/echoserver/testserver/simpletest.pb.cc

@@ -0,0 +1,6594 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: simpletest.proto
+
+#include "simpletest.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// This is a temporary google only hack
+#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+#include "third_party/protobuf/version.h"
+#endif
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_simpletest_2eproto {
+extern PROTOBUF_INTERNAL_EXPORT_protobuf_simpletest_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_SimpleStringMessage;
+extern PROTOBUF_INTERNAL_EXPORT_protobuf_simpletest_2eproto ::google::protobuf::internal::SCCInfo<1> scc_info_ComplexMessage;
+}  // namespace protobuf_simpletest_2eproto
+namespace qtprotobufnamespace {
+namespace tests {
+class SimpleEnumMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleEnumMessage>
+      _instance;
+} _SimpleEnumMessage_default_instance_;
+class SimpleFileEnumMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleFileEnumMessage>
+      _instance;
+} _SimpleFileEnumMessage_default_instance_;
+class SimpleBoolMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleBoolMessage>
+      _instance;
+} _SimpleBoolMessage_default_instance_;
+class SimpleIntMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleIntMessage>
+      _instance;
+} _SimpleIntMessage_default_instance_;
+class SimpleSIntMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleSIntMessage>
+      _instance;
+} _SimpleSIntMessage_default_instance_;
+class SimpleUIntMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleUIntMessage>
+      _instance;
+} _SimpleUIntMessage_default_instance_;
+class SimpleInt64MessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleInt64Message>
+      _instance;
+} _SimpleInt64Message_default_instance_;
+class SimpleSInt64MessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleSInt64Message>
+      _instance;
+} _SimpleSInt64Message_default_instance_;
+class SimpleUInt64MessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleUInt64Message>
+      _instance;
+} _SimpleUInt64Message_default_instance_;
+class SimpleStringMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleStringMessage>
+      _instance;
+} _SimpleStringMessage_default_instance_;
+class SimpleFloatMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleFloatMessage>
+      _instance;
+} _SimpleFloatMessage_default_instance_;
+class SimpleDoubleMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleDoubleMessage>
+      _instance;
+} _SimpleDoubleMessage_default_instance_;
+class SimpleBytesMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleBytesMessage>
+      _instance;
+} _SimpleBytesMessage_default_instance_;
+class SimpleFixedInt32MessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleFixedInt32Message>
+      _instance;
+} _SimpleFixedInt32Message_default_instance_;
+class SimpleFixedInt64MessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleFixedInt64Message>
+      _instance;
+} _SimpleFixedInt64Message_default_instance_;
+class SimpleSFixedInt32MessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleSFixedInt32Message>
+      _instance;
+} _SimpleSFixedInt32Message_default_instance_;
+class SimpleSFixedInt64MessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<SimpleSFixedInt64Message>
+      _instance;
+} _SimpleSFixedInt64Message_default_instance_;
+class ComplexMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<ComplexMessage>
+      _instance;
+} _ComplexMessage_default_instance_;
+class RepeatedIntMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<RepeatedIntMessage>
+      _instance;
+} _RepeatedIntMessage_default_instance_;
+class RepeatedStringMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<RepeatedStringMessage>
+      _instance;
+} _RepeatedStringMessage_default_instance_;
+class RepeatedDoubleMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<RepeatedDoubleMessage>
+      _instance;
+} _RepeatedDoubleMessage_default_instance_;
+class RepeatedBytesMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<RepeatedBytesMessage>
+      _instance;
+} _RepeatedBytesMessage_default_instance_;
+class RepeatedFloatMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<RepeatedFloatMessage>
+      _instance;
+} _RepeatedFloatMessage_default_instance_;
+class RepeatedComplexMessageDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<RepeatedComplexMessage>
+      _instance;
+} _RepeatedComplexMessage_default_instance_;
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace protobuf_simpletest_2eproto {
+static void InitDefaultsSimpleEnumMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleEnumMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleEnumMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleEnumMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleEnumMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleEnumMessage}, {}};
+
+static void InitDefaultsSimpleFileEnumMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleFileEnumMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleFileEnumMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleFileEnumMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleFileEnumMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleFileEnumMessage}, {}};
+
+static void InitDefaultsSimpleBoolMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleBoolMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleBoolMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleBoolMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleBoolMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleBoolMessage}, {}};
+
+static void InitDefaultsSimpleIntMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleIntMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleIntMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleIntMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleIntMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleIntMessage}, {}};
+
+static void InitDefaultsSimpleSIntMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleSIntMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleSIntMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleSIntMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleSIntMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleSIntMessage}, {}};
+
+static void InitDefaultsSimpleUIntMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleUIntMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleUIntMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleUIntMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleUIntMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleUIntMessage}, {}};
+
+static void InitDefaultsSimpleInt64Message() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleInt64Message_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleInt64Message();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleInt64Message::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleInt64Message =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleInt64Message}, {}};
+
+static void InitDefaultsSimpleSInt64Message() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleSInt64Message_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleSInt64Message();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleSInt64Message::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleSInt64Message =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleSInt64Message}, {}};
+
+static void InitDefaultsSimpleUInt64Message() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleUInt64Message_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleUInt64Message();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleUInt64Message::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleUInt64Message =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleUInt64Message}, {}};
+
+static void InitDefaultsSimpleStringMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleStringMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleStringMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleStringMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleStringMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleStringMessage}, {}};
+
+static void InitDefaultsSimpleFloatMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleFloatMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleFloatMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleFloatMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleFloatMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleFloatMessage}, {}};
+
+static void InitDefaultsSimpleDoubleMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleDoubleMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleDoubleMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleDoubleMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleDoubleMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleDoubleMessage}, {}};
+
+static void InitDefaultsSimpleBytesMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleBytesMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleBytesMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleBytesMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleBytesMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleBytesMessage}, {}};
+
+static void InitDefaultsSimpleFixedInt32Message() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleFixedInt32Message_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleFixedInt32Message();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleFixedInt32Message::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleFixedInt32Message =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleFixedInt32Message}, {}};
+
+static void InitDefaultsSimpleFixedInt64Message() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleFixedInt64Message_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleFixedInt64Message();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleFixedInt64Message::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleFixedInt64Message =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleFixedInt64Message}, {}};
+
+static void InitDefaultsSimpleSFixedInt32Message() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleSFixedInt32Message_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleSFixedInt32Message();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleSFixedInt32Message::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleSFixedInt32Message =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleSFixedInt32Message}, {}};
+
+static void InitDefaultsSimpleSFixedInt64Message() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_SimpleSFixedInt64Message_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::SimpleSFixedInt64Message();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::SimpleSFixedInt64Message::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_SimpleSFixedInt64Message =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsSimpleSFixedInt64Message}, {}};
+
+static void InitDefaultsComplexMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_ComplexMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::ComplexMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::ComplexMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<1> scc_info_ComplexMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsComplexMessage}, {
+      &protobuf_simpletest_2eproto::scc_info_SimpleStringMessage.base,}};
+
+static void InitDefaultsRepeatedIntMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_RepeatedIntMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::RepeatedIntMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::RepeatedIntMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_RepeatedIntMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRepeatedIntMessage}, {}};
+
+static void InitDefaultsRepeatedStringMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_RepeatedStringMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::RepeatedStringMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::RepeatedStringMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_RepeatedStringMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRepeatedStringMessage}, {}};
+
+static void InitDefaultsRepeatedDoubleMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_RepeatedDoubleMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::RepeatedDoubleMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::RepeatedDoubleMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_RepeatedDoubleMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRepeatedDoubleMessage}, {}};
+
+static void InitDefaultsRepeatedBytesMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_RepeatedBytesMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::RepeatedBytesMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::RepeatedBytesMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_RepeatedBytesMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRepeatedBytesMessage}, {}};
+
+static void InitDefaultsRepeatedFloatMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_RepeatedFloatMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::RepeatedFloatMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::RepeatedFloatMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<0> scc_info_RepeatedFloatMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsRepeatedFloatMessage}, {}};
+
+static void InitDefaultsRepeatedComplexMessage() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::qtprotobufnamespace::tests::_RepeatedComplexMessage_default_instance_;
+    new (ptr) ::qtprotobufnamespace::tests::RepeatedComplexMessage();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::qtprotobufnamespace::tests::RepeatedComplexMessage::InitAsDefaultInstance();
+}
+
+::google::protobuf::internal::SCCInfo<1> scc_info_RepeatedComplexMessage =
+    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsRepeatedComplexMessage}, {
+      &protobuf_simpletest_2eproto::scc_info_ComplexMessage.base,}};
+
+void InitDefaults() {
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleEnumMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleFileEnumMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleBoolMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleIntMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleSIntMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleUIntMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleInt64Message.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleSInt64Message.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleUInt64Message.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleStringMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleFloatMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleDoubleMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleBytesMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleFixedInt32Message.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleFixedInt64Message.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleSFixedInt32Message.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_SimpleSFixedInt64Message.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_ComplexMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_RepeatedIntMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_RepeatedStringMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_RepeatedDoubleMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_RepeatedBytesMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_RepeatedFloatMessage.base);
+  ::google::protobuf::internal::InitSCC(&scc_info_RepeatedComplexMessage.base);
+}
+
+::google::protobuf::Metadata file_level_metadata[24];
+const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[2];
+
+const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleEnumMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleEnumMessage, localenum_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleEnumMessage, localenumlist_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleFileEnumMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleFileEnumMessage, globalenum_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleFileEnumMessage, globalenumlist_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleBoolMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleBoolMessage, testfieldbool_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleIntMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleIntMessage, testfieldint_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleSIntMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleSIntMessage, testfieldint_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleUIntMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleUIntMessage, testfieldint_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleInt64Message, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleInt64Message, testfieldint_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleSInt64Message, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleSInt64Message, testfieldint_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleUInt64Message, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleUInt64Message, testfieldint_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleStringMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleStringMessage, testfieldstring_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleFloatMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleFloatMessage, testfieldfloat_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleDoubleMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleDoubleMessage, testfielddouble_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleBytesMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleBytesMessage, testfieldbytes_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleFixedInt32Message, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleFixedInt32Message, testfieldfixedint32_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleFixedInt64Message, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleFixedInt64Message, testfieldfixedint64_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleSFixedInt32Message, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleSFixedInt32Message, testfieldfixedint32_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleSFixedInt64Message, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::SimpleSFixedInt64Message, testfieldfixedint64_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::ComplexMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::ComplexMessage, testfieldint_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::ComplexMessage, testcomplexfield_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedIntMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedIntMessage, testrepeatedint_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedStringMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedStringMessage, testrepeatedstring_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedDoubleMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedDoubleMessage, testrepeateddouble_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedBytesMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedBytesMessage, testrepeatedbytes_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedFloatMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedFloatMessage, testrepeatedfloat_),
+  ~0u,  // no _has_bits_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedComplexMessage, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::qtprotobufnamespace::tests::RepeatedComplexMessage, testrepeatedcomplex_),
+};
+static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, sizeof(::qtprotobufnamespace::tests::SimpleEnumMessage)},
+  { 7, -1, sizeof(::qtprotobufnamespace::tests::SimpleFileEnumMessage)},
+  { 14, -1, sizeof(::qtprotobufnamespace::tests::SimpleBoolMessage)},
+  { 20, -1, sizeof(::qtprotobufnamespace::tests::SimpleIntMessage)},
+  { 26, -1, sizeof(::qtprotobufnamespace::tests::SimpleSIntMessage)},
+  { 32, -1, sizeof(::qtprotobufnamespace::tests::SimpleUIntMessage)},
+  { 38, -1, sizeof(::qtprotobufnamespace::tests::SimpleInt64Message)},
+  { 44, -1, sizeof(::qtprotobufnamespace::tests::SimpleSInt64Message)},
+  { 50, -1, sizeof(::qtprotobufnamespace::tests::SimpleUInt64Message)},
+  { 56, -1, sizeof(::qtprotobufnamespace::tests::SimpleStringMessage)},
+  { 62, -1, sizeof(::qtprotobufnamespace::tests::SimpleFloatMessage)},
+  { 68, -1, sizeof(::qtprotobufnamespace::tests::SimpleDoubleMessage)},
+  { 74, -1, sizeof(::qtprotobufnamespace::tests::SimpleBytesMessage)},
+  { 80, -1, sizeof(::qtprotobufnamespace::tests::SimpleFixedInt32Message)},
+  { 86, -1, sizeof(::qtprotobufnamespace::tests::SimpleFixedInt64Message)},
+  { 92, -1, sizeof(::qtprotobufnamespace::tests::SimpleSFixedInt32Message)},
+  { 98, -1, sizeof(::qtprotobufnamespace::tests::SimpleSFixedInt64Message)},
+  { 104, -1, sizeof(::qtprotobufnamespace::tests::ComplexMessage)},
+  { 111, -1, sizeof(::qtprotobufnamespace::tests::RepeatedIntMessage)},
+  { 117, -1, sizeof(::qtprotobufnamespace::tests::RepeatedStringMessage)},
+  { 123, -1, sizeof(::qtprotobufnamespace::tests::RepeatedDoubleMessage)},
+  { 129, -1, sizeof(::qtprotobufnamespace::tests::RepeatedBytesMessage)},
+  { 135, -1, sizeof(::qtprotobufnamespace::tests::RepeatedFloatMessage)},
+  { 141, -1, sizeof(::qtprotobufnamespace::tests::RepeatedComplexMessage)},
+};
+
+static ::google::protobuf::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleEnumMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleFileEnumMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleBoolMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleIntMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleSIntMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleUIntMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleInt64Message_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleSInt64Message_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleUInt64Message_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleStringMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleFloatMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleDoubleMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleBytesMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleFixedInt32Message_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleFixedInt64Message_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleSFixedInt32Message_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_SimpleSFixedInt64Message_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_ComplexMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_RepeatedIntMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_RepeatedStringMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_RepeatedDoubleMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_RepeatedBytesMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_RepeatedFloatMessage_default_instance_),
+  reinterpret_cast<const ::google::protobuf::Message*>(&::qtprotobufnamespace::tests::_RepeatedComplexMessage_default_instance_),
+};
+
+void protobuf_AssignDescriptors() {
+  AddDescriptors();
+  AssignDescriptors(
+      "simpletest.proto", schemas, file_default_instances, TableStruct::offsets,
+      file_level_metadata, file_level_enum_descriptors, NULL);
+}
+
+void protobuf_AssignDescriptorsOnce() {
+  static ::google::protobuf::internal::once_flag once;
+  ::google::protobuf::internal::call_once(once, protobuf_AssignDescriptors);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 24);
+}
+
+void AddDescriptorsImpl() {
+  InitDefaults();
+  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+      "\n\020simpletest.proto\022\031qtprotobufnamespace."
+      "tests\"\226\002\n\021SimpleEnumMessage\022I\n\tlocalEnum"
+      "\030\001 \001(\01626.qtprotobufnamespace.tests.Simpl"
+      "eEnumMessage.LocalEnum\022M\n\rlocalEnumList\030"
+      "\002 \003(\01626.qtprotobufnamespace.tests.Simple"
+      "EnumMessage.LocalEnum\"g\n\tLocalEnum\022\025\n\021LO"
+      "CAL_ENUM_VALUE0\020\000\022\025\n\021LOCAL_ENUM_VALUE1\020\001"
+      "\022\025\n\021LOCAL_ENUM_VALUE2\020\002\022\025\n\021LOCAL_ENUM_VA"
+      "LUE3\020\003\"\215\001\n\025SimpleFileEnumMessage\0227\n\nglob"
+      "alEnum\030\001 \001(\0162#.qtprotobufnamespace.tests"
+      ".TestEnum\022;\n\016globalEnumList\030\002 \003(\0162#.qtpr"
+      "otobufnamespace.tests.TestEnum\"*\n\021Simple"
+      "BoolMessage\022\025\n\rtestFieldBool\030\001 \001(\010\"(\n\020Si"
+      "mpleIntMessage\022\024\n\014testFieldInt\030\001 \001(\005\")\n\021"
+      "SimpleSIntMessage\022\024\n\014testFieldInt\030\001 \001(\021\""
+      ")\n\021SimpleUIntMessage\022\024\n\014testFieldInt\030\001 \001"
+      "(\r\"*\n\022SimpleInt64Message\022\024\n\014testFieldInt"
+      "\030\001 \001(\003\"+\n\023SimpleSInt64Message\022\024\n\014testFie"
+      "ldInt\030\001 \001(\022\"+\n\023SimpleUInt64Message\022\024\n\014te"
+      "stFieldInt\030\001 \001(\004\".\n\023SimpleStringMessage\022"
+      "\027\n\017testFieldString\030\006 \001(\t\",\n\022SimpleFloatM"
+      "essage\022\026\n\016testFieldFloat\030\007 \001(\002\".\n\023Simple"
+      "DoubleMessage\022\027\n\017testFieldDouble\030\010 \001(\001\","
+      "\n\022SimpleBytesMessage\022\026\n\016testFieldBytes\030\001"
+      " \001(\014\"6\n\027SimpleFixedInt32Message\022\033\n\023testF"
+      "ieldFixedInt32\030\001 \001(\007\"6\n\027SimpleFixedInt64"
+      "Message\022\033\n\023testFieldFixedInt64\030\001 \001(\006\"7\n\030"
+      "SimpleSFixedInt32Message\022\033\n\023testFieldFix"
+      "edInt32\030\001 \001(\017\"7\n\030SimpleSFixedInt64Messag"
+      "e\022\033\n\023testFieldFixedInt64\030\001 \001(\020\"p\n\016Comple"
+      "xMessage\022\024\n\014testFieldInt\030\001 \001(\005\022H\n\020testCo"
+      "mplexField\030\002 \001(\0132..qtprotobufnamespace.t"
+      "ests.SimpleStringMessage\"-\n\022RepeatedIntM"
+      "essage\022\027\n\017testRepeatedInt\030\001 \003(\021\"3\n\025Repea"
+      "tedStringMessage\022\032\n\022testRepeatedString\030\001"
+      " \003(\t\"3\n\025RepeatedDoubleMessage\022\032\n\022testRep"
+      "eatedDouble\030\001 \003(\001\"1\n\024RepeatedBytesMessag"
+      "e\022\031\n\021testRepeatedBytes\030\001 \003(\014\"1\n\024Repeated"
+      "FloatMessage\022\031\n\021testRepeatedFloat\030\001 \003(\002\""
+      "`\n\026RepeatedComplexMessage\022F\n\023testRepeate"
+      "dComplex\030\001 \003(\0132).qtprotobufnamespace.tes"
+      "ts.ComplexMessage*x\n\010TestEnum\022\024\n\020TEST_EN"
+      "UM_VALUE0\020\000\022\024\n\020TEST_ENUM_VALUE1\020\001\022\024\n\020TES"
+      "T_ENUM_VALUE2\020\002\022\024\n\020TEST_ENUM_VALUE3\020\004\022\024\n"
+      "\020TEST_ENUM_VALUE4\020\003b\006proto3"
+  };
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+      descriptor, 1787);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "simpletest.proto", &protobuf_RegisterTypes);
+}
+
+void AddDescriptors() {
+  static ::google::protobuf::internal::once_flag once;
+  ::google::protobuf::internal::call_once(once, AddDescriptorsImpl);
+}
+// Force AddDescriptors() to be called at dynamic initialization time.
+struct StaticDescriptorInitializer {
+  StaticDescriptorInitializer() {
+    AddDescriptors();
+  }
+} static_descriptor_initializer;
+}  // namespace protobuf_simpletest_2eproto
+namespace qtprotobufnamespace {
+namespace tests {
+const ::google::protobuf::EnumDescriptor* SimpleEnumMessage_LocalEnum_descriptor() {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return protobuf_simpletest_2eproto::file_level_enum_descriptors[0];
+}
+bool SimpleEnumMessage_LocalEnum_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const SimpleEnumMessage_LocalEnum SimpleEnumMessage::LOCAL_ENUM_VALUE0;
+const SimpleEnumMessage_LocalEnum SimpleEnumMessage::LOCAL_ENUM_VALUE1;
+const SimpleEnumMessage_LocalEnum SimpleEnumMessage::LOCAL_ENUM_VALUE2;
+const SimpleEnumMessage_LocalEnum SimpleEnumMessage::LOCAL_ENUM_VALUE3;
+const SimpleEnumMessage_LocalEnum SimpleEnumMessage::LocalEnum_MIN;
+const SimpleEnumMessage_LocalEnum SimpleEnumMessage::LocalEnum_MAX;
+const int SimpleEnumMessage::LocalEnum_ARRAYSIZE;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+const ::google::protobuf::EnumDescriptor* TestEnum_descriptor() {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return protobuf_simpletest_2eproto::file_level_enum_descriptors[1];
+}
+bool TestEnum_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+void SimpleEnumMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleEnumMessage::kLocalEnumFieldNumber;
+const int SimpleEnumMessage::kLocalEnumListFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleEnumMessage::SimpleEnumMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleEnumMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleEnumMessage)
+}
+SimpleEnumMessage::SimpleEnumMessage(const SimpleEnumMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      localenumlist_(from.localenumlist_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  localenum_ = from.localenum_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleEnumMessage)
+}
+
+void SimpleEnumMessage::SharedCtor() {
+  localenum_ = 0;
+}
+
+SimpleEnumMessage::~SimpleEnumMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleEnumMessage)
+  SharedDtor();
+}
+
+void SimpleEnumMessage::SharedDtor() {
+}
+
+void SimpleEnumMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleEnumMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleEnumMessage& SimpleEnumMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleEnumMessage.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleEnumMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleEnumMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  localenumlist_.Clear();
+  localenum_ = 0;
+  _internal_metadata_.Clear();
+}
+
+bool SimpleEnumMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleEnumMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnum = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          set_localenum(static_cast< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum >(value));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // repeated .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnumList = 2;
+      case 2: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
+          ::google::protobuf::uint32 length;
+          DO_(input->ReadVarint32(&length));
+          ::google::protobuf::io::CodedInputStream::Limit limit = input->PushLimit(static_cast<int>(length));
+          while (input->BytesUntilLimit() > 0) {
+            int value;
+            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+            add_localenumlist(static_cast< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum >(value));
+          }
+          input->PopLimit(limit);
+        } else if (
+            static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          add_localenumlist(static_cast< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum >(value));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleEnumMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleEnumMessage)
+  return false;
+#undef DO_
+}
+
+void SimpleEnumMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleEnumMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnum = 1;
+  if (this->localenum() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->localenum(), output);
+  }
+
+  // repeated .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnumList = 2;
+  if (this->localenumlist_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(
+      2,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      output);
+    output->WriteVarint32(
+        static_cast< ::google::protobuf::uint32>(_localenumlist_cached_byte_size_));
+  }
+  for (int i = 0, n = this->localenumlist_size(); i < n; i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnumNoTag(
+      this->localenumlist(i), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleEnumMessage)
+}
+
+::google::protobuf::uint8* SimpleEnumMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleEnumMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnum = 1;
+  if (this->localenum() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->localenum(), target);
+  }
+
+  // repeated .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnumList = 2;
+  if (this->localenumlist_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      2,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(      static_cast< ::google::protobuf::uint32>(
+            _localenumlist_cached_byte_size_), target);
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumNoTagToArray(
+      this->localenumlist_, target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleEnumMessage)
+  return target;
+}
+
+size_t SimpleEnumMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleEnumMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // repeated .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnumList = 2;
+  {
+    size_t data_size = 0;
+    unsigned int count = static_cast<unsigned int>(this->localenumlist_size());for (unsigned int i = 0; i < count; i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
+        this->localenumlist(static_cast<int>(i)));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+            static_cast< ::google::protobuf::int32>(data_size));
+    }
+    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _localenumlist_cached_byte_size_ = cached_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnum = 1;
+  if (this->localenum() != 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::EnumSize(this->localenum());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleEnumMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleEnumMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleEnumMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleEnumMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleEnumMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleEnumMessage)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleEnumMessage::MergeFrom(const SimpleEnumMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleEnumMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  localenumlist_.MergeFrom(from.localenumlist_);
+  if (from.localenum() != 0) {
+    set_localenum(from.localenum());
+  }
+}
+
+void SimpleEnumMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleEnumMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleEnumMessage::CopyFrom(const SimpleEnumMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleEnumMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleEnumMessage::IsInitialized() const {
+  return true;
+}
+
+void SimpleEnumMessage::Swap(SimpleEnumMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleEnumMessage::InternalSwap(SimpleEnumMessage* other) {
+  using std::swap;
+  localenumlist_.InternalSwap(&other->localenumlist_);
+  swap(localenum_, other->localenum_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleEnumMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleFileEnumMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleFileEnumMessage::kGlobalEnumFieldNumber;
+const int SimpleFileEnumMessage::kGlobalEnumListFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleFileEnumMessage::SimpleFileEnumMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleFileEnumMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+}
+SimpleFileEnumMessage::SimpleFileEnumMessage(const SimpleFileEnumMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      globalenumlist_(from.globalenumlist_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  globalenum_ = from.globalenum_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+}
+
+void SimpleFileEnumMessage::SharedCtor() {
+  globalenum_ = 0;
+}
+
+SimpleFileEnumMessage::~SimpleFileEnumMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  SharedDtor();
+}
+
+void SimpleFileEnumMessage::SharedDtor() {
+}
+
+void SimpleFileEnumMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleFileEnumMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleFileEnumMessage& SimpleFileEnumMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleFileEnumMessage.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleFileEnumMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  globalenumlist_.Clear();
+  globalenum_ = 0;
+  _internal_metadata_.Clear();
+}
+
+bool SimpleFileEnumMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .qtprotobufnamespace.tests.TestEnum globalEnum = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          set_globalenum(static_cast< ::qtprotobufnamespace::tests::TestEnum >(value));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // repeated .qtprotobufnamespace.tests.TestEnum globalEnumList = 2;
+      case 2: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
+          ::google::protobuf::uint32 length;
+          DO_(input->ReadVarint32(&length));
+          ::google::protobuf::io::CodedInputStream::Limit limit = input->PushLimit(static_cast<int>(length));
+          while (input->BytesUntilLimit() > 0) {
+            int value;
+            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+            add_globalenumlist(static_cast< ::qtprotobufnamespace::tests::TestEnum >(value));
+          }
+          input->PopLimit(limit);
+        } else if (
+            static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          add_globalenumlist(static_cast< ::qtprotobufnamespace::tests::TestEnum >(value));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  return false;
+#undef DO_
+}
+
+void SimpleFileEnumMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .qtprotobufnamespace.tests.TestEnum globalEnum = 1;
+  if (this->globalenum() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->globalenum(), output);
+  }
+
+  // repeated .qtprotobufnamespace.tests.TestEnum globalEnumList = 2;
+  if (this->globalenumlist_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(
+      2,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      output);
+    output->WriteVarint32(
+        static_cast< ::google::protobuf::uint32>(_globalenumlist_cached_byte_size_));
+  }
+  for (int i = 0, n = this->globalenumlist_size(); i < n; i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnumNoTag(
+      this->globalenumlist(i), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+}
+
+::google::protobuf::uint8* SimpleFileEnumMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .qtprotobufnamespace.tests.TestEnum globalEnum = 1;
+  if (this->globalenum() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->globalenum(), target);
+  }
+
+  // repeated .qtprotobufnamespace.tests.TestEnum globalEnumList = 2;
+  if (this->globalenumlist_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      2,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(      static_cast< ::google::protobuf::uint32>(
+            _globalenumlist_cached_byte_size_), target);
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumNoTagToArray(
+      this->globalenumlist_, target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  return target;
+}
+
+size_t SimpleFileEnumMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // repeated .qtprotobufnamespace.tests.TestEnum globalEnumList = 2;
+  {
+    size_t data_size = 0;
+    unsigned int count = static_cast<unsigned int>(this->globalenumlist_size());for (unsigned int i = 0; i < count; i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
+        this->globalenumlist(static_cast<int>(i)));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+            static_cast< ::google::protobuf::int32>(data_size));
+    }
+    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _globalenumlist_cached_byte_size_ = cached_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // .qtprotobufnamespace.tests.TestEnum globalEnum = 1;
+  if (this->globalenum() != 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::EnumSize(this->globalenum());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleFileEnumMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleFileEnumMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleFileEnumMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleFileEnumMessage::MergeFrom(const SimpleFileEnumMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  globalenumlist_.MergeFrom(from.globalenumlist_);
+  if (from.globalenum() != 0) {
+    set_globalenum(from.globalenum());
+  }
+}
+
+void SimpleFileEnumMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleFileEnumMessage::CopyFrom(const SimpleFileEnumMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleFileEnumMessage::IsInitialized() const {
+  return true;
+}
+
+void SimpleFileEnumMessage::Swap(SimpleFileEnumMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleFileEnumMessage::InternalSwap(SimpleFileEnumMessage* other) {
+  using std::swap;
+  globalenumlist_.InternalSwap(&other->globalenumlist_);
+  swap(globalenum_, other->globalenum_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleFileEnumMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleBoolMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleBoolMessage::kTestFieldBoolFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleBoolMessage::SimpleBoolMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleBoolMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleBoolMessage)
+}
+SimpleBoolMessage::SimpleBoolMessage(const SimpleBoolMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldbool_ = from.testfieldbool_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleBoolMessage)
+}
+
+void SimpleBoolMessage::SharedCtor() {
+  testfieldbool_ = false;
+}
+
+SimpleBoolMessage::~SimpleBoolMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleBoolMessage)
+  SharedDtor();
+}
+
+void SimpleBoolMessage::SharedDtor() {
+}
+
+void SimpleBoolMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleBoolMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleBoolMessage& SimpleBoolMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleBoolMessage.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleBoolMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleBoolMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldbool_ = false;
+  _internal_metadata_.Clear();
+}
+
+bool SimpleBoolMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleBoolMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // bool testFieldBool = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &testfieldbool_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleBoolMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleBoolMessage)
+  return false;
+#undef DO_
+}
+
+void SimpleBoolMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleBoolMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bool testFieldBool = 1;
+  if (this->testfieldbool() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->testfieldbool(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleBoolMessage)
+}
+
+::google::protobuf::uint8* SimpleBoolMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleBoolMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bool testFieldBool = 1;
+  if (this->testfieldbool() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->testfieldbool(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleBoolMessage)
+  return target;
+}
+
+size_t SimpleBoolMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleBoolMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // bool testFieldBool = 1;
+  if (this->testfieldbool() != 0) {
+    total_size += 1 + 1;
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleBoolMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleBoolMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleBoolMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleBoolMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleBoolMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleBoolMessage)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleBoolMessage::MergeFrom(const SimpleBoolMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleBoolMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldbool() != 0) {
+    set_testfieldbool(from.testfieldbool());
+  }
+}
+
+void SimpleBoolMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleBoolMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleBoolMessage::CopyFrom(const SimpleBoolMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleBoolMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleBoolMessage::IsInitialized() const {
+  return true;
+}
+
+void SimpleBoolMessage::Swap(SimpleBoolMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleBoolMessage::InternalSwap(SimpleBoolMessage* other) {
+  using std::swap;
+  swap(testfieldbool_, other->testfieldbool_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleBoolMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleIntMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleIntMessage::kTestFieldIntFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleIntMessage::SimpleIntMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleIntMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleIntMessage)
+}
+SimpleIntMessage::SimpleIntMessage(const SimpleIntMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldint_ = from.testfieldint_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleIntMessage)
+}
+
+void SimpleIntMessage::SharedCtor() {
+  testfieldint_ = 0;
+}
+
+SimpleIntMessage::~SimpleIntMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleIntMessage)
+  SharedDtor();
+}
+
+void SimpleIntMessage::SharedDtor() {
+}
+
+void SimpleIntMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleIntMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleIntMessage& SimpleIntMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleIntMessage.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleIntMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldint_ = 0;
+  _internal_metadata_.Clear();
+}
+
+bool SimpleIntMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleIntMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // int32 testFieldInt = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &testfieldint_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleIntMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleIntMessage)
+  return false;
+#undef DO_
+}
+
+void SimpleIntMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->testfieldint(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleIntMessage)
+}
+
+::google::protobuf::uint8* SimpleIntMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->testfieldint(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleIntMessage)
+  return target;
+}
+
+size_t SimpleIntMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleIntMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // int32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->testfieldint());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleIntMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleIntMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleIntMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleIntMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleIntMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleIntMessage)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleIntMessage::MergeFrom(const SimpleIntMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleIntMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldint() != 0) {
+    set_testfieldint(from.testfieldint());
+  }
+}
+
+void SimpleIntMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleIntMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleIntMessage::CopyFrom(const SimpleIntMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleIntMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleIntMessage::IsInitialized() const {
+  return true;
+}
+
+void SimpleIntMessage::Swap(SimpleIntMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleIntMessage::InternalSwap(SimpleIntMessage* other) {
+  using std::swap;
+  swap(testfieldint_, other->testfieldint_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleIntMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleSIntMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleSIntMessage::kTestFieldIntFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleSIntMessage::SimpleSIntMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleSIntMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleSIntMessage)
+}
+SimpleSIntMessage::SimpleSIntMessage(const SimpleSIntMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldint_ = from.testfieldint_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleSIntMessage)
+}
+
+void SimpleSIntMessage::SharedCtor() {
+  testfieldint_ = 0;
+}
+
+SimpleSIntMessage::~SimpleSIntMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleSIntMessage)
+  SharedDtor();
+}
+
+void SimpleSIntMessage::SharedDtor() {
+}
+
+void SimpleSIntMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleSIntMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleSIntMessage& SimpleSIntMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleSIntMessage.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleSIntMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleSIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldint_ = 0;
+  _internal_metadata_.Clear();
+}
+
+bool SimpleSIntMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleSIntMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // sint32 testFieldInt = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
+                 input, &testfieldint_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleSIntMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleSIntMessage)
+  return false;
+#undef DO_
+}
+
+void SimpleSIntMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleSIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // sint32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteSInt32(1, this->testfieldint(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleSIntMessage)
+}
+
+::google::protobuf::uint8* SimpleSIntMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleSIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // sint32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(1, this->testfieldint(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleSIntMessage)
+  return target;
+}
+
+size_t SimpleSIntMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleSIntMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // sint32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::SInt32Size(
+        this->testfieldint());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleSIntMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleSIntMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleSIntMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleSIntMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleSIntMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleSIntMessage)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleSIntMessage::MergeFrom(const SimpleSIntMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleSIntMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldint() != 0) {
+    set_testfieldint(from.testfieldint());
+  }
+}
+
+void SimpleSIntMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleSIntMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleSIntMessage::CopyFrom(const SimpleSIntMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleSIntMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleSIntMessage::IsInitialized() const {
+  return true;
+}
+
+void SimpleSIntMessage::Swap(SimpleSIntMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleSIntMessage::InternalSwap(SimpleSIntMessage* other) {
+  using std::swap;
+  swap(testfieldint_, other->testfieldint_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleSIntMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleUIntMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleUIntMessage::kTestFieldIntFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleUIntMessage::SimpleUIntMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleUIntMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleUIntMessage)
+}
+SimpleUIntMessage::SimpleUIntMessage(const SimpleUIntMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldint_ = from.testfieldint_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleUIntMessage)
+}
+
+void SimpleUIntMessage::SharedCtor() {
+  testfieldint_ = 0u;
+}
+
+SimpleUIntMessage::~SimpleUIntMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleUIntMessage)
+  SharedDtor();
+}
+
+void SimpleUIntMessage::SharedDtor() {
+}
+
+void SimpleUIntMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleUIntMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleUIntMessage& SimpleUIntMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleUIntMessage.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleUIntMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleUIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldint_ = 0u;
+  _internal_metadata_.Clear();
+}
+
+bool SimpleUIntMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleUIntMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // uint32 testFieldInt = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &testfieldint_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleUIntMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleUIntMessage)
+  return false;
+#undef DO_
+}
+
+void SimpleUIntMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleUIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->testfieldint(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleUIntMessage)
+}
+
+::google::protobuf::uint8* SimpleUIntMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleUIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->testfieldint(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleUIntMessage)
+  return target;
+}
+
+size_t SimpleUIntMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleUIntMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // uint32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::UInt32Size(
+        this->testfieldint());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleUIntMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleUIntMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleUIntMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleUIntMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleUIntMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleUIntMessage)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleUIntMessage::MergeFrom(const SimpleUIntMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleUIntMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldint() != 0) {
+    set_testfieldint(from.testfieldint());
+  }
+}
+
+void SimpleUIntMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleUIntMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleUIntMessage::CopyFrom(const SimpleUIntMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleUIntMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleUIntMessage::IsInitialized() const {
+  return true;
+}
+
+void SimpleUIntMessage::Swap(SimpleUIntMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleUIntMessage::InternalSwap(SimpleUIntMessage* other) {
+  using std::swap;
+  swap(testfieldint_, other->testfieldint_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleUIntMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleInt64Message::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleInt64Message::kTestFieldIntFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleInt64Message::SimpleInt64Message()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleInt64Message.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleInt64Message)
+}
+SimpleInt64Message::SimpleInt64Message(const SimpleInt64Message& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldint_ = from.testfieldint_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleInt64Message)
+}
+
+void SimpleInt64Message::SharedCtor() {
+  testfieldint_ = GOOGLE_LONGLONG(0);
+}
+
+SimpleInt64Message::~SimpleInt64Message() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleInt64Message)
+  SharedDtor();
+}
+
+void SimpleInt64Message::SharedDtor() {
+}
+
+void SimpleInt64Message::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleInt64Message::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleInt64Message& SimpleInt64Message::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleInt64Message.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleInt64Message::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldint_ = GOOGLE_LONGLONG(0);
+  _internal_metadata_.Clear();
+}
+
+bool SimpleInt64Message::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleInt64Message)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // int64 testFieldInt = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &testfieldint_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleInt64Message)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleInt64Message)
+  return false;
+#undef DO_
+}
+
+void SimpleInt64Message::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int64 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->testfieldint(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleInt64Message)
+}
+
+::google::protobuf::uint8* SimpleInt64Message::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int64 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->testfieldint(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleInt64Message)
+  return target;
+}
+
+size_t SimpleInt64Message::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleInt64Message)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // int64 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int64Size(
+        this->testfieldint());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleInt64Message::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleInt64Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleInt64Message* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleInt64Message>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleInt64Message)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleInt64Message)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleInt64Message::MergeFrom(const SimpleInt64Message& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleInt64Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldint() != 0) {
+    set_testfieldint(from.testfieldint());
+  }
+}
+
+void SimpleInt64Message::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleInt64Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleInt64Message::CopyFrom(const SimpleInt64Message& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleInt64Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleInt64Message::IsInitialized() const {
+  return true;
+}
+
+void SimpleInt64Message::Swap(SimpleInt64Message* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleInt64Message::InternalSwap(SimpleInt64Message* other) {
+  using std::swap;
+  swap(testfieldint_, other->testfieldint_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleInt64Message::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleSInt64Message::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleSInt64Message::kTestFieldIntFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleSInt64Message::SimpleSInt64Message()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleSInt64Message.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleSInt64Message)
+}
+SimpleSInt64Message::SimpleSInt64Message(const SimpleSInt64Message& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldint_ = from.testfieldint_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleSInt64Message)
+}
+
+void SimpleSInt64Message::SharedCtor() {
+  testfieldint_ = GOOGLE_LONGLONG(0);
+}
+
+SimpleSInt64Message::~SimpleSInt64Message() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleSInt64Message)
+  SharedDtor();
+}
+
+void SimpleSInt64Message::SharedDtor() {
+}
+
+void SimpleSInt64Message::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleSInt64Message::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleSInt64Message& SimpleSInt64Message::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleSInt64Message.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleSInt64Message::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleSInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldint_ = GOOGLE_LONGLONG(0);
+  _internal_metadata_.Clear();
+}
+
+bool SimpleSInt64Message::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleSInt64Message)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // sint64 testFieldInt = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
+                 input, &testfieldint_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleSInt64Message)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleSInt64Message)
+  return false;
+#undef DO_
+}
+
+void SimpleSInt64Message::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleSInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // sint64 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteSInt64(1, this->testfieldint(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleSInt64Message)
+}
+
+::google::protobuf::uint8* SimpleSInt64Message::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleSInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // sint64 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteSInt64ToArray(1, this->testfieldint(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleSInt64Message)
+  return target;
+}
+
+size_t SimpleSInt64Message::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleSInt64Message)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // sint64 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::SInt64Size(
+        this->testfieldint());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleSInt64Message::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleSInt64Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleSInt64Message* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleSInt64Message>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleSInt64Message)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleSInt64Message)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleSInt64Message::MergeFrom(const SimpleSInt64Message& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleSInt64Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldint() != 0) {
+    set_testfieldint(from.testfieldint());
+  }
+}
+
+void SimpleSInt64Message::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleSInt64Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleSInt64Message::CopyFrom(const SimpleSInt64Message& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleSInt64Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleSInt64Message::IsInitialized() const {
+  return true;
+}
+
+void SimpleSInt64Message::Swap(SimpleSInt64Message* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleSInt64Message::InternalSwap(SimpleSInt64Message* other) {
+  using std::swap;
+  swap(testfieldint_, other->testfieldint_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleSInt64Message::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleUInt64Message::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleUInt64Message::kTestFieldIntFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleUInt64Message::SimpleUInt64Message()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleUInt64Message.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleUInt64Message)
+}
+SimpleUInt64Message::SimpleUInt64Message(const SimpleUInt64Message& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldint_ = from.testfieldint_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleUInt64Message)
+}
+
+void SimpleUInt64Message::SharedCtor() {
+  testfieldint_ = GOOGLE_ULONGLONG(0);
+}
+
+SimpleUInt64Message::~SimpleUInt64Message() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleUInt64Message)
+  SharedDtor();
+}
+
+void SimpleUInt64Message::SharedDtor() {
+}
+
+void SimpleUInt64Message::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleUInt64Message::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleUInt64Message& SimpleUInt64Message::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleUInt64Message.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleUInt64Message::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleUInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldint_ = GOOGLE_ULONGLONG(0);
+  _internal_metadata_.Clear();
+}
+
+bool SimpleUInt64Message::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleUInt64Message)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // uint64 testFieldInt = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &testfieldint_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleUInt64Message)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleUInt64Message)
+  return false;
+#undef DO_
+}
+
+void SimpleUInt64Message::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleUInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint64 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->testfieldint(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleUInt64Message)
+}
+
+::google::protobuf::uint8* SimpleUInt64Message::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleUInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint64 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->testfieldint(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleUInt64Message)
+  return target;
+}
+
+size_t SimpleUInt64Message::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleUInt64Message)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // uint64 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::UInt64Size(
+        this->testfieldint());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleUInt64Message::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleUInt64Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleUInt64Message* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleUInt64Message>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleUInt64Message)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleUInt64Message)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleUInt64Message::MergeFrom(const SimpleUInt64Message& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleUInt64Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldint() != 0) {
+    set_testfieldint(from.testfieldint());
+  }
+}
+
+void SimpleUInt64Message::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleUInt64Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleUInt64Message::CopyFrom(const SimpleUInt64Message& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleUInt64Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleUInt64Message::IsInitialized() const {
+  return true;
+}
+
+void SimpleUInt64Message::Swap(SimpleUInt64Message* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleUInt64Message::InternalSwap(SimpleUInt64Message* other) {
+  using std::swap;
+  swap(testfieldint_, other->testfieldint_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleUInt64Message::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleStringMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleStringMessage::kTestFieldStringFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleStringMessage::SimpleStringMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleStringMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleStringMessage)
+}
+SimpleStringMessage::SimpleStringMessage(const SimpleStringMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldstring_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  if (from.testfieldstring().size() > 0) {
+    testfieldstring_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.testfieldstring_);
+  }
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleStringMessage)
+}
+
+void SimpleStringMessage::SharedCtor() {
+  testfieldstring_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+
+SimpleStringMessage::~SimpleStringMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleStringMessage)
+  SharedDtor();
+}
+
+void SimpleStringMessage::SharedDtor() {
+  testfieldstring_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+
+void SimpleStringMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleStringMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleStringMessage& SimpleStringMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleStringMessage.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleStringMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleStringMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldstring_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  _internal_metadata_.Clear();
+}
+
+bool SimpleStringMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleStringMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // string testFieldString = 6;
+      case 6: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_testfieldstring()));
+          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
+            this->testfieldstring().data(), static_cast<int>(this->testfieldstring().length()),
+            ::google::protobuf::internal::WireFormatLite::PARSE,
+            "qtprotobufnamespace.tests.SimpleStringMessage.testFieldString"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleStringMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleStringMessage)
+  return false;
+#undef DO_
+}
+
+void SimpleStringMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleStringMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string testFieldString = 6;
+  if (this->testfieldstring().size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
+      this->testfieldstring().data(), static_cast<int>(this->testfieldstring().length()),
+      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
+      "qtprotobufnamespace.tests.SimpleStringMessage.testFieldString");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      6, this->testfieldstring(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleStringMessage)
+}
+
+::google::protobuf::uint8* SimpleStringMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleStringMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string testFieldString = 6;
+  if (this->testfieldstring().size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
+      this->testfieldstring().data(), static_cast<int>(this->testfieldstring().length()),
+      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
+      "qtprotobufnamespace.tests.SimpleStringMessage.testFieldString");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        6, this->testfieldstring(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleStringMessage)
+  return target;
+}
+
+size_t SimpleStringMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleStringMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // string testFieldString = 6;
+  if (this->testfieldstring().size() > 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::StringSize(
+        this->testfieldstring());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleStringMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleStringMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleStringMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleStringMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleStringMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleStringMessage)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleStringMessage::MergeFrom(const SimpleStringMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleStringMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldstring().size() > 0) {
+
+    testfieldstring_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.testfieldstring_);
+  }
+}
+
+void SimpleStringMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleStringMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleStringMessage::CopyFrom(const SimpleStringMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleStringMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleStringMessage::IsInitialized() const {
+  return true;
+}
+
+void SimpleStringMessage::Swap(SimpleStringMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleStringMessage::InternalSwap(SimpleStringMessage* other) {
+  using std::swap;
+  testfieldstring_.Swap(&other->testfieldstring_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleStringMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleFloatMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleFloatMessage::kTestFieldFloatFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleFloatMessage::SimpleFloatMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleFloatMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleFloatMessage)
+}
+SimpleFloatMessage::SimpleFloatMessage(const SimpleFloatMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldfloat_ = from.testfieldfloat_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleFloatMessage)
+}
+
+void SimpleFloatMessage::SharedCtor() {
+  testfieldfloat_ = 0;
+}
+
+SimpleFloatMessage::~SimpleFloatMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleFloatMessage)
+  SharedDtor();
+}
+
+void SimpleFloatMessage::SharedDtor() {
+}
+
+void SimpleFloatMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleFloatMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleFloatMessage& SimpleFloatMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleFloatMessage.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleFloatMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleFloatMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldfloat_ = 0;
+  _internal_metadata_.Clear();
+}
+
+bool SimpleFloatMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleFloatMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // float testFieldFloat = 7;
+      case 7: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(61u /* 61 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &testfieldfloat_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleFloatMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleFloatMessage)
+  return false;
+#undef DO_
+}
+
+void SimpleFloatMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleFloatMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // float testFieldFloat = 7;
+  if (this->testfieldfloat() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->testfieldfloat(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleFloatMessage)
+}
+
+::google::protobuf::uint8* SimpleFloatMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleFloatMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // float testFieldFloat = 7;
+  if (this->testfieldfloat() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->testfieldfloat(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleFloatMessage)
+  return target;
+}
+
+size_t SimpleFloatMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleFloatMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // float testFieldFloat = 7;
+  if (this->testfieldfloat() != 0) {
+    total_size += 1 + 4;
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleFloatMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleFloatMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleFloatMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleFloatMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleFloatMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleFloatMessage)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleFloatMessage::MergeFrom(const SimpleFloatMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleFloatMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldfloat() != 0) {
+    set_testfieldfloat(from.testfieldfloat());
+  }
+}
+
+void SimpleFloatMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleFloatMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleFloatMessage::CopyFrom(const SimpleFloatMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleFloatMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleFloatMessage::IsInitialized() const {
+  return true;
+}
+
+void SimpleFloatMessage::Swap(SimpleFloatMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleFloatMessage::InternalSwap(SimpleFloatMessage* other) {
+  using std::swap;
+  swap(testfieldfloat_, other->testfieldfloat_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleFloatMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleDoubleMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleDoubleMessage::kTestFieldDoubleFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleDoubleMessage::SimpleDoubleMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleDoubleMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleDoubleMessage)
+}
+SimpleDoubleMessage::SimpleDoubleMessage(const SimpleDoubleMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfielddouble_ = from.testfielddouble_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleDoubleMessage)
+}
+
+void SimpleDoubleMessage::SharedCtor() {
+  testfielddouble_ = 0;
+}
+
+SimpleDoubleMessage::~SimpleDoubleMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  SharedDtor();
+}
+
+void SimpleDoubleMessage::SharedDtor() {
+}
+
+void SimpleDoubleMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleDoubleMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleDoubleMessage& SimpleDoubleMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleDoubleMessage.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleDoubleMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfielddouble_ = 0;
+  _internal_metadata_.Clear();
+}
+
+bool SimpleDoubleMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // double testFieldDouble = 8;
+      case 8: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(65u /* 65 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &testfielddouble_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  return false;
+#undef DO_
+}
+
+void SimpleDoubleMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // double testFieldDouble = 8;
+  if (this->testfielddouble() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(8, this->testfielddouble(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleDoubleMessage)
+}
+
+::google::protobuf::uint8* SimpleDoubleMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // double testFieldDouble = 8;
+  if (this->testfielddouble() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(8, this->testfielddouble(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  return target;
+}
+
+size_t SimpleDoubleMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // double testFieldDouble = 8;
+  if (this->testfielddouble() != 0) {
+    total_size += 1 + 8;
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleDoubleMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleDoubleMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleDoubleMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleDoubleMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleDoubleMessage)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleDoubleMessage::MergeFrom(const SimpleDoubleMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfielddouble() != 0) {
+    set_testfielddouble(from.testfielddouble());
+  }
+}
+
+void SimpleDoubleMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleDoubleMessage::CopyFrom(const SimpleDoubleMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleDoubleMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleDoubleMessage::IsInitialized() const {
+  return true;
+}
+
+void SimpleDoubleMessage::Swap(SimpleDoubleMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleDoubleMessage::InternalSwap(SimpleDoubleMessage* other) {
+  using std::swap;
+  swap(testfielddouble_, other->testfielddouble_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleDoubleMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleBytesMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleBytesMessage::kTestFieldBytesFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleBytesMessage::SimpleBytesMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleBytesMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleBytesMessage)
+}
+SimpleBytesMessage::SimpleBytesMessage(const SimpleBytesMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldbytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  if (from.testfieldbytes().size() > 0) {
+    testfieldbytes_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.testfieldbytes_);
+  }
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleBytesMessage)
+}
+
+void SimpleBytesMessage::SharedCtor() {
+  testfieldbytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+
+SimpleBytesMessage::~SimpleBytesMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleBytesMessage)
+  SharedDtor();
+}
+
+void SimpleBytesMessage::SharedDtor() {
+  testfieldbytes_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+
+void SimpleBytesMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleBytesMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleBytesMessage& SimpleBytesMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleBytesMessage.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleBytesMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleBytesMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldbytes_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  _internal_metadata_.Clear();
+}
+
+bool SimpleBytesMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleBytesMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // bytes testFieldBytes = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_testfieldbytes()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleBytesMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleBytesMessage)
+  return false;
+#undef DO_
+}
+
+void SimpleBytesMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleBytesMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes testFieldBytes = 1;
+  if (this->testfieldbytes().size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->testfieldbytes(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleBytesMessage)
+}
+
+::google::protobuf::uint8* SimpleBytesMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleBytesMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes testFieldBytes = 1;
+  if (this->testfieldbytes().size() > 0) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        1, this->testfieldbytes(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleBytesMessage)
+  return target;
+}
+
+size_t SimpleBytesMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleBytesMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // bytes testFieldBytes = 1;
+  if (this->testfieldbytes().size() > 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::BytesSize(
+        this->testfieldbytes());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleBytesMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleBytesMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleBytesMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleBytesMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleBytesMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleBytesMessage)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleBytesMessage::MergeFrom(const SimpleBytesMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleBytesMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldbytes().size() > 0) {
+
+    testfieldbytes_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.testfieldbytes_);
+  }
+}
+
+void SimpleBytesMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleBytesMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleBytesMessage::CopyFrom(const SimpleBytesMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleBytesMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleBytesMessage::IsInitialized() const {
+  return true;
+}
+
+void SimpleBytesMessage::Swap(SimpleBytesMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleBytesMessage::InternalSwap(SimpleBytesMessage* other) {
+  using std::swap;
+  testfieldbytes_.Swap(&other->testfieldbytes_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleBytesMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleFixedInt32Message::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleFixedInt32Message::kTestFieldFixedInt32FieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleFixedInt32Message::SimpleFixedInt32Message()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleFixedInt32Message.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+}
+SimpleFixedInt32Message::SimpleFixedInt32Message(const SimpleFixedInt32Message& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldfixedint32_ = from.testfieldfixedint32_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+}
+
+void SimpleFixedInt32Message::SharedCtor() {
+  testfieldfixedint32_ = 0u;
+}
+
+SimpleFixedInt32Message::~SimpleFixedInt32Message() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  SharedDtor();
+}
+
+void SimpleFixedInt32Message::SharedDtor() {
+}
+
+void SimpleFixedInt32Message::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleFixedInt32Message::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleFixedInt32Message& SimpleFixedInt32Message::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleFixedInt32Message.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleFixedInt32Message::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldfixedint32_ = 0u;
+  _internal_metadata_.Clear();
+}
+
+bool SimpleFixedInt32Message::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // fixed32 testFieldFixedInt32 = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &testfieldfixedint32_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  return false;
+#undef DO_
+}
+
+void SimpleFixedInt32Message::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // fixed32 testFieldFixedInt32 = 1;
+  if (this->testfieldfixedint32() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->testfieldfixedint32(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+}
+
+::google::protobuf::uint8* SimpleFixedInt32Message::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // fixed32 testFieldFixedInt32 = 1;
+  if (this->testfieldfixedint32() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->testfieldfixedint32(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  return target;
+}
+
+size_t SimpleFixedInt32Message::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // fixed32 testFieldFixedInt32 = 1;
+  if (this->testfieldfixedint32() != 0) {
+    total_size += 1 + 4;
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleFixedInt32Message::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleFixedInt32Message* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleFixedInt32Message>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleFixedInt32Message::MergeFrom(const SimpleFixedInt32Message& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldfixedint32() != 0) {
+    set_testfieldfixedint32(from.testfieldfixedint32());
+  }
+}
+
+void SimpleFixedInt32Message::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleFixedInt32Message::CopyFrom(const SimpleFixedInt32Message& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleFixedInt32Message::IsInitialized() const {
+  return true;
+}
+
+void SimpleFixedInt32Message::Swap(SimpleFixedInt32Message* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleFixedInt32Message::InternalSwap(SimpleFixedInt32Message* other) {
+  using std::swap;
+  swap(testfieldfixedint32_, other->testfieldfixedint32_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleFixedInt32Message::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleFixedInt64Message::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleFixedInt64Message::kTestFieldFixedInt64FieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleFixedInt64Message::SimpleFixedInt64Message()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleFixedInt64Message.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+}
+SimpleFixedInt64Message::SimpleFixedInt64Message(const SimpleFixedInt64Message& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldfixedint64_ = from.testfieldfixedint64_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+}
+
+void SimpleFixedInt64Message::SharedCtor() {
+  testfieldfixedint64_ = GOOGLE_ULONGLONG(0);
+}
+
+SimpleFixedInt64Message::~SimpleFixedInt64Message() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  SharedDtor();
+}
+
+void SimpleFixedInt64Message::SharedDtor() {
+}
+
+void SimpleFixedInt64Message::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleFixedInt64Message::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleFixedInt64Message& SimpleFixedInt64Message::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleFixedInt64Message.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleFixedInt64Message::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldfixedint64_ = GOOGLE_ULONGLONG(0);
+  _internal_metadata_.Clear();
+}
+
+bool SimpleFixedInt64Message::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // fixed64 testFieldFixedInt64 = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(9u /* 9 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &testfieldfixedint64_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  return false;
+#undef DO_
+}
+
+void SimpleFixedInt64Message::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // fixed64 testFieldFixedInt64 = 1;
+  if (this->testfieldfixedint64() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->testfieldfixedint64(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+}
+
+::google::protobuf::uint8* SimpleFixedInt64Message::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // fixed64 testFieldFixedInt64 = 1;
+  if (this->testfieldfixedint64() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->testfieldfixedint64(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  return target;
+}
+
+size_t SimpleFixedInt64Message::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // fixed64 testFieldFixedInt64 = 1;
+  if (this->testfieldfixedint64() != 0) {
+    total_size += 1 + 8;
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleFixedInt64Message::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleFixedInt64Message* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleFixedInt64Message>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleFixedInt64Message::MergeFrom(const SimpleFixedInt64Message& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldfixedint64() != 0) {
+    set_testfieldfixedint64(from.testfieldfixedint64());
+  }
+}
+
+void SimpleFixedInt64Message::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleFixedInt64Message::CopyFrom(const SimpleFixedInt64Message& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleFixedInt64Message::IsInitialized() const {
+  return true;
+}
+
+void SimpleFixedInt64Message::Swap(SimpleFixedInt64Message* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleFixedInt64Message::InternalSwap(SimpleFixedInt64Message* other) {
+  using std::swap;
+  swap(testfieldfixedint64_, other->testfieldfixedint64_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleFixedInt64Message::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleSFixedInt32Message::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleSFixedInt32Message::kTestFieldFixedInt32FieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleSFixedInt32Message::SimpleSFixedInt32Message()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleSFixedInt32Message.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+}
+SimpleSFixedInt32Message::SimpleSFixedInt32Message(const SimpleSFixedInt32Message& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldfixedint32_ = from.testfieldfixedint32_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+}
+
+void SimpleSFixedInt32Message::SharedCtor() {
+  testfieldfixedint32_ = 0;
+}
+
+SimpleSFixedInt32Message::~SimpleSFixedInt32Message() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  SharedDtor();
+}
+
+void SimpleSFixedInt32Message::SharedDtor() {
+}
+
+void SimpleSFixedInt32Message::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleSFixedInt32Message::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleSFixedInt32Message& SimpleSFixedInt32Message::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleSFixedInt32Message.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleSFixedInt32Message::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldfixedint32_ = 0;
+  _internal_metadata_.Clear();
+}
+
+bool SimpleSFixedInt32Message::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // sfixed32 testFieldFixedInt32 = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SFIXED32>(
+                 input, &testfieldfixedint32_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  return false;
+#undef DO_
+}
+
+void SimpleSFixedInt32Message::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // sfixed32 testFieldFixedInt32 = 1;
+  if (this->testfieldfixedint32() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteSFixed32(1, this->testfieldfixedint32(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+}
+
+::google::protobuf::uint8* SimpleSFixedInt32Message::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // sfixed32 testFieldFixedInt32 = 1;
+  if (this->testfieldfixedint32() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteSFixed32ToArray(1, this->testfieldfixedint32(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  return target;
+}
+
+size_t SimpleSFixedInt32Message::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // sfixed32 testFieldFixedInt32 = 1;
+  if (this->testfieldfixedint32() != 0) {
+    total_size += 1 + 4;
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleSFixedInt32Message::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleSFixedInt32Message* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleSFixedInt32Message>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleSFixedInt32Message::MergeFrom(const SimpleSFixedInt32Message& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldfixedint32() != 0) {
+    set_testfieldfixedint32(from.testfieldfixedint32());
+  }
+}
+
+void SimpleSFixedInt32Message::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleSFixedInt32Message::CopyFrom(const SimpleSFixedInt32Message& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleSFixedInt32Message::IsInitialized() const {
+  return true;
+}
+
+void SimpleSFixedInt32Message::Swap(SimpleSFixedInt32Message* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleSFixedInt32Message::InternalSwap(SimpleSFixedInt32Message* other) {
+  using std::swap;
+  swap(testfieldfixedint32_, other->testfieldfixedint32_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleSFixedInt32Message::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void SimpleSFixedInt64Message::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int SimpleSFixedInt64Message::kTestFieldFixedInt64FieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+SimpleSFixedInt64Message::SimpleSFixedInt64Message()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_SimpleSFixedInt64Message.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+}
+SimpleSFixedInt64Message::SimpleSFixedInt64Message(const SimpleSFixedInt64Message& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  testfieldfixedint64_ = from.testfieldfixedint64_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+}
+
+void SimpleSFixedInt64Message::SharedCtor() {
+  testfieldfixedint64_ = GOOGLE_LONGLONG(0);
+}
+
+SimpleSFixedInt64Message::~SimpleSFixedInt64Message() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  SharedDtor();
+}
+
+void SimpleSFixedInt64Message::SharedDtor() {
+}
+
+void SimpleSFixedInt64Message::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* SimpleSFixedInt64Message::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const SimpleSFixedInt64Message& SimpleSFixedInt64Message::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_SimpleSFixedInt64Message.base);
+  return *internal_default_instance();
+}
+
+
+void SimpleSFixedInt64Message::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testfieldfixedint64_ = GOOGLE_LONGLONG(0);
+  _internal_metadata_.Clear();
+}
+
+bool SimpleSFixedInt64Message::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // sfixed64 testFieldFixedInt64 = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(9u /* 9 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SFIXED64>(
+                 input, &testfieldfixedint64_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  return false;
+#undef DO_
+}
+
+void SimpleSFixedInt64Message::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // sfixed64 testFieldFixedInt64 = 1;
+  if (this->testfieldfixedint64() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteSFixed64(1, this->testfieldfixedint64(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+}
+
+::google::protobuf::uint8* SimpleSFixedInt64Message::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // sfixed64 testFieldFixedInt64 = 1;
+  if (this->testfieldfixedint64() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteSFixed64ToArray(1, this->testfieldfixedint64(), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  return target;
+}
+
+size_t SimpleSFixedInt64Message::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // sfixed64 testFieldFixedInt64 = 1;
+  if (this->testfieldfixedint64() != 0) {
+    total_size += 1 + 8;
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SimpleSFixedInt64Message::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SimpleSFixedInt64Message* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const SimpleSFixedInt64Message>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+    MergeFrom(*source);
+  }
+}
+
+void SimpleSFixedInt64Message::MergeFrom(const SimpleSFixedInt64Message& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.testfieldfixedint64() != 0) {
+    set_testfieldfixedint64(from.testfieldfixedint64());
+  }
+}
+
+void SimpleSFixedInt64Message::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SimpleSFixedInt64Message::CopyFrom(const SimpleSFixedInt64Message& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleSFixedInt64Message::IsInitialized() const {
+  return true;
+}
+
+void SimpleSFixedInt64Message::Swap(SimpleSFixedInt64Message* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void SimpleSFixedInt64Message::InternalSwap(SimpleSFixedInt64Message* other) {
+  using std::swap;
+  swap(testfieldfixedint64_, other->testfieldfixedint64_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata SimpleSFixedInt64Message::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void ComplexMessage::InitAsDefaultInstance() {
+  ::qtprotobufnamespace::tests::_ComplexMessage_default_instance_._instance.get_mutable()->testcomplexfield_ = const_cast< ::qtprotobufnamespace::tests::SimpleStringMessage*>(
+      ::qtprotobufnamespace::tests::SimpleStringMessage::internal_default_instance());
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int ComplexMessage::kTestFieldIntFieldNumber;
+const int ComplexMessage::kTestComplexFieldFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+ComplexMessage::ComplexMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_ComplexMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.ComplexMessage)
+}
+ComplexMessage::ComplexMessage(const ComplexMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  if (from.has_testcomplexfield()) {
+    testcomplexfield_ = new ::qtprotobufnamespace::tests::SimpleStringMessage(*from.testcomplexfield_);
+  } else {
+    testcomplexfield_ = NULL;
+  }
+  testfieldint_ = from.testfieldint_;
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.ComplexMessage)
+}
+
+void ComplexMessage::SharedCtor() {
+  ::memset(&testcomplexfield_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&testfieldint_) -
+      reinterpret_cast<char*>(&testcomplexfield_)) + sizeof(testfieldint_));
+}
+
+ComplexMessage::~ComplexMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.ComplexMessage)
+  SharedDtor();
+}
+
+void ComplexMessage::SharedDtor() {
+  if (this != internal_default_instance()) delete testcomplexfield_;
+}
+
+void ComplexMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* ComplexMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const ComplexMessage& ComplexMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_ComplexMessage.base);
+  return *internal_default_instance();
+}
+
+
+void ComplexMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.ComplexMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaNoVirtual() == NULL && testcomplexfield_ != NULL) {
+    delete testcomplexfield_;
+  }
+  testcomplexfield_ = NULL;
+  testfieldint_ = 0;
+  _internal_metadata_.Clear();
+}
+
+bool ComplexMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.ComplexMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // int32 testFieldInt = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &testfieldint_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // .qtprotobufnamespace.tests.SimpleStringMessage testComplexField = 2;
+      case 2: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
+               input, mutable_testcomplexfield()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.ComplexMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.ComplexMessage)
+  return false;
+#undef DO_
+}
+
+void ComplexMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.ComplexMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->testfieldint(), output);
+  }
+
+  // .qtprotobufnamespace.tests.SimpleStringMessage testComplexField = 2;
+  if (this->has_testcomplexfield()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->_internal_testcomplexfield(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.ComplexMessage)
+}
+
+::google::protobuf::uint8* ComplexMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.ComplexMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->testfieldint(), target);
+  }
+
+  // .qtprotobufnamespace.tests.SimpleStringMessage testComplexField = 2;
+  if (this->has_testcomplexfield()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        2, this->_internal_testcomplexfield(), deterministic, target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.ComplexMessage)
+  return target;
+}
+
+size_t ComplexMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.ComplexMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // .qtprotobufnamespace.tests.SimpleStringMessage testComplexField = 2;
+  if (this->has_testcomplexfield()) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::MessageSize(
+        *testcomplexfield_);
+  }
+
+  // int32 testFieldInt = 1;
+  if (this->testfieldint() != 0) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->testfieldint());
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void ComplexMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.ComplexMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const ComplexMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const ComplexMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.ComplexMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.ComplexMessage)
+    MergeFrom(*source);
+  }
+}
+
+void ComplexMessage::MergeFrom(const ComplexMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.ComplexMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.has_testcomplexfield()) {
+    mutable_testcomplexfield()->::qtprotobufnamespace::tests::SimpleStringMessage::MergeFrom(from.testcomplexfield());
+  }
+  if (from.testfieldint() != 0) {
+    set_testfieldint(from.testfieldint());
+  }
+}
+
+void ComplexMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.ComplexMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ComplexMessage::CopyFrom(const ComplexMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.ComplexMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ComplexMessage::IsInitialized() const {
+  return true;
+}
+
+void ComplexMessage::Swap(ComplexMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void ComplexMessage::InternalSwap(ComplexMessage* other) {
+  using std::swap;
+  swap(testcomplexfield_, other->testcomplexfield_);
+  swap(testfieldint_, other->testfieldint_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata ComplexMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void RepeatedIntMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int RepeatedIntMessage::kTestRepeatedIntFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+RepeatedIntMessage::RepeatedIntMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_RepeatedIntMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.RepeatedIntMessage)
+}
+RepeatedIntMessage::RepeatedIntMessage(const RepeatedIntMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      testrepeatedint_(from.testrepeatedint_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.RepeatedIntMessage)
+}
+
+void RepeatedIntMessage::SharedCtor() {
+}
+
+RepeatedIntMessage::~RepeatedIntMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.RepeatedIntMessage)
+  SharedDtor();
+}
+
+void RepeatedIntMessage::SharedDtor() {
+}
+
+void RepeatedIntMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* RepeatedIntMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const RepeatedIntMessage& RepeatedIntMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_RepeatedIntMessage.base);
+  return *internal_default_instance();
+}
+
+
+void RepeatedIntMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.RepeatedIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testrepeatedint_.Clear();
+  _internal_metadata_.Clear();
+}
+
+bool RepeatedIntMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.RepeatedIntMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated sint32 testRepeatedInt = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
+                 input, this->mutable_testrepeatedint())));
+        } else if (
+            static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
+                 1, 10u, input, this->mutable_testrepeatedint())));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.RepeatedIntMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.RepeatedIntMessage)
+  return false;
+#undef DO_
+}
+
+void RepeatedIntMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.RepeatedIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated sint32 testRepeatedInt = 1;
+  if (this->testrepeatedint_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
+        _testrepeatedint_cached_byte_size_));
+  }
+  for (int i = 0, n = this->testrepeatedint_size(); i < n; i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteSInt32NoTag(
+      this->testrepeatedint(i), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.RepeatedIntMessage)
+}
+
+::google::protobuf::uint8* RepeatedIntMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.RepeatedIntMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated sint32 testRepeatedInt = 1;
+  if (this->testrepeatedint_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      1,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+        static_cast< ::google::protobuf::int32>(
+            _testrepeatedint_cached_byte_size_), target);
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteSInt32NoTagToArray(this->testrepeatedint_, target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.RepeatedIntMessage)
+  return target;
+}
+
+size_t RepeatedIntMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.RepeatedIntMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // repeated sint32 testRepeatedInt = 1;
+  {
+    size_t data_size = ::google::protobuf::internal::WireFormatLite::
+      SInt32Size(this->testrepeatedint_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+            static_cast< ::google::protobuf::int32>(data_size));
+    }
+    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _testrepeatedint_cached_byte_size_ = cached_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void RepeatedIntMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.RepeatedIntMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const RepeatedIntMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const RepeatedIntMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.RepeatedIntMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.RepeatedIntMessage)
+    MergeFrom(*source);
+  }
+}
+
+void RepeatedIntMessage::MergeFrom(const RepeatedIntMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.RepeatedIntMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  testrepeatedint_.MergeFrom(from.testrepeatedint_);
+}
+
+void RepeatedIntMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.RepeatedIntMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RepeatedIntMessage::CopyFrom(const RepeatedIntMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.RepeatedIntMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RepeatedIntMessage::IsInitialized() const {
+  return true;
+}
+
+void RepeatedIntMessage::Swap(RepeatedIntMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void RepeatedIntMessage::InternalSwap(RepeatedIntMessage* other) {
+  using std::swap;
+  testrepeatedint_.InternalSwap(&other->testrepeatedint_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata RepeatedIntMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void RepeatedStringMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int RepeatedStringMessage::kTestRepeatedStringFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+RepeatedStringMessage::RepeatedStringMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_RepeatedStringMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.RepeatedStringMessage)
+}
+RepeatedStringMessage::RepeatedStringMessage(const RepeatedStringMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      testrepeatedstring_(from.testrepeatedstring_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.RepeatedStringMessage)
+}
+
+void RepeatedStringMessage::SharedCtor() {
+}
+
+RepeatedStringMessage::~RepeatedStringMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.RepeatedStringMessage)
+  SharedDtor();
+}
+
+void RepeatedStringMessage::SharedDtor() {
+}
+
+void RepeatedStringMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* RepeatedStringMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const RepeatedStringMessage& RepeatedStringMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_RepeatedStringMessage.base);
+  return *internal_default_instance();
+}
+
+
+void RepeatedStringMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.RepeatedStringMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testrepeatedstring_.Clear();
+  _internal_metadata_.Clear();
+}
+
+bool RepeatedStringMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.RepeatedStringMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated string testRepeatedString = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_testrepeatedstring()));
+          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
+            this->testrepeatedstring(this->testrepeatedstring_size() - 1).data(),
+            static_cast<int>(this->testrepeatedstring(this->testrepeatedstring_size() - 1).length()),
+            ::google::protobuf::internal::WireFormatLite::PARSE,
+            "qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.RepeatedStringMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.RepeatedStringMessage)
+  return false;
+#undef DO_
+}
+
+void RepeatedStringMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.RepeatedStringMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string testRepeatedString = 1;
+  for (int i = 0, n = this->testrepeatedstring_size(); i < n; i++) {
+    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
+      this->testrepeatedstring(i).data(), static_cast<int>(this->testrepeatedstring(i).length()),
+      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
+      "qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString");
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      1, this->testrepeatedstring(i), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.RepeatedStringMessage)
+}
+
+::google::protobuf::uint8* RepeatedStringMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.RepeatedStringMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string testRepeatedString = 1;
+  for (int i = 0, n = this->testrepeatedstring_size(); i < n; i++) {
+    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
+      this->testrepeatedstring(i).data(), static_cast<int>(this->testrepeatedstring(i).length()),
+      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
+      "qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString");
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteStringToArray(1, this->testrepeatedstring(i), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.RepeatedStringMessage)
+  return target;
+}
+
+size_t RepeatedStringMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.RepeatedStringMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // repeated string testRepeatedString = 1;
+  total_size += 1 *
+      ::google::protobuf::internal::FromIntSize(this->testrepeatedstring_size());
+  for (int i = 0, n = this->testrepeatedstring_size(); i < n; i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->testrepeatedstring(i));
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void RepeatedStringMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.RepeatedStringMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const RepeatedStringMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const RepeatedStringMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.RepeatedStringMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.RepeatedStringMessage)
+    MergeFrom(*source);
+  }
+}
+
+void RepeatedStringMessage::MergeFrom(const RepeatedStringMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.RepeatedStringMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  testrepeatedstring_.MergeFrom(from.testrepeatedstring_);
+}
+
+void RepeatedStringMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.RepeatedStringMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RepeatedStringMessage::CopyFrom(const RepeatedStringMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.RepeatedStringMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RepeatedStringMessage::IsInitialized() const {
+  return true;
+}
+
+void RepeatedStringMessage::Swap(RepeatedStringMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void RepeatedStringMessage::InternalSwap(RepeatedStringMessage* other) {
+  using std::swap;
+  testrepeatedstring_.InternalSwap(CastToBase(&other->testrepeatedstring_));
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata RepeatedStringMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void RepeatedDoubleMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int RepeatedDoubleMessage::kTestRepeatedDoubleFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+RepeatedDoubleMessage::RepeatedDoubleMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_RepeatedDoubleMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+}
+RepeatedDoubleMessage::RepeatedDoubleMessage(const RepeatedDoubleMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      testrepeateddouble_(from.testrepeateddouble_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+}
+
+void RepeatedDoubleMessage::SharedCtor() {
+}
+
+RepeatedDoubleMessage::~RepeatedDoubleMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  SharedDtor();
+}
+
+void RepeatedDoubleMessage::SharedDtor() {
+}
+
+void RepeatedDoubleMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* RepeatedDoubleMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const RepeatedDoubleMessage& RepeatedDoubleMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_RepeatedDoubleMessage.base);
+  return *internal_default_instance();
+}
+
+
+void RepeatedDoubleMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testrepeateddouble_.Clear();
+  _internal_metadata_.Clear();
+}
+
+bool RepeatedDoubleMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated double testRepeatedDouble = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, this->mutable_testrepeateddouble())));
+        } else if (
+            static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(9u /* 9 & 0xFF */)) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 1, 10u, input, this->mutable_testrepeateddouble())));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  return false;
+#undef DO_
+}
+
+void RepeatedDoubleMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated double testRepeatedDouble = 1;
+  if (this->testrepeateddouble_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
+        _testrepeateddouble_cached_byte_size_));
+    ::google::protobuf::internal::WireFormatLite::WriteDoubleArray(
+      this->testrepeateddouble().data(), this->testrepeateddouble_size(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+}
+
+::google::protobuf::uint8* RepeatedDoubleMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated double testRepeatedDouble = 1;
+  if (this->testrepeateddouble_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      1,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+        static_cast< ::google::protobuf::int32>(
+            _testrepeateddouble_cached_byte_size_), target);
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteDoubleNoTagToArray(this->testrepeateddouble_, target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  return target;
+}
+
+size_t RepeatedDoubleMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // repeated double testRepeatedDouble = 1;
+  {
+    unsigned int count = static_cast<unsigned int>(this->testrepeateddouble_size());
+    size_t data_size = 8UL * count;
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+            static_cast< ::google::protobuf::int32>(data_size));
+    }
+    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _testrepeateddouble_cached_byte_size_ = cached_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void RepeatedDoubleMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const RepeatedDoubleMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const RepeatedDoubleMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+    MergeFrom(*source);
+  }
+}
+
+void RepeatedDoubleMessage::MergeFrom(const RepeatedDoubleMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  testrepeateddouble_.MergeFrom(from.testrepeateddouble_);
+}
+
+void RepeatedDoubleMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RepeatedDoubleMessage::CopyFrom(const RepeatedDoubleMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RepeatedDoubleMessage::IsInitialized() const {
+  return true;
+}
+
+void RepeatedDoubleMessage::Swap(RepeatedDoubleMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void RepeatedDoubleMessage::InternalSwap(RepeatedDoubleMessage* other) {
+  using std::swap;
+  testrepeateddouble_.InternalSwap(&other->testrepeateddouble_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata RepeatedDoubleMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void RepeatedBytesMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int RepeatedBytesMessage::kTestRepeatedBytesFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+RepeatedBytesMessage::RepeatedBytesMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_RepeatedBytesMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.RepeatedBytesMessage)
+}
+RepeatedBytesMessage::RepeatedBytesMessage(const RepeatedBytesMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      testrepeatedbytes_(from.testrepeatedbytes_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.RepeatedBytesMessage)
+}
+
+void RepeatedBytesMessage::SharedCtor() {
+}
+
+RepeatedBytesMessage::~RepeatedBytesMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  SharedDtor();
+}
+
+void RepeatedBytesMessage::SharedDtor() {
+}
+
+void RepeatedBytesMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* RepeatedBytesMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const RepeatedBytesMessage& RepeatedBytesMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_RepeatedBytesMessage.base);
+  return *internal_default_instance();
+}
+
+
+void RepeatedBytesMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testrepeatedbytes_.Clear();
+  _internal_metadata_.Clear();
+}
+
+bool RepeatedBytesMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated bytes testRepeatedBytes = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->add_testrepeatedbytes()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  return false;
+#undef DO_
+}
+
+void RepeatedBytesMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated bytes testRepeatedBytes = 1;
+  for (int i = 0, n = this->testrepeatedbytes_size(); i < n; i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      1, this->testrepeatedbytes(i), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.RepeatedBytesMessage)
+}
+
+::google::protobuf::uint8* RepeatedBytesMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated bytes testRepeatedBytes = 1;
+  for (int i = 0, n = this->testrepeatedbytes_size(); i < n; i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteBytesToArray(1, this->testrepeatedbytes(i), target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  return target;
+}
+
+size_t RepeatedBytesMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // repeated bytes testRepeatedBytes = 1;
+  total_size += 1 *
+      ::google::protobuf::internal::FromIntSize(this->testrepeatedbytes_size());
+  for (int i = 0, n = this->testrepeatedbytes_size(); i < n; i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
+      this->testrepeatedbytes(i));
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void RepeatedBytesMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const RepeatedBytesMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const RepeatedBytesMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.RepeatedBytesMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.RepeatedBytesMessage)
+    MergeFrom(*source);
+  }
+}
+
+void RepeatedBytesMessage::MergeFrom(const RepeatedBytesMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  testrepeatedbytes_.MergeFrom(from.testrepeatedbytes_);
+}
+
+void RepeatedBytesMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RepeatedBytesMessage::CopyFrom(const RepeatedBytesMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.RepeatedBytesMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RepeatedBytesMessage::IsInitialized() const {
+  return true;
+}
+
+void RepeatedBytesMessage::Swap(RepeatedBytesMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void RepeatedBytesMessage::InternalSwap(RepeatedBytesMessage* other) {
+  using std::swap;
+  testrepeatedbytes_.InternalSwap(CastToBase(&other->testrepeatedbytes_));
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata RepeatedBytesMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void RepeatedFloatMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int RepeatedFloatMessage::kTestRepeatedFloatFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+RepeatedFloatMessage::RepeatedFloatMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_RepeatedFloatMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.RepeatedFloatMessage)
+}
+RepeatedFloatMessage::RepeatedFloatMessage(const RepeatedFloatMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      testrepeatedfloat_(from.testrepeatedfloat_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.RepeatedFloatMessage)
+}
+
+void RepeatedFloatMessage::SharedCtor() {
+}
+
+RepeatedFloatMessage::~RepeatedFloatMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  SharedDtor();
+}
+
+void RepeatedFloatMessage::SharedDtor() {
+}
+
+void RepeatedFloatMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* RepeatedFloatMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const RepeatedFloatMessage& RepeatedFloatMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_RepeatedFloatMessage.base);
+  return *internal_default_instance();
+}
+
+
+void RepeatedFloatMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testrepeatedfloat_.Clear();
+  _internal_metadata_.Clear();
+}
+
+bool RepeatedFloatMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated float testRepeatedFloat = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, this->mutable_testrepeatedfloat())));
+        } else if (
+            static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 1, 10u, input, this->mutable_testrepeatedfloat())));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  return false;
+#undef DO_
+}
+
+void RepeatedFloatMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated float testRepeatedFloat = 1;
+  if (this->testrepeatedfloat_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
+        _testrepeatedfloat_cached_byte_size_));
+    ::google::protobuf::internal::WireFormatLite::WriteFloatArray(
+      this->testrepeatedfloat().data(), this->testrepeatedfloat_size(), output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.RepeatedFloatMessage)
+}
+
+::google::protobuf::uint8* RepeatedFloatMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated float testRepeatedFloat = 1;
+  if (this->testrepeatedfloat_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      1,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+        static_cast< ::google::protobuf::int32>(
+            _testrepeatedfloat_cached_byte_size_), target);
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteFloatNoTagToArray(this->testrepeatedfloat_, target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  return target;
+}
+
+size_t RepeatedFloatMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // repeated float testRepeatedFloat = 1;
+  {
+    unsigned int count = static_cast<unsigned int>(this->testrepeatedfloat_size());
+    size_t data_size = 4UL * count;
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+            static_cast< ::google::protobuf::int32>(data_size));
+    }
+    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _testrepeatedfloat_cached_byte_size_ = cached_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void RepeatedFloatMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const RepeatedFloatMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const RepeatedFloatMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.RepeatedFloatMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.RepeatedFloatMessage)
+    MergeFrom(*source);
+  }
+}
+
+void RepeatedFloatMessage::MergeFrom(const RepeatedFloatMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  testrepeatedfloat_.MergeFrom(from.testrepeatedfloat_);
+}
+
+void RepeatedFloatMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RepeatedFloatMessage::CopyFrom(const RepeatedFloatMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.RepeatedFloatMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RepeatedFloatMessage::IsInitialized() const {
+  return true;
+}
+
+void RepeatedFloatMessage::Swap(RepeatedFloatMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void RepeatedFloatMessage::InternalSwap(RepeatedFloatMessage* other) {
+  using std::swap;
+  testrepeatedfloat_.InternalSwap(&other->testrepeatedfloat_);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata RepeatedFloatMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// ===================================================================
+
+void RepeatedComplexMessage::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int RepeatedComplexMessage::kTestRepeatedComplexFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+RepeatedComplexMessage::RepeatedComplexMessage()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  ::google::protobuf::internal::InitSCC(
+      &protobuf_simpletest_2eproto::scc_info_RepeatedComplexMessage.base);
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:qtprotobufnamespace.tests.RepeatedComplexMessage)
+}
+RepeatedComplexMessage::RepeatedComplexMessage(const RepeatedComplexMessage& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      testrepeatedcomplex_(from.testrepeatedcomplex_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:qtprotobufnamespace.tests.RepeatedComplexMessage)
+}
+
+void RepeatedComplexMessage::SharedCtor() {
+}
+
+RepeatedComplexMessage::~RepeatedComplexMessage() {
+  // @@protoc_insertion_point(destructor:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  SharedDtor();
+}
+
+void RepeatedComplexMessage::SharedDtor() {
+}
+
+void RepeatedComplexMessage::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const ::google::protobuf::Descriptor* RepeatedComplexMessage::descriptor() {
+  ::protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const RepeatedComplexMessage& RepeatedComplexMessage::default_instance() {
+  ::google::protobuf::internal::InitSCC(&protobuf_simpletest_2eproto::scc_info_RepeatedComplexMessage.base);
+  return *internal_default_instance();
+}
+
+
+void RepeatedComplexMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  testrepeatedcomplex_.Clear();
+  _internal_metadata_.Clear();
+}
+
+bool RepeatedComplexMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  for (;;) {
+    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .qtprotobufnamespace.tests.ComplexMessage testRepeatedComplex = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
+                input, add_testrepeatedcomplex()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  return false;
+#undef DO_
+}
+
+void RepeatedComplexMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .qtprotobufnamespace.tests.ComplexMessage testRepeatedComplex = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->testrepeatedcomplex_size()); i < n; i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1,
+      this->testrepeatedcomplex(static_cast<int>(i)),
+      output);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
+  }
+  // @@protoc_insertion_point(serialize_end:qtprotobufnamespace.tests.RepeatedComplexMessage)
+}
+
+::google::protobuf::uint8* RepeatedComplexMessage::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .qtprotobufnamespace.tests.ComplexMessage testRepeatedComplex = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->testrepeatedcomplex_size()); i < n; i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, this->testrepeatedcomplex(static_cast<int>(i)), deterministic, target);
+  }
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  return target;
+}
+
+size_t RepeatedComplexMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  size_t total_size = 0;
+
+  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
+  }
+  // repeated .qtprotobufnamespace.tests.ComplexMessage testRepeatedComplex = 1;
+  {
+    unsigned int count = static_cast<unsigned int>(this->testrepeatedcomplex_size());
+    total_size += 1UL * count;
+    for (unsigned int i = 0; i < count; i++) {
+      total_size +=
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          this->testrepeatedcomplex(static_cast<int>(i)));
+    }
+  }
+
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void RepeatedComplexMessage::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  const RepeatedComplexMessage* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const RepeatedComplexMessage>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:qtprotobufnamespace.tests.RepeatedComplexMessage)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:qtprotobufnamespace.tests.RepeatedComplexMessage)
+    MergeFrom(*source);
+  }
+}
+
+void RepeatedComplexMessage::MergeFrom(const RepeatedComplexMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  testrepeatedcomplex_.MergeFrom(from.testrepeatedcomplex_);
+}
+
+void RepeatedComplexMessage::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RepeatedComplexMessage::CopyFrom(const RepeatedComplexMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:qtprotobufnamespace.tests.RepeatedComplexMessage)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RepeatedComplexMessage::IsInitialized() const {
+  return true;
+}
+
+void RepeatedComplexMessage::Swap(RepeatedComplexMessage* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void RepeatedComplexMessage::InternalSwap(RepeatedComplexMessage* other) {
+  using std::swap;
+  CastToBase(&testrepeatedcomplex_)->InternalSwap(CastToBase(&other->testrepeatedcomplex_));
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+}
+
+::google::protobuf::Metadata RepeatedComplexMessage::GetMetadata() const {
+  protobuf_simpletest_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_simpletest_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace google {
+namespace protobuf {
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleEnumMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleEnumMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleEnumMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleFileEnumMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleFileEnumMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleFileEnumMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleBoolMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleBoolMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleBoolMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleIntMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleIntMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleIntMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleSIntMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleSIntMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleSIntMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleUIntMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleUIntMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleUIntMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleInt64Message* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleInt64Message >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleInt64Message >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleSInt64Message* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleSInt64Message >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleSInt64Message >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleUInt64Message* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleUInt64Message >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleUInt64Message >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleStringMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleStringMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleStringMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleFloatMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleFloatMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleFloatMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleDoubleMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleDoubleMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleDoubleMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleBytesMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleBytesMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleBytesMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleFixedInt32Message* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleFixedInt32Message >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleFixedInt32Message >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleFixedInt64Message* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleFixedInt64Message >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleFixedInt64Message >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleSFixedInt32Message* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleSFixedInt32Message >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleSFixedInt32Message >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::SimpleSFixedInt64Message* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::SimpleSFixedInt64Message >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::SimpleSFixedInt64Message >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::ComplexMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::ComplexMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::ComplexMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::RepeatedIntMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::RepeatedIntMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::RepeatedIntMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::RepeatedStringMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::RepeatedStringMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::RepeatedStringMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::RepeatedDoubleMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::RepeatedDoubleMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::RepeatedDoubleMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::RepeatedBytesMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::RepeatedBytesMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::RepeatedBytesMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::RepeatedFloatMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::RepeatedFloatMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::RepeatedFloatMessage >(arena);
+}
+template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::qtprotobufnamespace::tests::RepeatedComplexMessage* Arena::CreateMaybeMessage< ::qtprotobufnamespace::tests::RepeatedComplexMessage >(Arena* arena) {
+  return Arena::CreateInternal< ::qtprotobufnamespace::tests::RepeatedComplexMessage >(arena);
+}
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)

+ 3696 - 0
tests/echoserver/testserver/simpletest.pb.h

@@ -0,0 +1,3696 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: simpletest.proto
+
+#ifndef PROTOBUF_INCLUDED_simpletest_2eproto
+#define PROTOBUF_INCLUDED_simpletest_2eproto
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3006001
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/inlined_string_field.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#define PROTOBUF_INTERNAL_EXPORT_protobuf_simpletest_2eproto 
+
+namespace protobuf_simpletest_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[24];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+}  // namespace protobuf_simpletest_2eproto
+namespace qtprotobufnamespace {
+namespace tests {
+class ComplexMessage;
+class ComplexMessageDefaultTypeInternal;
+extern ComplexMessageDefaultTypeInternal _ComplexMessage_default_instance_;
+class RepeatedBytesMessage;
+class RepeatedBytesMessageDefaultTypeInternal;
+extern RepeatedBytesMessageDefaultTypeInternal _RepeatedBytesMessage_default_instance_;
+class RepeatedComplexMessage;
+class RepeatedComplexMessageDefaultTypeInternal;
+extern RepeatedComplexMessageDefaultTypeInternal _RepeatedComplexMessage_default_instance_;
+class RepeatedDoubleMessage;
+class RepeatedDoubleMessageDefaultTypeInternal;
+extern RepeatedDoubleMessageDefaultTypeInternal _RepeatedDoubleMessage_default_instance_;
+class RepeatedFloatMessage;
+class RepeatedFloatMessageDefaultTypeInternal;
+extern RepeatedFloatMessageDefaultTypeInternal _RepeatedFloatMessage_default_instance_;
+class RepeatedIntMessage;
+class RepeatedIntMessageDefaultTypeInternal;
+extern RepeatedIntMessageDefaultTypeInternal _RepeatedIntMessage_default_instance_;
+class RepeatedStringMessage;
+class RepeatedStringMessageDefaultTypeInternal;
+extern RepeatedStringMessageDefaultTypeInternal _RepeatedStringMessage_default_instance_;
+class SimpleBoolMessage;
+class SimpleBoolMessageDefaultTypeInternal;
+extern SimpleBoolMessageDefaultTypeInternal _SimpleBoolMessage_default_instance_;
+class SimpleBytesMessage;
+class SimpleBytesMessageDefaultTypeInternal;
+extern SimpleBytesMessageDefaultTypeInternal _SimpleBytesMessage_default_instance_;
+class SimpleDoubleMessage;
+class SimpleDoubleMessageDefaultTypeInternal;
+extern SimpleDoubleMessageDefaultTypeInternal _SimpleDoubleMessage_default_instance_;
+class SimpleEnumMessage;
+class SimpleEnumMessageDefaultTypeInternal;
+extern SimpleEnumMessageDefaultTypeInternal _SimpleEnumMessage_default_instance_;
+class SimpleFileEnumMessage;
+class SimpleFileEnumMessageDefaultTypeInternal;
+extern SimpleFileEnumMessageDefaultTypeInternal _SimpleFileEnumMessage_default_instance_;
+class SimpleFixedInt32Message;
+class SimpleFixedInt32MessageDefaultTypeInternal;
+extern SimpleFixedInt32MessageDefaultTypeInternal _SimpleFixedInt32Message_default_instance_;
+class SimpleFixedInt64Message;
+class SimpleFixedInt64MessageDefaultTypeInternal;
+extern SimpleFixedInt64MessageDefaultTypeInternal _SimpleFixedInt64Message_default_instance_;
+class SimpleFloatMessage;
+class SimpleFloatMessageDefaultTypeInternal;
+extern SimpleFloatMessageDefaultTypeInternal _SimpleFloatMessage_default_instance_;
+class SimpleInt64Message;
+class SimpleInt64MessageDefaultTypeInternal;
+extern SimpleInt64MessageDefaultTypeInternal _SimpleInt64Message_default_instance_;
+class SimpleIntMessage;
+class SimpleIntMessageDefaultTypeInternal;
+extern SimpleIntMessageDefaultTypeInternal _SimpleIntMessage_default_instance_;
+class SimpleSFixedInt32Message;
+class SimpleSFixedInt32MessageDefaultTypeInternal;
+extern SimpleSFixedInt32MessageDefaultTypeInternal _SimpleSFixedInt32Message_default_instance_;
+class SimpleSFixedInt64Message;
+class SimpleSFixedInt64MessageDefaultTypeInternal;
+extern SimpleSFixedInt64MessageDefaultTypeInternal _SimpleSFixedInt64Message_default_instance_;
+class SimpleSInt64Message;
+class SimpleSInt64MessageDefaultTypeInternal;
+extern SimpleSInt64MessageDefaultTypeInternal _SimpleSInt64Message_default_instance_;
+class SimpleSIntMessage;
+class SimpleSIntMessageDefaultTypeInternal;
+extern SimpleSIntMessageDefaultTypeInternal _SimpleSIntMessage_default_instance_;
+class SimpleStringMessage;
+class SimpleStringMessageDefaultTypeInternal;
+extern SimpleStringMessageDefaultTypeInternal _SimpleStringMessage_default_instance_;
+class SimpleUInt64Message;
+class SimpleUInt64MessageDefaultTypeInternal;
+extern SimpleUInt64MessageDefaultTypeInternal _SimpleUInt64Message_default_instance_;
+class SimpleUIntMessage;
+class SimpleUIntMessageDefaultTypeInternal;
+extern SimpleUIntMessageDefaultTypeInternal _SimpleUIntMessage_default_instance_;
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace google {
+namespace protobuf {
+template<> ::qtprotobufnamespace::tests::ComplexMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::ComplexMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::RepeatedBytesMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedBytesMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::RepeatedComplexMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedComplexMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::RepeatedDoubleMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedDoubleMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::RepeatedFloatMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedFloatMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::RepeatedIntMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedIntMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::RepeatedStringMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedStringMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleBoolMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleBoolMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleBytesMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleBytesMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleDoubleMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleDoubleMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleEnumMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleEnumMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleFileEnumMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleFileEnumMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleFixedInt32Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleFixedInt32Message>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleFixedInt64Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleFixedInt64Message>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleFloatMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleFloatMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleInt64Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleInt64Message>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleIntMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleIntMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleSFixedInt32Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleSFixedInt32Message>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleSFixedInt64Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleSFixedInt64Message>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleSInt64Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleSInt64Message>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleSIntMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleSIntMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleStringMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleStringMessage>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleUInt64Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleUInt64Message>(Arena*);
+template<> ::qtprotobufnamespace::tests::SimpleUIntMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleUIntMessage>(Arena*);
+}  // namespace protobuf
+}  // namespace google
+namespace qtprotobufnamespace {
+namespace tests {
+
+enum SimpleEnumMessage_LocalEnum {
+  SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE0 = 0,
+  SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE1 = 1,
+  SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE2 = 2,
+  SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE3 = 3,
+  SimpleEnumMessage_LocalEnum_SimpleEnumMessage_LocalEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SimpleEnumMessage_LocalEnum_SimpleEnumMessage_LocalEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SimpleEnumMessage_LocalEnum_IsValid(int value);
+const SimpleEnumMessage_LocalEnum SimpleEnumMessage_LocalEnum_LocalEnum_MIN = SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE0;
+const SimpleEnumMessage_LocalEnum SimpleEnumMessage_LocalEnum_LocalEnum_MAX = SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE3;
+const int SimpleEnumMessage_LocalEnum_LocalEnum_ARRAYSIZE = SimpleEnumMessage_LocalEnum_LocalEnum_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SimpleEnumMessage_LocalEnum_descriptor();
+inline const ::std::string& SimpleEnumMessage_LocalEnum_Name(SimpleEnumMessage_LocalEnum value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SimpleEnumMessage_LocalEnum_descriptor(), value);
+}
+inline bool SimpleEnumMessage_LocalEnum_Parse(
+    const ::std::string& name, SimpleEnumMessage_LocalEnum* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SimpleEnumMessage_LocalEnum>(
+    SimpleEnumMessage_LocalEnum_descriptor(), name, value);
+}
+enum TestEnum {
+  TEST_ENUM_VALUE0 = 0,
+  TEST_ENUM_VALUE1 = 1,
+  TEST_ENUM_VALUE2 = 2,
+  TEST_ENUM_VALUE3 = 4,
+  TEST_ENUM_VALUE4 = 3,
+  TestEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  TestEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool TestEnum_IsValid(int value);
+const TestEnum TestEnum_MIN = TEST_ENUM_VALUE0;
+const TestEnum TestEnum_MAX = TEST_ENUM_VALUE3;
+const int TestEnum_ARRAYSIZE = TestEnum_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* TestEnum_descriptor();
+inline const ::std::string& TestEnum_Name(TestEnum value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    TestEnum_descriptor(), value);
+}
+inline bool TestEnum_Parse(
+    const ::std::string& name, TestEnum* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<TestEnum>(
+    TestEnum_descriptor(), name, value);
+}
+// ===================================================================
+
+class SimpleEnumMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleEnumMessage) */ {
+ public:
+  SimpleEnumMessage();
+  virtual ~SimpleEnumMessage();
+
+  SimpleEnumMessage(const SimpleEnumMessage& from);
+
+  inline SimpleEnumMessage& operator=(const SimpleEnumMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleEnumMessage(SimpleEnumMessage&& from) noexcept
+    : SimpleEnumMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleEnumMessage& operator=(SimpleEnumMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleEnumMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleEnumMessage* internal_default_instance() {
+    return reinterpret_cast<const SimpleEnumMessage*>(
+               &_SimpleEnumMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  void Swap(SimpleEnumMessage* other);
+  friend void swap(SimpleEnumMessage& a, SimpleEnumMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleEnumMessage* New() const final {
+    return CreateMaybeMessage<SimpleEnumMessage>(NULL);
+  }
+
+  SimpleEnumMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleEnumMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleEnumMessage& from);
+  void MergeFrom(const SimpleEnumMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleEnumMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SimpleEnumMessage_LocalEnum LocalEnum;
+  static const LocalEnum LOCAL_ENUM_VALUE0 =
+    SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE0;
+  static const LocalEnum LOCAL_ENUM_VALUE1 =
+    SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE1;
+  static const LocalEnum LOCAL_ENUM_VALUE2 =
+    SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE2;
+  static const LocalEnum LOCAL_ENUM_VALUE3 =
+    SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE3;
+  static inline bool LocalEnum_IsValid(int value) {
+    return SimpleEnumMessage_LocalEnum_IsValid(value);
+  }
+  static const LocalEnum LocalEnum_MIN =
+    SimpleEnumMessage_LocalEnum_LocalEnum_MIN;
+  static const LocalEnum LocalEnum_MAX =
+    SimpleEnumMessage_LocalEnum_LocalEnum_MAX;
+  static const int LocalEnum_ARRAYSIZE =
+    SimpleEnumMessage_LocalEnum_LocalEnum_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  LocalEnum_descriptor() {
+    return SimpleEnumMessage_LocalEnum_descriptor();
+  }
+  static inline const ::std::string& LocalEnum_Name(LocalEnum value) {
+    return SimpleEnumMessage_LocalEnum_Name(value);
+  }
+  static inline bool LocalEnum_Parse(const ::std::string& name,
+      LocalEnum* value) {
+    return SimpleEnumMessage_LocalEnum_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // repeated .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnumList = 2;
+  int localenumlist_size() const;
+  void clear_localenumlist();
+  static const int kLocalEnumListFieldNumber = 2;
+  ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum localenumlist(int index) const;
+  void set_localenumlist(int index, ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value);
+  void add_localenumlist(::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value);
+  const ::google::protobuf::RepeatedField<int>& localenumlist() const;
+  ::google::protobuf::RepeatedField<int>* mutable_localenumlist();
+
+  // .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnum = 1;
+  void clear_localenum();
+  static const int kLocalEnumFieldNumber = 1;
+  ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum localenum() const;
+  void set_localenum(::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleEnumMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField<int> localenumlist_;
+  mutable int _localenumlist_cached_byte_size_;
+  int localenum_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleFileEnumMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleFileEnumMessage) */ {
+ public:
+  SimpleFileEnumMessage();
+  virtual ~SimpleFileEnumMessage();
+
+  SimpleFileEnumMessage(const SimpleFileEnumMessage& from);
+
+  inline SimpleFileEnumMessage& operator=(const SimpleFileEnumMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleFileEnumMessage(SimpleFileEnumMessage&& from) noexcept
+    : SimpleFileEnumMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleFileEnumMessage& operator=(SimpleFileEnumMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleFileEnumMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleFileEnumMessage* internal_default_instance() {
+    return reinterpret_cast<const SimpleFileEnumMessage*>(
+               &_SimpleFileEnumMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  void Swap(SimpleFileEnumMessage* other);
+  friend void swap(SimpleFileEnumMessage& a, SimpleFileEnumMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleFileEnumMessage* New() const final {
+    return CreateMaybeMessage<SimpleFileEnumMessage>(NULL);
+  }
+
+  SimpleFileEnumMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleFileEnumMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleFileEnumMessage& from);
+  void MergeFrom(const SimpleFileEnumMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleFileEnumMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .qtprotobufnamespace.tests.TestEnum globalEnumList = 2;
+  int globalenumlist_size() const;
+  void clear_globalenumlist();
+  static const int kGlobalEnumListFieldNumber = 2;
+  ::qtprotobufnamespace::tests::TestEnum globalenumlist(int index) const;
+  void set_globalenumlist(int index, ::qtprotobufnamespace::tests::TestEnum value);
+  void add_globalenumlist(::qtprotobufnamespace::tests::TestEnum value);
+  const ::google::protobuf::RepeatedField<int>& globalenumlist() const;
+  ::google::protobuf::RepeatedField<int>* mutable_globalenumlist();
+
+  // .qtprotobufnamespace.tests.TestEnum globalEnum = 1;
+  void clear_globalenum();
+  static const int kGlobalEnumFieldNumber = 1;
+  ::qtprotobufnamespace::tests::TestEnum globalenum() const;
+  void set_globalenum(::qtprotobufnamespace::tests::TestEnum value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleFileEnumMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField<int> globalenumlist_;
+  mutable int _globalenumlist_cached_byte_size_;
+  int globalenum_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleBoolMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleBoolMessage) */ {
+ public:
+  SimpleBoolMessage();
+  virtual ~SimpleBoolMessage();
+
+  SimpleBoolMessage(const SimpleBoolMessage& from);
+
+  inline SimpleBoolMessage& operator=(const SimpleBoolMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleBoolMessage(SimpleBoolMessage&& from) noexcept
+    : SimpleBoolMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleBoolMessage& operator=(SimpleBoolMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleBoolMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleBoolMessage* internal_default_instance() {
+    return reinterpret_cast<const SimpleBoolMessage*>(
+               &_SimpleBoolMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  void Swap(SimpleBoolMessage* other);
+  friend void swap(SimpleBoolMessage& a, SimpleBoolMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleBoolMessage* New() const final {
+    return CreateMaybeMessage<SimpleBoolMessage>(NULL);
+  }
+
+  SimpleBoolMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleBoolMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleBoolMessage& from);
+  void MergeFrom(const SimpleBoolMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleBoolMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bool testFieldBool = 1;
+  void clear_testfieldbool();
+  static const int kTestFieldBoolFieldNumber = 1;
+  bool testfieldbool() const;
+  void set_testfieldbool(bool value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleBoolMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  bool testfieldbool_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleIntMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleIntMessage) */ {
+ public:
+  SimpleIntMessage();
+  virtual ~SimpleIntMessage();
+
+  SimpleIntMessage(const SimpleIntMessage& from);
+
+  inline SimpleIntMessage& operator=(const SimpleIntMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleIntMessage(SimpleIntMessage&& from) noexcept
+    : SimpleIntMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleIntMessage& operator=(SimpleIntMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleIntMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleIntMessage* internal_default_instance() {
+    return reinterpret_cast<const SimpleIntMessage*>(
+               &_SimpleIntMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  void Swap(SimpleIntMessage* other);
+  friend void swap(SimpleIntMessage& a, SimpleIntMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleIntMessage* New() const final {
+    return CreateMaybeMessage<SimpleIntMessage>(NULL);
+  }
+
+  SimpleIntMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleIntMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleIntMessage& from);
+  void MergeFrom(const SimpleIntMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleIntMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // int32 testFieldInt = 1;
+  void clear_testfieldint();
+  static const int kTestFieldIntFieldNumber = 1;
+  ::google::protobuf::int32 testfieldint() const;
+  void set_testfieldint(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleIntMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::int32 testfieldint_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleSIntMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleSIntMessage) */ {
+ public:
+  SimpleSIntMessage();
+  virtual ~SimpleSIntMessage();
+
+  SimpleSIntMessage(const SimpleSIntMessage& from);
+
+  inline SimpleSIntMessage& operator=(const SimpleSIntMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleSIntMessage(SimpleSIntMessage&& from) noexcept
+    : SimpleSIntMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleSIntMessage& operator=(SimpleSIntMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleSIntMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleSIntMessage* internal_default_instance() {
+    return reinterpret_cast<const SimpleSIntMessage*>(
+               &_SimpleSIntMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  void Swap(SimpleSIntMessage* other);
+  friend void swap(SimpleSIntMessage& a, SimpleSIntMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleSIntMessage* New() const final {
+    return CreateMaybeMessage<SimpleSIntMessage>(NULL);
+  }
+
+  SimpleSIntMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleSIntMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleSIntMessage& from);
+  void MergeFrom(const SimpleSIntMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleSIntMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // sint32 testFieldInt = 1;
+  void clear_testfieldint();
+  static const int kTestFieldIntFieldNumber = 1;
+  ::google::protobuf::int32 testfieldint() const;
+  void set_testfieldint(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleSIntMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::int32 testfieldint_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleUIntMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleUIntMessage) */ {
+ public:
+  SimpleUIntMessage();
+  virtual ~SimpleUIntMessage();
+
+  SimpleUIntMessage(const SimpleUIntMessage& from);
+
+  inline SimpleUIntMessage& operator=(const SimpleUIntMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleUIntMessage(SimpleUIntMessage&& from) noexcept
+    : SimpleUIntMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleUIntMessage& operator=(SimpleUIntMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleUIntMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleUIntMessage* internal_default_instance() {
+    return reinterpret_cast<const SimpleUIntMessage*>(
+               &_SimpleUIntMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  void Swap(SimpleUIntMessage* other);
+  friend void swap(SimpleUIntMessage& a, SimpleUIntMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleUIntMessage* New() const final {
+    return CreateMaybeMessage<SimpleUIntMessage>(NULL);
+  }
+
+  SimpleUIntMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleUIntMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleUIntMessage& from);
+  void MergeFrom(const SimpleUIntMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleUIntMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 testFieldInt = 1;
+  void clear_testfieldint();
+  static const int kTestFieldIntFieldNumber = 1;
+  ::google::protobuf::uint32 testfieldint() const;
+  void set_testfieldint(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleUIntMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 testfieldint_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleInt64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleInt64Message) */ {
+ public:
+  SimpleInt64Message();
+  virtual ~SimpleInt64Message();
+
+  SimpleInt64Message(const SimpleInt64Message& from);
+
+  inline SimpleInt64Message& operator=(const SimpleInt64Message& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleInt64Message(SimpleInt64Message&& from) noexcept
+    : SimpleInt64Message() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleInt64Message& operator=(SimpleInt64Message&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleInt64Message& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleInt64Message* internal_default_instance() {
+    return reinterpret_cast<const SimpleInt64Message*>(
+               &_SimpleInt64Message_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  void Swap(SimpleInt64Message* other);
+  friend void swap(SimpleInt64Message& a, SimpleInt64Message& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleInt64Message* New() const final {
+    return CreateMaybeMessage<SimpleInt64Message>(NULL);
+  }
+
+  SimpleInt64Message* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleInt64Message>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleInt64Message& from);
+  void MergeFrom(const SimpleInt64Message& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleInt64Message* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // int64 testFieldInt = 1;
+  void clear_testfieldint();
+  static const int kTestFieldIntFieldNumber = 1;
+  ::google::protobuf::int64 testfieldint() const;
+  void set_testfieldint(::google::protobuf::int64 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleInt64Message)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::int64 testfieldint_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleSInt64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleSInt64Message) */ {
+ public:
+  SimpleSInt64Message();
+  virtual ~SimpleSInt64Message();
+
+  SimpleSInt64Message(const SimpleSInt64Message& from);
+
+  inline SimpleSInt64Message& operator=(const SimpleSInt64Message& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleSInt64Message(SimpleSInt64Message&& from) noexcept
+    : SimpleSInt64Message() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleSInt64Message& operator=(SimpleSInt64Message&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleSInt64Message& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleSInt64Message* internal_default_instance() {
+    return reinterpret_cast<const SimpleSInt64Message*>(
+               &_SimpleSInt64Message_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  void Swap(SimpleSInt64Message* other);
+  friend void swap(SimpleSInt64Message& a, SimpleSInt64Message& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleSInt64Message* New() const final {
+    return CreateMaybeMessage<SimpleSInt64Message>(NULL);
+  }
+
+  SimpleSInt64Message* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleSInt64Message>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleSInt64Message& from);
+  void MergeFrom(const SimpleSInt64Message& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleSInt64Message* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // sint64 testFieldInt = 1;
+  void clear_testfieldint();
+  static const int kTestFieldIntFieldNumber = 1;
+  ::google::protobuf::int64 testfieldint() const;
+  void set_testfieldint(::google::protobuf::int64 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleSInt64Message)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::int64 testfieldint_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleUInt64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleUInt64Message) */ {
+ public:
+  SimpleUInt64Message();
+  virtual ~SimpleUInt64Message();
+
+  SimpleUInt64Message(const SimpleUInt64Message& from);
+
+  inline SimpleUInt64Message& operator=(const SimpleUInt64Message& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleUInt64Message(SimpleUInt64Message&& from) noexcept
+    : SimpleUInt64Message() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleUInt64Message& operator=(SimpleUInt64Message&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleUInt64Message& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleUInt64Message* internal_default_instance() {
+    return reinterpret_cast<const SimpleUInt64Message*>(
+               &_SimpleUInt64Message_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  void Swap(SimpleUInt64Message* other);
+  friend void swap(SimpleUInt64Message& a, SimpleUInt64Message& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleUInt64Message* New() const final {
+    return CreateMaybeMessage<SimpleUInt64Message>(NULL);
+  }
+
+  SimpleUInt64Message* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleUInt64Message>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleUInt64Message& from);
+  void MergeFrom(const SimpleUInt64Message& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleUInt64Message* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint64 testFieldInt = 1;
+  void clear_testfieldint();
+  static const int kTestFieldIntFieldNumber = 1;
+  ::google::protobuf::uint64 testfieldint() const;
+  void set_testfieldint(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleUInt64Message)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint64 testfieldint_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleStringMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleStringMessage) */ {
+ public:
+  SimpleStringMessage();
+  virtual ~SimpleStringMessage();
+
+  SimpleStringMessage(const SimpleStringMessage& from);
+
+  inline SimpleStringMessage& operator=(const SimpleStringMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleStringMessage(SimpleStringMessage&& from) noexcept
+    : SimpleStringMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleStringMessage& operator=(SimpleStringMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleStringMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleStringMessage* internal_default_instance() {
+    return reinterpret_cast<const SimpleStringMessage*>(
+               &_SimpleStringMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  void Swap(SimpleStringMessage* other);
+  friend void swap(SimpleStringMessage& a, SimpleStringMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleStringMessage* New() const final {
+    return CreateMaybeMessage<SimpleStringMessage>(NULL);
+  }
+
+  SimpleStringMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleStringMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleStringMessage& from);
+  void MergeFrom(const SimpleStringMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleStringMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string testFieldString = 6;
+  void clear_testfieldstring();
+  static const int kTestFieldStringFieldNumber = 6;
+  const ::std::string& testfieldstring() const;
+  void set_testfieldstring(const ::std::string& value);
+  #if LANG_CXX11
+  void set_testfieldstring(::std::string&& value);
+  #endif
+  void set_testfieldstring(const char* value);
+  void set_testfieldstring(const char* value, size_t size);
+  ::std::string* mutable_testfieldstring();
+  ::std::string* release_testfieldstring();
+  void set_allocated_testfieldstring(::std::string* testfieldstring);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleStringMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr testfieldstring_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleFloatMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleFloatMessage) */ {
+ public:
+  SimpleFloatMessage();
+  virtual ~SimpleFloatMessage();
+
+  SimpleFloatMessage(const SimpleFloatMessage& from);
+
+  inline SimpleFloatMessage& operator=(const SimpleFloatMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleFloatMessage(SimpleFloatMessage&& from) noexcept
+    : SimpleFloatMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleFloatMessage& operator=(SimpleFloatMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleFloatMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleFloatMessage* internal_default_instance() {
+    return reinterpret_cast<const SimpleFloatMessage*>(
+               &_SimpleFloatMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  void Swap(SimpleFloatMessage* other);
+  friend void swap(SimpleFloatMessage& a, SimpleFloatMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleFloatMessage* New() const final {
+    return CreateMaybeMessage<SimpleFloatMessage>(NULL);
+  }
+
+  SimpleFloatMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleFloatMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleFloatMessage& from);
+  void MergeFrom(const SimpleFloatMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleFloatMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float testFieldFloat = 7;
+  void clear_testfieldfloat();
+  static const int kTestFieldFloatFieldNumber = 7;
+  float testfieldfloat() const;
+  void set_testfieldfloat(float value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleFloatMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float testfieldfloat_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleDoubleMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleDoubleMessage) */ {
+ public:
+  SimpleDoubleMessage();
+  virtual ~SimpleDoubleMessage();
+
+  SimpleDoubleMessage(const SimpleDoubleMessage& from);
+
+  inline SimpleDoubleMessage& operator=(const SimpleDoubleMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleDoubleMessage(SimpleDoubleMessage&& from) noexcept
+    : SimpleDoubleMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleDoubleMessage& operator=(SimpleDoubleMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleDoubleMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleDoubleMessage* internal_default_instance() {
+    return reinterpret_cast<const SimpleDoubleMessage*>(
+               &_SimpleDoubleMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  void Swap(SimpleDoubleMessage* other);
+  friend void swap(SimpleDoubleMessage& a, SimpleDoubleMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleDoubleMessage* New() const final {
+    return CreateMaybeMessage<SimpleDoubleMessage>(NULL);
+  }
+
+  SimpleDoubleMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleDoubleMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleDoubleMessage& from);
+  void MergeFrom(const SimpleDoubleMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleDoubleMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // double testFieldDouble = 8;
+  void clear_testfielddouble();
+  static const int kTestFieldDoubleFieldNumber = 8;
+  double testfielddouble() const;
+  void set_testfielddouble(double value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleDoubleMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  double testfielddouble_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleBytesMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleBytesMessage) */ {
+ public:
+  SimpleBytesMessage();
+  virtual ~SimpleBytesMessage();
+
+  SimpleBytesMessage(const SimpleBytesMessage& from);
+
+  inline SimpleBytesMessage& operator=(const SimpleBytesMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleBytesMessage(SimpleBytesMessage&& from) noexcept
+    : SimpleBytesMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleBytesMessage& operator=(SimpleBytesMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleBytesMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleBytesMessage* internal_default_instance() {
+    return reinterpret_cast<const SimpleBytesMessage*>(
+               &_SimpleBytesMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  void Swap(SimpleBytesMessage* other);
+  friend void swap(SimpleBytesMessage& a, SimpleBytesMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleBytesMessage* New() const final {
+    return CreateMaybeMessage<SimpleBytesMessage>(NULL);
+  }
+
+  SimpleBytesMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleBytesMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleBytesMessage& from);
+  void MergeFrom(const SimpleBytesMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleBytesMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bytes testFieldBytes = 1;
+  void clear_testfieldbytes();
+  static const int kTestFieldBytesFieldNumber = 1;
+  const ::std::string& testfieldbytes() const;
+  void set_testfieldbytes(const ::std::string& value);
+  #if LANG_CXX11
+  void set_testfieldbytes(::std::string&& value);
+  #endif
+  void set_testfieldbytes(const char* value);
+  void set_testfieldbytes(const void* value, size_t size);
+  ::std::string* mutable_testfieldbytes();
+  ::std::string* release_testfieldbytes();
+  void set_allocated_testfieldbytes(::std::string* testfieldbytes);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleBytesMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr testfieldbytes_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleFixedInt32Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleFixedInt32Message) */ {
+ public:
+  SimpleFixedInt32Message();
+  virtual ~SimpleFixedInt32Message();
+
+  SimpleFixedInt32Message(const SimpleFixedInt32Message& from);
+
+  inline SimpleFixedInt32Message& operator=(const SimpleFixedInt32Message& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleFixedInt32Message(SimpleFixedInt32Message&& from) noexcept
+    : SimpleFixedInt32Message() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleFixedInt32Message& operator=(SimpleFixedInt32Message&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleFixedInt32Message& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleFixedInt32Message* internal_default_instance() {
+    return reinterpret_cast<const SimpleFixedInt32Message*>(
+               &_SimpleFixedInt32Message_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  void Swap(SimpleFixedInt32Message* other);
+  friend void swap(SimpleFixedInt32Message& a, SimpleFixedInt32Message& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleFixedInt32Message* New() const final {
+    return CreateMaybeMessage<SimpleFixedInt32Message>(NULL);
+  }
+
+  SimpleFixedInt32Message* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleFixedInt32Message>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleFixedInt32Message& from);
+  void MergeFrom(const SimpleFixedInt32Message& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleFixedInt32Message* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 testFieldFixedInt32 = 1;
+  void clear_testfieldfixedint32();
+  static const int kTestFieldFixedInt32FieldNumber = 1;
+  ::google::protobuf::uint32 testfieldfixedint32() const;
+  void set_testfieldfixedint32(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleFixedInt32Message)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 testfieldfixedint32_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleFixedInt64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleFixedInt64Message) */ {
+ public:
+  SimpleFixedInt64Message();
+  virtual ~SimpleFixedInt64Message();
+
+  SimpleFixedInt64Message(const SimpleFixedInt64Message& from);
+
+  inline SimpleFixedInt64Message& operator=(const SimpleFixedInt64Message& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleFixedInt64Message(SimpleFixedInt64Message&& from) noexcept
+    : SimpleFixedInt64Message() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleFixedInt64Message& operator=(SimpleFixedInt64Message&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleFixedInt64Message& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleFixedInt64Message* internal_default_instance() {
+    return reinterpret_cast<const SimpleFixedInt64Message*>(
+               &_SimpleFixedInt64Message_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  void Swap(SimpleFixedInt64Message* other);
+  friend void swap(SimpleFixedInt64Message& a, SimpleFixedInt64Message& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleFixedInt64Message* New() const final {
+    return CreateMaybeMessage<SimpleFixedInt64Message>(NULL);
+  }
+
+  SimpleFixedInt64Message* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleFixedInt64Message>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleFixedInt64Message& from);
+  void MergeFrom(const SimpleFixedInt64Message& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleFixedInt64Message* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed64 testFieldFixedInt64 = 1;
+  void clear_testfieldfixedint64();
+  static const int kTestFieldFixedInt64FieldNumber = 1;
+  ::google::protobuf::uint64 testfieldfixedint64() const;
+  void set_testfieldfixedint64(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleFixedInt64Message)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint64 testfieldfixedint64_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleSFixedInt32Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleSFixedInt32Message) */ {
+ public:
+  SimpleSFixedInt32Message();
+  virtual ~SimpleSFixedInt32Message();
+
+  SimpleSFixedInt32Message(const SimpleSFixedInt32Message& from);
+
+  inline SimpleSFixedInt32Message& operator=(const SimpleSFixedInt32Message& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleSFixedInt32Message(SimpleSFixedInt32Message&& from) noexcept
+    : SimpleSFixedInt32Message() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleSFixedInt32Message& operator=(SimpleSFixedInt32Message&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleSFixedInt32Message& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleSFixedInt32Message* internal_default_instance() {
+    return reinterpret_cast<const SimpleSFixedInt32Message*>(
+               &_SimpleSFixedInt32Message_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  void Swap(SimpleSFixedInt32Message* other);
+  friend void swap(SimpleSFixedInt32Message& a, SimpleSFixedInt32Message& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleSFixedInt32Message* New() const final {
+    return CreateMaybeMessage<SimpleSFixedInt32Message>(NULL);
+  }
+
+  SimpleSFixedInt32Message* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleSFixedInt32Message>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleSFixedInt32Message& from);
+  void MergeFrom(const SimpleSFixedInt32Message& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleSFixedInt32Message* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // sfixed32 testFieldFixedInt32 = 1;
+  void clear_testfieldfixedint32();
+  static const int kTestFieldFixedInt32FieldNumber = 1;
+  ::google::protobuf::int32 testfieldfixedint32() const;
+  void set_testfieldfixedint32(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::int32 testfieldfixedint32_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SimpleSFixedInt64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleSFixedInt64Message) */ {
+ public:
+  SimpleSFixedInt64Message();
+  virtual ~SimpleSFixedInt64Message();
+
+  SimpleSFixedInt64Message(const SimpleSFixedInt64Message& from);
+
+  inline SimpleSFixedInt64Message& operator=(const SimpleSFixedInt64Message& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SimpleSFixedInt64Message(SimpleSFixedInt64Message&& from) noexcept
+    : SimpleSFixedInt64Message() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleSFixedInt64Message& operator=(SimpleSFixedInt64Message&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SimpleSFixedInt64Message& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SimpleSFixedInt64Message* internal_default_instance() {
+    return reinterpret_cast<const SimpleSFixedInt64Message*>(
+               &_SimpleSFixedInt64Message_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  void Swap(SimpleSFixedInt64Message* other);
+  friend void swap(SimpleSFixedInt64Message& a, SimpleSFixedInt64Message& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SimpleSFixedInt64Message* New() const final {
+    return CreateMaybeMessage<SimpleSFixedInt64Message>(NULL);
+  }
+
+  SimpleSFixedInt64Message* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SimpleSFixedInt64Message>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const SimpleSFixedInt64Message& from);
+  void MergeFrom(const SimpleSFixedInt64Message& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleSFixedInt64Message* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // sfixed64 testFieldFixedInt64 = 1;
+  void clear_testfieldfixedint64();
+  static const int kTestFieldFixedInt64FieldNumber = 1;
+  ::google::protobuf::int64 testfieldfixedint64() const;
+  void set_testfieldfixedint64(::google::protobuf::int64 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::int64 testfieldfixedint64_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class ComplexMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.ComplexMessage) */ {
+ public:
+  ComplexMessage();
+  virtual ~ComplexMessage();
+
+  ComplexMessage(const ComplexMessage& from);
+
+  inline ComplexMessage& operator=(const ComplexMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ComplexMessage(ComplexMessage&& from) noexcept
+    : ComplexMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline ComplexMessage& operator=(ComplexMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ComplexMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ComplexMessage* internal_default_instance() {
+    return reinterpret_cast<const ComplexMessage*>(
+               &_ComplexMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  void Swap(ComplexMessage* other);
+  friend void swap(ComplexMessage& a, ComplexMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ComplexMessage* New() const final {
+    return CreateMaybeMessage<ComplexMessage>(NULL);
+  }
+
+  ComplexMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<ComplexMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const ComplexMessage& from);
+  void MergeFrom(const ComplexMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ComplexMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .qtprotobufnamespace.tests.SimpleStringMessage testComplexField = 2;
+  bool has_testcomplexfield() const;
+  void clear_testcomplexfield();
+  static const int kTestComplexFieldFieldNumber = 2;
+  private:
+  const ::qtprotobufnamespace::tests::SimpleStringMessage& _internal_testcomplexfield() const;
+  public:
+  const ::qtprotobufnamespace::tests::SimpleStringMessage& testcomplexfield() const;
+  ::qtprotobufnamespace::tests::SimpleStringMessage* release_testcomplexfield();
+  ::qtprotobufnamespace::tests::SimpleStringMessage* mutable_testcomplexfield();
+  void set_allocated_testcomplexfield(::qtprotobufnamespace::tests::SimpleStringMessage* testcomplexfield);
+
+  // int32 testFieldInt = 1;
+  void clear_testfieldint();
+  static const int kTestFieldIntFieldNumber = 1;
+  ::google::protobuf::int32 testfieldint() const;
+  void set_testfieldint(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.ComplexMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::qtprotobufnamespace::tests::SimpleStringMessage* testcomplexfield_;
+  ::google::protobuf::int32 testfieldint_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class RepeatedIntMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedIntMessage) */ {
+ public:
+  RepeatedIntMessage();
+  virtual ~RepeatedIntMessage();
+
+  RepeatedIntMessage(const RepeatedIntMessage& from);
+
+  inline RepeatedIntMessage& operator=(const RepeatedIntMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RepeatedIntMessage(RepeatedIntMessage&& from) noexcept
+    : RepeatedIntMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline RepeatedIntMessage& operator=(RepeatedIntMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RepeatedIntMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RepeatedIntMessage* internal_default_instance() {
+    return reinterpret_cast<const RepeatedIntMessage*>(
+               &_RepeatedIntMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  void Swap(RepeatedIntMessage* other);
+  friend void swap(RepeatedIntMessage& a, RepeatedIntMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RepeatedIntMessage* New() const final {
+    return CreateMaybeMessage<RepeatedIntMessage>(NULL);
+  }
+
+  RepeatedIntMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<RepeatedIntMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const RepeatedIntMessage& from);
+  void MergeFrom(const RepeatedIntMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RepeatedIntMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated sint32 testRepeatedInt = 1;
+  int testrepeatedint_size() const;
+  void clear_testrepeatedint();
+  static const int kTestRepeatedIntFieldNumber = 1;
+  ::google::protobuf::int32 testrepeatedint(int index) const;
+  void set_testrepeatedint(int index, ::google::protobuf::int32 value);
+  void add_testrepeatedint(::google::protobuf::int32 value);
+  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+      testrepeatedint() const;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+      mutable_testrepeatedint();
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedIntMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > testrepeatedint_;
+  mutable int _testrepeatedint_cached_byte_size_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class RepeatedStringMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedStringMessage) */ {
+ public:
+  RepeatedStringMessage();
+  virtual ~RepeatedStringMessage();
+
+  RepeatedStringMessage(const RepeatedStringMessage& from);
+
+  inline RepeatedStringMessage& operator=(const RepeatedStringMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RepeatedStringMessage(RepeatedStringMessage&& from) noexcept
+    : RepeatedStringMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline RepeatedStringMessage& operator=(RepeatedStringMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RepeatedStringMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RepeatedStringMessage* internal_default_instance() {
+    return reinterpret_cast<const RepeatedStringMessage*>(
+               &_RepeatedStringMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  void Swap(RepeatedStringMessage* other);
+  friend void swap(RepeatedStringMessage& a, RepeatedStringMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RepeatedStringMessage* New() const final {
+    return CreateMaybeMessage<RepeatedStringMessage>(NULL);
+  }
+
+  RepeatedStringMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<RepeatedStringMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const RepeatedStringMessage& from);
+  void MergeFrom(const RepeatedStringMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RepeatedStringMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated string testRepeatedString = 1;
+  int testrepeatedstring_size() const;
+  void clear_testrepeatedstring();
+  static const int kTestRepeatedStringFieldNumber = 1;
+  const ::std::string& testrepeatedstring(int index) const;
+  ::std::string* mutable_testrepeatedstring(int index);
+  void set_testrepeatedstring(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_testrepeatedstring(int index, ::std::string&& value);
+  #endif
+  void set_testrepeatedstring(int index, const char* value);
+  void set_testrepeatedstring(int index, const char* value, size_t size);
+  ::std::string* add_testrepeatedstring();
+  void add_testrepeatedstring(const ::std::string& value);
+  #if LANG_CXX11
+  void add_testrepeatedstring(::std::string&& value);
+  #endif
+  void add_testrepeatedstring(const char* value);
+  void add_testrepeatedstring(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& testrepeatedstring() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_testrepeatedstring();
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedStringMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> testrepeatedstring_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class RepeatedDoubleMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedDoubleMessage) */ {
+ public:
+  RepeatedDoubleMessage();
+  virtual ~RepeatedDoubleMessage();
+
+  RepeatedDoubleMessage(const RepeatedDoubleMessage& from);
+
+  inline RepeatedDoubleMessage& operator=(const RepeatedDoubleMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RepeatedDoubleMessage(RepeatedDoubleMessage&& from) noexcept
+    : RepeatedDoubleMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline RepeatedDoubleMessage& operator=(RepeatedDoubleMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RepeatedDoubleMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RepeatedDoubleMessage* internal_default_instance() {
+    return reinterpret_cast<const RepeatedDoubleMessage*>(
+               &_RepeatedDoubleMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  void Swap(RepeatedDoubleMessage* other);
+  friend void swap(RepeatedDoubleMessage& a, RepeatedDoubleMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RepeatedDoubleMessage* New() const final {
+    return CreateMaybeMessage<RepeatedDoubleMessage>(NULL);
+  }
+
+  RepeatedDoubleMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<RepeatedDoubleMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const RepeatedDoubleMessage& from);
+  void MergeFrom(const RepeatedDoubleMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RepeatedDoubleMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated double testRepeatedDouble = 1;
+  int testrepeateddouble_size() const;
+  void clear_testrepeateddouble();
+  static const int kTestRepeatedDoubleFieldNumber = 1;
+  double testrepeateddouble(int index) const;
+  void set_testrepeateddouble(int index, double value);
+  void add_testrepeateddouble(double value);
+  const ::google::protobuf::RepeatedField< double >&
+      testrepeateddouble() const;
+  ::google::protobuf::RepeatedField< double >*
+      mutable_testrepeateddouble();
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedDoubleMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< double > testrepeateddouble_;
+  mutable int _testrepeateddouble_cached_byte_size_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class RepeatedBytesMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedBytesMessage) */ {
+ public:
+  RepeatedBytesMessage();
+  virtual ~RepeatedBytesMessage();
+
+  RepeatedBytesMessage(const RepeatedBytesMessage& from);
+
+  inline RepeatedBytesMessage& operator=(const RepeatedBytesMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RepeatedBytesMessage(RepeatedBytesMessage&& from) noexcept
+    : RepeatedBytesMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline RepeatedBytesMessage& operator=(RepeatedBytesMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RepeatedBytesMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RepeatedBytesMessage* internal_default_instance() {
+    return reinterpret_cast<const RepeatedBytesMessage*>(
+               &_RepeatedBytesMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    21;
+
+  void Swap(RepeatedBytesMessage* other);
+  friend void swap(RepeatedBytesMessage& a, RepeatedBytesMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RepeatedBytesMessage* New() const final {
+    return CreateMaybeMessage<RepeatedBytesMessage>(NULL);
+  }
+
+  RepeatedBytesMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<RepeatedBytesMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const RepeatedBytesMessage& from);
+  void MergeFrom(const RepeatedBytesMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RepeatedBytesMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated bytes testRepeatedBytes = 1;
+  int testrepeatedbytes_size() const;
+  void clear_testrepeatedbytes();
+  static const int kTestRepeatedBytesFieldNumber = 1;
+  const ::std::string& testrepeatedbytes(int index) const;
+  ::std::string* mutable_testrepeatedbytes(int index);
+  void set_testrepeatedbytes(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_testrepeatedbytes(int index, ::std::string&& value);
+  #endif
+  void set_testrepeatedbytes(int index, const char* value);
+  void set_testrepeatedbytes(int index, const void* value, size_t size);
+  ::std::string* add_testrepeatedbytes();
+  void add_testrepeatedbytes(const ::std::string& value);
+  #if LANG_CXX11
+  void add_testrepeatedbytes(::std::string&& value);
+  #endif
+  void add_testrepeatedbytes(const char* value);
+  void add_testrepeatedbytes(const void* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& testrepeatedbytes() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_testrepeatedbytes();
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedBytesMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> testrepeatedbytes_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class RepeatedFloatMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedFloatMessage) */ {
+ public:
+  RepeatedFloatMessage();
+  virtual ~RepeatedFloatMessage();
+
+  RepeatedFloatMessage(const RepeatedFloatMessage& from);
+
+  inline RepeatedFloatMessage& operator=(const RepeatedFloatMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RepeatedFloatMessage(RepeatedFloatMessage&& from) noexcept
+    : RepeatedFloatMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline RepeatedFloatMessage& operator=(RepeatedFloatMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RepeatedFloatMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RepeatedFloatMessage* internal_default_instance() {
+    return reinterpret_cast<const RepeatedFloatMessage*>(
+               &_RepeatedFloatMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    22;
+
+  void Swap(RepeatedFloatMessage* other);
+  friend void swap(RepeatedFloatMessage& a, RepeatedFloatMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RepeatedFloatMessage* New() const final {
+    return CreateMaybeMessage<RepeatedFloatMessage>(NULL);
+  }
+
+  RepeatedFloatMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<RepeatedFloatMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const RepeatedFloatMessage& from);
+  void MergeFrom(const RepeatedFloatMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RepeatedFloatMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float testRepeatedFloat = 1;
+  int testrepeatedfloat_size() const;
+  void clear_testrepeatedfloat();
+  static const int kTestRepeatedFloatFieldNumber = 1;
+  float testrepeatedfloat(int index) const;
+  void set_testrepeatedfloat(int index, float value);
+  void add_testrepeatedfloat(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      testrepeatedfloat() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_testrepeatedfloat();
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedFloatMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > testrepeatedfloat_;
+  mutable int _testrepeatedfloat_cached_byte_size_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class RepeatedComplexMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedComplexMessage) */ {
+ public:
+  RepeatedComplexMessage();
+  virtual ~RepeatedComplexMessage();
+
+  RepeatedComplexMessage(const RepeatedComplexMessage& from);
+
+  inline RepeatedComplexMessage& operator=(const RepeatedComplexMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RepeatedComplexMessage(RepeatedComplexMessage&& from) noexcept
+    : RepeatedComplexMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline RepeatedComplexMessage& operator=(RepeatedComplexMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RepeatedComplexMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RepeatedComplexMessage* internal_default_instance() {
+    return reinterpret_cast<const RepeatedComplexMessage*>(
+               &_RepeatedComplexMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    23;
+
+  void Swap(RepeatedComplexMessage* other);
+  friend void swap(RepeatedComplexMessage& a, RepeatedComplexMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RepeatedComplexMessage* New() const final {
+    return CreateMaybeMessage<RepeatedComplexMessage>(NULL);
+  }
+
+  RepeatedComplexMessage* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<RepeatedComplexMessage>(arena);
+  }
+  void CopyFrom(const ::google::protobuf::Message& from) final;
+  void MergeFrom(const ::google::protobuf::Message& from) final;
+  void CopyFrom(const RepeatedComplexMessage& from);
+  void MergeFrom(const RepeatedComplexMessage& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RepeatedComplexMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .qtprotobufnamespace.tests.ComplexMessage testRepeatedComplex = 1;
+  int testrepeatedcomplex_size() const;
+  void clear_testrepeatedcomplex();
+  static const int kTestRepeatedComplexFieldNumber = 1;
+  ::qtprotobufnamespace::tests::ComplexMessage* mutable_testrepeatedcomplex(int index);
+  ::google::protobuf::RepeatedPtrField< ::qtprotobufnamespace::tests::ComplexMessage >*
+      mutable_testrepeatedcomplex();
+  const ::qtprotobufnamespace::tests::ComplexMessage& testrepeatedcomplex(int index) const;
+  ::qtprotobufnamespace::tests::ComplexMessage* add_testrepeatedcomplex();
+  const ::google::protobuf::RepeatedPtrField< ::qtprotobufnamespace::tests::ComplexMessage >&
+      testrepeatedcomplex() const;
+
+  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedComplexMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::qtprotobufnamespace::tests::ComplexMessage > testrepeatedcomplex_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  friend struct ::protobuf_simpletest_2eproto::TableStruct;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SimpleEnumMessage
+
+// .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnum = 1;
+inline void SimpleEnumMessage::clear_localenum() {
+  localenum_ = 0;
+}
+inline ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum SimpleEnumMessage::localenum() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleEnumMessage.localEnum)
+  return static_cast< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum >(localenum_);
+}
+inline void SimpleEnumMessage::set_localenum(::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value) {
+  
+  localenum_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleEnumMessage.localEnum)
+}
+
+// repeated .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnumList = 2;
+inline int SimpleEnumMessage::localenumlist_size() const {
+  return localenumlist_.size();
+}
+inline void SimpleEnumMessage::clear_localenumlist() {
+  localenumlist_.Clear();
+}
+inline ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum SimpleEnumMessage::localenumlist(int index) const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleEnumMessage.localEnumList)
+  return static_cast< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum >(localenumlist_.Get(index));
+}
+inline void SimpleEnumMessage::set_localenumlist(int index, ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value) {
+  localenumlist_.Set(index, value);
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleEnumMessage.localEnumList)
+}
+inline void SimpleEnumMessage::add_localenumlist(::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value) {
+  localenumlist_.Add(value);
+  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.SimpleEnumMessage.localEnumList)
+}
+inline const ::google::protobuf::RepeatedField<int>&
+SimpleEnumMessage::localenumlist() const {
+  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.SimpleEnumMessage.localEnumList)
+  return localenumlist_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+SimpleEnumMessage::mutable_localenumlist() {
+  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.SimpleEnumMessage.localEnumList)
+  return &localenumlist_;
+}
+
+// -------------------------------------------------------------------
+
+// SimpleFileEnumMessage
+
+// .qtprotobufnamespace.tests.TestEnum globalEnum = 1;
+inline void SimpleFileEnumMessage::clear_globalenum() {
+  globalenum_ = 0;
+}
+inline ::qtprotobufnamespace::tests::TestEnum SimpleFileEnumMessage::globalenum() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnum)
+  return static_cast< ::qtprotobufnamespace::tests::TestEnum >(globalenum_);
+}
+inline void SimpleFileEnumMessage::set_globalenum(::qtprotobufnamespace::tests::TestEnum value) {
+  
+  globalenum_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnum)
+}
+
+// repeated .qtprotobufnamespace.tests.TestEnum globalEnumList = 2;
+inline int SimpleFileEnumMessage::globalenumlist_size() const {
+  return globalenumlist_.size();
+}
+inline void SimpleFileEnumMessage::clear_globalenumlist() {
+  globalenumlist_.Clear();
+}
+inline ::qtprotobufnamespace::tests::TestEnum SimpleFileEnumMessage::globalenumlist(int index) const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnumList)
+  return static_cast< ::qtprotobufnamespace::tests::TestEnum >(globalenumlist_.Get(index));
+}
+inline void SimpleFileEnumMessage::set_globalenumlist(int index, ::qtprotobufnamespace::tests::TestEnum value) {
+  globalenumlist_.Set(index, value);
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnumList)
+}
+inline void SimpleFileEnumMessage::add_globalenumlist(::qtprotobufnamespace::tests::TestEnum value) {
+  globalenumlist_.Add(value);
+  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnumList)
+}
+inline const ::google::protobuf::RepeatedField<int>&
+SimpleFileEnumMessage::globalenumlist() const {
+  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnumList)
+  return globalenumlist_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+SimpleFileEnumMessage::mutable_globalenumlist() {
+  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnumList)
+  return &globalenumlist_;
+}
+
+// -------------------------------------------------------------------
+
+// SimpleBoolMessage
+
+// bool testFieldBool = 1;
+inline void SimpleBoolMessage::clear_testfieldbool() {
+  testfieldbool_ = false;
+}
+inline bool SimpleBoolMessage::testfieldbool() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleBoolMessage.testFieldBool)
+  return testfieldbool_;
+}
+inline void SimpleBoolMessage::set_testfieldbool(bool value) {
+  
+  testfieldbool_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleBoolMessage.testFieldBool)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleIntMessage
+
+// int32 testFieldInt = 1;
+inline void SimpleIntMessage::clear_testfieldint() {
+  testfieldint_ = 0;
+}
+inline ::google::protobuf::int32 SimpleIntMessage::testfieldint() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleIntMessage.testFieldInt)
+  return testfieldint_;
+}
+inline void SimpleIntMessage::set_testfieldint(::google::protobuf::int32 value) {
+  
+  testfieldint_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleIntMessage.testFieldInt)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleSIntMessage
+
+// sint32 testFieldInt = 1;
+inline void SimpleSIntMessage::clear_testfieldint() {
+  testfieldint_ = 0;
+}
+inline ::google::protobuf::int32 SimpleSIntMessage::testfieldint() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleSIntMessage.testFieldInt)
+  return testfieldint_;
+}
+inline void SimpleSIntMessage::set_testfieldint(::google::protobuf::int32 value) {
+  
+  testfieldint_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleSIntMessage.testFieldInt)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleUIntMessage
+
+// uint32 testFieldInt = 1;
+inline void SimpleUIntMessage::clear_testfieldint() {
+  testfieldint_ = 0u;
+}
+inline ::google::protobuf::uint32 SimpleUIntMessage::testfieldint() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleUIntMessage.testFieldInt)
+  return testfieldint_;
+}
+inline void SimpleUIntMessage::set_testfieldint(::google::protobuf::uint32 value) {
+  
+  testfieldint_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleUIntMessage.testFieldInt)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleInt64Message
+
+// int64 testFieldInt = 1;
+inline void SimpleInt64Message::clear_testfieldint() {
+  testfieldint_ = GOOGLE_LONGLONG(0);
+}
+inline ::google::protobuf::int64 SimpleInt64Message::testfieldint() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleInt64Message.testFieldInt)
+  return testfieldint_;
+}
+inline void SimpleInt64Message::set_testfieldint(::google::protobuf::int64 value) {
+  
+  testfieldint_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleInt64Message.testFieldInt)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleSInt64Message
+
+// sint64 testFieldInt = 1;
+inline void SimpleSInt64Message::clear_testfieldint() {
+  testfieldint_ = GOOGLE_LONGLONG(0);
+}
+inline ::google::protobuf::int64 SimpleSInt64Message::testfieldint() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleSInt64Message.testFieldInt)
+  return testfieldint_;
+}
+inline void SimpleSInt64Message::set_testfieldint(::google::protobuf::int64 value) {
+  
+  testfieldint_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleSInt64Message.testFieldInt)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleUInt64Message
+
+// uint64 testFieldInt = 1;
+inline void SimpleUInt64Message::clear_testfieldint() {
+  testfieldint_ = GOOGLE_ULONGLONG(0);
+}
+inline ::google::protobuf::uint64 SimpleUInt64Message::testfieldint() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleUInt64Message.testFieldInt)
+  return testfieldint_;
+}
+inline void SimpleUInt64Message::set_testfieldint(::google::protobuf::uint64 value) {
+  
+  testfieldint_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleUInt64Message.testFieldInt)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleStringMessage
+
+// string testFieldString = 6;
+inline void SimpleStringMessage::clear_testfieldstring() {
+  testfieldstring_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& SimpleStringMessage::testfieldstring() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
+  return testfieldstring_.GetNoArena();
+}
+inline void SimpleStringMessage::set_testfieldstring(const ::std::string& value) {
+  
+  testfieldstring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
+}
+#if LANG_CXX11
+inline void SimpleStringMessage::set_testfieldstring(::std::string&& value) {
+  
+  testfieldstring_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
+}
+#endif
+inline void SimpleStringMessage::set_testfieldstring(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  testfieldstring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
+}
+inline void SimpleStringMessage::set_testfieldstring(const char* value, size_t size) {
+  
+  testfieldstring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
+}
+inline ::std::string* SimpleStringMessage::mutable_testfieldstring() {
+  
+  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
+  return testfieldstring_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* SimpleStringMessage::release_testfieldstring() {
+  // @@protoc_insertion_point(field_release:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
+  
+  return testfieldstring_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void SimpleStringMessage::set_allocated_testfieldstring(::std::string* testfieldstring) {
+  if (testfieldstring != NULL) {
+    
+  } else {
+    
+  }
+  testfieldstring_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), testfieldstring);
+  // @@protoc_insertion_point(field_set_allocated:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleFloatMessage
+
+// float testFieldFloat = 7;
+inline void SimpleFloatMessage::clear_testfieldfloat() {
+  testfieldfloat_ = 0;
+}
+inline float SimpleFloatMessage::testfieldfloat() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleFloatMessage.testFieldFloat)
+  return testfieldfloat_;
+}
+inline void SimpleFloatMessage::set_testfieldfloat(float value) {
+  
+  testfieldfloat_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleFloatMessage.testFieldFloat)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleDoubleMessage
+
+// double testFieldDouble = 8;
+inline void SimpleDoubleMessage::clear_testfielddouble() {
+  testfielddouble_ = 0;
+}
+inline double SimpleDoubleMessage::testfielddouble() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleDoubleMessage.testFieldDouble)
+  return testfielddouble_;
+}
+inline void SimpleDoubleMessage::set_testfielddouble(double value) {
+  
+  testfielddouble_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleDoubleMessage.testFieldDouble)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleBytesMessage
+
+// bytes testFieldBytes = 1;
+inline void SimpleBytesMessage::clear_testfieldbytes() {
+  testfieldbytes_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& SimpleBytesMessage::testfieldbytes() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
+  return testfieldbytes_.GetNoArena();
+}
+inline void SimpleBytesMessage::set_testfieldbytes(const ::std::string& value) {
+  
+  testfieldbytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
+}
+#if LANG_CXX11
+inline void SimpleBytesMessage::set_testfieldbytes(::std::string&& value) {
+  
+  testfieldbytes_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
+}
+#endif
+inline void SimpleBytesMessage::set_testfieldbytes(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  testfieldbytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
+}
+inline void SimpleBytesMessage::set_testfieldbytes(const void* value, size_t size) {
+  
+  testfieldbytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
+}
+inline ::std::string* SimpleBytesMessage::mutable_testfieldbytes() {
+  
+  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
+  return testfieldbytes_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* SimpleBytesMessage::release_testfieldbytes() {
+  // @@protoc_insertion_point(field_release:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
+  
+  return testfieldbytes_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void SimpleBytesMessage::set_allocated_testfieldbytes(::std::string* testfieldbytes) {
+  if (testfieldbytes != NULL) {
+    
+  } else {
+    
+  }
+  testfieldbytes_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), testfieldbytes);
+  // @@protoc_insertion_point(field_set_allocated:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleFixedInt32Message
+
+// fixed32 testFieldFixedInt32 = 1;
+inline void SimpleFixedInt32Message::clear_testfieldfixedint32() {
+  testfieldfixedint32_ = 0u;
+}
+inline ::google::protobuf::uint32 SimpleFixedInt32Message::testfieldfixedint32() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleFixedInt32Message.testFieldFixedInt32)
+  return testfieldfixedint32_;
+}
+inline void SimpleFixedInt32Message::set_testfieldfixedint32(::google::protobuf::uint32 value) {
+  
+  testfieldfixedint32_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleFixedInt32Message.testFieldFixedInt32)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleFixedInt64Message
+
+// fixed64 testFieldFixedInt64 = 1;
+inline void SimpleFixedInt64Message::clear_testfieldfixedint64() {
+  testfieldfixedint64_ = GOOGLE_ULONGLONG(0);
+}
+inline ::google::protobuf::uint64 SimpleFixedInt64Message::testfieldfixedint64() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleFixedInt64Message.testFieldFixedInt64)
+  return testfieldfixedint64_;
+}
+inline void SimpleFixedInt64Message::set_testfieldfixedint64(::google::protobuf::uint64 value) {
+  
+  testfieldfixedint64_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleFixedInt64Message.testFieldFixedInt64)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleSFixedInt32Message
+
+// sfixed32 testFieldFixedInt32 = 1;
+inline void SimpleSFixedInt32Message::clear_testfieldfixedint32() {
+  testfieldfixedint32_ = 0;
+}
+inline ::google::protobuf::int32 SimpleSFixedInt32Message::testfieldfixedint32() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleSFixedInt32Message.testFieldFixedInt32)
+  return testfieldfixedint32_;
+}
+inline void SimpleSFixedInt32Message::set_testfieldfixedint32(::google::protobuf::int32 value) {
+  
+  testfieldfixedint32_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleSFixedInt32Message.testFieldFixedInt32)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleSFixedInt64Message
+
+// sfixed64 testFieldFixedInt64 = 1;
+inline void SimpleSFixedInt64Message::clear_testfieldfixedint64() {
+  testfieldfixedint64_ = GOOGLE_LONGLONG(0);
+}
+inline ::google::protobuf::int64 SimpleSFixedInt64Message::testfieldfixedint64() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleSFixedInt64Message.testFieldFixedInt64)
+  return testfieldfixedint64_;
+}
+inline void SimpleSFixedInt64Message::set_testfieldfixedint64(::google::protobuf::int64 value) {
+  
+  testfieldfixedint64_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleSFixedInt64Message.testFieldFixedInt64)
+}
+
+// -------------------------------------------------------------------
+
+// ComplexMessage
+
+// int32 testFieldInt = 1;
+inline void ComplexMessage::clear_testfieldint() {
+  testfieldint_ = 0;
+}
+inline ::google::protobuf::int32 ComplexMessage::testfieldint() const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.ComplexMessage.testFieldInt)
+  return testfieldint_;
+}
+inline void ComplexMessage::set_testfieldint(::google::protobuf::int32 value) {
+  
+  testfieldint_ = value;
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.ComplexMessage.testFieldInt)
+}
+
+// .qtprotobufnamespace.tests.SimpleStringMessage testComplexField = 2;
+inline bool ComplexMessage::has_testcomplexfield() const {
+  return this != internal_default_instance() && testcomplexfield_ != NULL;
+}
+inline void ComplexMessage::clear_testcomplexfield() {
+  if (GetArenaNoVirtual() == NULL && testcomplexfield_ != NULL) {
+    delete testcomplexfield_;
+  }
+  testcomplexfield_ = NULL;
+}
+inline const ::qtprotobufnamespace::tests::SimpleStringMessage& ComplexMessage::_internal_testcomplexfield() const {
+  return *testcomplexfield_;
+}
+inline const ::qtprotobufnamespace::tests::SimpleStringMessage& ComplexMessage::testcomplexfield() const {
+  const ::qtprotobufnamespace::tests::SimpleStringMessage* p = testcomplexfield_;
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.ComplexMessage.testComplexField)
+  return p != NULL ? *p : *reinterpret_cast<const ::qtprotobufnamespace::tests::SimpleStringMessage*>(
+      &::qtprotobufnamespace::tests::_SimpleStringMessage_default_instance_);
+}
+inline ::qtprotobufnamespace::tests::SimpleStringMessage* ComplexMessage::release_testcomplexfield() {
+  // @@protoc_insertion_point(field_release:qtprotobufnamespace.tests.ComplexMessage.testComplexField)
+  
+  ::qtprotobufnamespace::tests::SimpleStringMessage* temp = testcomplexfield_;
+  testcomplexfield_ = NULL;
+  return temp;
+}
+inline ::qtprotobufnamespace::tests::SimpleStringMessage* ComplexMessage::mutable_testcomplexfield() {
+  
+  if (testcomplexfield_ == NULL) {
+    auto* p = CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleStringMessage>(GetArenaNoVirtual());
+    testcomplexfield_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.ComplexMessage.testComplexField)
+  return testcomplexfield_;
+}
+inline void ComplexMessage::set_allocated_testcomplexfield(::qtprotobufnamespace::tests::SimpleStringMessage* testcomplexfield) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete testcomplexfield_;
+  }
+  if (testcomplexfield) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      testcomplexfield = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, testcomplexfield, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  testcomplexfield_ = testcomplexfield;
+  // @@protoc_insertion_point(field_set_allocated:qtprotobufnamespace.tests.ComplexMessage.testComplexField)
+}
+
+// -------------------------------------------------------------------
+
+// RepeatedIntMessage
+
+// repeated sint32 testRepeatedInt = 1;
+inline int RepeatedIntMessage::testrepeatedint_size() const {
+  return testrepeatedint_.size();
+}
+inline void RepeatedIntMessage::clear_testrepeatedint() {
+  testrepeatedint_.Clear();
+}
+inline ::google::protobuf::int32 RepeatedIntMessage::testrepeatedint(int index) const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedIntMessage.testRepeatedInt)
+  return testrepeatedint_.Get(index);
+}
+inline void RepeatedIntMessage::set_testrepeatedint(int index, ::google::protobuf::int32 value) {
+  testrepeatedint_.Set(index, value);
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedIntMessage.testRepeatedInt)
+}
+inline void RepeatedIntMessage::add_testrepeatedint(::google::protobuf::int32 value) {
+  testrepeatedint_.Add(value);
+  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedIntMessage.testRepeatedInt)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+RepeatedIntMessage::testrepeatedint() const {
+  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedIntMessage.testRepeatedInt)
+  return testrepeatedint_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+RepeatedIntMessage::mutable_testrepeatedint() {
+  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedIntMessage.testRepeatedInt)
+  return &testrepeatedint_;
+}
+
+// -------------------------------------------------------------------
+
+// RepeatedStringMessage
+
+// repeated string testRepeatedString = 1;
+inline int RepeatedStringMessage::testrepeatedstring_size() const {
+  return testrepeatedstring_.size();
+}
+inline void RepeatedStringMessage::clear_testrepeatedstring() {
+  testrepeatedstring_.Clear();
+}
+inline const ::std::string& RepeatedStringMessage::testrepeatedstring(int index) const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+  return testrepeatedstring_.Get(index);
+}
+inline ::std::string* RepeatedStringMessage::mutable_testrepeatedstring(int index) {
+  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+  return testrepeatedstring_.Mutable(index);
+}
+inline void RepeatedStringMessage::set_testrepeatedstring(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+  testrepeatedstring_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void RepeatedStringMessage::set_testrepeatedstring(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+  testrepeatedstring_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void RepeatedStringMessage::set_testrepeatedstring(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  testrepeatedstring_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+}
+inline void RepeatedStringMessage::set_testrepeatedstring(int index, const char* value, size_t size) {
+  testrepeatedstring_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+}
+inline ::std::string* RepeatedStringMessage::add_testrepeatedstring() {
+  // @@protoc_insertion_point(field_add_mutable:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+  return testrepeatedstring_.Add();
+}
+inline void RepeatedStringMessage::add_testrepeatedstring(const ::std::string& value) {
+  testrepeatedstring_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+}
+#if LANG_CXX11
+inline void RepeatedStringMessage::add_testrepeatedstring(::std::string&& value) {
+  testrepeatedstring_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+}
+#endif
+inline void RepeatedStringMessage::add_testrepeatedstring(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  testrepeatedstring_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+}
+inline void RepeatedStringMessage::add_testrepeatedstring(const char* value, size_t size) {
+  testrepeatedstring_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+RepeatedStringMessage::testrepeatedstring() const {
+  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+  return testrepeatedstring_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+RepeatedStringMessage::mutable_testrepeatedstring() {
+  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
+  return &testrepeatedstring_;
+}
+
+// -------------------------------------------------------------------
+
+// RepeatedDoubleMessage
+
+// repeated double testRepeatedDouble = 1;
+inline int RepeatedDoubleMessage::testrepeateddouble_size() const {
+  return testrepeateddouble_.size();
+}
+inline void RepeatedDoubleMessage::clear_testrepeateddouble() {
+  testrepeateddouble_.Clear();
+}
+inline double RepeatedDoubleMessage::testrepeateddouble(int index) const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedDoubleMessage.testRepeatedDouble)
+  return testrepeateddouble_.Get(index);
+}
+inline void RepeatedDoubleMessage::set_testrepeateddouble(int index, double value) {
+  testrepeateddouble_.Set(index, value);
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedDoubleMessage.testRepeatedDouble)
+}
+inline void RepeatedDoubleMessage::add_testrepeateddouble(double value) {
+  testrepeateddouble_.Add(value);
+  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedDoubleMessage.testRepeatedDouble)
+}
+inline const ::google::protobuf::RepeatedField< double >&
+RepeatedDoubleMessage::testrepeateddouble() const {
+  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedDoubleMessage.testRepeatedDouble)
+  return testrepeateddouble_;
+}
+inline ::google::protobuf::RepeatedField< double >*
+RepeatedDoubleMessage::mutable_testrepeateddouble() {
+  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedDoubleMessage.testRepeatedDouble)
+  return &testrepeateddouble_;
+}
+
+// -------------------------------------------------------------------
+
+// RepeatedBytesMessage
+
+// repeated bytes testRepeatedBytes = 1;
+inline int RepeatedBytesMessage::testrepeatedbytes_size() const {
+  return testrepeatedbytes_.size();
+}
+inline void RepeatedBytesMessage::clear_testrepeatedbytes() {
+  testrepeatedbytes_.Clear();
+}
+inline const ::std::string& RepeatedBytesMessage::testrepeatedbytes(int index) const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+  return testrepeatedbytes_.Get(index);
+}
+inline ::std::string* RepeatedBytesMessage::mutable_testrepeatedbytes(int index) {
+  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+  return testrepeatedbytes_.Mutable(index);
+}
+inline void RepeatedBytesMessage::set_testrepeatedbytes(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+  testrepeatedbytes_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void RepeatedBytesMessage::set_testrepeatedbytes(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+  testrepeatedbytes_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void RepeatedBytesMessage::set_testrepeatedbytes(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  testrepeatedbytes_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+}
+inline void RepeatedBytesMessage::set_testrepeatedbytes(int index, const void* value, size_t size) {
+  testrepeatedbytes_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+}
+inline ::std::string* RepeatedBytesMessage::add_testrepeatedbytes() {
+  // @@protoc_insertion_point(field_add_mutable:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+  return testrepeatedbytes_.Add();
+}
+inline void RepeatedBytesMessage::add_testrepeatedbytes(const ::std::string& value) {
+  testrepeatedbytes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+}
+#if LANG_CXX11
+inline void RepeatedBytesMessage::add_testrepeatedbytes(::std::string&& value) {
+  testrepeatedbytes_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+}
+#endif
+inline void RepeatedBytesMessage::add_testrepeatedbytes(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  testrepeatedbytes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+}
+inline void RepeatedBytesMessage::add_testrepeatedbytes(const void* value, size_t size) {
+  testrepeatedbytes_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+RepeatedBytesMessage::testrepeatedbytes() const {
+  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+  return testrepeatedbytes_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+RepeatedBytesMessage::mutable_testrepeatedbytes() {
+  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
+  return &testrepeatedbytes_;
+}
+
+// -------------------------------------------------------------------
+
+// RepeatedFloatMessage
+
+// repeated float testRepeatedFloat = 1;
+inline int RepeatedFloatMessage::testrepeatedfloat_size() const {
+  return testrepeatedfloat_.size();
+}
+inline void RepeatedFloatMessage::clear_testrepeatedfloat() {
+  testrepeatedfloat_.Clear();
+}
+inline float RepeatedFloatMessage::testrepeatedfloat(int index) const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedFloatMessage.testRepeatedFloat)
+  return testrepeatedfloat_.Get(index);
+}
+inline void RepeatedFloatMessage::set_testrepeatedfloat(int index, float value) {
+  testrepeatedfloat_.Set(index, value);
+  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedFloatMessage.testRepeatedFloat)
+}
+inline void RepeatedFloatMessage::add_testrepeatedfloat(float value) {
+  testrepeatedfloat_.Add(value);
+  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedFloatMessage.testRepeatedFloat)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+RepeatedFloatMessage::testrepeatedfloat() const {
+  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedFloatMessage.testRepeatedFloat)
+  return testrepeatedfloat_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+RepeatedFloatMessage::mutable_testrepeatedfloat() {
+  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedFloatMessage.testRepeatedFloat)
+  return &testrepeatedfloat_;
+}
+
+// -------------------------------------------------------------------
+
+// RepeatedComplexMessage
+
+// repeated .qtprotobufnamespace.tests.ComplexMessage testRepeatedComplex = 1;
+inline int RepeatedComplexMessage::testrepeatedcomplex_size() const {
+  return testrepeatedcomplex_.size();
+}
+inline void RepeatedComplexMessage::clear_testrepeatedcomplex() {
+  testrepeatedcomplex_.Clear();
+}
+inline ::qtprotobufnamespace::tests::ComplexMessage* RepeatedComplexMessage::mutable_testrepeatedcomplex(int index) {
+  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.RepeatedComplexMessage.testRepeatedComplex)
+  return testrepeatedcomplex_.Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::qtprotobufnamespace::tests::ComplexMessage >*
+RepeatedComplexMessage::mutable_testrepeatedcomplex() {
+  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedComplexMessage.testRepeatedComplex)
+  return &testrepeatedcomplex_;
+}
+inline const ::qtprotobufnamespace::tests::ComplexMessage& RepeatedComplexMessage::testrepeatedcomplex(int index) const {
+  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedComplexMessage.testRepeatedComplex)
+  return testrepeatedcomplex_.Get(index);
+}
+inline ::qtprotobufnamespace::tests::ComplexMessage* RepeatedComplexMessage::add_testrepeatedcomplex() {
+  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedComplexMessage.testRepeatedComplex)
+  return testrepeatedcomplex_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::qtprotobufnamespace::tests::ComplexMessage >&
+RepeatedComplexMessage::testrepeatedcomplex() const {
+  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedComplexMessage.testRepeatedComplex)
+  return testrepeatedcomplex_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum>() {
+  return ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum_descriptor();
+}
+template <> struct is_proto_enum< ::qtprotobufnamespace::tests::TestEnum> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::qtprotobufnamespace::tests::TestEnum>() {
+  return ::qtprotobufnamespace::tests::TestEnum_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_INCLUDED_simpletest_2eproto

+ 117 - 0
tests/echoserver/testserver/simpletest.proto

@@ -0,0 +1,117 @@
+syntax = "proto3";
+
+package qtprotobufnamespace.tests;
+
+message SimpleEnumMessage {
+  enum LocalEnum {
+    LOCAL_ENUM_VALUE0 = 0;
+    LOCAL_ENUM_VALUE1 = 1;
+    LOCAL_ENUM_VALUE2 = 2;
+    LOCAL_ENUM_VALUE3 = 3;
+  }
+
+  LocalEnum localEnum = 1;
+  repeated LocalEnum localEnumList = 2;
+}
+
+message SimpleFileEnumMessage {
+  TestEnum globalEnum = 1;
+  repeated TestEnum globalEnumList = 2;
+}
+
+message SimpleBoolMessage {
+    bool testFieldBool = 1;
+}
+
+message SimpleIntMessage {
+    int32 testFieldInt = 1;
+}
+
+message SimpleSIntMessage {
+    sint32 testFieldInt = 1;
+}
+
+message SimpleUIntMessage {
+    uint32 testFieldInt = 1;
+}
+
+message SimpleInt64Message {
+    int64 testFieldInt = 1;
+}
+
+message SimpleSInt64Message {
+    sint64 testFieldInt = 1;
+}
+
+message SimpleUInt64Message {
+    uint64 testFieldInt = 1;
+}
+
+message SimpleStringMessage {
+    string testFieldString = 6;
+}
+
+message SimpleFloatMessage {
+    float testFieldFloat = 7;
+}
+
+message SimpleDoubleMessage {
+    double testFieldDouble = 8;
+}
+
+message SimpleBytesMessage {
+    bytes testFieldBytes = 1;
+}
+
+message SimpleFixedInt32Message {
+    fixed32 testFieldFixedInt32 = 1;
+}
+
+message SimpleFixedInt64Message {
+    fixed64 testFieldFixedInt64 = 1;
+}
+
+message SimpleSFixedInt32Message {
+    sfixed32 testFieldFixedInt32 = 1;
+}
+
+message SimpleSFixedInt64Message {
+    sfixed64 testFieldFixedInt64 = 1;
+}
+
+message ComplexMessage {
+    int32 testFieldInt = 1;
+    SimpleStringMessage testComplexField = 2;
+}
+
+message RepeatedIntMessage {
+    repeated sint32 testRepeatedInt = 1;
+}
+
+message RepeatedStringMessage {
+    repeated string testRepeatedString = 1;
+}
+
+message RepeatedDoubleMessage {
+    repeated double testRepeatedDouble = 1;
+}
+
+message RepeatedBytesMessage {
+    repeated bytes testRepeatedBytes = 1;
+}
+
+message RepeatedFloatMessage {
+    repeated float testRepeatedFloat = 1;
+}
+
+message RepeatedComplexMessage {
+    repeated ComplexMessage testRepeatedComplex = 1;
+}
+
+enum TestEnum {
+    TEST_ENUM_VALUE0 = 0;
+    TEST_ENUM_VALUE1 = 1;
+    TEST_ENUM_VALUE2 = 2;
+    TEST_ENUM_VALUE3 = 4;
+    TEST_ENUM_VALUE4 = 3;
+}

+ 45 - 0
tests/echoserver/testserver/testserver.pro

@@ -0,0 +1,45 @@
+QT -= gui
+
+CONFIG += c++11 console
+CONFIG -= app_bundle
+
+# The following define makes your compiler emit warnings if you use
+# any feature of Qt which as been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if you use deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += \
+        main.cpp \
+    globalenumssamenamespace.grpc.pb.cc \
+    globalenumssamenamespace.pb.cc \
+    globalenums.grpc.pb.cc \
+    simpletest.grpc.pb.cc \
+    simpletest.pb.cc \
+    testservice.grpc.pb.cc \
+    testservice.pb.cc \
+    globalenums.pb.cc
+
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target
+
+HEADERS += \
+    helloworld.grpc.pb.h \
+    helloworld.pb.h \
+    globalenumssamenamespace.grpc.pb.h \
+    globalenumssamenamespace.pb.h \
+    globalenums.grpc.pb.h \
+    simpletest.grpc.pb.h \
+    simpletest.pb.h \
+    testservice.grpc.pb.h \
+    testservice.pb.h \
+    globalenums.pb.h
+
+LIBS += -lgrpc++ -lprotobuf

+ 66 - 0
tests/echoserver/testserver/testservice.grpc.pb.cc

@@ -0,0 +1,66 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: testservice.proto
+
+#include "testservice.pb.h"
+#include "testservice.grpc.pb.h"
+
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace qtprotobufnamespace {
+namespace tests {
+
+static const char* TestService_method_names[] = {
+  "/qtprotobufnamespace.tests.TestService/testMethod",
+};
+
+std::unique_ptr< TestService::Stub> TestService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
+  (void)options;
+  std::unique_ptr< TestService::Stub> stub(new TestService::Stub(channel));
+  return stub;
+}
+
+TestService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel)
+  : channel_(channel), rpcmethod_testMethod_(TestService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  {}
+
+::grpc::Status TestService::Stub::testMethod(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::qtprotobufnamespace::tests::SimpleStringMessage* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_testMethod_, context, request, response);
+}
+
+::grpc::ClientAsyncResponseReader< ::qtprotobufnamespace::tests::SimpleStringMessage>* TestService::Stub::AsynctestMethodRaw(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderFactory< ::qtprotobufnamespace::tests::SimpleStringMessage>::Create(channel_.get(), cq, rpcmethod_testMethod_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::qtprotobufnamespace::tests::SimpleStringMessage>* TestService::Stub::PrepareAsynctestMethodRaw(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderFactory< ::qtprotobufnamespace::tests::SimpleStringMessage>::Create(channel_.get(), cq, rpcmethod_testMethod_, context, request, false);
+}
+
+TestService::Service::Service() {
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      TestService_method_names[0],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< TestService::Service, ::qtprotobufnamespace::tests::SimpleStringMessage, ::qtprotobufnamespace::tests::SimpleStringMessage>(
+          std::mem_fn(&TestService::Service::testMethod), this)));
+}
+
+TestService::Service::~Service() {
+}
+
+::grpc::Status TestService::Service::testMethod(::grpc::ServerContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage* request, ::qtprotobufnamespace::tests::SimpleStringMessage* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+
+}  // namespace qtprotobufnamespace
+}  // namespace tests
+

+ 161 - 0
tests/echoserver/testserver/testservice.grpc.pb.h

@@ -0,0 +1,161 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: testservice.proto
+#ifndef GRPC_testservice_2eproto__INCLUDED
+#define GRPC_testservice_2eproto__INCLUDED
+
+#include "testservice.pb.h"
+
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace grpc {
+class CompletionQueue;
+class Channel;
+class ServerCompletionQueue;
+class ServerContext;
+}  // namespace grpc
+
+namespace qtprotobufnamespace {
+namespace tests {
+
+class TestService final {
+ public:
+  static constexpr char const* service_full_name() {
+    return "qtprotobufnamespace.tests.TestService";
+  }
+  class StubInterface {
+   public:
+    virtual ~StubInterface() {}
+    virtual ::grpc::Status testMethod(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::qtprotobufnamespace::tests::SimpleStringMessage* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::qtprotobufnamespace::tests::SimpleStringMessage>> AsynctestMethod(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::qtprotobufnamespace::tests::SimpleStringMessage>>(AsynctestMethodRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::qtprotobufnamespace::tests::SimpleStringMessage>> PrepareAsynctestMethod(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::qtprotobufnamespace::tests::SimpleStringMessage>>(PrepareAsynctestMethodRaw(context, request, cq));
+    }
+  private:
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::qtprotobufnamespace::tests::SimpleStringMessage>* AsynctestMethodRaw(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::qtprotobufnamespace::tests::SimpleStringMessage>* PrepareAsynctestMethodRaw(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::grpc::CompletionQueue* cq) = 0;
+  };
+  class Stub final : public StubInterface {
+   public:
+    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
+    ::grpc::Status testMethod(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::qtprotobufnamespace::tests::SimpleStringMessage* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::qtprotobufnamespace::tests::SimpleStringMessage>> AsynctestMethod(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::qtprotobufnamespace::tests::SimpleStringMessage>>(AsynctestMethodRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::qtprotobufnamespace::tests::SimpleStringMessage>> PrepareAsynctestMethod(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::qtprotobufnamespace::tests::SimpleStringMessage>>(PrepareAsynctestMethodRaw(context, request, cq));
+    }
+
+   private:
+    std::shared_ptr< ::grpc::ChannelInterface> channel_;
+    ::grpc::ClientAsyncResponseReader< ::qtprotobufnamespace::tests::SimpleStringMessage>* AsynctestMethodRaw(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::qtprotobufnamespace::tests::SimpleStringMessage>* PrepareAsynctestMethodRaw(::grpc::ClientContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage& request, ::grpc::CompletionQueue* cq) override;
+    const ::grpc::internal::RpcMethod rpcmethod_testMethod_;
+  };
+  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+
+  class Service : public ::grpc::Service {
+   public:
+    Service();
+    virtual ~Service();
+    virtual ::grpc::Status testMethod(::grpc::ServerContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage* request, ::qtprotobufnamespace::tests::SimpleStringMessage* response);
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_testMethod : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_testMethod() {
+      ::grpc::Service::MarkMethodAsync(0);
+    }
+    ~WithAsyncMethod_testMethod() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status testMethod(::grpc::ServerContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage* request, ::qtprotobufnamespace::tests::SimpleStringMessage* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequesttestMethod(::grpc::ServerContext* context, ::qtprotobufnamespace::tests::SimpleStringMessage* request, ::grpc::ServerAsyncResponseWriter< ::qtprotobufnamespace::tests::SimpleStringMessage>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  typedef WithAsyncMethod_testMethod<Service > AsyncService;
+  template <class BaseClass>
+  class WithGenericMethod_testMethod : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_testMethod() {
+      ::grpc::Service::MarkMethodGeneric(0);
+    }
+    ~WithGenericMethod_testMethod() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status testMethod(::grpc::ServerContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage* request, ::qtprotobufnamespace::tests::SimpleStringMessage* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_testMethod : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_testMethod() {
+      ::grpc::Service::MarkMethodRaw(0);
+    }
+    ~WithRawMethod_testMethod() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status testMethod(::grpc::ServerContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage* request, ::qtprotobufnamespace::tests::SimpleStringMessage* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequesttestMethod(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_testMethod : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_testMethod() {
+      ::grpc::Service::MarkMethodStreamed(0,
+        new ::grpc::internal::StreamedUnaryHandler< ::qtprotobufnamespace::tests::SimpleStringMessage, ::qtprotobufnamespace::tests::SimpleStringMessage>(std::bind(&WithStreamedUnaryMethod_testMethod<BaseClass>::StreamedtestMethod, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_testMethod() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status testMethod(::grpc::ServerContext* context, const ::qtprotobufnamespace::tests::SimpleStringMessage* request, ::qtprotobufnamespace::tests::SimpleStringMessage* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedtestMethod(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::qtprotobufnamespace::tests::SimpleStringMessage,::qtprotobufnamespace::tests::SimpleStringMessage>* server_unary_streamer) = 0;
+  };
+  typedef WithStreamedUnaryMethod_testMethod<Service > StreamedUnaryService;
+  typedef Service SplitStreamedService;
+  typedef WithStreamedUnaryMethod_testMethod<Service > StreamedService;
+};
+
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+
+
+#endif  // GRPC_testservice_2eproto__INCLUDED

+ 89 - 0
tests/echoserver/testserver/testservice.pb.cc

@@ -0,0 +1,89 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: testservice.proto
+
+#include "testservice.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// This is a temporary google only hack
+#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+#include "third_party/protobuf/version.h"
+#endif
+// @@protoc_insertion_point(includes)
+
+namespace qtprotobufnamespace {
+namespace tests {
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace protobuf_testservice_2eproto {
+void InitDefaults() {
+}
+
+const ::google::protobuf::uint32 TableStruct::offsets[1] = {};
+static const ::google::protobuf::internal::MigrationSchema* schemas = NULL;
+static const ::google::protobuf::Message* const* file_default_instances = NULL;
+
+void protobuf_AssignDescriptors() {
+  AddDescriptors();
+  AssignDescriptors(
+      "testservice.proto", schemas, file_default_instances, TableStruct::offsets,
+      NULL, NULL, NULL);
+}
+
+void protobuf_AssignDescriptorsOnce() {
+  static ::google::protobuf::internal::once_flag once;
+  ::google::protobuf::internal::call_once(once, protobuf_AssignDescriptors);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+}
+
+void AddDescriptorsImpl() {
+  InitDefaults();
+  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+      "\n\021testservice.proto\022\031qtprotobufnamespace"
+      ".tests\032\020simpletest.proto2}\n\013TestService\022"
+      "n\n\ntestMethod\022..qtprotobufnamespace.test"
+      "s.SimpleStringMessage\032..qtprotobufnamesp"
+      "ace.tests.SimpleStringMessage\"\000b\006proto3"
+  };
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+      descriptor, 199);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "testservice.proto", &protobuf_RegisterTypes);
+  ::protobuf_simpletest_2eproto::AddDescriptors();
+}
+
+void AddDescriptors() {
+  static ::google::protobuf::internal::once_flag once;
+  ::google::protobuf::internal::call_once(once, AddDescriptorsImpl);
+}
+// Force AddDescriptors() to be called at dynamic initialization time.
+struct StaticDescriptorInitializer {
+  StaticDescriptorInitializer() {
+    AddDescriptors();
+  }
+} static_descriptor_initializer;
+}  // namespace protobuf_testservice_2eproto
+namespace qtprotobufnamespace {
+namespace tests {
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace google {
+namespace protobuf {
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)

+ 77 - 0
tests/echoserver/testserver/testservice.pb.h

@@ -0,0 +1,77 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: testservice.proto
+
+#ifndef PROTOBUF_INCLUDED_testservice_2eproto
+#define PROTOBUF_INCLUDED_testservice_2eproto
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3006001
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/inlined_string_field.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include "simpletest.pb.h"
+// @@protoc_insertion_point(includes)
+#define PROTOBUF_INTERNAL_EXPORT_protobuf_testservice_2eproto 
+
+namespace protobuf_testservice_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+}  // namespace protobuf_testservice_2eproto
+namespace qtprotobufnamespace {
+namespace tests {
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+namespace qtprotobufnamespace {
+namespace tests {
+
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace tests
+}  // namespace qtprotobufnamespace
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_INCLUDED_testservice_2eproto

+ 9 - 0
tests/echoserver/testserver/testservice.proto

@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+import "simpletest.proto";
+
+package qtprotobufnamespace.tests;
+
+service TestService {
+  rpc testMethod(SimpleStringMessage) returns (SimpleStringMessage) {}
+} 

+ 11 - 11
tests/serializationcomplexmessagemap.cpp

@@ -47,7 +47,7 @@ using namespace qtprotobuf;
 TEST_F(SerializationTest, SimpleFixed32ComplexMapSerializeTest)
 {
     SimpleFixed32ComplexMessageMapMessage test;
-    test.setMapField({{10, {16, {"ten sixteen"}}}, {42, {10, {"fourty two ten sixteen"}}}, {65555, {10, {"WUT?"}}}});
+    test.setMapField({{10, new ComplexMessage{16, {"ten sixteen"}}}, {42, new ComplexMessage{10, {"fourty two ten sixteen"}}}, {65555, new ComplexMessage{10, {"WUT?"}}}});
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
@@ -57,7 +57,7 @@ TEST_F(SerializationTest, SimpleFixed32ComplexMapSerializeTest)
 TEST_F(SerializationTest, SimpleSFixed32ComplexMapSerializeTest)
 {
     SimpleSFixed32ComplexMessageMapMessage test;
-    test.setMapField({{10, {16 , {"ten sixteen"}}}, {-42, {10 , {"minus fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}});
+    test.setMapField({{10, new ComplexMessage{16 , {"ten sixteen"}}}, {-42, new ComplexMessage{10 , {"minus fourty two ten sixteen"}}}, {65555, new ComplexMessage{10 , {"WUT?"}}}});
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
@@ -67,7 +67,7 @@ TEST_F(SerializationTest, SimpleSFixed32ComplexMapSerializeTest)
 TEST_F(SerializationTest, SimpleInt32ComplexMapSerializeTest)
 {
     SimpleInt32ComplexMessageMapMessage test;
-    test.setMapField({{10, {16 , {"ten sixteen"}}}, {-42, {10 , {"minus fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}});
+    test.setMapField({{10, new ComplexMessage{16 , {"ten sixteen"}}}, {-42, new ComplexMessage{10 , {"minus fourty two ten sixteen"}}}, {65555, new ComplexMessage{10 , {"WUT?"}}}});
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
@@ -77,7 +77,7 @@ TEST_F(SerializationTest, SimpleInt32ComplexMapSerializeTest)
 TEST_F(SerializationTest, SimpleSInt32ComplexMapSerializeTest)
 {
     SimpleSInt32ComplexMessageMapMessage test;
-    test.setMapField({{10, {16 , {"ten sixteen"}}}, {42, {10 , {"fourty two ten sixteen"}}}, {-65555, {10 , {"minus WUT?"}}}});
+    test.setMapField({{10, new ComplexMessage{16 , {"ten sixteen"}}}, {42, new ComplexMessage{10 , {"fourty two ten sixteen"}}}, {-65555, new ComplexMessage{10 , {"minus WUT?"}}}});
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
@@ -87,7 +87,7 @@ TEST_F(SerializationTest, SimpleSInt32ComplexMapSerializeTest)
 TEST_F(SerializationTest, SimpleUInt32ComplexMapSerializeTest)
 {
     SimpleUInt32ComplexMessageMapMessage test;
-    test.setMapField({{10, {16 , {"ten sixteen"}}}, {42, {10 , {"fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}});
+    test.setMapField({{10, new ComplexMessage{16 , {"ten sixteen"}}}, {42, new ComplexMessage{10 , {"fourty two ten sixteen"}}}, {65555, new ComplexMessage{10 , {"WUT?"}}}});
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
@@ -97,7 +97,7 @@ TEST_F(SerializationTest, SimpleUInt32ComplexMapSerializeTest)
 TEST_F(SerializationTest, SimpleFixed64ComplexMapSerializeTest)
 {
     SimpleFixed64ComplexMessageMapMessage test;
-    test.setMapField({{10, {16 , {"ten sixteen"}}}, {UINT64_MAX, {42 , {"minus fourty two ten MAAAX"}}}, {65555, {10 , {"WUT?"}}}});
+    test.setMapField({{10, new ComplexMessage{16 , {"ten sixteen"}}}, {UINT64_MAX, new ComplexMessage{42 , {"minus fourty two ten MAAAX"}}}, {65555, new ComplexMessage{10 , {"WUT?"}}}});
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
@@ -107,7 +107,7 @@ TEST_F(SerializationTest, SimpleFixed64ComplexMapSerializeTest)
 TEST_F(SerializationTest, SimpleSFixed64ComplexMapSerializeTest)
 {
     SimpleSFixed64ComplexMessageMapMessage test;
-    test.setMapField({{10, {16 , {"ten sixteen"}}}, {-42, {10 , {"minus fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}});
+    test.setMapField({{10, new ComplexMessage{16 , {"ten sixteen"}}}, {-42, new ComplexMessage{10 , {"minus fourty two ten sixteen"}}}, {65555, new ComplexMessage{10 , {"WUT?"}}}});
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
@@ -117,7 +117,7 @@ TEST_F(SerializationTest, SimpleSFixed64ComplexMapSerializeTest)
 TEST_F(SerializationTest, SimpleInt64ComplexMapSerializeTest)
 {
     SimpleInt64ComplexMessageMapMessage test;
-    test.setMapField({{10, {16 , {"ten sixteen"}}}, {-42, {10 , {"minus fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}});
+    test.setMapField({{10, new ComplexMessage{16 , {"ten sixteen"}}}, {-42, new ComplexMessage{10 , {"minus fourty two ten sixteen"}}}, {65555, new ComplexMessage{10 , {"WUT?"}}}});
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
@@ -127,7 +127,7 @@ TEST_F(SerializationTest, SimpleInt64ComplexMapSerializeTest)
 TEST_F(SerializationTest, SimpleSInt64ComplexMapSerializeTest)
 {
     SimpleSInt64ComplexMessageMapMessage test;
-    test.setMapField({{10, {16 , {"ten sixteen"}}}, {-42, {10 , {"minus fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}});
+    test.setMapField({{10, new ComplexMessage{16 , {"ten sixteen"}}}, {-42, new ComplexMessage{10 , {"minus fourty two ten sixteen"}}}, {65555, new ComplexMessage{10 , {"WUT?"}}}});
     QByteArray result = test.serialize();
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
                 "122608531222121e321c6d696e757320666f757274792074776f2074656e207369787465656e080a121508141211120d320b74656e207369787465656e0810121008a68008120a120632045755543f080a");
@@ -136,7 +136,7 @@ TEST_F(SerializationTest, SimpleSInt64ComplexMapSerializeTest)
 TEST_F(SerializationTest, SimpleUInt64ComplexMapSerializeTest)
 {
     SimpleUInt64ComplexMessageMapMessage test;
-    test.setMapField({{10, {11 , {"ten eleven"}}}, {42, {10 , {"fourty two ten sixteen"}}}, {65555, {10 , {"WUT?"}}}});
+    test.setMapField({{10, new ComplexMessage{11 , {"ten eleven"}}}, {42, new ComplexMessage{10 , {"fourty two ten sixteen"}}}, {65555, new ComplexMessage{10 , {"WUT?"}}}});
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),
@@ -146,7 +146,7 @@ TEST_F(SerializationTest, SimpleUInt64ComplexMapSerializeTest)
 TEST_F(SerializationTest, SimpleStringComplexMapSerializeTest)
 {
     SimpleStringComplexMessageMapMessage test;
-    test.setMapField({{"ben", {11 , {"ten eleven"}}}, {"where is my car dude?", {10 , {"fourty two ten sixteen"}}}, {"WUT??", {10 , {"?WUT?"}}}});
+    test.setMapField({{"ben", new ComplexMessage{11 , {"ten eleven"}}}, {"where is my car dude?", new ComplexMessage{10 , {"fourty two ten sixteen"}}}, {"WUT??", new ComplexMessage{10 , {"?WUT?"}}}});
     QByteArray result = test.serialize();
 
     ASSERT_STREQ(result.toHex().toStdString().c_str(),

+ 1 - 1
tests/serializationtest.cpp

@@ -1527,7 +1527,7 @@ TEST_F(SerializationTest, RepeatedComplexMessageTest)
     msg.setTestFieldInt(25);
     msg.setTestComplexField(stringMsg);
     RepeatedComplexMessage test;
-    test.setTestRepeatedComplex({msg, msg, msg});
+    test.setTestRepeatedComplex({&msg, &msg, &msg});
     QByteArray result = test.serialize();
     //qDebug() << "result " << result.toHex();
 

+ 1 - 1
tests/simpletest.cpp

@@ -407,7 +407,7 @@ TEST_F(SimpleTest, RepeatedExternalComplexMessageTest)
     externalMessage.setTestFieldInt(complexMessage);
 
     qtprotobufnamespace1::externaltests::ExternalComplexMessageList complexMessageList;
-    complexMessageList << externalMessage;
+    complexMessageList << &externalMessage;
 
     ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue(complexMessageList)));
     ASSERT_TRUE(test.property(propertyName).value<qtprotobufnamespace1::externaltests::ExternalComplexMessageList>() == complexMessageList);