qiurui
/
qtgrpc
mirror of https://github.com/qt/qtgrpc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtgrpc/tests/auto/protobuf/syntax/tst_protobuf_syntax.cpp

149 lines
5.5 KiB
C++
Raw Normal View History

Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2022 Alexey Edelev <semlanik@gmail.com>, Viktor Kopp <vifactor@gmail.com>
Correct license for tests file According to QUIP-18 [1], all tests file should be LicenseRef-Qt-Commercial OR GPL-3.0-only [1]: https://contribute.qt-project.org/quips/18 Pick-to: 6.7 Task-number: QTBUG-121787 Change-Id: If8971276e27806c9cb5aad6511e3fb6770695ed0 Reviewed-by: Kai Köhne <kai.koehne@qt.io>
2024-03-15 12:04:02 +00:00
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
#include "syntax.qpb.h"
#include <QMetaProperty>
#include <QSignalSpy>
Slim down test includes The <QtTest/QtTest> include is a module-include and includes _all_ of QtTest + its dependencies (QtCore) Change-Id: I2a3d04798c259924b462f6e2eaec9d863c6c9edb Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
2022-10-05 17:31:33 +00:00
#include <QTest>
Long live mutable getters The functionality is desirable by some users, we re-enable it. New API addresses the core issue that is partially related to QTBUG-119912, but has wider concequences in blind use in user projects. We add the 'mut' prefix to all mutable getters to make the mutable access explicit. Overload approach leads to unwanted detaches not only whe is used be moc-generated code, but also in user projects if developers do not pay enough attention to const modifiers of their variables/references. We declined to restore it, dispite it was the better looking API, in favor to the code safety. This also reveals the code clashing scenario, when the overload might happen if the message has both 'a' and 'mutA' fields in its definition. This scenario is kindly forbidden by our generator, and sanitized at very early stages. We expect that it won't happen in user projects, but even if it will, the solution is to rename the field when generating Qt code. The serialization/deserialization do not depend on field naming directly. json_name attribute also will help to workaround this. The undocumented ALLOW_MUTABLE_GETTER_CONFLICTS option allows clashing the mutable getter names, but its usage currently limited by our internal code only. The reason unfixed QTBUG-119912 issue in moc. Once the issue is fixed, the moc version check should get the proper version, but not '99' as for now and the ALLOW_MUTABLE_GETTER_CONFLICTS will become public. Another design solution is the use of overloaded functions that return pointers, like it's done it the reference protobuf. But this kind of API leaves the pointer ownership undefined and decided to not be used. [ChangeLog][Protobuf] The generated messages now have the mutable getters for the fiels of the message type. The getters have 'mut' prefix and implicily allocate the respective fields if needed, so the use of intermediate message objects is not required. Task-number: QTBUG-119913 Change-Id: I09b9ee37e1fbbe37b9c3cb501e92442da8ad3e4b Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2025-03-14 11:40:54 +00:00
#include <QDebug>
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
#include <qtprotobuftestscommon.h>
class QtProtobufSyntaxTest : public QObject
{
Q_OBJECT
Support QT_NO_SIGNALS_SLOTS_KEYWORDS Replace signals/slots macros with Q_SIGNALS/SLOTS counterparts. Change-Id: Ie44734106c553f6e14e2ac0f406329b77bb5c17b Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io> Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-05-10 13:12:09 +00:00
private Q_SLOTS:
Adjust all test names to be consistent to the generic Qt coding style Test function names should be cAmEl-case, adjust them. Change-Id: I98f537211148632bf62dd210dab6378ace96e27d Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-05-10 09:18:02 +00:00
void underscoresTest();
void upperCaseTest();
void reservedTest();
void reservedUpperCaseTest();
void reservedEnumTest();
void lowerCaseEnumTest();
void upperCaseEnumTest();
Long live mutable getters The functionality is desirable by some users, we re-enable it. New API addresses the core issue that is partially related to QTBUG-119912, but has wider concequences in blind use in user projects. We add the 'mut' prefix to all mutable getters to make the mutable access explicit. Overload approach leads to unwanted detaches not only whe is used be moc-generated code, but also in user projects if developers do not pay enough attention to const modifiers of their variables/references. We declined to restore it, dispite it was the better looking API, in favor to the code safety. This also reveals the code clashing scenario, when the overload might happen if the message has both 'a' and 'mutA' fields in its definition. This scenario is kindly forbidden by our generator, and sanitized at very early stages. We expect that it won't happen in user projects, but even if it will, the solution is to rename the field when generating Qt code. The serialization/deserialization do not depend on field naming directly. json_name attribute also will help to workaround this. The undocumented ALLOW_MUTABLE_GETTER_CONFLICTS option allows clashing the mutable getter names, but its usage currently limited by our internal code only. The reason unfixed QTBUG-119912 issue in moc. Once the issue is fixed, the moc version check should get the proper version, but not '99' as for now and the ALLOW_MUTABLE_GETTER_CONFLICTS will become public. Another design solution is the use of overloaded functions that return pointers, like it's done it the reference protobuf. But this kind of API leaves the pointer ownership undefined and decided to not be used. [ChangeLog][Protobuf] The generated messages now have the mutable getters for the fiels of the message type. The getters have 'mut' prefix and implicily allocate the respective fields if needed, so the use of intermediate message objects is not required. Task-number: QTBUG-119913 Change-Id: I09b9ee37e1fbbe37b9c3cb501e92442da8ad3e4b Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2025-03-14 11:40:54 +00:00
void mutableGetterConflicts();
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
};
using namespace qtprotobufnamespace::tests;
Adjust all test names to be consistent to the generic Qt coding style Test function names should be cAmEl-case, adjust them. Change-Id: I98f537211148632bf62dd210dab6378ace96e27d Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-05-10 09:18:02 +00:00
void QtProtobufSyntaxTest::underscoresTest()
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
//Sanity compilation checks
Message_Uderscore_name msg1;
MessageUderscorename msg2;
MessageUnderscoreField msg3;
PriorMessageUnderscoreField msg4;
FollowingMessageUnderscoreField msg5;
CombinedMessageUnderscoreField msg6;
qProtobufAssertMessagePropertyRegistered<MessageUnderscoreField, QtProtobuf::sint32>(1, "QtProtobuf::sint32", "underScoreMessageField");
qProtobufAssertMessagePropertyRegistered<PriorMessageUnderscoreField, QtProtobuf::sint32>(1, "QtProtobuf::sint32", "underScoreMessageField");
qProtobufAssertMessagePropertyRegistered<PriorMessageUnderscoreField, QtProtobuf::sint32>(1, "QtProtobuf::sint32", "underScoreMessageField");
qProtobufAssertMessagePropertyRegistered<FollowingMessageUnderscoreField , QtProtobuf::sint32>(1, "QtProtobuf::sint32", "underScoreMessageField");
qProtobufAssertMessagePropertyRegistered<CombinedMessageUnderscoreField , QtProtobuf::sint32>(1, "QtProtobuf::sint32", "underScoreMessageField");
}
Adjust all test names to be consistent to the generic Qt coding style Test function names should be cAmEl-case, adjust them. Change-Id: I98f537211148632bf62dd210dab6378ace96e27d Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-05-10 09:18:02 +00:00
void QtProtobufSyntaxTest::upperCaseTest()
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
qProtobufAssertMessagePropertyRegistered<MessageUpperCase, QtProtobuf::sint32>(1, "QtProtobuf::sint32", "testField");
}
Adjust all test names to be consistent to the generic Qt coding style Test function names should be cAmEl-case, adjust them. Change-Id: I98f537211148632bf62dd210dab6378ace96e27d Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-05-10 09:18:02 +00:00
void QtProtobufSyntaxTest::reservedTest()
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
qProtobufAssertMessagePropertyRegistered<MessageReserved, QtProtobuf::sint32>(1, "QtProtobuf::sint32", "import_proto");
qProtobufAssertMessagePropertyRegistered<MessageReserved, QtProtobuf::sint32>(2, "QtProtobuf::sint32", "property_proto");
qProtobufAssertMessagePropertyRegistered<MessageReserved, QtProtobuf::sint32>(3, "QtProtobuf::sint32", "id_proto");
}
Adjust all test names to be consistent to the generic Qt coding style Test function names should be cAmEl-case, adjust them. Change-Id: I98f537211148632bf62dd210dab6378ace96e27d Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-05-10 09:18:02 +00:00
void QtProtobufSyntaxTest::reservedUpperCaseTest()
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
qProtobufAssertMessagePropertyRegistered<MessageUpperCaseReserved, QtProtobuf::sint32>(1, "QtProtobuf::sint32", "import_proto");
qProtobufAssertMessagePropertyRegistered<MessageUpperCaseReserved, QtProtobuf::sint32>(2, "QtProtobuf::sint32", "property_proto");
qProtobufAssertMessagePropertyRegistered<MessageUpperCaseReserved, QtProtobuf::sint32>(3, "QtProtobuf::sint32", "id_proto");
}
Adjust all test names to be consistent to the generic Qt coding style Test function names should be cAmEl-case, adjust them. Change-Id: I98f537211148632bf62dd210dab6378ace96e27d Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-05-10 09:18:02 +00:00
void QtProtobufSyntaxTest::reservedEnumTest()
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
Move enums to the nested namespace out of class Protobuf allows the following construction: message A { enum AEnum { AVal0 = 0; } B.BEnum val = 1; } message B { enum BEnum { BVal0 = 0; } A.AEnum val = 1; } This requires forward declaration of nested enums, that is not possible in C++. To solve this problem we may do the same trick that we do for nested messages already. This patch moves the nested enum type out of class to the _QtProtobufNested namespace. The solution require the enum name specification when using enums from this moment, since the owning messages only contain type aliases now. So from example above to access the AVal0 you need to use the full qualifier: A::AEnum::AVal0 The new generated code structure registrates Qml types using the built-in macros, that unlocks direct linking of backing library without the need of Qml plugin usage. [ChangeLog][Protobuf] Nested enums moved out of message classes to the nested namespace, same as the nested messages. [ChangeLog][Protobuf][Qml] The geneated protobuf Qml modules do not require the use of Qml plugins. Fixes: QTBUG-115800 Change-Id: Ia67fcbecf492c3fd41350eada4d62fc9e5ea4dab Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2023-08-05 15:10:53 +00:00
const auto &metaObject = MessageEnumReserved_QtProtobufNested::staticMetaObject;
QVERIFY(metaObject.enumeratorCount() > 0);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
QMetaEnum simpleEnum;
Move enums to the nested namespace out of class Protobuf allows the following construction: message A { enum AEnum { AVal0 = 0; } B.BEnum val = 1; } message B { enum BEnum { BVal0 = 0; } A.AEnum val = 1; } This requires forward declaration of nested enums, that is not possible in C++. To solve this problem we may do the same trick that we do for nested messages already. This patch moves the nested enum type out of class to the _QtProtobufNested namespace. The solution require the enum name specification when using enums from this moment, since the owning messages only contain type aliases now. So from example above to access the AVal0 you need to use the full qualifier: A::AEnum::AVal0 The new generated code structure registrates Qml types using the built-in macros, that unlocks direct linking of backing library without the need of Qml plugin usage. [ChangeLog][Protobuf] Nested enums moved out of message classes to the nested namespace, same as the nested messages. [ChangeLog][Protobuf][Qml] The geneated protobuf Qml modules do not require the use of Qml plugins. Fixes: QTBUG-115800 Change-Id: Ia67fcbecf492c3fd41350eada4d62fc9e5ea4dab Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2023-08-05 15:10:53 +00:00
for (int i = 0; i < metaObject.enumeratorCount(); i++) {
QMetaEnum tmp = metaObject.enumerator(i);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
if (QString(tmp.name()) == QString("ReservedEnum")) {
simpleEnum = tmp;
break;
}
}
QVERIFY(simpleEnum.isValid());
QCOMPARE(simpleEnum.key(0), "Import");
QCOMPARE(simpleEnum.key(1), "Property");
QCOMPARE(simpleEnum.key(2), "Id");
QCOMPARE(simpleEnum.value(0), 0);
QCOMPARE(simpleEnum.value(1), 1);
QCOMPARE(simpleEnum.value(2), 2);
}
Adjust all test names to be consistent to the generic Qt coding style Test function names should be cAmEl-case, adjust them. Change-Id: I98f537211148632bf62dd210dab6378ace96e27d Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-05-10 09:18:02 +00:00
void QtProtobufSyntaxTest::lowerCaseEnumTest()
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
Move enums to the nested namespace out of class Protobuf allows the following construction: message A { enum AEnum { AVal0 = 0; } B.BEnum val = 1; } message B { enum BEnum { BVal0 = 0; } A.AEnum val = 1; } This requires forward declaration of nested enums, that is not possible in C++. To solve this problem we may do the same trick that we do for nested messages already. This patch moves the nested enum type out of class to the _QtProtobufNested namespace. The solution require the enum name specification when using enums from this moment, since the owning messages only contain type aliases now. So from example above to access the AVal0 you need to use the full qualifier: A::AEnum::AVal0 The new generated code structure registrates Qml types using the built-in macros, that unlocks direct linking of backing library without the need of Qml plugin usage. [ChangeLog][Protobuf] Nested enums moved out of message classes to the nested namespace, same as the nested messages. [ChangeLog][Protobuf][Qml] The geneated protobuf Qml modules do not require the use of Qml plugins. Fixes: QTBUG-115800 Change-Id: Ia67fcbecf492c3fd41350eada4d62fc9e5ea4dab Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2023-08-05 15:10:53 +00:00
const auto &metaObject = MessageEnumReserved_QtProtobufNested::staticMetaObject;
QVERIFY(metaObject.enumeratorCount() > 0);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
QMetaEnum simpleEnum;
Move enums to the nested namespace out of class Protobuf allows the following construction: message A { enum AEnum { AVal0 = 0; } B.BEnum val = 1; } message B { enum BEnum { BVal0 = 0; } A.AEnum val = 1; } This requires forward declaration of nested enums, that is not possible in C++. To solve this problem we may do the same trick that we do for nested messages already. This patch moves the nested enum type out of class to the _QtProtobufNested namespace. The solution require the enum name specification when using enums from this moment, since the owning messages only contain type aliases now. So from example above to access the AVal0 you need to use the full qualifier: A::AEnum::AVal0 The new generated code structure registrates Qml types using the built-in macros, that unlocks direct linking of backing library without the need of Qml plugin usage. [ChangeLog][Protobuf] Nested enums moved out of message classes to the nested namespace, same as the nested messages. [ChangeLog][Protobuf][Qml] The geneated protobuf Qml modules do not require the use of Qml plugins. Fixes: QTBUG-115800 Change-Id: Ia67fcbecf492c3fd41350eada4d62fc9e5ea4dab Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2023-08-05 15:10:53 +00:00
for (int i = 0; i < metaObject.enumeratorCount(); i++) {
QMetaEnum tmp = metaObject.enumerator(i);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
if (QString(tmp.name()) == QString("LowerCaseEnum")) {
simpleEnum = tmp;
break;
}
}
QVERIFY(simpleEnum.isValid());
Do not capitalize the enum field names This lead to name conflicts that are not detected by protoc. Protoc disallows using the same enum field names in single scope, but names are case-sensetive. So we shouldn't capitalize the enum names since it breaks the code in situations when two enums have values with same name, but only case of first character differs: message A { enum E1 { val = 1; } enum E2 { Val = 1; } } [ChangeLog][Protobuf][Generator] Enum fields now preserve the case of first letter. Previosly generator capitalized the generated enum field names. Change-Id: I476c940041454918c958a4b31787731cadf9f6fe Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-09-02 10:14:23 +00:00
QCOMPARE(simpleEnum.key(0), "enumValue0");
QCOMPARE(simpleEnum.key(1), "enumValue1");
QCOMPARE(simpleEnum.key(2), "enumValue2");
}
Adjust all test names to be consistent to the generic Qt coding style Test function names should be cAmEl-case, adjust them. Change-Id: I98f537211148632bf62dd210dab6378ace96e27d Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-05-10 09:18:02 +00:00
void QtProtobufSyntaxTest::upperCaseEnumTest()
Do not capitalize the enum field names This lead to name conflicts that are not detected by protoc. Protoc disallows using the same enum field names in single scope, but names are case-sensetive. So we shouldn't capitalize the enum names since it breaks the code in situations when two enums have values with same name, but only case of first character differs: message A { enum E1 { val = 1; } enum E2 { Val = 1; } } [ChangeLog][Protobuf][Generator] Enum fields now preserve the case of first letter. Previosly generator capitalized the generated enum field names. Change-Id: I476c940041454918c958a4b31787731cadf9f6fe Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-09-02 10:14:23 +00:00
{
const auto &metaObject = MessageEnumReserved_QtProtobufNested::staticMetaObject;
QVERIFY(metaObject.enumeratorCount() > 0);
QMetaEnum simpleEnum;
for (int i = 0; i < metaObject.enumeratorCount(); i++) {
QMetaEnum tmp = metaObject.enumerator(i);
if (QString(tmp.name()) == QString("UpperCaseEnum")) {
simpleEnum = tmp;
break;
}
}
QVERIFY(simpleEnum.isValid());
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
QCOMPARE(simpleEnum.key(0), "EnumValue0");
QCOMPARE(simpleEnum.key(1), "EnumValue1");
QCOMPARE(simpleEnum.key(2), "EnumValue2");
}
Long live mutable getters The functionality is desirable by some users, we re-enable it. New API addresses the core issue that is partially related to QTBUG-119912, but has wider concequences in blind use in user projects. We add the 'mut' prefix to all mutable getters to make the mutable access explicit. Overload approach leads to unwanted detaches not only whe is used be moc-generated code, but also in user projects if developers do not pay enough attention to const modifiers of their variables/references. We declined to restore it, dispite it was the better looking API, in favor to the code safety. This also reveals the code clashing scenario, when the overload might happen if the message has both 'a' and 'mutA' fields in its definition. This scenario is kindly forbidden by our generator, and sanitized at very early stages. We expect that it won't happen in user projects, but even if it will, the solution is to rename the field when generating Qt code. The serialization/deserialization do not depend on field naming directly. json_name attribute also will help to workaround this. The undocumented ALLOW_MUTABLE_GETTER_CONFLICTS option allows clashing the mutable getter names, but its usage currently limited by our internal code only. The reason unfixed QTBUG-119912 issue in moc. Once the issue is fixed, the moc version check should get the proper version, but not '99' as for now and the ALLOW_MUTABLE_GETTER_CONFLICTS will become public. Another design solution is the use of overloaded functions that return pointers, like it's done it the reference protobuf. But this kind of API leaves the pointer ownership undefined and decided to not be used. [ChangeLog][Protobuf] The generated messages now have the mutable getters for the fiels of the message type. The getters have 'mut' prefix and implicily allocate the respective fields if needed, so the use of intermediate message objects is not required. Task-number: QTBUG-119913 Change-Id: I09b9ee37e1fbbe37b9c3cb501e92442da8ad3e4b Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2025-03-14 11:40:54 +00:00
void QtProtobufSyntaxTest::mutableGetterConflicts()
{
NameClashingMutableGetters msg;
// Set 'data' field for the 'field' field using the mutable getter
msg.mutField().setData(1);
// Set 'data' field for the 'mutField' field using the mutable getter
msg.mutMutField().setData(2);
// Access the immutable 'field' field
QVERIFY(msg.field().data() == 1);
// Access the mutable 'field' field
QVERIFY(msg.mutField().data() == 1);
// Access the immutable 'mutField' field
QVERIFY(std::as_const(msg).mutField().data() == 2);
// Ensure we use the correct value in serialization
QVERIFY(!msg.property("mutField_p").isNull());
QVERIFY(msg.property("mutField_p").value<MutFieldMessage *>()->data() == 2);
}
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
QTEST_MAIN(QtProtobufSyntaxTest)
#include "tst_protobuf_syntax.moc"