Adds immediate migration results

qt6-after/qt6-migrated-legatus/include/rti/apputils/test/SqliteVerifier.hpp

@@ -0,0 +1,214 @@
+/*
+ (c) Copyright, Real-Time Innovations, 2023-.
+ All rights reserved.
+ No duplications, whole or partial, manual or electronic, may be made
+ without express written permission.  Any such copies, or
+ revisions thereof, must display this notice unaltered.
+ This code contains trade secrets of Real-Time Innovations, Inc.
+*/
+
+#ifndef HPP_APPUTILS_SQLITEVERIFIER_HPP_
+#define HPP_APPUTILS_SQLITEVERIFIER_HPP_
+
+#include "rti/apputils/SQLiteConnection.hpp"
+#include "rti/apputils/test/TestFramework.hpp"
+#include "rti/util/util.hpp"
+
+#include "rti/recording/storage/EStorageFormat.hpp"
+
+namespace rti { namespace apputils { namespace test {
+
+/**
+ * @brief Basic utility class with different checks for an SQLite Connection.
+ */
+class SQLiteVerifierBase {
+public:
+
+    SQLiteVerifierBase(rti::apputils::SQLiteConnection& connection) :
+        connection_(connection) { }
+
+    bool check_table_exists(const std::string& table)
+    {
+        std::ostringstream string_stream;
+        string_stream << "SELECT name FROM sqlite_master WHERE name = '";
+        string_stream << table;
+        string_stream << "'";
+
+        rti::apputils::SQLiteConnection::RowIterator row_it =
+                connection_.begin(string_stream.str());
+        if (!row_it.at_end()) {
+            return true;
+        }
+        return false;
+    }
+
+    bool wait_till_table_exists(
+            const std::string& table,
+            const unsigned int seconds = DEFAULT_TEST_TIMEOUT_SEC)
+    {
+        bool exists = check_table_exists(table);
+        dds::core::Duration sleepDuration(1,0);
+        for (uint32_t i = 0; i < seconds && !exists; i++) {
+            rti::util::sleep(sleepDuration);
+            exists = check_table_exists(table);
+        }
+        if (!exists) {
+            RTITestLogger_log(
+                    RTI_LOG_BIT_EXCEPTION,
+                    &RTI_TEST_LOG_FAILURE_TEMPLATE,
+                    "Table not found: %s",
+                    table.c_str());
+        }
+        return exists;
+    }
+
+    bool check_column_exists(
+            const std::string& table,
+            const std::string& column)
+    {
+        std::ostringstream string_stream;
+        string_stream << "PRAGMA table_info([" << table << "])";
+
+        rti::apputils::SQLiteConnection::RowIterator row_it =
+                connection_.begin(string_stream.str());
+        while (!row_it.at_end()) {
+            std::string column_name;
+            row_it.get(1, column_name);
+            if (column_name.compare(column) == 0) {
+                return true;
+            }
+            ++row_it;
+        }
+        return false;
+    }
+
+
+    uint32_t num_rows_for_statement(const std::string& sql)
+    {
+        rti::apputils::SQLiteConnection::RowIterator row_it =
+                connection_.begin(sql);
+        uint32_t row_count = 0;
+        while (!row_it.at_end()) {
+            row_count++;
+            ++row_it;
+        }
+        return row_count;
+    }
+
+    /**
+     * @pre check_table_exists(table) == true
+     */
+    uint32_t num_rows(
+            const std::string& table,
+            const bool filter_invalid = false)
+    {
+        std::ostringstream string_stream;
+        string_stream << "SELECT COUNT(*) FROM [" << table << "]";
+        if (filter_invalid) {
+            string_stream << " WHERE SampleInfo_valid_data = 1";
+        }
+        rti::apputils::SQLiteConnection::RowIterator row_it =
+                connection_.begin(string_stream.str());
+        int64_t value = 0;
+        row_it.get(0, value);
+        return (uint32_t) value;
+    }
+
+    bool check_num_rows(
+            const std::string& table,
+            const uint32_t expected_count,
+            const bool filter_invalid = false)
+    {
+        try {
+            RTI_TEST_ASSERT_EQUALS_INT(
+                    expected_count,
+                    num_rows(table, filter_invalid));
+        } catch (const std::exception&) {
+            return false;
+        }
+        return true;
+    }
+
+    bool check_num_rows_for_statement(
+            const std::string& sql,
+            const unsigned int expected_count)
+    {
+        try {
+            RTI_TEST_ASSERT_EQUALS_INT(
+                    expected_count,
+                    num_rows_for_statement(sql));
+        } catch (const std::exception&) {
+            return false;
+        }
+        return true;
+    }
+
+    bool wait_till_num_rows(
+            const std::string& table,
+            const unsigned int expected_count,
+            const bool filter_invalid = false,
+            const unsigned int seconds = DEFAULT_TEST_TIMEOUT_SEC)
+    {
+        try {
+            RTI_TEST_WAIT_FOR_EQUALS_INT(
+                    expected_count,
+                    num_rows(table, filter_invalid),
+                    static_cast<int32_t>(seconds));
+        } catch (const std::exception& ex) {
+            RTITestLogger_log(
+                    RTI_LOG_BIT_EXCEPTION,
+                    &RTI_TEST_LOG_FAILURE_TEMPLATE,
+                    "exception thrown: %s",
+                    ex.what());
+            return false;
+        }
+        return true;
+    }
+
+    bool wait_till_num_rows_for_statement(
+            const std::string& sql,
+            const unsigned int expected_count,
+            const unsigned int seconds = DEFAULT_TEST_TIMEOUT_SEC)
+    {
+        try {
+            RTI_TEST_WAIT_FOR_EQUALS_INT(
+                    expected_count,
+                    num_rows_for_statement(sql),
+                    static_cast<int32_t>(seconds));
+        } catch (const std::exception& ex) {
+            RTITestLogger_log(
+                    RTI_LOG_BIT_EXCEPTION,
+                    &RTI_TEST_LOG_FAILURE_TEMPLATE,
+                    "exception thrown: %s",
+                    ex.what());
+            return false;
+        }
+        return true;
+    }
+
+    bool check_num_rows_invariant(
+            const std::string& table,
+            const unsigned int expected_count,
+            const bool filter_invalid = false,
+            const unsigned int seconds = DEFAULT_TEST_TIMEOUT_SEC)
+    {
+        const struct RTINtpTime sleepTime = {0,429496730};
+        int sleeps = 0;
+        bool result = check_num_rows(table, expected_count, filter_invalid);
+        while(result && sleeps < (static_cast<int32_t>(seconds)) * 10) {
+            RTIOsapiThread_sleep(&sleepTime);
+            ++sleeps;
+            result = check_num_rows(table, expected_count, filter_invalid);
+        }
+        return result;
+    }
+
+protected:
+
+    rti::apputils::SQLiteConnection& connection_;
+};
+
+} } } /* namespace rti::apputils::test */
+
+
+#endif /* HPP_APPUTILS_SQLITEVERIFIER_HPP_ */