mirror of
https://github.com/RobTillaart/Arduino.git
synced 2024-10-03 18:09:02 -04:00
187 lines
3.4 KiB
C++
187 lines
3.4 KiB
C++
//
|
|
// FILE: unit_test_001.cpp
|
|
// AUTHOR: Rob Tillaart
|
|
// DATE: 2022-07-28
|
|
// PURPOSE: unit tests for the AD56X8 DA convertor.
|
|
// https://github.com/RobTillaart/AD56X8
|
|
// https://github.com/Arduino-CI/arduino_ci/blob/master/REFERENCE.md
|
|
//
|
|
|
|
// supported assertions
|
|
// ----------------------------
|
|
// assertEqual(expected, actual)
|
|
// assertNotEqual(expected, actual)
|
|
// assertLess(expected, actual)
|
|
// assertMore(expected, actual)
|
|
// assertLessOrEqual(expected, actual)
|
|
// assertMoreOrEqual(expected, actual)
|
|
// assertTrue(actual)
|
|
// assertFalse(actual)
|
|
// assertNull(actual)
|
|
|
|
|
|
#include <ArduinoUnitTests.h>
|
|
|
|
#include "Arduino.h"
|
|
#include "AD56X8.h"
|
|
|
|
|
|
|
|
unittest_setup()
|
|
{
|
|
fprintf(stderr, "AD56X8_LIB_VERSION: %s\n", (char *) AD56X8_LIB_VERSION);
|
|
}
|
|
|
|
unittest_teardown()
|
|
{
|
|
}
|
|
|
|
|
|
unittest(constant)
|
|
{
|
|
assertEqual(0x00, AD56X8_PWR_NORMAL );
|
|
assertEqual(0x01, AD56X8_PWR_1K );
|
|
assertEqual(0x02, AD56X8_PWR_100K );
|
|
assertEqual(0x03, AD56X8_PWR_TRI_STATE );
|
|
|
|
assertEqual(0x00, AD56X8_CC_0000 );
|
|
assertEqual(0x01, AD56X8_CC_8000 );
|
|
assertEqual(0x02, AD56X8_CC_FFFF );
|
|
assertEqual(0x03, AD56X8_CC_NOP );
|
|
}
|
|
|
|
|
|
unittest(constructors)
|
|
{
|
|
AD56X8 AD0(8);
|
|
AD5668 AD16(9);
|
|
AD5648 AD14(10, 11, 12);
|
|
AD5628 AD12(4, 5, 6);
|
|
AD5668_3 AD16M(7, 3, 2);
|
|
|
|
assertTrue(AD0.usesHWSPI());
|
|
assertTrue(AD16.usesHWSPI());
|
|
assertFalse(AD14.usesHWSPI());
|
|
assertFalse(AD12.usesHWSPI());
|
|
assertFalse(AD16M.usesHWSPI());
|
|
}
|
|
|
|
|
|
unittest(get_type)
|
|
{
|
|
AD56X8 AD0(8);
|
|
AD5668 AD16(9);
|
|
AD5648 AD14(10, 11, 12);
|
|
AD5628 AD12(4, 5, 6);
|
|
AD5668_3 AD16M(7);
|
|
|
|
assertEqual(0, AD0.getType());
|
|
assertEqual(16, AD16.getType());
|
|
assertEqual(14, AD14.getType());
|
|
assertEqual(12, AD12.getType());
|
|
assertEqual(16, AD16M.getType());
|
|
}
|
|
|
|
|
|
unittest(get_setValue)
|
|
{
|
|
AD56X8 AD0(8);
|
|
|
|
AD0.begin();
|
|
|
|
// valid channels
|
|
for (uint8_t chan = 0; chan < 8; chan++)
|
|
{
|
|
assertTrue(AD0.setValue(chan, chan * 100));
|
|
}
|
|
for (uint8_t chan = 0; chan < 8; chan++)
|
|
{
|
|
assertEqual(chan * 100, AD0.getValue(chan));
|
|
}
|
|
|
|
// channel out of range test.
|
|
assertFalse(AD0.setValue(8, 0));
|
|
}
|
|
|
|
|
|
unittest(get_PowerUpValue)
|
|
{
|
|
AD56X8 AD0(8);
|
|
AD5668_3 AD16M(7);
|
|
|
|
AD0.begin();
|
|
AD16M.begin();
|
|
|
|
// valid channels 0 Volts
|
|
for (uint8_t chan = 0; chan < 8; chan++)
|
|
{
|
|
assertEqual(0, AD0.getValue(chan));
|
|
}
|
|
// valid channels 0 Volts
|
|
for (uint8_t chan = 0; chan < 8; chan++)
|
|
{
|
|
assertEqual(32768, AD16M.getValue(chan));
|
|
}
|
|
|
|
// invalid channel returns 0.
|
|
assertEqual(0, AD16M.getValue(8));
|
|
}
|
|
|
|
|
|
unittest(prepareChannel)
|
|
{
|
|
AD56X8 AD0(8);
|
|
|
|
AD0.begin();
|
|
|
|
// valid channels
|
|
for (uint8_t chan = 0; chan < 8; chan++)
|
|
{
|
|
assertTrue(AD0.prepareChannel(chan, chan * 100));
|
|
}
|
|
for (uint8_t chan = 0; chan < 8; chan++)
|
|
{
|
|
assertEqual(chan * 100, AD0.getValue(chan));
|
|
}
|
|
|
|
// channel out of range test.
|
|
assertFalse(AD0.prepareChannel(8, 0));
|
|
}
|
|
|
|
|
|
unittest(set_power_mode)
|
|
{
|
|
AD56X8 AD0(8);
|
|
|
|
AD0.begin();
|
|
|
|
assertTrue(AD0.setPowerMode(0, 0));
|
|
assertTrue(AD0.setPowerMode(1, 0));
|
|
assertTrue(AD0.setPowerMode(2, 0));
|
|
assertTrue(AD0.setPowerMode(3, 0));
|
|
|
|
// powerMode out of range test.
|
|
assertFalse(AD0.setPowerMode(4, 0));
|
|
}
|
|
|
|
|
|
unittest(set_clear_code)
|
|
{
|
|
AD56X8 AD0(8);
|
|
|
|
AD0.begin();
|
|
|
|
assertTrue(AD0.setClearCode(0));
|
|
assertTrue(AD0.setClearCode(1));
|
|
assertTrue(AD0.setClearCode(2));
|
|
|
|
// CCMode out of range test.
|
|
assertFalse(AD0.setClearCode(4));
|
|
}
|
|
|
|
|
|
unittest_main()
|
|
|
|
|
|
// -- END OF FILE --
|