Extend reserved fields tests

tests/test_protobuf/proto/simpletest.proto

@@ -589,6 +589,40 @@ message CombinedMessageUnderscoreField {
 
 message MessageUpperCase {
     sint32 TestField = 1;
+}
+
+message MessageReserved {
+    sint32 import = 1;
     sint32 property = 2;
     sint32 id = 3;
 }
+
+message MessageUpperCaseReserved {
+    sint32 Import = 1;
+    sint32 Property = 2;
+    sint32 Id = 3;
+}
+
+message MessageEnumReserved {
+    enum ReservedEnum {
+        Import = 0;
+        Property = 1;
+        Id = 2;
+    }
+
+    enum LowerCaseEnum {
+        enumValue0 = 0;
+        enumValue1 = 1;
+        enumValue2 = 2;
+    }
+
+    enum UnderScoreEnum {
+        _enumUnderscoreValue0 = 0;
+        _EnumUnderscoreValue1 = 1;
+    }
+}
+
+message lowerCaseMessageName {
+    sint32 testField = 1;
+}
+

tests/test_protobuf/simpletest.cpp.inc

@@ -782,8 +782,59 @@ TEST_F(SimpleTest, CyclingTest)
 TEST_F(SimpleTest, UpperCaseTest)
 {
     assertMessagePropertyRegistered<MessageUpperCase, sint32>(1, "QtProtobuf::sint32", "testField");
-    assertMessagePropertyRegistered<MessageUpperCase, sint32>(2, "QtProtobuf::sint32", "propertyProto");
-    assertMessagePropertyRegistered<MessageUpperCase, sint32>(3, "QtProtobuf::sint32", "idProto");
+}
+
+TEST_F(SimpleTest, ReservedTest)
+{
+    assertMessagePropertyRegistered<MessageReserved, sint32>(1, "QtProtobuf::sint32", "importProto");
+    assertMessagePropertyRegistered<MessageReserved, sint32>(2, "QtProtobuf::sint32", "propertyProto");
+    assertMessagePropertyRegistered<MessageReserved, sint32>(3, "QtProtobuf::sint32", "idProto");
+}
+
+TEST_F(SimpleTest, ReservedUpperCaseTest)
+{
+    assertMessagePropertyRegistered<MessageUpperCaseReserved, sint32>(1, "QtProtobuf::sint32", "importProto");
+    assertMessagePropertyRegistered<MessageUpperCaseReserved, sint32>(2, "QtProtobuf::sint32", "propertyProto");
+    assertMessagePropertyRegistered<MessageUpperCaseReserved, sint32>(3, "QtProtobuf::sint32", "idProto");
+}
+
+TEST_F(SimpleTest, ReservedEnumTest)
+{
+    ASSERT_GT(MessageEnumReserved::staticMetaObject.enumeratorCount(), 0);
+    QMetaEnum simpleEnum;
+    for (int i = 0; i < MessageEnumReserved::staticMetaObject.enumeratorCount(); i++) {
+        QMetaEnum tmp = MessageEnumReserved::staticMetaObject.enumerator(i);
+        if (QString(tmp.name()) == QString("ReservedEnum")) {
+            simpleEnum = tmp;
+            break;
+        }
+    }
+    ASSERT_TRUE(simpleEnum.isValid());
+    ASSERT_STREQ(simpleEnum.key(0), "Import");
+    ASSERT_STREQ(simpleEnum.key(1), "Property");
+    ASSERT_STREQ(simpleEnum.key(2), "Id");
+
+    ASSERT_EQ(simpleEnum.value(0), 0);
+    ASSERT_EQ(simpleEnum.value(1), 1);
+    ASSERT_EQ(simpleEnum.value(2), 2);
+}
+
+TEST_F(SimpleTest, LowerCaseEnumTest)
+{
+    ASSERT_GT(MessageEnumReserved::staticMetaObject.enumeratorCount(), 0);
+    QMetaEnum simpleEnum;
+    for (int i = 0; i < MessageEnumReserved::staticMetaObject.enumeratorCount(); i++) {
+        QMetaEnum tmp = MessageEnumReserved::staticMetaObject.enumerator(i);
+        if (QString(tmp.name()) == QString("LowerCaseEnum")) {
+            simpleEnum = tmp;
+            break;
+        }
+    }
+    ASSERT_TRUE(simpleEnum.isValid());
+    //TODO: #191
+    ASSERT_STREQ(simpleEnum.key(0), "EnumValue0");
+    ASSERT_STREQ(simpleEnum.key(1), "EnumValue1");
+    ASSERT_STREQ(simpleEnum.key(2), "EnumValue2");
 }
 
 } // tests

