Merge remote-tracking branch 'origin/qds-1.59'

Change-Id: I8a5d7d98b4d75379fe3953fe00bdb939d1722676

7 files changed, 439 insertions, 28 deletions

diff --git a/tests/unit/unittest/CMakeLists.txt b/tests/unit/unittest/CMakeLists.txt
index 4e7b97d53b..904af9b6d1 100644
--- a/tests/unit/unittest/CMakeLists.txt
+++ b/tests/unit/unittest/CMakeLists.txt
@@ -164,6 +164,14 @@ add_qtc_test(unittest GTEST
     unittest-utility-functions.h
     usedmacrofilter-test.cpp
     utf8-test.cpp
+    sqlitecolumn-test.cpp
+    sqlitedatabasebackend-test.cpp
+    sqlitedatabase-test.cpp
+    sqlitestatement-test.cpp
+    sqlitetable-test.cpp
+    sqlstatementbuilder-test.cpp
+    createtablesqlstatementbuilder-test.cpp
+    sqlitevalue-test.cpp
 )
 
 # Do not work on the source directory data
@@ -219,7 +227,6 @@ if (TARGET libclang)
     codecompleter-test.cpp
     codecompletionsextractor-test.cpp
     completionchunkstotextconverter-test.cpp
-    createtablesqlstatementbuilder-test.cpp
     cursor-test.cpp
     diagnosticset-test.cpp
     diagnostic-test.cpp
@@ -228,12 +235,6 @@ if (TARGET libclang)
     skippedsourceranges-test.cpp
     sourcelocation-test.cpp
     sourcerange-test.cpp
-    sqlitecolumn-test.cpp
-    sqlitedatabasebackend-test.cpp
-    sqlitedatabase-test.cpp
-    sqlitestatement-test.cpp
-    sqlitetable-test.cpp
-    sqlstatementbuilder-test.cpp
     token-test.cpp
     translationunitupdater-test.cpp
     unsavedfiles-test.cpp
