Add substring filter to test program. Port another SV test.

Author: Mysticial

Common/Cpp/Options/TextEditOption.cpp

@@ -16,7 +16,7 @@ namespace PokemonAutomation{
 
 
 struct TextEditOption::Data{
-    const std::string m_label;
+    std::string m_label;
     const std::string m_default;
     const std::string m_placeholder_text;
     const bool m_report_all_text_changes;
@@ -80,9 +80,17 @@ std::unique_ptr<ConfigOption> TextEditOption::clone() const{
 }
 #endif
 
-const std::string& TextEditOption::label() const{
+std::string TextEditOption::label() const{
+    ReadSpinLock lg(m_data->m_lock);
     return m_data->m_label;
 }
+void TextEditOption::set_label(std::string label){
+    {
+        ReadSpinLock lg(m_data->m_lock);
+        m_data->m_label = std::move(label);
+    }
+    report_value_changed(this);
+}
 const std::string& TextEditOption::placeholder_text() const{
     return m_data->m_placeholder_text;
 }

Common/Cpp/Options/TextEditOption.h

@@ -41,7 +41,9 @@ class TextEditOption : public ConfigOptionImpl<TextEditOption>{
     );
 //    virtual std::unique_ptr<ConfigOption> clone() const override;
 
-    const std::string& label() const;
+    std::string label() const;
+    void set_label(std::string label);
+
     const std::string& placeholder_text() const;
     bool signal_all_text_changes() const;
 

Common/Qt/Options/TextEditWidget.cpp

@@ -86,9 +86,9 @@ TextEditWidget::TextEditWidget(QWidget& parent, TextEditOption& value)
 
     QVBoxLayout* layout = new QVBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
-    QLabel* label = new QLabel(QString::fromStdString(value.label()), this);
-    label->setWordWrap(true);
-    layout->addWidget(label);
+    m_label = new QLabel(QString::fromStdString(value.label()), this);
+    m_label->setWordWrap(true);
+    layout->addWidget(m_label);
     m_box = new Box(*this);
     m_box->setText(QString::fromStdString(value));
     if (value.lock_mode() == LockMode::READ_ONLY){
@@ -99,12 +99,20 @@ TextEditWidget::TextEditWidget(QWidget& parent, TextEditOption& value)
     m_value.ConfigOption::add_listener(*this);
 }
 void TextEditWidget::update_value(){
-    std::string new_value = (std::string)m_value;
-    std::string text = m_box->toPlainText().toStdString();
-    if (new_value == text){
-        return;
+    {
+        std::string new_value = m_value.label();
+        std::string text = m_label->text().toStdString();
+        if (new_value != text){
+            m_label->setText(QString::fromStdString(new_value));
+        }
+    }
+    {
+        std::string new_value = (std::string)m_value;
+        std::string text = m_box->toPlainText().toStdString();
+        if (new_value != text){
+            m_box->setText(QString::fromStdString(new_value));
+        }
     }
-    m_box->setText(QString::fromStdString(m_value));
 }
 void TextEditWidget::on_config_value_changed(void* object){
     //  This function gets called every time the contents changes.

Common/Qt/Options/TextEditWidget.h

@@ -11,6 +11,7 @@
 #include "Common/Cpp/Options/TextEditOption.h"
 #include "ConfigWidget.h"
 
+class QLabel;
 class QTextEdit;
 
 namespace PokemonAutomation{
@@ -33,6 +34,7 @@ class TextEditWidget : public QWidget, public ConfigWidget, public TextEditOptio
     class Box;
 
     TextEditOption& m_value;
+    QLabel* m_label;
     QTextEdit* m_box;
 
     bool m_pending_append = false;

SerialPrograms/Source/ComputerPrograms/UnitTestRunner.cpp

@@ -98,6 +98,7 @@ std::unique_ptr<StatsTracker> UnitTestRunner_Descriptor::make_stats() const{
 
 
 UnitTestRunner::~UnitTestRunner(){
+    SUBSTRING_TEST.remove_listener(*this);
     RUN_MODE.remove_listener(*this);
 }
 UnitTestRunner::UnitTestRunner()
@@ -111,25 +112,33 @@ UnitTestRunner::UnitTestRunner()
     , RUN_MODE(
         "<b>Run Mode:</b>",
         {
-            {RunMode::RUN_ALL, "run-all", "Run All Tests"},
-            {RunMode::RUN_ONE, "run-one", "Run One Test"},
+            {RunMode::RUN_ONE,              "run-one",              "Run One Test"},
+            {RunMode::RUN_SUBSTRING_MATCH,  "run-substring-match",  "Run Matching Substrings"},
+            {RunMode::RUN_ALL,              "run-all",              "Run All Tests"},
         },
         LockMode::LOCK_WHILE_RUNNING,
-        RunMode::RUN_ALL
+        RunMode::RUN_SUBSTRING_MATCH
     )
     , SINGLE_TEST_LABEL("<b>Test Name:</b>")
     , SINGLE_TEST(
         TEST_DATABASE(),
         LockMode::LOCK_WHILE_RUNNING,
         0
     )
+    , SUBSTRING_TEST_LABEL("<b>Run All Tests Containing This Substring:</b>")
+    , SUBSTRING_TEST(false, LockMode::LOCK_WHILE_RUNNING, "", "PokemonSwSh")
+    , TESTS_TO_RUN(
+        "<b>Tests to Run:</b>",
+        LockMode::READ_ONLY,
+        "", ""
+    )
     , PASSED_TESTS(
-        "<b>Passing Tests</b>",
+        "<b>Passing Tests:</b>",
         LockMode::READ_ONLY,
         "", ""
     )
     , FAILED_TESTS(
-        "<b>Failing Tests</b>",
+        "<b>Failing Tests:</b>",
         LockMode::READ_ONLY,
         "", ""
     )
@@ -139,20 +148,51 @@ UnitTestRunner::UnitTestRunner()
     PA_ADD_OPTION(RUN_MODE);
     PA_ADD_STATIC(SINGLE_TEST_LABEL);
     PA_ADD_OPTION(SINGLE_TEST);
+    PA_ADD_STATIC(SUBSTRING_TEST_LABEL);
+    PA_ADD_OPTION(SUBSTRING_TEST);
+    PA_ADD_OPTION(TESTS_TO_RUN);
     PA_ADD_OPTION(PASSED_TESTS);
     PA_ADD_OPTION(FAILED_TESTS);
 
     UnitTestRunner::on_config_value_changed(this);
 
     RUN_MODE.add_listener(*this);
+    SUBSTRING_TEST.add_listener(*this);
 }
 void UnitTestRunner::on_config_value_changed(void* object){
-    if ((RunMode)RUN_MODE == RunMode::RUN_ONE){
-        SINGLE_TEST_LABEL.set_visibility(ConfigOptionState::ENABLED);
-        SINGLE_TEST.set_visibility(ConfigOptionState::ENABLED);
-    }else{
+    if (object == &RUN_MODE){
         SINGLE_TEST_LABEL.set_visibility(ConfigOptionState::HIDDEN);
         SINGLE_TEST.set_visibility(ConfigOptionState::HIDDEN);
+        SUBSTRING_TEST_LABEL.set_visibility(ConfigOptionState::HIDDEN);
+        SUBSTRING_TEST.set_visibility(ConfigOptionState::HIDDEN);
+        TESTS_TO_RUN.set_visibility(ConfigOptionState::HIDDEN);
+
+        switch ((RunMode)RUN_MODE){
+        case RunMode::RUN_ONE:
+            SINGLE_TEST_LABEL.set_visibility(ConfigOptionState::ENABLED);
+            SINGLE_TEST.set_visibility(ConfigOptionState::ENABLED);
+            break;
+        case RunMode::RUN_SUBSTRING_MATCH:
+            SUBSTRING_TEST_LABEL.set_visibility(ConfigOptionState::ENABLED);
+            SUBSTRING_TEST.set_visibility(ConfigOptionState::ENABLED);
+            TESTS_TO_RUN.set_visibility(ConfigOptionState::ENABLED);
+            break;
+        case RunMode::RUN_ALL:
+            break;
+        }
+        return;
+    }
+    if (object == &SUBSTRING_TEST){
+        std::string name = SUBSTRING_TEST;
+        TESTS_TO_RUN.set("");
+        size_t count = 0;
+        for (const auto& test : UNIT_TESTS_ALL()){
+            if (test.first.contains(name)){
+                count++;
+                TESTS_TO_RUN.append(test.first + "\n");
+            }
+        }
+        TESTS_TO_RUN.set_label("<b>Tests to Run: " + tostr_u_commas(count) + "</b>");
     }
 }
 
@@ -176,11 +216,8 @@ void UnitTestRunner::program(ProgramEnvironment& env, CancellableScope& scope){
 
     const UnitTestDatabase& all_tests = UNIT_TESTS_ALL();
 
-    if ((RunMode)RUN_MODE == RunMode::RUN_ALL){
-        for (const auto& test : all_tests){
-            runner.add_test(test.second);
-        }
-    }else{
+    switch ((RunMode)RUN_MODE){
+    case RunMode::RUN_ONE:{
         auto iter = all_tests.find(SINGLE_TEST.slug());
         if (iter == all_tests.end()){
             throw InternalProgramError(
@@ -190,6 +227,23 @@ void UnitTestRunner::program(ProgramEnvironment& env, CancellableScope& scope){
             );
         }
         runner.add_test(iter->second);
+        break;
+    }
+    case RunMode::RUN_SUBSTRING_MATCH:{
+        std::string name = SUBSTRING_TEST;
+        for (const auto& test : all_tests){
+            if (test.first.contains(name)){
+                runner.add_test(test.second);
+            }
+        }
+        break;
+    }
+    case RunMode::RUN_ALL:{
+        for (const auto& test : all_tests){
+            runner.add_test(test.second);
+        }
+        break;
+    }
     }
 
     runner.run();

SerialPrograms/Source/ComputerPrograms/UnitTestRunner.h

@@ -55,14 +55,19 @@ class UnitTestRunner
     StringCell RESOURCE_PATH;
 
     enum class RunMode{
-        RUN_ALL,
         RUN_ONE,
+        RUN_SUBSTRING_MATCH,
+        RUN_ALL,
     };
     EnumDropdownOption<RunMode> RUN_MODE;
 
     StaticTextOption SINGLE_TEST_LABEL;
     StringSelectCell SINGLE_TEST;
 
+    StaticTextOption SUBSTRING_TEST_LABEL;
+    StringCell SUBSTRING_TEST;
+
+    TextEditOption TESTS_TO_RUN;
     TextEditOption PASSED_TESTS;
     TextEditOption FAILED_TESTS;
 

SerialPrograms/Source/PokemonSV/Inference/Picnics/PokemonSV_PicnicDetector.cpp

@@ -4,13 +4,14 @@
  *
  */
 
+#include "Common/Cpp/TestRunners/UnitTestDatabase.h"
 #include "CommonFramework/Globals.h"
 #include "CommonFramework/VideoPipeline/VideoOverlayScopes.h"
 #include "PokemonSV_PicnicDetector.h"
 
-#include <iostream>
-using std::cout;
-using std::endl;
+//#include <iostream>
+//using std::cout;
+//using std::endl;
 
 namespace PokemonAutomation{
 namespace NintendoSwitch{
@@ -37,6 +38,44 @@ bool PicnicDetector::detect(const ImageViewRGB32& frame){
 }
 
 
+
+
+
+
+class Test_PicnicDetector : public UnitTest{
+public:
+    Test_PicnicDetector(
+        const std::string& image,
+        bool expected
+    )
+        : UnitTest("PokemonSV::PicnicDetector - " + image)
+        , m_image(UNIT_TEST_RESOURCE_PATH() + image)
+        , m_expected(expected)
+    {}
+
+    virtual UnitTestResult run(Logger& logger, CancellableScope& scope) const override{
+        PicnicDetector detector;
+        ImageRGB32 image(m_image);
+        return detector.detect(image) == m_expected;
+    };
+
+private:
+    std::string m_image;
+    bool m_expected;
+};
+
+
+
+
+void add_tests_PicnicDetector(UnitTestDatabase& database){
+    database.add<Test_PicnicDetector>("PokemonSV/PicnicDetector/macOS/Picinic_1_True.png", true);
+    database.add<Test_PicnicDetector>("PokemonSV/PicnicDetector/macOS/Picnic_0_True.png", true);
+}
+
+
+
+
+
 }
 }
 }

SerialPrograms/Source/PokemonSV/Inference/Picnics/PokemonSV_PicnicDetector.h

@@ -8,6 +8,7 @@
 #define PokemonAutomation_PokemonSV_PicnicDetector_H
 
 #include "Common/Cpp/Color.h"
+#include "Common/Cpp/TestRunners/UnitTest.h"
 #include "CommonFramework/ImageTools/ImageBoxes.h"
 #include "CommonTools/InferenceCallbacks/VisualInferenceCallback.h"
 #include "CommonTools/VisualDetector.h"
@@ -41,6 +42,14 @@ class PicnicWatcher : public DetectorToFinder<PicnicDetector>{
 
 
 
+
+
+
+void add_tests_PicnicDetector(UnitTestDatabase& database);
+
+
+
+
 }
 }
 }

SerialPrograms/Source/PokemonSV/PokemonSV_Tests.cpp

@@ -7,6 +7,7 @@
 #include "Common/Cpp/TestRunners/UnitTestDatabase.h"
 #include "Inference/PokemonSV_WhiteButtonDetector.h"
 #include "Inference/Map/PokemonSV_MapDetector.h"
+#include "Inference/Picnics/PokemonSV_PicnicDetector.h"
 #include "PokemonSV_Tests.h"
 
 namespace PokemonAutomation{
@@ -18,7 +19,7 @@ namespace PokemonSV{
 void add_tests(UnitTestDatabase& database){
     add_tests_WhiteButtonDetector(database);
     add_tests_MapDetector(database);
-
+    add_tests_PicnicDetector(database);
 }