Updated tester.

res/Examples/MIDI_LibValidator/MIDI_LibValidator.ino

@@ -16,7 +16,6 @@ void setup()
     setupSerialDebug();
     setupLCD();
     setupLEDs();
-    setupMidiInstances();
     setupTesters();
 }
 
@@ -24,5 +23,14 @@ void setup()
 
 void loop()
 {
-    launchTests();
+    if (launchTests() == true)
+    {
+    	setLedsFinal(true);
+    	Serial.println("All tests passed.");
+    }
+    else
+    {
+    	setLedsFinal(false);
+    	Serial.println("Some tests failed!");
+    }
 }

res/Examples/MIDI_LibValidator/midi_ValidatorInstances.h

@@ -6,5 +6,3 @@
 
 extern midi::MidiInterface<HardwareSerial> midiHW;
 extern midi::MidiInterface<SoftwareSerial> midiSW;
-
-void setupMidiInstances();

res/Examples/MIDI_LibValidator/midi_ValidatorInstances.ino

@@ -15,20 +15,3 @@ SoftwareSerial softSerial(2, 3);
 
 // \todo Create instance for USB if available
 
-// -----------------------------------------------------------------------------
-
-template<class SerialClass>
-void setupMidiInstance(MIDI_CLASS(SerialClass)& inInstance)
-{
-    inInstance.begin(MIDI_CHANNEL_OMNI);
-    inInstance.turnThruOff();
-}
-
-// -----------------------------------------------------------------------------
-
-void setupMidiInstances()
-{
-    setupMidiInstance<HardwareSerial>(midiHW);
-    setupMidiInstance<SoftwareSerial>(midiSW);
-}
-

res/Examples/MIDI_LibValidator/midi_ValidatorSerialDebug.h

@@ -1,5 +1,3 @@
 #pragma once
 
 void setupSerialDebug();
-
-void print(const char* inString);

res/Examples/MIDI_LibValidator/midi_ValidatorSerialDebug.ino

@@ -5,8 +5,3 @@ void setupSerialDebug()
 	Serial.begin(38400);
 }
 
-void print(const char* inString)
-{
-	Serial.println(inString);
-}
-

res/Examples/MIDI_LibValidator/midi_ValidatorTester.h

@@ -1,4 +1,7 @@
 #pragma once
 
 void setupTesters();
-void launchTests();
+bool launchTests();
+
+
+

res/Examples/MIDI_LibValidator/midi_ValidatorTester.ino

@@ -1,140 +1,92 @@
 
 #include "midi_ValidatorTester.h"
 #include "midi_ValidatorInstances.h"
-/*
+#include "midi_ValidatorTests.h"
-// -----------------------------------------------------------------------------
-
-BEGIN_MIDI_NAMESPACE
-
-template<class SerialClass>
-class TestFixture
-{
-public:
-    typedef const char* String;
-    typedef bool (*Functor) (MidiInterface<SerialClass>&);
-    
-public:
-    TestFixture(String inTestName, 
-                Functor inFunctor)
-        : mTestName(inTestName)
-        , mFunctor(inFunctor)
-    {
-    }
-    
-public:
-    inline bool operator() (void)
-    {
-        return mFunctor();
-    }
-    
-    inline String getName() const
-    {
-        return mTestName;
-    }
-    
-private:
-    String mTestName;
-    Functor mFunctor;
-};
 
 // -----------------------------------------------------------------------------
 
 template<class SerialClass>
-class MidiTester
+class Tester
 {
+public: 
+    typedef bool (*Functor) (MIDI_CLASS(SerialClass)&);
+    
 public:
-    explicit MidiTester(MidiInterface<SerialClass>& inInstance)
+    explicit Tester(MIDI_CLASS(SerialClass)& inInstance)
-        : mInstance(inInstance)
+        : mMidiInstance(inInstance)
+        , mProgress(0)
     {
     }
     
-    virtual ~MidiTester()
+    void setup()
     {
+        mProgress = 0;
+        mMidiInstance.begin(MIDI_CHANNEL_OMNI);
+        mMidiInstance.turnThruOff();
     }
     
 public:
-    inline bool performTestFixture(TestFixture<SerialClass>* inFixture)
+    inline bool performTest(Functor inTestMethod)
     {
-        if (inFixture != 0)
+        if (inTestMethod != 0)
         {
-            return (*inFixture)();
+            const bool result = expect((*inTestMethod)(mMidiInstance));
+            setProgressBar(++mProgress, NUM_TESTS);
+            return result;
         }
         return false;
     }
     
     inline bool expect(bool inCondition) const
     {
+        Serial.print(testNames[mProgress]);
+        Serial.print(": ");
         if (inCondition == false)
+        {
+            Serial.println("Failed! /!\\");
             blinkFail();
+        }
         else
+        {
+            Serial.println("Passed.");
             blinkPass();
+        }
         return inCondition;
     }
     
-public:
+    bool run()
-    inline void registerTest(TestFixture<SerialClass>* inFixture)
     {
-        mTests[mNumActiveTests++] = inFixture;
+        performTest(testNoteOn);
-    }
+        performTest(testNoteOff);
-    
+        performTest(testControlChange);
-    bool runTests()
+        performTest(testProgramChange);
-    {
-        for (unsigned i = 0; i < mNumActiveTests; ++i)
-        {
-            if (mTests[i] != 0)
-            {
-                if (expect(performTestFixture(mTests[i]) == false))
-                {
-                    // \todo Display message
-                    // \todo Store error number and continue.
-                    return false;
-                }
-            }
-            setProgressBar(i, mNumActiveTests);
-        }
-        return true;
     }
     
 private:
-    MidiInterface<SerialClass>& mInstance;
+    MIDI_CLASS(SerialClass)& mMidiInstance;
-    TestFixture<SerialClass>* mTests[NUM_TESTS];
+    unsigned mProgress;
-    unsigned mNumActiveTests;
 };
 
 // -----------------------------------------------------------------------------
 
-template<class SerialClass>
+Tester<HardwareSerial> testerHW(midiHW);
-bool testNoteOn(MIDI_CLASS(SerialClass)& inMidi)
+Tester<SoftwareSerial> testerSW(midiSW);
-{
-    inMidi.sendNoteOn(12, 42);
-    return true;
-}
 
 // -----------------------------------------------------------------------------
 
-END_MIDI_NAMESPACE
-
-midi::MidiTester<HardwareSerial> testerHW(midiHW);
-midi::MidiTester<SoftwareSerial> testerSW(midiSW);
-
-// -----------------------------------------------------------------------------
-
-template<class SerialClass>
-void setupTester(MIDI_CLASS(SerialClass)& inTester)
-{
-    inTester.registerTest(new midi::TestFixture("Note On", midi::testNoteOn));
-}
-
-// -----------------------------------------------------------------------------
-*/
 void setupTesters()
 {
-    //setupTester<HardwareSerial>(testerHW);
+    testerHW.setup();
-    //setupTester<SoftwareSerial>(testerSW);
+    testerSW.setup();
 }
 