diff --git a/tests/unit/unittest/creator_dependency.pri b/tests/unit/unittest/creator_dependency.pri
index 2e84e1cdca..e5b10f65ae 100644
--- a/tests/unit/unittest/creator_dependency.pri
+++ b/tests/unit/unittest/creator_dependency.pri
@@ -14,11 +14,11 @@ include($$PWD/../../../src/tools/clangpchmanagerbackend/source/clangpchmanagerba
 include($$PWD/../../../src/plugins/clangrefactoring/clangrefactoring-source.pri)
 include($$PWD/../../../src/plugins/clangpchmanager/clangpchmanager-source.pri)
 include($$PWD/../../../src/plugins/cpptools/cpptoolsunittestfiles.pri)
-include($$PWD/../../../src/plugins/clangtools/clangtoolsunittestfiles.pri)
 include($$PWD/../../../src/plugins/debugger/debuggerunittestfiles.pri)
 include($$PWD/../../../src/plugins/compilationdatabaseprojectmanager/compilationdatabaseunittestfiles.pri)
 include(cplusplus.pri)
 !isEmpty(LLVM_VERSION) {
+include($$PWD/../../../src/plugins/clangtools/clangtoolsunittestfiles.pri)
 include($$PWD/../../../src/shared/clang/clang_defines.pri)
 include($$PWD/../../../src/tools/clangbackend/source/clangbackendclangipc-source.pri)
 include($$PWD/../../../src/plugins/clangcodemodel/clangcodemodelunittestfiles.pri)
diff --git a/tests/unit/unittest/gtest-creator-printing.cpp b/tests/unit/unittest/gtest-creator-printing.cpp
index 2bbcdbaa45..6d5f7a2cf3 100644
--- a/tests/unit/unittest/gtest-creator-printing.cpp
+++ b/tests/unit/unittest/gtest-creator-printing.cpp
@@ -37,6 +37,7 @@
 #include <clangcodemodelservermessages.h>
 #include <clangpathwatcher.h>
 #include <clangrefactoringmessages.h>
+#include <clangtools/clangtoolsdiagnostic.h>
 #include <coreplugin/find/searchresultitem.h>
 #include <coreplugin/locator/ilocatorfilter.h>
 #include <cpptools/usages.h>
@@ -57,6 +58,7 @@
 #include <sourcedependency.h>
 #include <sourcelocationentry.h>
 #include <sourcelocationscontainer.h>
+#include <sqlitevalue.h>
 #include <symbol.h>
 #include <symbolentry.h>
 #include <symbolindexertaskqueue.h>
@@ -64,12 +66,6 @@
 #include <tooltipinfo.h>
 #include <usedmacro.h>
 #include <utils/link.h>
-#include <cpptools/usages.h>
-#include <projectexplorer/projectmacro.h>
-#include <projectexplorer/headerpath.h>
-#include <coreplugin/find/searchresultitem.h>
-#include <coreplugin/locator/ilocatorfilter.h>
-#include <clangtools/clangtoolsdiagnostic.h>
 
 namespace {
 ClangBackEnd::FilePathCaching *filePathCache = nullptr;
@@ -306,6 +302,27 @@ void PrintTo(const Utils::PathString &text, ::std::ostream *os)
 
 } // namespace Utils
 
+namespace Sqlite {
+std::ostream &operator<<(std::ostream &out, const Value &value)
+{
+    out << "(";
+
+    switch (value.type()) {
+    case Sqlite::ValueType::Integer:
+        out << value.toInteger();
+        break;
+    case Sqlite::ValueType::Float:
+        out << value.toFloat();
+        break;
+    case Sqlite::ValueType::String:
+        out << "\"" << value.toStringView() << "\"";
+        break;
+    }
+
+    return out << ")";
+}
+} // namespace Sqlite
+
 namespace ClangBackEnd {
 
 std::ostream &operator<<(std::ostream &out, const FilePathId &id)
diff --git a/tests/unit/unittest/gtest-creator-printing.h b/tests/unit/unittest/gtest-creator-printing.h
index e26809ca51..b91c8d46be 100644
--- a/tests/unit/unittest/gtest-creator-printing.h
+++ b/tests/unit/unittest/gtest-creator-printing.h
@@ -64,6 +64,12 @@ void PrintTo(const TextRange &range, ::std::ostream *os);
 } // namespace TextPosition
 } // namespace TextPosition
 
+namespace Sqlite {
+class Value;
+
+std::ostream &operator<<(std::ostream &out, const Value &value);
+} // namespace Sqlite
+
 namespace ProjectExplorer {
 
 enum class MacroType;
diff --git a/tests/unit/unittest/sqlitestatement-test.cpp b/tests/unit/unittest/sqlitestatement-test.cpp
index cb8206d875..c7da3971e4 100644
--- a/tests/unit/unittest/sqlitestatement-test.cpp
+++ b/tests/unit/unittest/sqlitestatement-test.cpp
@@ -40,11 +40,12 @@
 
 namespace {
 
-using Sqlite::JournalMode;
-using Sqlite::Exception;
 using Sqlite::Database;
+using Sqlite::Exception;
+using Sqlite::JournalMode;
 using Sqlite::ReadStatement;
 using Sqlite::ReadWriteStatement;
+using Sqlite::Value;
 using Sqlite::WriteStatement;
 
 MATCHER_P3(HasValues, value1, value2, rowid,
@@ -125,7 +126,7 @@ TEST_F(SqliteStatement, CountRows)
 
 TEST_F(SqliteStatement, Value)
 {
-    SqliteTestStatement statement("SELECT name, number FROM test ORDER BY name", database);
+    SqliteTestStatement statement("SELECT name, number, value FROM test ORDER BY name", database);
     statement.next();
 
     statement.next();
@@ -142,6 +143,9 @@ TEST_F(SqliteStatement, Value)
     ASSERT_THAT(statement.fetchValue<Utils::SmallString>(1), "23.3");
     ASSERT_THAT(statement.fetchValue<Utils::PathString>(1), "23.3");
     ASSERT_THAT(statement.fetchSmallStringViewValue(1), "23.3");
+    ASSERT_THAT(statement.fetchValueView(0), Eq("foo"));
+    ASSERT_THAT(statement.fetchValueView(1), Eq(23.3));
+    ASSERT_THAT(statement.fetchValueView(2), Eq(2));
 }
 
 TEST_F(SqliteStatement, ThrowNoValuesToFetchForNotSteppedStatement)
@@ -175,14 +179,14 @@ TEST_F(SqliteStatement, ThrowInvalidColumnFetchedForNotExistingColumn)
     ASSERT_THROW(statement.fetchValue<int>(2), Sqlite::InvalidColumnFetched);
 }
 
-TEST_F(SqliteStatement, ToIntergerValue)
+TEST_F(SqliteStatement, ToIntegerValue)
 {
     auto value = ReadStatement::toValue<int>("SELECT number FROM test WHERE name='foo'", database);
 
     ASSERT_THAT(value, 23);
 }
 
-TEST_F(SqliteStatement, ToLongIntergerValue)
+TEST_F(SqliteStatement, ToLongIntegerValue)
 {
     ASSERT_THAT(ReadStatement::toValue<qint64>("SELECT number FROM test WHERE name='foo'", database), Eq(23));
 }
@@ -319,6 +323,15 @@ TEST_F(SqliteStatement, WriteValues)
     ASSERT_THAT(statement, HasValues("see", "7.23", 1));
 }
 
+TEST_F(SqliteStatement, WriteSqliteValues)
+{
+    WriteStatement statement("UPDATE test SET name=?, number=? WHERE rowid=?", database);
+
+    statement.write(Value{"see"}, Value{7.23}, Value{1});
+
+    ASSERT_THAT(statement, HasValues("see", "7.23", 1));
+}
+
 TEST_F(SqliteStatement, BindNamedValues)
 {
     SqliteTestStatement statement("UPDATE test SET name=@name, number=@number WHERE rowid=@id", database);
@@ -375,6 +388,31 @@ TEST_F(SqliteStatement, GetSingleValuesWithoutArguments)
     ASSERT_THAT(values, ElementsAre("bar", "foo", "poo"));
 }
 
+class FooValue
+{
+public:
+    FooValue(Sqlite::ValueView value)
+        : value(value)
+    {}
+
+    Sqlite::Value value;
+
+    template<typename Type>
+    friend bool operator==(const FooValue &value, const Type &other)
+    {
+        return value.value == other;
+    }
+};
+
+TEST_F(SqliteStatement, GetSingleSqliteValuesWithoutArguments)
+{
+    ReadStatement statement("SELECT number FROM test", database);
+
+    std::vector<FooValue> values = statement.values<FooValue>(3);
+
+    ASSERT_THAT(values, ElementsAre(Eq("blah"), Eq(23.3), Eq(40)));
+}
+
 TEST_F(SqliteStatement, GetStructValuesWithoutArguments)
 {
     ReadStatement statement("SELECT name, number, value FROM test", database);
diff --git a/tests/unit/unittest/sqlitevalue-test.cpp b/tests/unit/unittest/sqlitevalue-test.cpp
new file mode 100644
index 0000000000..e9cc5c9e40
--- /dev/null
+++ b/tests/unit/unittest/sqlitevalue-test.cpp
@@ -0,0 +1,348 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+****************************************************************************/
+
+#include "googletest.h"
+
+#include <sqlitevalue.h>
+
+namespace {
+
+TEST(SqliteValue, ConstructLongLong)
+{
+    Sqlite::Value value{1LL};
+
+    ASSERT_THAT(value.toInteger(), Eq(1LL));
+}
+
+TEST(SqliteValue, Construct)
+{
+    Sqlite::Value value{1};
+
+    ASSERT_THAT(value.toInteger(), Eq(1LL));
+}
+
+TEST(SqliteValue, ConstructFloatingPoint)
+{
+    Sqlite::Value value{1.1};
+
+    ASSERT_THAT(value.toFloat(), Eq(1.1));
+}
+
+TEST(SqliteValue, ConstructStringFromCString)
+{
+    Sqlite::Value value{"foo"};
+
+    ASSERT_THAT(value.toStringView(), Eq("foo"));
+}
+
+TEST(SqliteValue, ConstructStringFromUtilsString)
+{
+    Sqlite::Value value{Utils::SmallString{"foo"}};
+
+    ASSERT_THAT(value.toStringView(), Eq("foo"));
+}
+
+TEST(SqliteValue, ConstructStringFromQString)
+{
+    Sqlite::Value value{QString{"foo"}};
+
+    ASSERT_THAT(value.toStringView(), Eq("foo"));
+}
+
+TEST(SqliteValue, ConstructStringFromIntQVariant)
+{
+    QVariant variant{1};
+
+    Sqlite::Value value{variant};
+
+    ASSERT_THAT(value.toInteger(), Eq(1));
+}
+
+TEST(SqliteValue, ConstructStringFromLongLongQVariant)
+{
+    QVariant variant{1LL};
+
+    Sqlite::Value value{variant};
+
+    ASSERT_THAT(value.toInteger(), Eq(1));
+}
+
+TEST(SqliteValue, ConstructStringFromUintQVariant)
+{
+    QVariant variant{1u};
+
+    Sqlite::Value value{variant};
+
+    ASSERT_THAT(value.toInteger(), Eq(1));
+}
+
+TEST(SqliteValue, ConstructStringFromFloatQVariant)
+{
+    QVariant variant{1.};
+
+    Sqlite::Value value{variant};
+
+    ASSERT_THAT(value.toFloat(), Eq(1));
+}
+
+TEST(SqliteValue, ConstructStringFromStringQVariant)
+{
+    QVariant variant{QString{"foo"}};
+
+    Sqlite::Value value{variant};
+
+    ASSERT_THAT(value.toStringView(), Eq("foo"));
+}
+
+TEST(SqliteValue, ConvertToStringQVariant)
+{
+    Sqlite::Value value{"foo"};
+
+    auto variant = QVariant{value};
+
+    ASSERT_THAT(variant, Eq("foo"));
+}
+
+TEST(SqliteValue, ConvertToIntegerQVariant)
+{
+    Sqlite::Value value{1};
+
+    auto variant = QVariant{value};
+
+    ASSERT_THAT(variant, Eq(1));
+}
+
+TEST(SqliteValue, ConvertToFloatQVariant)
+{
+    Sqlite::Value value{1.1};
+
+    auto variant = QVariant{value};
+
+    ASSERT_THAT(variant, Eq(1.1));
+}
+
+TEST(SqliteValue, IntegerEquals)
+{
+    bool isEqual = Sqlite::Value{1} == 1LL;
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, IntegerEqualsInverse)
+{
+    bool isEqual = 1LL == Sqlite::Value{1};
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, FloatEquals)
+{
+    bool isEqual = Sqlite::Value{1.0} == 1.;
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, FloatEqualsInverse)
+{
+    bool isEqual = 1. == Sqlite::Value{1.0};
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, StringEquals)
+{
+    bool isEqual = Sqlite::Value{"foo"} == "foo";
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, StringEqualsInverse)
+{
+    bool isEqual = "foo" == Sqlite::Value{"foo"};
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, IntegerAndFloatAreNotEquals)
+{
+    bool isEqual = Sqlite::Value{1} == 1.;
+
+    ASSERT_FALSE(isEqual);
+}
+
+TEST(SqliteValue, IntegerValuesAreEquals)
+{
+    bool isEqual = Sqlite::Value{1} == Sqlite::Value{1};
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, IntegerAndFloatValuesAreNotEquals)
+{
+    bool isEqual = Sqlite::Value{1} == Sqlite::Value{1.};
+
+    ASSERT_FALSE(isEqual);
+}
+
+TEST(SqliteValue, StringAndQStringAreEquals)
+{
+    bool isEqual = Sqlite::Value{"foo"} == QString{"foo"};
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, IntegerAndFloatValuesAreUnequal)
+{
+    bool isUnequal = Sqlite::Value{1} != Sqlite::Value{1.0};
+
+    ASSERT_TRUE(isUnequal);
+}
+
+TEST(SqliteValue, IntegerAndFloatAreUnequal)
+{
+    bool isUnequal = Sqlite::Value{1} != 1.0;
+
+    ASSERT_TRUE(isUnequal);
+}
+
+TEST(SqliteValue, IntegerAndFloatAreUnequalInverse)
+{
+    bool isUnequal = 1.0 != Sqlite::Value{1};
+
+    ASSERT_TRUE(isUnequal);
+}
+
+TEST(SqliteValue, IntegersAreUnequal)
+{
+    bool isUnequal = Sqlite::Value{1} != 2;
+
+    ASSERT_TRUE(isUnequal);
+}
+
+TEST(SqliteValue, IntegersAreUnequalInverse)
+{
+    bool isUnequal = 2 != Sqlite::Value{1};
+
+    ASSERT_TRUE(isUnequal);
+}
+
+TEST(SqliteValue, IntegerType)
+{
+    auto type = Sqlite::Value{1}.type();
+
+    ASSERT_THAT(type, Sqlite::ValueType::Integer);
+}
+
+TEST(SqliteValue, FloatType)
+{
+    auto type = Sqlite::Value{1.}.type();
+
+    ASSERT_THAT(type, Sqlite::ValueType::Float);
+}
+
+TEST(SqliteValue, StringType)
+{
+    auto type = Sqlite::Value{"foo"}.type();
+
+    ASSERT_THAT(type, Sqlite::ValueType::String);
+}
+
+TEST(SqliteValue, StringValueAndValueViewEquals)
+{
+    bool isEqual = Sqlite::ValueView::create("foo") == Sqlite::Value{"foo"};
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, StringValueAndValueViewEqualsInverse)
+{
+    bool isEqual = Sqlite::Value{"foo"} == Sqlite::ValueView::create("foo");
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, IntegerValueAndValueViewEquals)
+{
+    bool isEqual = Sqlite::ValueView::create(1) == Sqlite::Value{1};
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, IntegerValueAndValueViewEqualsInverse)
+{
+    bool isEqual = Sqlite::Value{2} == Sqlite::ValueView::create(2);
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, FloatValueAndValueViewEquals)
+{
+    bool isEqual = Sqlite::ValueView::create(1.1) == Sqlite::Value{1.1};
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, FloatValueAndValueViewEqualsInverse)
+{
+    bool isEqual = Sqlite::Value{1.1} == Sqlite::ValueView::create(1.1);
+
+    ASSERT_TRUE(isEqual);
+}
+
+TEST(SqliteValue, StringValueAndIntergerValueViewAreNotEqual)
+{
+    bool isEqual = Sqlite::Value{"foo"} == Sqlite::ValueView::create(1);
+
+    ASSERT_FALSE(isEqual);
+}
+
+TEST(SqliteValue, ConvertStringValueViewIntoValue)
+{
+    auto view = Sqlite::ValueView::create("foo");
+
+    Sqlite::Value value{view};
+
+    ASSERT_THAT(value, Eq("foo"));
+}
+
+TEST(SqliteValue, ConvertIntegerValueViewIntoValue)
+{
+    auto view = Sqlite::ValueView::create(1);
+
+    Sqlite::Value value{view};
+
+    ASSERT_THAT(value, Eq(1));
+}
+
+TEST(SqliteValue, ConvertFloatValueViewIntoValue)
+{
+    auto view = Sqlite::ValueView::create(1.4);
+
+    Sqlite::Value value{view};
+
+    ASSERT_THAT(value, Eq(1.4));
+}
+
+} // namespace
diff --git a/tests/unit/unittest/unittest.pro b/tests/unit/unittest/unittest.pro
index 1db48813e8..6155cf3212 100644
--- a/tests/unit/unittest/unittest.pro
+++ b/tests/unit/unittest/unittest.pro
@@ -80,6 +80,7 @@ SOURCES += \
     smallstring-test.cpp \
     sourcerangefilter-test.cpp \
     spydummy.cpp \
+    sqlitevalue-test.cpp \
     symbolindexer-test.cpp \
     symbolsfindfilter-test.cpp \
     stringcache-test.cpp \
@@ -122,7 +123,13 @@ SOURCES += \
     headerpathfilter-test.cpp \
     toolchainargumentscache-test.cpp \
     modifiedtimechecker-test.cpp \
-    readexporteddiagnostics-test.cpp
+    sqlitecolumn-test.cpp \
+    sqlitedatabasebackend-test.cpp \
+    sqlitedatabase-test.cpp \
+    sqlitestatement-test.cpp \
+    sqlitetable-test.cpp \
+    sqlstatementbuilder-test.cpp \
+    createtablesqlstatementbuilder-test.cpp
 
 !isEmpty(LIBCLANG_LIBS) {
 SOURCES += \
@@ -158,7 +165,6 @@ SOURCES += \
     codecompleter-test.cpp \
     codecompletionsextractor-test.cpp \
     completionchunkstotextconverter-test.cpp \
-    createtablesqlstatementbuilder-test.cpp \
     cursor-test.cpp \
     diagnosticset-test.cpp \
     diagnostic-test.cpp \
@@ -168,17 +174,12 @@ SOURCES += \
     skippedsourceranges-test.cpp \
     sourcelocation-test.cpp \
     sourcerange-test.cpp \
-    sqlitecolumn-test.cpp \
-    sqlitedatabasebackend-test.cpp \
-    sqlitedatabase-test.cpp \
-    sqlitestatement-test.cpp \
-    sqlitetable-test.cpp \
-    sqlstatementbuilder-test.cpp \
     token-test.cpp \
     translationunitupdater-test.cpp \
     unsavedfiles-test.cpp \
     unsavedfile-test.cpp \
-    utf8positionfromlinecolumn-test.cpp
+    utf8positionfromlinecolumn-test.cpp \
+    readexporteddiagnostics-test.cpp
 }
 
 !isEmpty(LIBTOOLING_LIBS) {