Updated tester (more modularity).

res/Examples/MIDI_LibValidator/MIDI_LibValidator.ino

@@ -3,175 +3,26 @@
 #include <MIDI.h>
 #include <LiquidCrystal.h>
 
+#include "midi_ValidatorSerialDebug.h"
 #include "midi_ValidatorLCD.h"
 #include "midi_ValidatorLEDs.h"
-
+#include "midi_ValidatorInstances.h"
-// -----------------------------------------------------------------------------
+#include "midi_ValidatorTester.h"
-
-#define NUM_TESTS       1
-
-// -----------------------------------------------------------------------------
-
-SoftwareSerial softSerial(2, 3);
-
-MIDI_CREATE_INSTANCE(HardwareSerial, Serial,        midiHW);
-MIDI_CREATE_INSTANCE(SoftwareSerial, softSerial,    midiSW);
-// \todo Create instance for USB if available
-
-
-// -----------------------------------------------------------------------------
-/*
-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
-{
-public:
-    explicit MidiTester(MidiInterface<SerialClass>& inInstance)
-        : mInstance(inInstance)
-    {
-    }
-    
-    virtual ~MidiTester()
-    {
-    }
-    
-public:
-    inline bool performTestFixture(TestFixture<SerialClass>* inFixture)
-    {
-        if (inFixture != 0)
-        {
-            return (*inFixture)();
-        }
-        return false;
-    }
-    
-    inline bool expect(bool inCondition) const
-    {
-        if (inCondition == false)
-            blinkFail();
-        else
-            blinkPass();
-        return inCondition;
-    }
-    
-public:
-    inline void registerTest(TestFixture<SerialClass>* inFixture)
-    {
-        mTests[mNumActiveTests++] = inFixture;
-    }
-    
-    bool runTests()
-    {
-        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;
-    TestFixture<SerialClass>* mTests[NUM_TESTS];
-    unsigned mNumActiveTests;
-};
-
-// -----------------------------------------------------------------------------
-
-template<class SerialClass>
-bool testNoteOn(midi::MidiInterface<SerialClass>& inMidi)
-{
-    inMidi.sendNoteOn(12, 42);
-    return true;
-}
-
-// -----------------------------------------------------------------------------
-
-END_MIDI_NAMESPACE
-
-midi::MidiTester<HardwareSerial> testerHW(midiHW);
-midi::MidiTester<SoftwareSerial> testerSW(midiSW);
-*/
-// -----------------------------------------------------------------------------
-
-template<class SerialClass>
-void setupMidiInstance(midi::MidiInterface<SerialClass>& inInstance)
-{
-    inInstance.begin(MIDI_CHANNEL_OMNI);
-    inInstance.turnThruOff();
-}
-
-/*
-template<class SerialClass>
-void setupTester(midi::MidiTester<SerialClass>& inTester)
-{
-    inTester.registerTest(new midi::TestFixture("Note On", midi::testNoteOn));
-}
-
-void setupTesters()
-{
-    setupTester<HardwareSerial>(testerHW);
-    setupTester<SoftwareSerial>(testerSW);
-}
-*/
 
 // -----------------------------------------------------------------------------
 
 void setup()
 {
-    setupMidiInstance<HardwareSerial>(midiHW);
+    setupSerialDebug();
-    setupMidiInstance<SoftwareSerial>(midiSW);
     setupLCD();
     setupLEDs();
-    //setupTesters();
+    setupMidiInstances();
+    setupTesters();
 }
 
 // -----------------------------------------------------------------------------
 
 void loop()
 {
-    //testerHW.runTests();
+    launchTests();
-    //testerSW.runTests();
 }

res/Examples/MIDI_LibValidator/midi_ValidatorInstances.h

@@ -0,0 +1,10 @@
+
+#pragma once
+
+#include <SoftwareSerial.h>
+#include <MIDI.h>
+
+extern midi::MidiInterface<HardwareSerial> midiHW;
+extern midi::MidiInterface<SoftwareSerial> midiSW;
+
+void setupMidiInstances();

res/Examples/MIDI_LibValidator/midi_ValidatorInstances.ino

@@ -0,0 +1,34 @@
+
+#include "midi_ValidatorInstances.h"
+
+// -----------------------------------------------------------------------------
+
+SoftwareSerial softSerial(2, 3);
+
+#if defined(__AVR_ATmega32U4__) // Leonardo uses Serial1 as hardware serial.
+    MIDI_CREATE_INSTANCE(HardwareSerial, Serial1,       midiHW);
+    MIDI_CREATE_INSTANCE(SoftwareSerial, softSerial,    midiSW);
+#else
+    MIDI_CREATE_INSTANCE(HardwareSerial, Serial,        midiHW);
+    MIDI_CREATE_INSTANCE(SoftwareSerial, softSerial,    midiSW);
+#endif
+
+// \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

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

res/Examples/MIDI_LibValidator/midi_ValidatorSerialDebug.ino

@@ -0,0 +1,12 @@
+#include "midi_ValidatorSerialDebug.h"
+
+void setupSerialDebug()
+{
+	Serial.begin(38400);
+}
+
+void print(const char* inString)
+{
+	Serial.println(inString);
+}
+

res/Examples/MIDI_LibValidator/midi_ValidatorTester.h

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

res/Examples/MIDI_LibValidator/midi_ValidatorTester.ino

@@ -0,0 +1,140 @@
+
+#include "midi_ValidatorTester.h"
+#include "midi_ValidatorInstances.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
+{
+public:
+    explicit MidiTester(MidiInterface<SerialClass>& inInstance)
+        : mInstance(inInstance)
+    {
+    }
+    
+    virtual ~MidiTester()
+    {
+    }
+    
+public:
+    inline bool performTestFixture(TestFixture<SerialClass>* inFixture)
+    {
+        if (inFixture != 0)
+        {
+            return (*inFixture)();
+        }
+        return false;
+    }
+    
+    inline bool expect(bool inCondition) const
+    {
+        if (inCondition == false)
+            blinkFail();
+        else
+            blinkPass();
+        return inCondition;
+    }
+    
+public:
+    inline void registerTest(TestFixture<SerialClass>* inFixture)
+    {
+        mTests[mNumActiveTests++] = inFixture;
+    }
+    
+    bool runTests()
+    {
+        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;
+    TestFixture<SerialClass>* mTests[NUM_TESTS];
+    unsigned mNumActiveTests;
+};
+
+// -----------------------------------------------------------------------------
+
+template<class SerialClass>
+bool testNoteOn(MIDI_CLASS(SerialClass)& inMidi)
+{
+    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);
+    //setupTester<SoftwareSerial>(testerSW);
+}
+
+void launchTests()
+{
+    //testerHW.runTests();
+    //testerSW.runTests();
+}