-void launchTests()
+bool launchTests()
 {
-    //testerHW.runTests();
+    Serial.println("Testing HW:");
-    //testerSW.runTests();
+    if (testerHW.run() == false)
+        return false;
+    Serial.println("Testing SW:");
+    if (testerSW.run() == false)
+        return false;
+    return true;
 }

res/Examples/MIDI_LibValidator/midi_ValidatorTests.h

@@ -0,0 +1,34 @@
+#pragma once
+
+// -----------------------------------------------------------------------------
+
+#define NUM_TESTS 4
+
+// -----------------------------------------------------------------------------
+
+#define DECLARE_MIDI_TEST(Name)                                                 \
+    template<class SerialClass>                                                 \
+    bool Name(MIDI_CLASS(SerialClass)& inMidi)
+
+#define IMPLEMENT_MIDI_TEST(Name, Instance)                                     \
+    template<class SerialClass>                                                 \
+    bool Name(MIDI_CLASS(SerialClass)& Instance)
+
+// -----------------------------------------------------------------------------
+    
+static const char * testNames[] = 
+{
+  // 0123456789ABCDEF
+    "NoteOn        ",
+    "NoteOff       ",
+    "ControlChange ",
+    "ProgramChange ",
+    
+};
+
+// -----------------------------------------------------------------------------
+
+DECLARE_MIDI_TEST(testNoteOn);
+DECLARE_MIDI_TEST(testNoteOff);
+DECLARE_MIDI_TEST(testControlChange);
+DECLARE_MIDI_TEST(testProgramChange);

res/Examples/MIDI_LibValidator/midi_ValidatorTests.ino

@@ -0,0 +1,52 @@
+
+#include "midi_ValidatorTests.h"
+
+// -----------------------------------------------------------------------------
+
+IMPLEMENT_MIDI_TEST(testNoteOn, inMidi)
+{
+    inMidi.sendNoteOn(12, 42, 3);
+    while (inMidi.read() == false) { }
+    
+    bool result =   inMidi.getType()  == midi::NoteOn && 
+                    inMidi.getData1() == 12 && 
+                    inMidi.getData2() == 42 &&
+                    inMidi.getChannel() == 3;
+    return result;
+}
+
+IMPLEMENT_MIDI_TEST(testNoteOff, inMidi)
+{
+    inMidi.sendNoteOff(12, 42, 3);
+    while (inMidi.read() == false) { }
+    
+    bool result =   inMidi.getType()  == midi::NoteOff && 
+                    inMidi.getData1() == 12 && 
+                    inMidi.getData2() == 42 &&
+                    inMidi.getChannel() == 3;
+    return result;
+}
+
+IMPLEMENT_MIDI_TEST(testControlChange, inMidi)
+{
+    inMidi.sendControlChange(12, 42, 3);
+    while (inMidi.read() == false) { }
+    
+    bool result =   inMidi.getType()  == midi::ControlChange && 
+                    inMidi.getData1() == 12 && 
+                    inMidi.getData2() == 42 &&
+                    inMidi.getChannel() == 3;
+    return result;
+}
+
+IMPLEMENT_MIDI_TEST(testProgramChange, inMidi)
+{
+    inMidi.sendProgramChange(12, 3);
+    while (inMidi.read() == false) { }
+    
+    bool result =   inMidi.getType()  == midi::ProgramChange && 
+                    inMidi.getData1() == 12 && 
+                    inMidi.getData2() == 42 &&
+                    inMidi.getChannel() == 3;
+    return result;
+}