tests/test_protobuf_multifile/simpletest.cpp

@@ -74,6 +74,9 @@
 #include "testmessagesequence2.h"
 #include "cyclingseconddependency.h"
 #include "cyclingfirstdependency.h"
+#include "messageuppercasereserved.h"
+#include "messagereserved.h"
+#include "messageenumreserved.h"
 
 #include "globalenums.h"
 

tests/test_qml/qml/tst_simple.qml

@@ -61,9 +61,23 @@ TestCase {
     }
 
     MessageUpperCase {
-        id: idTest
+        id: caseSenseMsg
     }
 
+    MessageReserved {
+        id: reservedMsg
+    }
+
+    PriorMessageUnderscoreField {
+        id: underScoreMsg
+    }
+
+    //TODO: uncomment when functionality is implemented
+    //TODO: #192
+//    LowerCaseMessageName {
+//        id: lowerCaseMsg
+//    }
+
     function test_simpleboolmessage() {
         boolMsg.testFieldBool = true;
         compare(boolMsg.testFieldBool, true, "SimpleBoolMessage == true")
@@ -188,4 +202,40 @@ TestCase {
     function test_simplesstringmessage() {
         compare(stringMsg.testFieldString, "Test string", "SimpleStringMessage")
     }
+
+    function test_reservedNames() {
+        reservedMsg.idProto = 34;
+        reservedMsg.importProto = 35;
+        reservedMsg.propertyProto = 36;
+        compare(reservedMsg.idProto, 34, "reservedMsg.idProto == 34")
+        compare(reservedMsg.importProto, 35, "reservedMsg.importProto == 35")
+        compare(reservedMsg.propertyProto, 36, "reservedMsg.propertyProto == 36")
+    }
+
+    function test_reservedEnums() {
+        compare(MessageEnumReserved.Import, 0, "MessageEnumReserved.Import == 0")
+        compare(MessageEnumReserved.Property, 1, "MessageEnumReserved.Property == 1")
+        compare(MessageEnumReserved.Id, 2, "MessageEnumReserved.Id == 2")
+    }
+
+    function test_caseSense() {
+        caseSenseMsg.testField = 34;
+        compare(caseSenseMsg.testField == 34, true, "MessageUpperCase == 34")
+
+        //TODO: #191
+        compare(MessageEnumReserved.EnumValue0 == 0, true, "MessageEnumReserved.EnumValue0 == 0")
+        compare(MessageEnumReserved.EnumValue1 == 1, true, "MessageEnumReserved.EnumValue1 == 1")
+        compare(MessageEnumReserved.EnumValue2 == 2, true, "MessageEnumReserved.EnumValue2 == 2")
+    }
+
+    function test_underScoreField() {
+        underScoreMsg._underScoreMessageField = 123
+        compare(underScoreMsg._underScoreMessageField == 123, true, "underScoreMsg._underScoreMessageField == 123")
+    }
+
+    function test_lowerCaseMessage() {
+        //TODO: #192
+        lowerCaseMsg.testField = 34
+        compare(lowerCaseMsg.testField == 34, true, "LowerCaseMessageName == 34")
+    }
 }