Seich
/
arduino_midi_library
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updated tester (more modularity).

This commit is contained in:
Francois Best 2012-10-08 09:10:43 +02:00
parent ac86227ed1
commit def147e6e5
7 changed files with 212 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

163
res/Examples/MIDI_LibValidator/MIDI_LibValidator.ino
View File

@ -3,175 +3,26 @@
#include <MIDI.h>
#include <LiquidCrystal.h>
#include "midi_ValidatorSerialDebug.h"
#include "midi_ValidatorLCD.h"
#include "midi_ValidatorLEDs.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);
}
*/
#include "midi_ValidatorInstances.h"
#include "midi_ValidatorTester.h"
// -----------------------------------------------------------------------------
void setup()
{
setupMidiInstance<HardwareSerial>(midiHW);
setupMidiInstance<SoftwareSerial>(midiSW);
setupSerialDebug();
setupLCD();
setupLEDs();
//setupTesters();
setupMidiInstances();
setupTesters();
}
// -----------------------------------------------------------------------------
void loop()
{
//testerHW.runTests();
//testerSW.runTests();
launchTests();
}

10
res/Examples/MIDI_LibValidator/midi_ValidatorInstances.h Normal file
View File

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

34
res/Examples/MIDI_LibValidator/midi_ValidatorInstances.ino Normal file
View File

@ -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);
}

5
res/Examples/MIDI_LibValidator/midi_ValidatorSerialDebug.h Normal file
View File

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

12
res/Examples/MIDI_LibValidator/midi_ValidatorSerialDebug.ino Normal file
View File

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

4
res/Examples/MIDI_LibValidator/midi_ValidatorTester.h Normal file
View File

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

140
res/Examples/MIDI_LibValidator/midi_ValidatorTester.ino Normal file
View File

@ -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();
}