platformio/Alex2ESP
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
Alex2ESP/test/test_discovery/test_main.cpp
David c3d02f462e Announce a doorbell with proactivelyReported and a scene with supportsDeactivation 
An interface without properties says beside its name what Alexa has to know
of it; the library left both out. With a board and Alexa on 2026-09-28 the
discovery of a doorbell was accepted (202), the endpoint was not listed, and
its DoorbellPress was answered with 500 INTERNAL_SERVICE_EXCEPTION.

DoorbellEventSource now always carries "proactivelyReported": true.
SceneController carries "supportsDeactivation", false until the sketch calls
setSupportsDeactivation(true); on another interface the call is refused and
logged. The Scene example says that it can be undone.

148 host tests. Light: static RAM 30,616 B, flash 332,705 B (+140 B).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-28 22:20:34 +00:00

810 lines
42 KiB
C++
Raw Blame History

// Host tests of discovery: the object that each example announces on <root>/discover_r, compared byte by byte
// with what library 1.1.0 sent for the same sketch, what the descriptor rows of src/AlexaInterfaces.cpp hold, and
// what a capability announces and refuses (src/AlexaCapability.cpp).
// The devices are built with the calls of the example's setup().
// pio test -e native
#include <unity.h>
#include <ArduinoJson.h>
#include <string.h>
#include <string>
#include "AlexaDevice.h"
#include "AlexaLog.h"
#include "AlexaResources.h"
#include "AlexaVersion.h"
// The endpoint id and the defaults are the same in every example; its name, category and capabilities are not
static std::string endpoint(const char *friendlyName, const char *displayCategory, const std::string &capabilities)
{
return std::string("{\"endpointId\":\"ESP-01\",\"friendlyName\":\"") + friendlyName +
"\",\"description\":\"Alexa2MQTT Default Device\",\"manufacturerName\":\"Alexa2MQTT\","
"\"displayCategories\":[\"" + displayCategory + "\"],"
"\"additionalAttributes\":{\"manufacturer\":\"Alexa2MQTT\",\"model\":\"Alexa2MQTT\","
"\"serialNumber\":\"ESP2Alex\",\"firmwareVersion\":\"" ALEX2ESP_VERSION "\","
"\"softwareVersion\":\"" ALEX2ESP_VERSION "\",\"customIdentifier\":\"ESP2Alex\"},"
"\"capabilities\":[" + capabilities + "]}";
}
static const char POWER[] =
"{\"interface\":\"Alexa.PowerController\",\"version\":\"3\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":true,\"proactivelyReported\":false,\"supported\":[{\"name\":\"powerState\"}]}}";
static const char BRIGHTNESS[] =
"{\"interface\":\"Alexa.BrightnessController\",\"version\":\"3\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":true,\"proactivelyReported\":false,\"supported\":[{\"name\":\"brightness\"}]}}";
static const char COLOR_TEMPERATURE[] =
"{\"interface\":\"Alexa.ColorTemperatureController\",\"version\":\"3\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":true,\"proactivelyReported\":false,"
"\"supported\":[{\"name\":\"colorTemperatureInKelvin\"}]}}";
static const char TEMPERATURE[] =
"{\"interface\":\"Alexa.TemperatureSensor\",\"version\":\"3\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":true,\"proactivelyReported\":false,\"supported\":[{\"name\":\"temperature\"}]}}";
static const char BLIND_TOGGLE[] =
"{\"interface\":\"Alexa.ToggleController\",\"version\":\"3\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":true,\"proactivelyReported\":false,\"supported\":[{\"name\":\"toggleState\"}]},"
"\"semantics\":{\"actionMappings\":["
"{\"@type\":\"ActionsToDirective\",\"actions\":[\"Alexa.Actions.Close\"],\"directive\":{\"name\":\"TurnOn\"}},"
"{\"@type\":\"ActionsToDirective\",\"actions\":[\"Alexa.Actions.Open\"],\"directive\":{\"name\":\"TurnOff\"}}]},"
"\"instance\":\"ESP-01.Toggle\","
"\"capabilityResources\":{\"friendlyNames\":["
"{\"@type\":\"text\",\"value\":{\"text\":\"Bedroom Blinds\",\"locale\":\"en-US\"}}]}}";
static void assertDiscovery(const std::string &expected, const AlexaDevice &device)
{
std::string announced;
serializeJson(device.getDeviceJSON(), announced);
TEST_ASSERT_EQUAL_STRING(expected.c_str(), announced.c_str());
}
void setUp(void)
{
AlexaLog::setOutput(nullptr); // the lines about added capabilities are not what is tested
}
void tearDown(void) {}
void test_basic_light_discovery(void)
{
AlexaDevice device("Test Lamp", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::LIGHT);
device.addCapability(AlexaInterfaceType::POWER_CONTROLLER);
assertDiscovery(endpoint("Test Lamp", "LIGHT", POWER), device);
}
void test_light_with_brightness_discovery(void)
{
AlexaDevice device("Test Lamp", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::LIGHT);
device.addCapability(AlexaInterfaceType::POWER_CONTROLLER);
device.addCapability(AlexaInterfaceType::BRIGHTNESS_CONTROLLER);
assertDiscovery(endpoint("Test Lamp", "LIGHT", std::string(POWER) + "," + BRIGHTNESS), device);
}
void test_light_with_color_temperature_discovery(void)
{
AlexaDevice device("Test Lamp ESP", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::LIGHT);
device.addCapability(AlexaInterfaceType::POWER_CONTROLLER);
device.addCapability(AlexaInterfaceType::BRIGHTNESS_CONTROLLER);
device.addCapability(AlexaInterfaceType::COLOR_TEMPERATURE_CONTROLLER);
assertDiscovery(endpoint("Test Lamp ESP", "LIGHT", std::string(POWER) + "," + BRIGHTNESS + "," + COLOR_TEMPERATURE),
device);
}
void test_temperature_sensor_discovery(void)
{
AlexaDevice device("ESP Temp", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::TEMPERATURE_SENSOR);
device.addCapability(AlexaInterfaceType::TEMPERATURE_SENSOR);
assertDiscovery(endpoint("ESP Temp", "TEMPERATURE_SENSOR", TEMPERATURE), device);
}
void test_blind_control_discovery(void)
{
String deviceName = "Bedroom Blinds";
AlexaDevice device(deviceName, "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::INTERIOR_BLIND);
device.addCapability(AlexaInterfaceType::POWER_CONTROLLER);
AlexaInterface *toggleController = device.addCapability(AlexaInterfaceType::TOGGLE_CONTROLLER);
toggleController->setInstance("ESP-01.Toggle");
toggleController->addFriendlyName(deviceName.c_str(), "en-US");
ActionMapping closeMapping({AlexaActions::Close}, "TurnOn");
ActionMapping openMapping({AlexaActions::Open}, "TurnOff");
toggleController->addActionMapping(closeMapping);
toggleController->addActionMapping(openMapping);
assertDiscovery(endpoint("Bedroom Blinds", "INTERIOR_BLIND", std::string(POWER) + "," + BLIND_TOGGLE), device);
}
// What the library prints, for the tests that expect an error
class CapturedLog : public Print
{
public:
std::string text;
size_t write(const uint8_t *buffer, size_t size) override
{
text.append(reinterpret_cast<const char *>(buffer), size);
return size;
}
};
struct ExpectedRow
{
const AlexaInterfaceDesc *row;
AlexaInterfaceType type;
const char *ns;
const char *version;
const char *properties; // separated by commas
};
// The interface pages of the Alexa documentation, as the design lists them
static const ExpectedRow EXPECTED_ROWS[] = {
{&AlexaInterfaces::EndpointHealth, AlexaInterfaceType::ENDPOINT_HEALTH, "Alexa.EndpointHealth", "3.1", "connectivity"},
{&AlexaInterfaces::PowerController, AlexaInterfaceType::POWER_CONTROLLER, "Alexa.PowerController", "3", "powerState"},
{&AlexaInterfaces::BrightnessController, AlexaInterfaceType::BRIGHTNESS_CONTROLLER, "Alexa.BrightnessController", "3", "brightness"},
{&AlexaInterfaces::ColorController, AlexaInterfaceType::COLOR_CONTROLLER, "Alexa.ColorController", "3", "color"},
{&AlexaInterfaces::ColorTemperatureController, AlexaInterfaceType::COLOR_TEMPERATURE_CONTROLLER, "Alexa.ColorTemperatureController", "3", "colorTemperatureInKelvin"},
{&AlexaInterfaces::PowerLevelController, AlexaInterfaceType::POWER_LEVEL_CONTROLLER, "Alexa.PowerLevelController", "3", "powerLevel"},
{&AlexaInterfaces::PercentageController, AlexaInterfaceType::PERCENTAGE_CONTROLLER, "Alexa.PercentageController", "3", "percentage"},
{&AlexaInterfaces::RangeController, AlexaInterfaceType::RANGE_CONTROLLER, "Alexa.RangeController", "3", "rangeValue"},
{&AlexaInterfaces::ModeController, AlexaInterfaceType::MODE_CONTROLLER, "Alexa.ModeController", "3", "mode"},
{&AlexaInterfaces::ToggleController, AlexaInterfaceType::TOGGLE_CONTROLLER, "Alexa.ToggleController", "3", "toggleState"},
{&AlexaInterfaces::ThermostatController, AlexaInterfaceType::THERMOSTAT_CONTROLLER, "Alexa.ThermostatController", "3.2", "targetSetpoint,lowerSetpoint,upperSetpoint,thermostatMode"},
{&AlexaInterfaces::TemperatureSensor, AlexaInterfaceType::TEMPERATURE_SENSOR, "Alexa.TemperatureSensor", "3", "temperature"},
{&AlexaInterfaces::HumiditySensor, AlexaInterfaceType::HUMIDITY_SENSOR, "Alexa.HumiditySensor", "3", "relativeHumidity"},
{&AlexaInterfaces::LockController, AlexaInterfaceType::LOCK_CONTROLLER, "Alexa.LockController", "3", "lockState"},
{&AlexaInterfaces::SceneController, AlexaInterfaceType::SCENE_CONTROLLER, "Alexa.SceneController", "3", ""},
{&AlexaInterfaces::ContactSensor, AlexaInterfaceType::CONTACT_SENSOR, "Alexa.ContactSensor", "3", "detectionState"},
{&AlexaInterfaces::MotionSensor, AlexaInterfaceType::MOTION_SENSOR, "Alexa.MotionSensor", "3", "detectionState"},
{&AlexaInterfaces::DoorbellEventSource, AlexaInterfaceType::DOORBELL_EVENT_SOURCE, "Alexa.DoorbellEventSource", "3", ""},
{&AlexaInterfaces::TimeHoldController, AlexaInterfaceType::TIME_HOLD_CONTROLLER, "Alexa.TimeHoldController", "3", "holdStartTime,holdEndTime"},
{&AlexaInterfaces::Speaker, AlexaInterfaceType::SPEAKER, "Alexa.Speaker", "3", "volume,muted"},
{&AlexaInterfaces::StepSpeaker, AlexaInterfaceType::STEP_SPEAKER, "Alexa.StepSpeaker", "3", ""},
{&AlexaInterfaces::PlaybackController, AlexaInterfaceType::PLAYBACK_CONTROLLER, "Alexa.PlaybackController", "3", ""},
{&AlexaInterfaces::PlaybackStateReporter, AlexaInterfaceType::PLAYBACK_STATE_REPORTER, "Alexa.PlaybackStateReporter", "3", "playbackState"},
{&AlexaInterfaces::InputController, AlexaInterfaceType::INPUT_CONTROLLER, "Alexa.InputController", "3", "input"},
{&AlexaInterfaces::ChannelController, AlexaInterfaceType::CHANNEL_CONTROLLER, "Alexa.ChannelController", "3", "channel"},
{&AlexaInterfaces::InventoryLevelSensor, AlexaInterfaceType::INVENTORY_LEVEL_SENSOR, "Alexa.InventoryLevelSensor", "3", "level"},
{&AlexaInterfaces::SimpleEventSource, AlexaInterfaceType::SIMPLE_EVENT_SOURCE, "Alexa.SimpleEventSource", "1.0", ""},
{&AlexaInterfaces::WakeOnLANController, AlexaInterfaceType::WAKE_ON_LAN_CONTROLLER, "Alexa.WakeOnLANController", "3", ""},
};
void test_rows_hold_the_namespace_version_and_properties_of_their_interface(void)
{
TEST_ASSERT_EQUAL_size_t(28, sizeof(EXPECTED_ROWS) / sizeof(EXPECTED_ROWS[0]));
for (const ExpectedRow &expected : EXPECTED_ROWS)
{
const AlexaInterfaceDesc &row = *expected.row;
TEST_ASSERT_EQUAL_STRING(expected.ns, row.ns);
TEST_ASSERT_EQUAL_STRING_MESSAGE(expected.version, row.version, expected.ns);
TEST_ASSERT_TRUE_MESSAGE(expected.type == row.interfaceType(), expected.ns);
std::string properties;
for (uint8_t i = 0; i < row.propertyCount(); i++)
{
properties += (i == 0 ? "" : ",");
properties += row.property(i);
}
TEST_ASSERT_EQUAL_STRING_MESSAGE(expected.properties, properties.c_str(), expected.ns);
}
}
void test_every_row_is_found_by_its_type(void)
{
for (const ExpectedRow &expected : EXPECTED_ROWS)
{
TEST_ASSERT_EQUAL_PTR_MESSAGE(expected.row, alexaInterfaceRow(expected.type), expected.ns);
}
TEST_ASSERT_NULL(alexaInterfaceRow(AlexaInterfaceType::COOKING));
TEST_ASSERT_NULL(alexaInterfaceRow(AlexaInterfaceType::UNKNOWN));
}
void test_generic_controllers_and_interfaces_without_properties_are_flagged(void)
{
TEST_ASSERT_TRUE(AlexaInterfaces::ToggleController.has(AIF_INSTANCED));
TEST_ASSERT_TRUE(AlexaInterfaces::RangeController.has(AIF_SEMANTICS));
TEST_ASSERT_TRUE(AlexaInterfaces::InventoryLevelSensor.has(AIF_INSTANCED));
TEST_ASSERT_FALSE(AlexaInterfaces::InventoryLevelSensor.has(AIF_SEMANTICS));
TEST_ASSERT_TRUE(AlexaInterfaces::SimpleEventSource.has(AIF_NO_PROPERTIES));
TEST_ASSERT_FALSE(AlexaInterfaces::PowerController.has(AIF_INSTANCED));
TEST_ASSERT_FALSE(AlexaInterfaces::PlaybackController.has(AIF_NO_PROPERTIES));
}
void test_capability_by_row_and_by_type_is_the_same_capability(void)
{
AlexaDevice device("Test Lamp", "root", "ESP-01");
AlexaInterface *byType = device.addCapability(AlexaInterfaceType::POWER_CONTROLLER);
AlexaInterface *byRow = device.addCapability(AlexaInterfaces::PowerController);
TEST_ASSERT_NOT_NULL(byType);
TEST_ASSERT_EQUAL_PTR(byType, byRow);
assertDiscovery(endpoint("Test Lamp", "OTHER", POWER), device);
}
void test_type_without_a_row_is_refused_with_an_error(void)
{
CapturedLog log;
AlexaLog::setOutput(&log);
AlexaDevice device("Oven", "root", "ESP-01");
TEST_ASSERT_NULL(device.addCapability(AlexaInterfaceType::COOKING));
TEST_ASSERT_NOT_NULL(strstr(log.text.c_str(), "[Alex2ESP] error: ESP-01: capability not added"));
assertDiscovery(endpoint("Oven", "OTHER", ""), device);
}
void test_scene_is_announced_without_properties(void)
{
AlexaDevice device("Movie Night", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::SCENE_TRIGGER);
device.addCapability(AlexaInterfaces::SceneController);
assertDiscovery(endpoint("Movie Night", "SCENE_TRIGGER",
"{\"interface\":\"Alexa.SceneController\",\"version\":\"3\",\"type\":\"AlexaInterface\",\"supportsDeactivation\":false}"),
device);
}
void test_thermostat_announces_its_four_properties(void)
{
AlexaDevice device("Hallway", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::THERMOSTAT);
device.addCapability(AlexaInterfaceType::THERMOSTAT_CONTROLLER);
assertDiscovery(endpoint("Hallway", "THERMOSTAT",
"{\"interface\":\"Alexa.ThermostatController\",\"version\":\"3.2\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":true,\"proactivelyReported\":false,\"supported\":["
"{\"name\":\"targetSetpoint\"},{\"name\":\"lowerSetpoint\"},{\"name\":\"upperSetpoint\"},"
"{\"name\":\"thermostatMode\"}]}}"),
device);
}
void test_directive_gets_the_type_of_the_capability_it_names(void)
{
AlexaDevice device("Test Lamp", "root", "ESP-01");
device.addCapability(AlexaInterfaceType::POWER_CONTROLLER);
device.addCapability(AlexaInterfaceType::BRIGHTNESS_CONTROLLER);
TEST_ASSERT_TRUE(AlexaInterfaceType::BRIGHTNESS_CONTROLLER == device.getInterfaceType("Alexa.BrightnessController"));
TEST_ASSERT_TRUE(AlexaInterfaceType::POWER_CONTROLLER == device.getInterfaceType("Alexa.PowerController"));
// An interface of the library that this device does not have, and no interface at all
TEST_ASSERT_TRUE(AlexaInterfaceType::UNKNOWN == device.getInterfaceType("Alexa.LockController"));
TEST_ASSERT_TRUE(AlexaInterfaceType::UNKNOWN == device.getInterfaceType("Alexa"));
}
void test_display_categories_have_the_name_of_their_enumerator(void)
{
TEST_ASSERT_EQUAL_STRING("ACTIVITY_TRIGGER", alexaDisplayCategoryName(DisplayCategory::ACTIVITY_TRIGGER));
TEST_ASSERT_EQUAL_STRING("OTHER", alexaDisplayCategoryName(DisplayCategory::OTHER));
TEST_ASSERT_EQUAL_STRING("WEARABLE", alexaDisplayCategoryName(DisplayCategory::WEARABLE));
TEST_ASSERT_EQUAL_STRING("TV", DisplayCategoryUtils::toString(DisplayCategory::TV).c_str());
TEST_ASSERT_EQUAL_STRING("OTHER", alexaDisplayCategoryName(static_cast<DisplayCategory>(200)));
}
static std::string announcedBy(const AlexaDevice &device)
{
std::string announced;
serializeJson(device.getDeviceJSON(), announced);
return announced;
}
static void assertLogged(const CapturedLog &log, const char *expected)
{
TEST_ASSERT_NOT_NULL_MESSAGE(strstr(log.text.c_str(), expected), log.text.c_str());
}
struct LiftRange
{
int minimum;
int maximum;
};
static void fillLiftConfiguration(JsonObject configuration, void *context)
{
const LiftRange *range = static_cast<const LiftRange *>(context);
JsonObject supportedRange = configuration["supportedRange"].to<JsonObject>();
supportedRange["minimumValue"] = range->minimum;
supportedRange["maximumValue"] = range->maximum;
supportedRange["precision"] = 1;
configuration["unitOfMeasure"] = "Alexa.Unit.Percent";
}
void test_range_controller_blind_is_announced_with_names_configuration_and_semantics(void)
{
static LiftRange range = {0, 100};
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::INTERIOR_BLIND);
AlexaCapability *lift = device.addCapability(AlexaInterfaces::RangeController, "Blind.Lift");
TEST_ASSERT_NOT_NULL(lift);
lift->addFriendlyAsset(PSTR("Alexa.Setting.Opening"))
.addFriendlyName("Lift", "en-US")
.setProactivelyReported(true)
.setConfiguration(fillLiftConfiguration, &range)
.addActionMapping(ActionMapping({AlexaAction::Close, AlexaAction::Lower}, "SetRangeValue", "{\"rangeValue\":0}"))
.addActionMapping(ActionMapping({AlexaAction::Raise, AlexaAction::Open}, "SetRangeValue", "{\"rangeValue\":100}"))
.addStateMapping({AlexaState::Closed}, 0.0f)
.addStateMapping({AlexaState::Open}, 1.0f, 100.0f);
assertDiscovery(
endpoint("Bedroom Blinds", "INTERIOR_BLIND",
"{\"interface\":\"Alexa.RangeController\",\"version\":\"3\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":true,\"proactivelyReported\":true,"
"\"supported\":[{\"name\":\"rangeValue\"}]},"
"\"semantics\":{\"actionMappings\":["
"{\"@type\":\"ActionsToDirective\",\"actions\":[\"Alexa.Actions.Close\",\"Alexa.Actions.Lower\"],"
"\"directive\":{\"name\":\"SetRangeValue\",\"payload\":{\"rangeValue\":0}}},"
"{\"@type\":\"ActionsToDirective\",\"actions\":[\"Alexa.Actions.Open\",\"Alexa.Actions.Raise\"],"
"\"directive\":{\"name\":\"SetRangeValue\",\"payload\":{\"rangeValue\":100}}}],"
"\"stateMappings\":["
"{\"@type\":\"StatesToValue\",\"states\":[\"Alexa.States.Closed\"],\"value\":0},"
"{\"@type\":\"StatesToRange\",\"states\":[\"Alexa.States.Open\"],"
"\"range\":{\"minimumValue\":1,\"maximumValue\":100}}]},"
"\"instance\":\"Blind.Lift\","
"\"capabilityResources\":{\"friendlyNames\":["
"{\"@type\":\"asset\",\"value\":{\"assetId\":\"Alexa.Setting.Opening\"}},"
"{\"@type\":\"text\",\"value\":{\"text\":\"Lift\",\"locale\":\"en-US\"}}]},"
"\"configuration\":{\"supportedRange\":{\"minimumValue\":0,\"maximumValue\":100,\"precision\":1},"
"\"unitOfMeasure\":\"Alexa.Unit.Percent\"}}"),
device);
}
static void fillPositionConfiguration(JsonObject configuration, void *)
{
configuration["ordered"] = false;
JsonArray supportedModes = configuration["supportedModes"].to<JsonArray>();
for (const char *position : {"Up", "Down"})
{
JsonObject mode = supportedModes.add<JsonObject>();
mode["value"] = std::string("Position.") + position;
JsonObject name = mode["modeResources"]["friendlyNames"].add<JsonObject>();
name["@type"] = "text";
name["value"]["text"] = position;
name["value"]["locale"] = "en-US";
}
}
void test_mode_controller_is_announced_with_its_modes_and_text_states(void)
{
AlexaDevice device("Garage Door", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::GARAGE_DOOR);
device.addCapability(AlexaInterfaces::ModeController, "Door.Position")
->addFriendlyAsset(PSTR("Alexa.Setting.Mode"))
.setConfiguration(fillPositionConfiguration)
.addActionMapping(ActionMapping({AlexaAction::Open}, "SetMode", "{\"mode\":\"Position.Up\"}"))
.addStateMapping({AlexaState::Closed}, "Position.Down");
assertDiscovery(
endpoint("Garage Door", "GARAGE_DOOR",
"{\"interface\":\"Alexa.ModeController\",\"version\":\"3\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":true,\"proactivelyReported\":false,\"supported\":[{\"name\":\"mode\"}]},"
"\"semantics\":{\"actionMappings\":["
"{\"@type\":\"ActionsToDirective\",\"actions\":[\"Alexa.Actions.Open\"],"
"\"directive\":{\"name\":\"SetMode\",\"payload\":{\"mode\":\"Position.Up\"}}}],"
"\"stateMappings\":["
"{\"@type\":\"StatesToValue\",\"states\":[\"Alexa.States.Closed\"],\"value\":\"Position.Down\"}]},"
"\"instance\":\"Door.Position\","
"\"capabilityResources\":{\"friendlyNames\":["
"{\"@type\":\"asset\",\"value\":{\"assetId\":\"Alexa.Setting.Mode\"}}]},"
"\"configuration\":{\"ordered\":false,\"supportedModes\":["
"{\"value\":\"Position.Up\",\"modeResources\":{\"friendlyNames\":["
"{\"@type\":\"text\",\"value\":{\"text\":\"Up\",\"locale\":\"en-US\"}}]}},"
"{\"value\":\"Position.Down\",\"modeResources\":{\"friendlyNames\":["
"{\"@type\":\"text\",\"value\":{\"text\":\"Down\",\"locale\":\"en-US\"}}]}}]}}"),
device);
}
void test_toggle_controller_that_only_reports_is_announced_as_non_controllable(void)
{
AlexaDevice device("Fan", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::FAN);
device.addCapability(AlexaInterfaces::ToggleController, "Fan.Oscillate")
->addFriendlyName("Oscillate", "en-US")
.addFriendlyName("Schwenken", "de-DE")
.setRetrievable(false)
.setNonControllable(true);
assertDiscovery(
endpoint("Fan", "FAN",
"{\"interface\":\"Alexa.ToggleController\",\"version\":\"3\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":false,\"proactivelyReported\":false,"
"\"supported\":[{\"name\":\"toggleState\"}],\"nonControllable\":true},"
"\"instance\":\"Fan.Oscillate\","
"\"capabilityResources\":{\"friendlyNames\":["
"{\"@type\":\"text\",\"value\":{\"text\":\"Oscillate\",\"locale\":\"en-US\"}},"
"{\"@type\":\"text\",\"value\":{\"text\":\"Schwenken\",\"locale\":\"de-DE\"}}]}}"),
device);
}
// alexa-scenecontroller.html: supportsDeactivation says whether Alexa may send Deactivate
void test_scene_that_can_be_undone_says_so_and_no_other_interface_can(void)
{
AlexaDevice device("Movie Night", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::SCENE_TRIGGER);
device.addCapability(AlexaInterfaces::SceneController)->setSupportsDeactivation(true);
assertDiscovery(endpoint("Movie Night", "SCENE_TRIGGER",
"{\"interface\":\"Alexa.SceneController\",\"version\":\"3\",\"type\":\"AlexaInterface\",\"supportsDeactivation\":true}"),
device);
AlexaDevice lamp("Lamp", "root", "ESP-02");
AlexaCapability *power = lamp.addCapability(AlexaInterfaces::PowerController);
TEST_ASSERT_TRUE(power->isValid());
power->setSupportsDeactivation(true);
TEST_ASSERT_FALSE_MESSAGE(power->isValid(), "a call the interface cannot take is a refused call");
}
void test_doorbell_is_announced_without_properties(void)
{
AlexaDevice device("Front Door", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::DOORBELL);
device.addCapability(AlexaInterfaces::DoorbellEventSource);
assertDiscovery(endpoint("Front Door", "DOORBELL",
"{\"interface\":\"Alexa.DoorbellEventSource\",\"version\":\"3\",\"type\":\"AlexaInterface\",\"proactivelyReported\":true}"),
device);
}
void test_playback_and_wake_on_lan_are_announced_with_empty_properties(void)
{
AlexaDevice device("Media PC", "root", "ESP-01");
device.setDisplayCategory(DisplayCategory::COMPUTER);
device.addCapability(AlexaInterfaces::PlaybackController);
device.addCapability(AlexaInterfaces::WakeOnLANController);
assertDiscovery(
endpoint("Media PC", "COMPUTER",
"{\"interface\":\"Alexa.PlaybackController\",\"version\":\"3\",\"type\":\"AlexaInterface\",\"properties\":{}},"
"{\"interface\":\"Alexa.WakeOnLANController\",\"version\":\"3\",\"type\":\"AlexaInterface\",\"properties\":{}}"),
device);
}
void test_instance_and_friendly_name_are_copied(void)
{
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
{
std::string instance = "Blind.Tilt";
std::string name = "Tilt";
device.addCapability(AlexaInterfaces::RangeController, instance.c_str())->addFriendlyName(name.c_str(), "en-US");
instance.assign("overwritten");
name.assign("gone");
}
const std::string announced = announcedBy(device);
TEST_ASSERT_NOT_NULL(strstr(announced.c_str(), "\"instance\":\"Blind.Tilt\""));
TEST_ASSERT_NOT_NULL(strstr(announced.c_str(), "\"text\":\"Tilt\""));
}
void test_instances_of_one_interface_are_capabilities_of_their_own(void)
{
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
AlexaCapability *lift = device.addCapability(AlexaInterfaces::RangeController, "Blind.Lift");
AlexaCapability *tilt = device.addCapability(AlexaInterfaces::RangeController, "Blind.Tilt");
TEST_ASSERT_NOT_NULL(lift);
TEST_ASSERT_NOT_NULL(tilt);
TEST_ASSERT_TRUE(lift != tilt);
TEST_ASSERT_EQUAL_PTR(tilt, device.addCapability(AlexaInterfaces::RangeController, "Blind.Tilt"));
TEST_ASSERT_EQUAL_STRING("Blind.Lift", lift->getInstance());
// As a 1.x sketch asks for the capability it added by its type
TEST_ASSERT_EQUAL_PTR(lift, device.addCapability(AlexaInterfaceType::RANGE_CONTROLLER));
}
void test_directive_matches_by_namespace_and_for_instanced_interfaces_by_instance(void)
{
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
AlexaCapability *power = device.addCapability(AlexaInterfaces::PowerController);
AlexaCapability *lift = device.addCapability(AlexaInterfaces::RangeController, "Blind.Lift");
TEST_ASSERT_TRUE(power->matches("Alexa.PowerController", nullptr));
TEST_ASSERT_TRUE(power->matches("Alexa.PowerController", "Blind.Lift"));
TEST_ASSERT_FALSE(power->matches("Alexa.RangeController", nullptr));
TEST_ASSERT_FALSE(power->matches(nullptr, nullptr));
TEST_ASSERT_TRUE(lift->matches("Alexa.RangeController", "Blind.Lift"));
TEST_ASSERT_FALSE(lift->matches("Alexa.RangeController", "Blind.Tilt"));
TEST_ASSERT_FALSE(lift->matches("Alexa.RangeController", nullptr));
}
void test_instanced_row_without_an_instance_is_refused_with_an_error(void)
{
CapturedLog log;
AlexaLog::setOutput(&log);
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
TEST_ASSERT_NULL(device.addCapability(AlexaInterfaces::RangeController));
TEST_ASSERT_NULL(device.addCapability(AlexaInterfaces::ModeController, ""));
assertLogged(log, "error: ESP-01: capability Alexa.RangeController not added: it needs an instance, "
"addCapability(row, \"Blind.Lift\")");
assertLogged(log, "error: ESP-01: capability Alexa.ModeController not added: it needs an instance");
assertDiscovery(endpoint("Bedroom Blinds", "OTHER", ""), device);
}
void test_instance_for_an_interface_without_instances_is_refused_with_an_error(void)
{
CapturedLog log;
AlexaLog::setOutput(&log);
AlexaDevice device("Test Lamp", "root", "ESP-01");
TEST_ASSERT_NULL(device.addCapability(AlexaInterfaces::PowerController, "Lamp.Power"));
assertLogged(log, "error: ESP-01: capability Alexa.PowerController Lamp.Power not added: "
"the interface takes no instance, leave it out");
assertDiscovery(endpoint("Test Lamp", "OTHER", ""), device);
}
void test_capability_added_by_type_without_an_instance_is_left_out_of_discovery(void)
{
CapturedLog log;
AlexaLog::setOutput(&log);
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
device.addCapability(AlexaInterfaceType::POWER_CONTROLLER);
AlexaInterface *toggle = device.addCapability(AlexaInterfaceType::TOGGLE_CONTROLLER);
TEST_ASSERT_NOT_NULL(toggle);
toggle->addFriendlyName("Bedroom Blinds", "en-US");
assertDiscovery(endpoint("Bedroom Blinds", "OTHER", POWER), device);
assertLogged(log, "error: ESP-01: Alexa.ToggleController left out of discovery: it has no instance, "
"call setInstance(\"Blind.Lift\") on it");
}
void test_instanced_capability_without_a_friendly_name_is_left_out_of_discovery(void)
{
CapturedLog log;
AlexaLog::setOutput(&log);
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
device.addCapability(AlexaInterfaces::PowerController);
device.addCapability(AlexaInterfaces::ModeController, "Blind.Mode");
assertDiscovery(endpoint("Bedroom Blinds", "OTHER", POWER), device);
assertLogged(log, "error: ESP-01: Alexa.ModeController Blind.Mode left out of discovery: it has no name, "
"call addFriendlyName(\"Lift\", \"en-US\") on it");
}
void test_semantics_on_an_interface_that_takes_none_are_refused_with_an_error(void)
{
CapturedLog log;
AlexaLog::setOutput(&log);
AlexaDevice device("Test Lamp", "root", "ESP-01");
AlexaCapability *power = device.addCapability(AlexaInterfaces::PowerController);
power->addActionMapping(ActionMapping({AlexaAction::Open}, "TurnOn"));
AlexaCapability *brightness = device.addCapability(AlexaInterfaces::BrightnessController);
brightness->addStateMapping({AlexaState::Open}, "ON");
assertLogged(log, "error: Alexa.PowerController: action mapping not added: "
"only RangeController, ModeController and ToggleController take one");
assertLogged(log, "error: Alexa.BrightnessController: state mapping not added: "
"only RangeController, ModeController and ToggleController take one");
TEST_ASSERT_FALSE(power->isValid());
TEST_ASSERT_FALSE(brightness->isValid());
}
void test_more_names_and_mappings_than_a_capability_holds_are_refused_with_an_error(void)
{
CapturedLog log;
AlexaLog::setOutput(&log);
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
AlexaCapability *lift = device.addCapability(AlexaInterfaces::RangeController, "Blind.Lift");
for (int i = 0; i < ALEX2ESP_MAX_FRIENDLY_NAMES; i++)
{
lift->addFriendlyName("Lift", "en-US");
}
for (int i = 0; i < ALEX2ESP_MAX_ACTION_MAPPINGS; i++)
{
lift->addActionMapping(ActionMapping({AlexaAction::Open}, "SetRangeValue", "{\"rangeValue\":100}"));
}
for (int i = 0; i < ALEX2ESP_MAX_STATE_MAPPINGS; i++)
{
lift->addStateMapping({AlexaState::Open}, 100.0f);
}
TEST_ASSERT_NOT_NULL(strstr(announcedBy(device).c_str(), "Alexa.RangeController"));
TEST_ASSERT_TRUE(lift->isValid());
TEST_ASSERT_EQUAL_STRING("", log.text.c_str() + strlen("[Alex2ESP] ESP-01: capability Alexa.RangeController Blind.Lift added\r\n"));
lift->addFriendlyName("Shade", "en-US")
.addFriendlyAsset(AlexaAssets::Setting_Opening)
.addActionMapping(ActionMapping({AlexaAction::Close}, "SetRangeValue", "{\"rangeValue\":0}"))
.addStateMapping({AlexaState::Closed}, 0.0f);
assertLogged(log, "error: Alexa.RangeController Blind.Lift: friendly name \"Shade\" not added: "
"it has 3 already (ALEX2ESP_MAX_FRIENDLY_NAMES)");
assertLogged(log, "error: Alexa.RangeController Blind.Lift: asset not added: it has 3 names already");
assertLogged(log, "error: Alexa.RangeController Blind.Lift: action mapping to SetRangeValue not added: "
"it has 4 already (ALEX2ESP_MAX_ACTION_MAPPINGS)");
assertLogged(log, "error: Alexa.RangeController Blind.Lift: state mapping not added: "
"it has 2 already (ALEX2ESP_MAX_STATE_MAPPINGS)");
TEST_ASSERT_FALSE(lift->isValid());
}
// One capability for every call that a setter refuses: each has to make its capability invalid
void test_capability_is_valid_until_a_setter_refuses_what_it_is_given(void)
{
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
AlexaCapability *valid = device.addCapability(AlexaInterfaces::ToggleController, "Blind.Valid");
valid->addFriendlyName("Blind", "en-US")
.addFriendlyAsset(AlexaAssets::DeviceName_Shade)
.setNonControllable(true)
.addActionMapping(ActionMapping({AlexaAction::Close}, "TurnOn"))
.addStateMapping({AlexaState::Closed}, "ON");
TEST_ASSERT_TRUE(valid->isValid());
TEST_ASSERT_FALSE(device.addCapability(AlexaInterfaces::ToggleController, "Blind.A")->addFriendlyName("", "en-US").isValid());
TEST_ASSERT_FALSE(device.addCapability(AlexaInterfaces::ToggleController, "Blind.B")->addFriendlyName("Blind", nullptr).isValid());
TEST_ASSERT_FALSE(device.addCapability(AlexaInterfaces::ToggleController, "Blind.C")->addFriendlyAsset(nullptr).isValid());
TEST_ASSERT_FALSE(device.addCapability(AlexaInterfaces::ToggleController, "Blind.D")->addActionMapping(ActionMapping({}, "TurnOn")).isValid());
TEST_ASSERT_FALSE(device.addCapability(AlexaInterfaces::ToggleController, "Blind.E")->addActionMapping(ActionMapping({AlexaAction::Open}, "")).isValid());
TEST_ASSERT_FALSE(device.addCapability(AlexaInterfaces::ToggleController, "Blind.F")->addStateMapping({}, "ON").isValid());
TEST_ASSERT_FALSE(device.addCapability(AlexaInterfaces::ToggleController, "Blind.G")
->addStateMapping({AlexaState::Open}, static_cast<const char *>(nullptr))
.isValid());
}
void test_capability_that_is_not_valid_is_left_out_of_discovery_with_an_error(void)
{
CapturedLog log;
AlexaLog::setOutput(&log);
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
device.addCapability(AlexaInterfaces::PowerController);
// The name that was refused is followed by one that is taken: the capability could be announced, as half
// of what the sketch asked for
device.addCapability(AlexaInterfaces::RangeController, "Blind.Lift")
->addFriendlyName("Lift", nullptr)
.addFriendlyAsset(AlexaAssets::Setting_Opening);
assertDiscovery(endpoint("Bedroom Blinds", "OTHER", POWER), device);
assertLogged(log, "error: ESP-01: Alexa.RangeController Blind.Lift left out of discovery: "
"a call that set it up was refused, correct what the error of that call names");
}
void test_state_mapping_takes_a_number_of_any_type(void)
{
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
AlexaCapability *lift = device.addCapability(AlexaInterfaces::RangeController, "Blind.Lift");
lift->addFriendlyAsset(AlexaAssets::Setting_Opening).addStateMapping({AlexaState::Closed}, 0).addStateMapping({AlexaState::Open}, 1, 100);
AlexaCapability *tilt = device.addCapability(AlexaInterfaces::RangeController, "Blind.Tilt");
tilt->addFriendlyAsset(AlexaAssets::Setting_Direction).addStateMapping({AlexaState::Closed}, 0.0).addStateMapping({AlexaState::Open}, 90u);
TEST_ASSERT_TRUE(lift->isValid());
TEST_ASSERT_TRUE(tilt->isValid());
assertDiscovery(
endpoint("Bedroom Blinds", "OTHER",
"{\"interface\":\"Alexa.RangeController\",\"version\":\"3\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":true,\"proactivelyReported\":false,"
"\"supported\":[{\"name\":\"rangeValue\"}]},"
"\"semantics\":{\"stateMappings\":["
"{\"@type\":\"StatesToValue\",\"states\":[\"Alexa.States.Closed\"],\"value\":0},"
"{\"@type\":\"StatesToRange\",\"states\":[\"Alexa.States.Open\"],"
"\"range\":{\"minimumValue\":1,\"maximumValue\":100}}]},"
"\"instance\":\"Blind.Lift\","
"\"capabilityResources\":{\"friendlyNames\":["
"{\"@type\":\"asset\",\"value\":{\"assetId\":\"Alexa.Setting.Opening\"}}]}},"
"{\"interface\":\"Alexa.RangeController\",\"version\":\"3\",\"type\":\"AlexaInterface\","
"\"properties\":{\"retrievable\":true,\"proactivelyReported\":false,"
"\"supported\":[{\"name\":\"rangeValue\"}]},"
"\"semantics\":{\"stateMappings\":["
"{\"@type\":\"StatesToValue\",\"states\":[\"Alexa.States.Closed\"],\"value\":0},"
"{\"@type\":\"StatesToValue\",\"states\":[\"Alexa.States.Open\"],\"value\":90}]},"
"\"instance\":\"Blind.Tilt\","
"\"capabilityResources\":{\"friendlyNames\":["
"{\"@type\":\"asset\",\"value\":{\"assetId\":\"Alexa.Setting.Direction\"}}]}}"),
device);
}
void test_states_of_a_hunch_and_of_an_announcement_are_announced(void)
{
AlexaDevice device("Washer", "root", "ESP-01");
device.addCapability(AlexaInterfaces::ToggleController, "Washer.Eco")
->addFriendlyName("Eco", "en-US")
.addStateMapping({AlexaState::EcoOn}, "ON")
.addStateMapping({AlexaState::EcoOff}, "OFF");
device.addCapability(AlexaInterfaces::ModeController, "Washer.Cycle")
->addFriendlyAsset(AlexaAssets::Setting_WashCycle)
.addStateMapping({AlexaState::Stuck, AlexaState::Done}, "Cycle.End");
device.addCapability(AlexaInterfaces::RangeController, "Washer.Detergent")
->addFriendlyName("Detergent", "en-US")
.addStateMapping({AlexaState::Empty, AlexaState::Low}, 0, 10)
.addStateMapping({AlexaState::Full}, 100);
const std::string announced = announcedBy(device);
TEST_ASSERT_NOT_NULL(strstr(announced.c_str(),
"\"stateMappings\":[{\"@type\":\"StatesToValue\",\"states\":[\"Alexa.States.EcoOn\"],\"value\":\"ON\"},"
"{\"@type\":\"StatesToValue\",\"states\":[\"Alexa.States.EcoOff\"],\"value\":\"OFF\"}]"));
TEST_ASSERT_NOT_NULL(strstr(announced.c_str(),
"\"stateMappings\":[{\"@type\":\"StatesToValue\","
"\"states\":[\"Alexa.States.Done\",\"Alexa.States.Stuck\"],\"value\":\"Cycle.End\"}]"));
TEST_ASSERT_NOT_NULL(strstr(announced.c_str(),
"\"stateMappings\":[{\"@type\":\"StatesToRange\",\"states\":[\"Alexa.States.Low\",\"Alexa.States.Empty\"],"
"\"range\":{\"minimumValue\":0,\"maximumValue\":10}},"
"{\"@type\":\"StatesToValue\",\"states\":[\"Alexa.States.Full\"],\"value\":100}]"));
}
void test_assets_and_units_have_the_ids_of_alexa(void)
{
TEST_ASSERT_EQUAL_STRING("Alexa.Setting.Opening", AlexaAssets::Setting_Opening);
TEST_ASSERT_EQUAL_STRING("Alexa.Setting.2GGuestWiFi", AlexaAssets::Setting_2GGuestWiFi);
TEST_ASSERT_EQUAL_STRING("Alexa.DeviceName.SpaceHeater", AlexaAssets::DeviceName_SpaceHeater);
TEST_ASSERT_EQUAL_STRING("Alexa.Value.QuickWash", AlexaAssets::Value_QuickWash);
TEST_ASSERT_EQUAL_STRING("Alexa.Button.EighthButton", AlexaAssets::Button_EighthButton);
TEST_ASSERT_EQUAL_STRING("Alexa.Gestures.DoubleTap", AlexaAssets::Gesture_DoubleTap);
TEST_ASSERT_EQUAL_STRING("Alexa.Shower.RainHead", AlexaAssets::Shower_RainHead);
TEST_ASSERT_EQUAL_STRING("Alexa.Actions.Vacuum", AlexaAssets::Actions_Vacuum);
TEST_ASSERT_EQUAL_STRING("Alexa.Unit.Percent", AlexaUnits::Percent);
TEST_ASSERT_EQUAL_STRING("Alexa.Unit.Temperature.Celsius", AlexaUnits::Temperature_Celsius);
TEST_ASSERT_EQUAL_STRING("Alexa.Unit.Volume.CubicMeters", AlexaUnits::Volume_CubicMeters);
}
void test_action_mapping_payload_that_is_no_object_is_left_out_with_an_error(void)
{
CapturedLog log;
AlexaLog::setOutput(&log);
AlexaDevice device("Bedroom Blinds", "root", "ESP-01");
device.addCapability(AlexaInterfaces::ToggleController, "Blind.Toggle")
->addFriendlyName("Blind", "en-US")
.addActionMapping(ActionMapping({AlexaAction::Close}, "TurnOn", "rangeValue: 0"));
const std::string announced = announcedBy(device);
TEST_ASSERT_NOT_NULL(strstr(announced.c_str(), "\"directive\":{\"name\":\"TurnOn\"}"));
assertLogged(log, "error: Alexa.ToggleController Blind.Toggle: payload of the action mapping to TurnOn left out: "
"it is not the JSON text of an object");
}
void test_actions_and_states_have_the_names_of_alexa(void)
{
TEST_ASSERT_EQUAL_STRING("Alexa.Actions.Open", alexaActionName(AlexaAction::Open));
TEST_ASSERT_EQUAL_STRING("Alexa.Actions.SetEcoOff", alexaActionName(AlexaAction::SetEcoOff));
TEST_ASSERT_EQUAL_STRING("Alexa.States.Closed", alexaStateName(AlexaState::Closed));
TEST_ASSERT_EQUAL_STRING("Alexa.States.EcoOn", alexaStateName(AlexaState::EcoOn));
TEST_ASSERT_EQUAL_STRING("Alexa.States.Stuck", alexaStateName(AlexaState::Stuck));
TEST_ASSERT_EQUAL_STRING("Alexa.Actions.Lower", AlexaActionsUtils::toString(AlexaActions::Lower).c_str());
}
int main(int, char **)
{
UNITY_BEGIN();
RUN_TEST(test_basic_light_discovery);
RUN_TEST(test_light_with_brightness_discovery);
RUN_TEST(test_light_with_color_temperature_discovery);
RUN_TEST(test_temperature_sensor_discovery);
RUN_TEST(test_blind_control_discovery);
RUN_TEST(test_rows_hold_the_namespace_version_and_properties_of_their_interface);
RUN_TEST(test_every_row_is_found_by_its_type);
RUN_TEST(test_generic_controllers_and_interfaces_without_properties_are_flagged);
RUN_TEST(test_capability_by_row_and_by_type_is_the_same_capability);
RUN_TEST(test_type_without_a_row_is_refused_with_an_error);
RUN_TEST(test_scene_is_announced_without_properties);
RUN_TEST(test_thermostat_announces_its_four_properties);
RUN_TEST(test_directive_gets_the_type_of_the_capability_it_names);
RUN_TEST(test_display_categories_have_the_name_of_their_enumerator);
RUN_TEST(test_range_controller_blind_is_announced_with_names_configuration_and_semantics);
RUN_TEST(test_mode_controller_is_announced_with_its_modes_and_text_states);
RUN_TEST(test_toggle_controller_that_only_reports_is_announced_as_non_controllable);
RUN_TEST(test_scene_that_can_be_undone_says_so_and_no_other_interface_can);
RUN_TEST(test_doorbell_is_announced_without_properties);
RUN_TEST(test_playback_and_wake_on_lan_are_announced_with_empty_properties);
RUN_TEST(test_instance_and_friendly_name_are_copied);
RUN_TEST(test_instances_of_one_interface_are_capabilities_of_their_own);
RUN_TEST(test_directive_matches_by_namespace_and_for_instanced_interfaces_by_instance);
RUN_TEST(test_instanced_row_without_an_instance_is_refused_with_an_error);
RUN_TEST(test_instance_for_an_interface_without_instances_is_refused_with_an_error);
RUN_TEST(test_capability_added_by_type_without_an_instance_is_left_out_of_discovery);
RUN_TEST(test_instanced_capability_without_a_friendly_name_is_left_out_of_discovery);
RUN_TEST(test_semantics_on_an_interface_that_takes_none_are_refused_with_an_error);
RUN_TEST(test_more_names_and_mappings_than_a_capability_holds_are_refused_with_an_error);
RUN_TEST(test_action_mapping_payload_that_is_no_object_is_left_out_with_an_error);
RUN_TEST(test_actions_and_states_have_the_names_of_alexa);
RUN_TEST(test_capability_is_valid_until_a_setter_refuses_what_it_is_given);
RUN_TEST(test_capability_that_is_not_valid_is_left_out_of_discovery_with_an_error);
RUN_TEST(test_state_mapping_takes_a_number_of_any_type);
RUN_TEST(test_states_of_a_hunch_and_of_an_announcement_are_announced);
RUN_TEST(test_assets_and_units_have_the_ids_of_alexa);
return UNITY_END();
}
Reference in a new issue View git blame Copy permalink