Add 2-argument versions of include() and exclude() filters, matching testF() and testingF()

Author: bxparks

README.md

@@ -1,4 +1,7 @@
-# AUnit - Unit Testing Framework for Arduino Platforms
+# AUnit
+
+A unit testing framework for Arduino platforms inspired by ArduinoUnit and
+Google Test.
 
 Version: 0.4.0 (2018-03-30)
 
@@ -87,6 +90,8 @@ Here are the features in AUnit which are not available in ArduinoUnit:
     * `externTestF()`
     * `externTestingF()`
 * AUnit works on the ESP8266 platform.
+* Test filters (`TestRunner::include()` and `TestRunner::exclude()`) support the
+  same 2 arguments versions corresponding to `testF()` and `testingF()`
 
 ### Beta Status
 
@@ -130,6 +135,7 @@ The `examples/` directory has a number of examples:
 In the `tests/` directory:
 
 * `AUnitTest` - the unit test for `AUnit` itself has a large number of examples
+* `FilterTest` - manual tests for `include()` and `exclude()` filters
 
 ### Header and Namespace
 
@@ -237,7 +243,7 @@ class CustomTestAgain: public TestAgain {
     }
 };
 
-testingF(CustomTestAgain, examle_test) {
+testingF(CustomTestAgain, example_test) {
   ...
   assertBigStuff();
   ...
@@ -249,6 +255,7 @@ void setup() {
 
   TestRunner::exclude("*");
   TestRunner::include("looping*");
+  TestRunner::include("CustomTestAgain", "example*");
 }
 
 void loop() {
@@ -628,36 +635,45 @@ ArduinoUnit, each call to `Test::run()` will process the entire list of
 currently active test cases. In AUnit, each call to `TestRunner::run()` performs
 only a single test case, then returns._
 
-### Excluding and Including Test Cases
+### Filtering Test Cases
 
-We can `exclude()` or `include()` test cases using a pattern match,
-just like ArduinoUnit. The names are slightly different:
+We can `exclude()` or `include()` test cases using a pattern match:
+
+* `TestRunner::exclude(pattern)`
+* `TestRunner::exclude(testClass, pattern)`
+* `TestRunner::include(pattern)`
+* `TestRunner::include(testClass, pattern)`
 
-* `TestRunner::exclude()`
-* `TestRunner::include()`
 
 These methods are called from the global `setup()` method:
 
 ```
 void setup() {
   TestRunner::exclude("*");
   TestRunner::include("looping*");
+  TestRunner::exclude("CustomTestAgain", "*");
+  TestRunner::include("CustomTestAgain", "test*");
   ...
 }
 ```
 
+The 2-argument versions of `include()` and `exclude()` correspond to the
+2 arguments of `testF()` and `testingF()`.
+
 ***ArduinoUnit Compatibility***:
 _The equivalent versions in ArduinoUnit are `Test::exclude()` and
-`Test::include()` The matching algorithm in AUnit is not as powerful as one in
-ArduinoUnit. AUnit supports only a single wildcard character `*` and that
+`Test::include()` The matching algorithm in AUnit is not as powerful as the one
+in ArduinoUnit. AUnit supports only a single wildcard character `*` and that
 character can appear only at the end if it is present. For example, the
 following are accepted:_
 
 * `TestRunner::exclude("*");`
 * `TestRunner::include("f*");`
 * `TestRunner::exclude("flash_*");`
 * `TestRunner::include("looping*");`
-* `TestRunner::include("flashTest");`
+* `TestRunner::include("CustomTestOnce", "flashTest*");`
+
+_AUnit provides 2-argument versions of `include()` and `exclude()`_
 
 ### Output Printer
 

src/aunit/TestRunner.cpp

@@ -64,6 +64,15 @@ void TestRunner::setStatusMatchingPattern(const char* pattern, uint8_t status) {
   }
 }
 
+void TestRunner::setStatusMatchingPattern(const char* testClass,
+    const char* pattern, uint8_t status) {
+  String fullPattern(testClass);
+  fullPattern.concat('_');
+  fullPattern.concat(pattern);
+
+  setStatusMatchingPattern(fullPattern.c_str(), status);
+}
+
 TestRunner::TestRunner():
     mCurrent(nullptr),
     mIsResolved(false),

src/aunit/TestRunner.h

@@ -57,6 +57,17 @@ class TestRunner {
       getRunner()->setStatusMatchingPattern(pattern, Test::kStatusSkipped);
     }
 
+    /**
+     * Exclude the tests which match the pattern given by (testClass + "_" +
+     * pattern), the same concatenation rule used by the testF() macro.
+     * Currently supports only a trailing '*'. For example,
+     * exclude("CustomTest", "flash*").
+     */
+    static void exclude(const char* testClass, const char* pattern) {
+      getRunner()->setStatusMatchingPattern(testClass, pattern,
+          Test::kStatusSkipped);
+    }
+
     /**
      * Include the tests which match the pattern.
      * Currently supports only a trailing '*'. For example, include("flash*").
@@ -65,6 +76,17 @@ class TestRunner {
       getRunner()->setStatusMatchingPattern(pattern, Test::kStatusNew);
     }
 
+    /**
+     * Include the tests which match the pattern given by (testClass + "_" +
+     * pattern), the same concatenation rule used by the testF() macro.
+     * Currently supports only a trailing '*'. For example,
+     * include("CustomTest", "flash*").
+     */
+    static void include(const char* testClass, const char* pattern) {
+      getRunner()->setStatusMatchingPattern(testClass, pattern,
+          Test::kStatusNew);
+    }
+
     /** Set the verbosity flag. */
     static void setVerbosity(uint8_t verbosity) {
       getRunner()->setVerbosityFlag(verbosity);
@@ -129,6 +151,13 @@ class TestRunner {
     /** Set the status of the tests which match the pattern. */
     void setStatusMatchingPattern(const char* pattern, uint8_t status);
 
+    /**
+     * Set the status of the tests which match the pattern formed by (testClass
+     * + "_" + pattern), the same rule used by testF() and testingF()
+     */
+    void setStatusMatchingPattern(const char* testClass, const char* pattern,
+        uint8_t status);
+
     /** Set the test runner timeout. */
     void setRunnerTimeout(TimeoutType seconds);
 

tests/FilterTest/FilterTest.ino

@@ -49,25 +49,44 @@ testingF(CustomAgain, display) { pass(); }
 
 void setup() {
   delay(1000); // Wait for stability on some boards, otherwise garage on Serial
-  Serial.begin(74880); // 74880 is the default for some ESP8266 boards
+  Serial.begin(115200); // ESP8266 default of 74880 not supported on Linux
   while (! Serial); // Wait until Serial is ready - Leonardo
 
   // Verify that the names of these tests don't collide and can be
-  // independently selected. Name of test = "{test_class}_{name}".
+  // independently selected. Name of test is "{test_class}_{name}", but we can
+  // use the new 2-argument versions of include(testClass, pattern) and
+  // exclude(testClass, pattern) instead.
+
   TestRunner::list();
+
+  Serial.println("exclude(\"*\")");
   TestRunner::exclude("*");
   TestRunner::list();
+
+  Serial.println("include(\"configure*\")");
+  TestRunner::include("configure");
+  TestRunner::list();
+
+  Serial.println("include(\"CustomAgain*\")");
   TestRunner::include("CustomAgain*");
   TestRunner::list();
-  TestRunner::include("CustomOnce_dis*");
+
+  Serial.println("exclude(\"CustomAgain\", \"*\")");
+  TestRunner::exclude("CustomAgain", "*");
   TestRunner::list();
-  TestRunner::include("configure");
+
+  Serial.println("include(\"CustomAgain\", \"display\")");
+  TestRunner::include("CustomAgain", "display");
+  TestRunner::list();
+
+  Serial.println("include(\"CustomOnce_dis*\")");
+  TestRunner::include("CustomOnce_dis*");
   TestRunner::list();
 }
 
 void loop() {
-  // Should get:
+  // Should get something like:
   // TestRunner summary:
-  //    4 passed, 0 failed, 2 skipped, 0 timed out, out of 6 test(s).
+  //    3 passed, 0 failed, 3 skipped, 0 timed out, out of 6 test(s).
   TestRunner::run();
 }