bool ParameterTest::exportImport()
{
static constexpr float MAGIC_FLOAT_VAL = 0.314159f;
bool ret = true;
param_t test_params[] = {p0, p1, p2, p3, p4};
// set all params to corresponding param_t value
for (auto p : test_params) {
if (param_type(p) == PARAM_TYPE_INT32) {
const int32_t set_val = p;
if (param_set_no_notification(p, &set_val) != PX4_OK) {
PX4_ERR("param_set_no_notification failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
int32_t get_val = 0;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare("value for param doesn't match default value", p, get_val);
}
if (param_type(p) == PARAM_TYPE_FLOAT) {
const float set_val = (float)p + MAGIC_FLOAT_VAL;
if (param_set_no_notification(p, &set_val) != PX4_OK) {
PX4_ERR("param_set_no_notification failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
float get_val = 0.0f;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare("value for param doesn't match default value", p, (float)p + MAGIC_FLOAT_VAL);
}
}
// save
if (param_save_default() != PX4_OK) {
PX4_ERR("param_save_default failed");
return false;
}
// zero all params and verify, but don't save
for (auto p : test_params) {
if (param_type(p) == PARAM_TYPE_INT32) {
const int32_t set_val = 0;
if (param_set_no_notification(p, &set_val) != PX4_OK) {
PX4_ERR("param_set_no_notification failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
int32_t get_val = -1;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare("value for param doesn't match default value", set_val, get_val);
}
if (param_type(p) == PARAM_TYPE_FLOAT) {
const float set_val = 0.0f;
if (param_set_no_notification(p, &set_val) != PX4_OK) {
PX4_ERR("param_set_no_notification failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
float get_val = -1.0f;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare_float("value for param doesn't match default value", set_val, get_val, 0.001f);
}
}
// load saved params
if (param_load_default() != PX4_OK) {
PX4_ERR("param_save_default failed");
ret = true;
}
// check every param
for (auto p : test_params) {
if (param_type(p) == PARAM_TYPE_INT32) {
int32_t get_val = 0.0f;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare("value for param doesn't match default value", p, get_val);
}
if (param_type(p) == PARAM_TYPE_FLOAT) {
float get_val = 0.0f;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare_float("value for param doesn't match default value", p, (float)p + MAGIC_FLOAT_VAL, 0.001f);
}
}
return ret;
}
/* Set and get the time */
static int dm_test_rtc_set_get(struct dm_test_state *dms)
{
struct rtc_time now, time, cmp;
struct udevice *dev, *emul;
long offset, old_offset, old_base_time;
ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
ut_assertok(dm_rtc_get(dev, &now));
ut_assertok(device_find_first_child(dev, &emul));
ut_assert(emul != NULL);
/* Tell the RTC to go into manual mode */
old_offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, -1);
memset(&time, '\0', sizeof(time));
time.tm_mday = 25;
time.tm_mon = 8;
time.tm_year = 2004;
time.tm_sec = 0;
time.tm_min = 18;
time.tm_hour = 18;
ut_assertok(dm_rtc_set(dev, &time));
memset(&cmp, '\0', sizeof(cmp));
ut_assertok(dm_rtc_get(dev, &cmp));
ut_assertok(cmp_times(&time, &cmp, true));
/* Increment by 1 second */
offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
sandbox_i2c_rtc_set_offset(emul, false, offset + 1);
memset(&cmp, '\0', sizeof(cmp));
ut_assertok(dm_rtc_get(dev, &cmp));
ut_asserteq(1, cmp.tm_sec);
/* Check against original offset */
sandbox_i2c_rtc_set_offset(emul, false, old_offset);
ut_assertok(dm_rtc_get(dev, &cmp));
ut_assertok(cmp_times(&now, &cmp, true));
/* Back to the original offset */
sandbox_i2c_rtc_set_offset(emul, false, 0);
memset(&cmp, '\0', sizeof(cmp));
ut_assertok(dm_rtc_get(dev, &cmp));
ut_assertok(cmp_times(&now, &cmp, true));
/* Increment the base time by 1 emul */
sandbox_i2c_rtc_get_set_base_time(emul, old_base_time + 1);
memset(&cmp, '\0', sizeof(cmp));
ut_assertok(dm_rtc_get(dev, &cmp));
if (now.tm_sec == 59) {
ut_asserteq(0, cmp.tm_sec);
} else {
ut_asserteq(now.tm_sec + 1, cmp.tm_sec);
}
old_offset = sandbox_i2c_rtc_set_offset(emul, true, 0);
return 0;
}
static int sb_check_arp_reply(struct udevice *dev, void *packet,
unsigned int len)
{
struct eth_sandbox_priv *priv = dev_get_priv(dev);
struct ethernet_hdr *eth = packet;
struct arp_hdr *arp;
/* Used by all of the ut_assert macros */
struct unit_test_state *uts = priv->priv;
if (ntohs(eth->et_protlen) != PROT_ARP)
return 0;
arp = packet + ETHER_HDR_SIZE;
if (ntohs(arp->ar_op) != ARPOP_REPLY)
return 0;
/* This test would be worthless if we are not waiting */
ut_assert(arp_is_waiting());
/* Validate response */
ut_assert(memcmp(eth->et_src, net_ethaddr, ARP_HLEN) == 0);
ut_assert(memcmp(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN) == 0);
ut_assert(eth->et_protlen == htons(PROT_ARP));
ut_assert(arp->ar_hrd == htons(ARP_ETHER));
ut_assert(arp->ar_pro == htons(PROT_IP));
ut_assert(arp->ar_hln == ARP_HLEN);
ut_assert(arp->ar_pln == ARP_PLEN);
ut_assert(memcmp(&arp->ar_sha, net_ethaddr, ARP_HLEN) == 0);
ut_assert(net_read_ip(&arp->ar_spa).s_addr == net_ip.s_addr);
ut_assert(memcmp(&arp->ar_tha, priv->fake_host_hwaddr, ARP_HLEN) == 0);
ut_assert(net_read_ip(&arp->ar_tpa).s_addr ==
string_to_ip("1.1.2.4").s_addr);
return 0;
}
bool StateMachineHelperTest::mainStateTransitionTest(void)
{
struct vehicle_status_s current_state;
main_state_t new_main_state;
// Identical states.
current_state.main_state = MAIN_STATE_MANUAL;
new_main_state = MAIN_STATE_MANUAL;
ut_assert("no transition: identical states",
TRANSITION_NOT_CHANGED == main_state_transition(¤t_state, new_main_state));
ut_assert("current state: manual", MAIN_STATE_MANUAL == current_state.main_state);
// AUTO to MANUAL.
current_state.main_state = MAIN_STATE_AUTO;
new_main_state = MAIN_STATE_MANUAL;
ut_assert("transition changed: auto to manual",
TRANSITION_CHANGED == main_state_transition(¤t_state, new_main_state));
ut_assert("new state: manual", MAIN_STATE_MANUAL == current_state.main_state);
// MANUAL to ALTCTRL.
current_state.main_state = MAIN_STATE_MANUAL;
current_state.condition_local_altitude_valid = true;
new_main_state = MAIN_STATE_ALTCTRL;
ut_assert("tranisition: manual to altctrl",
TRANSITION_CHANGED == main_state_transition(¤t_state, new_main_state));
ut_assert("new state: altctrl", MAIN_STATE_ALTCTRL == current_state.main_state);
// MANUAL to ALTCTRL, invalid local altitude.
current_state.main_state = MAIN_STATE_MANUAL;
current_state.condition_local_altitude_valid = false;
new_main_state = MAIN_STATE_ALTCTRL;
ut_assert("no transition: invalid local altitude",
TRANSITION_DENIED == main_state_transition(¤t_state, new_main_state));
ut_assert("current state: manual", MAIN_STATE_MANUAL == current_state.main_state);
// MANUAL to POSCTRL.
current_state.main_state = MAIN_STATE_MANUAL;
current_state.condition_local_position_valid = true;
new_main_state = MAIN_STATE_POSCTRL;
ut_assert("transition: manual to posctrl",
TRANSITION_CHANGED == main_state_transition(¤t_state, new_main_state));
ut_assert("current state: posctrl", MAIN_STATE_POSCTRL == current_state.main_state);
// MANUAL to POSCTRL, invalid local position.
current_state.main_state = MAIN_STATE_MANUAL;
current_state.condition_local_position_valid = false;
new_main_state = MAIN_STATE_POSCTRL;
ut_assert("no transition: invalid position",
TRANSITION_DENIED == main_state_transition(¤t_state, new_main_state));
ut_assert("current state: manual", MAIN_STATE_MANUAL == current_state.main_state);
// MANUAL to AUTO.
current_state.main_state = MAIN_STATE_MANUAL;
current_state.condition_global_position_valid = true;
new_main_state = MAIN_STATE_AUTO;
ut_assert("transition: manual to auto",
TRANSITION_CHANGED == main_state_transition(¤t_state, new_main_state));
ut_assert("current state: auto", MAIN_STATE_AUTO == current_state.main_state);
// MANUAL to AUTO, invalid global position.
current_state.main_state = MAIN_STATE_MANUAL;
current_state.condition_global_position_valid = false;
new_main_state = MAIN_STATE_AUTO;
ut_assert("no transition: invalid global position",
TRANSITION_DENIED == main_state_transition(¤t_state, new_main_state));
ut_assert("current state: manual", MAIN_STATE_MANUAL == current_state.main_state);
return true;
}
static int dm_test_main(const char *test_name)
{
struct unit_test *tests = ll_entry_start(struct unit_test, dm_test);
const int n_ents = ll_entry_count(struct unit_test, dm_test);
struct unit_test_state *uts = &global_dm_test_state;
struct unit_test *test;
int run_count;
uts->priv = &_global_priv_dm_test_state;
uts->fail_count = 0;
/*
* If we have no device tree, or it only has a root node, then these
* tests clearly aren't going to work...
*/
if (!gd->fdt_blob || fdt_next_node(gd->fdt_blob, 0, NULL) < 0) {
puts("Please run with test device tree:\n"
" ./u-boot -d arch/sandbox/dts/test.dtb\n");
ut_assert(gd->fdt_blob);
}
if (!test_name)
printf("Running %d driver model tests\n", n_ents);
run_count = 0;
#ifdef CONFIG_OF_LIVE
uts->of_root = gd->of_root;
#endif
for (test = tests; test < tests + n_ents; test++) {
const char *name = test->name;
int runs;
/* All tests have this prefix */
if (!strncmp(name, "dm_test_", 8))
name += 8;
if (test_name && strcmp(test_name, name))
continue;
/* Run with the live tree if possible */
runs = 0;
if (IS_ENABLED(CONFIG_OF_LIVE)) {
if (!(test->flags & DM_TESTF_FLAT_TREE)) {
ut_assertok(dm_do_test(uts, test, true));
runs++;
}
}
/*
* Run with the flat tree if we couldn't run it with live tree,
* or it is a core test.
*/
if (!(test->flags & DM_TESTF_LIVE_TREE) &&
(!runs || dm_test_run_on_flattree(test))) {
ut_assertok(dm_do_test(uts, test, false));
runs++;
}
run_count += runs;
}
if (test_name && !run_count)
printf("Test '%s' not found\n", test_name);
else
printf("Failures: %d\n", uts->fail_count);
gd->dm_root = NULL;
ut_assertok(dm_init(false));
dm_scan_platdata(false);
dm_scan_fdt(gd->fdt_blob, false);
return uts->fail_count ? CMD_RET_FAILURE : 0;
}
bool MavlinkFtpTest::_list_test(void)
{
MavlinkFTP::PayloadHeader payload;
mavlink_file_transfer_protocol_t ftp_msg;
MavlinkFTP::PayloadHeader *reply;
char response1[] = "Dempty_dir|Ftest_238.data\t238|Ftest_239.data\t239|Ftest_240.data\t240";
char response2[] = "Ddev|Detc|Dfs|Dobj";
struct _testCase {
const char *dir; ///< Directory to run List command on
char *response; ///< Expected response entries from List command
int response_count; ///< Number of directories that should be returned
bool success; ///< true: List command should succeed, false: List command should fail
};
struct _testCase rgTestCases[] = {
{ "/bogus", nullptr, 0, false },
{ "/etc/unit_test_data/mavlink_tests", response1, 4, true },
{ "/", response2, 4, true },
};
for (size_t i=0; i<sizeof(rgTestCases)/sizeof(rgTestCases[0]); i++) {
const struct _testCase *test = &rgTestCases[i];
payload.opcode = MavlinkFTP::kCmdListDirectory;
payload.offset = 0;
bool success = _send_receive_msg(&payload, // FTP payload header
strlen(test->dir)+1, // size in bytes of data
(uint8_t*)test->dir, // Data to start into FTP message payload
&ftp_msg, // Response from server
&reply); // Payload inside FTP message response
if (!success) {
return false;
}
if (test->success) {
ut_compare("Didn't get Ack back", reply->opcode, MavlinkFTP::kRspAck);
ut_compare("Incorrect payload size", reply->size, strlen(test->response) + 1);
// The return order of directories from the List command is not repeatable. So we can't do a direct comparison
// to a hardcoded return result string.
// Convert null terminators to seperator char so we can use strok to parse returned data
for (uint8_t j=0; j<reply->size-1; j++) {
if (reply->data[j] == 0) {
reply->data[j] = '|';
}
}
// Loop over returned directory entries trying to find then in the response list
char *dir;
int response_count = 0;
dir = strtok((char *)&reply->data[0], "|");
while (dir != nullptr) {
ut_assert("Returned directory not found in expected response", strstr(test->response, dir));
response_count++;
dir = strtok(nullptr, "|");
}
ut_compare("Incorrect number of directory entires returned", test->response_count, response_count);
} else {
ut_compare("Didn't get Nak back", reply->opcode, MavlinkFTP::kRspNak);
ut_compare("Incorrect payload size", reply->size, 2);
ut_compare("Incorrect error code", reply->data[0], MavlinkFTP::kErrFailErrno);
}
}
return true;
}
/* Test that sandbox GPIOs work correctly */
static int dm_test_gpio(struct dm_test_state *dms)
{
unsigned int offset, gpio;
struct dm_gpio_ops *ops;
struct udevice *dev;
const char *name;
int offset_count;
char buf[80];
/*
* We expect to get 3 banks. One is anonymous (just numbered) and
* comes from platdata. The other two are named a (20 gpios)
* and b (10 gpios) and come from the device tree. See
* test/dm/test.dts.
*/
ut_assertok(gpio_lookup_name("b4", &dev, &offset, &gpio));
ut_asserteq_str(dev->name, "extra-gpios");
ut_asserteq(4, offset);
ut_asserteq(CONFIG_SANDBOX_GPIO_COUNT + 20 + 4, gpio);
name = gpio_get_bank_info(dev, &offset_count);
ut_asserteq_str("b", name);
ut_asserteq(10, offset_count);
/* Get the operations for this device */
ops = gpio_get_ops(dev);
ut_assert(ops->get_state);
/* Cannot get a value until it is reserved */
ut_asserteq(-1, ops->get_value(dev, offset));
/*
* Now some tests that use the 'sandbox' back door. All GPIOs
* should default to input, include b4 that we are using here.
*/
ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
ut_asserteq_str("b4: in: 0 [ ]", buf);
/* Change it to an output */
sandbox_gpio_set_direction(dev, offset, 1);
ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
ut_asserteq_str("b4: out: 0 [ ]", buf);
sandbox_gpio_set_value(dev, offset, 1);
ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
ut_asserteq_str("b4: out: 1 [ ]", buf);
ut_assertok(ops->request(dev, offset, "testing"));
ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
ut_asserteq_str("b4: out: 1 [x] testing", buf);
/* Change the value a bit */
ut_asserteq(1, ops->get_value(dev, offset));
ut_assertok(ops->set_value(dev, offset, 0));
ut_asserteq(0, ops->get_value(dev, offset));
ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
ut_asserteq_str("b4: out: 0 [x] testing", buf);
ut_assertok(ops->set_value(dev, offset, 1));
ut_asserteq(1, ops->get_value(dev, offset));
/* Make it an input */
ut_assertok(ops->direction_input(dev, offset));
ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
ut_asserteq_str("b4: in: 1 [x] testing", buf);
sandbox_gpio_set_value(dev, offset, 0);
ut_asserteq(0, sandbox_gpio_get_value(dev, offset));
ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
ut_asserteq_str("b4: in: 0 [x] testing", buf);
ut_assertok(ops->free(dev, offset));
ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
ut_asserteq_str("b4: in: 0 [ ]", buf);
/* Check the 'a' bank also */
ut_assertok(gpio_lookup_name("a15", &dev, &offset, &gpio));
ut_asserteq_str(dev->name, "base-gpios");
ut_asserteq(15, offset);
ut_asserteq(CONFIG_SANDBOX_GPIO_COUNT + 15, gpio);
name = gpio_get_bank_info(dev, &offset_count);
ut_asserteq_str("a", name);
ut_asserteq(20, offset_count);
/* And the anonymous bank */
ut_assertok(gpio_lookup_name("14", &dev, &offset, &gpio));
ut_asserteq_str(dev->name, "gpio_sandbox");
ut_asserteq(14, offset);
ut_asserteq(14, gpio);
name = gpio_get_bank_info(dev, &offset_count);
ut_asserteq_ptr(NULL, name);
ut_asserteq(CONFIG_SANDBOX_GPIO_COUNT, offset_count);
return 0;
}
bool StateMachineHelperTest::armingStateTransitionTest(void)
{
// These are the critical values from vehicle_status_s and actuator_armed_s which must be primed
// to simulate machine state prior to testing an arming state transition. This structure is also
// use to represent the expected machine state after the transition has been requested.
typedef struct {
arming_state_t arming_state; // vehicle_status_s.arming_state
bool armed; // actuator_armed_s.armed
bool ready_to_arm; // actuator_armed_s.ready_to_arm
} ArmingTransitionVolatileState_t;
// This structure represents a test case for arming_state_transition. It contains the machine
// state prior to transtion, the requested state to transition to and finally the expected
// machine state after transition.
typedef struct {
const char* assertMsg; // Text to show when test case fails
ArmingTransitionVolatileState_t current_state; // Machine state prior to transtion
hil_state_t hil_state; // Current vehicle_status_s.hil_state
bool condition_system_sensors_initialized; // Current vehicle_status_s.condition_system_sensors_initialized
bool safety_switch_available; // Current safety_s.safety_switch_available
bool safety_off; // Current safety_s.safety_off
arming_state_t requested_state; // Requested arming state to transition to
ArmingTransitionVolatileState_t expected_state; // Expected machine state after transition
transition_result_t expected_transition_result; // Expected result from arming_state_transition
} ArmingTransitionTest_t;
// We use these defines so that our test cases are more readable
#define ATT_ARMED true
#define ATT_DISARMED false
#define ATT_READY_TO_ARM true
#define ATT_NOT_READY_TO_ARM false
#define ATT_SENSORS_INITIALIZED true
#define ATT_SENSORS_NOT_INITIALIZED false
#define ATT_SAFETY_AVAILABLE true
#define ATT_SAFETY_NOT_AVAILABLE true
#define ATT_SAFETY_OFF true
#define ATT_SAFETY_ON false
// These are test cases for arming_state_transition
static const ArmingTransitionTest_t rgArmingTransitionTests[] = {
// TRANSITION_NOT_CHANGED tests
{ "no transition: identical states",
{ vehicle_status_s::ARMING_STATE_INIT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_INIT,
{ vehicle_status_s::ARMING_STATE_INIT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_NOT_CHANGED },
// TRANSITION_CHANGED tests
// Check all basic valid transitions, these don't require special state in vehicle_status_t or safety_s
{ "transition: init to standby",
{ vehicle_status_s::ARMING_STATE_INIT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_STANDBY,
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: init to standby error",
{ vehicle_status_s::ARMING_STATE_INIT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_STANDBY_ERROR,
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: init to reboot",
{ vehicle_status_s::ARMING_STATE_INIT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_REBOOT,
{ vehicle_status_s::ARMING_STATE_REBOOT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: standby to init",
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_INIT,
{ vehicle_status_s::ARMING_STATE_INIT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: standby to standby error",
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_STANDBY_ERROR,
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: standby to reboot",
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_REBOOT,
{ vehicle_status_s::ARMING_STATE_REBOOT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: armed to standby",
{ vehicle_status_s::ARMING_STATE_ARMED, ATT_ARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_STANDBY,
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: armed to armed error",
{ vehicle_status_s::ARMING_STATE_ARMED, ATT_ARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_ARMED_ERROR,
{ vehicle_status_s::ARMING_STATE_ARMED_ERROR, ATT_ARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: armed error to standby error",
{ vehicle_status_s::ARMING_STATE_ARMED_ERROR, ATT_ARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_STANDBY_ERROR,
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: standby error to reboot",
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_REBOOT,
{ vehicle_status_s::ARMING_STATE_REBOOT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: in air restore to armed",
{ vehicle_status_s::ARMING_STATE_IN_AIR_RESTORE, ATT_DISARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_ARMED,
{ vehicle_status_s::ARMING_STATE_ARMED, ATT_ARMED, ATT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: in air restore to reboot",
{ vehicle_status_s::ARMING_STATE_IN_AIR_RESTORE, ATT_DISARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_REBOOT,
{ vehicle_status_s::ARMING_STATE_REBOOT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_CHANGED },
// hil on tests, standby error to standby not normally allowed
{ "transition: standby error to standby, hil on",
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_ON, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_STANDBY,
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, TRANSITION_CHANGED },
// Safety switch arming tests
{ "transition: standby to armed, no safety switch",
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_NOT_AVAILABLE, ATT_SAFETY_OFF,
vehicle_status_s::ARMING_STATE_ARMED,
{ vehicle_status_s::ARMING_STATE_ARMED, ATT_ARMED, ATT_READY_TO_ARM }, TRANSITION_CHANGED },
{ "transition: standby to armed, safety switch off",
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_OFF,
vehicle_status_s::ARMING_STATE_ARMED,
{ vehicle_status_s::ARMING_STATE_ARMED, ATT_ARMED, ATT_READY_TO_ARM }, TRANSITION_CHANGED },
// standby error
{ "transition: armed error to standby error requested standby",
{ vehicle_status_s::ARMING_STATE_ARMED_ERROR, ATT_ARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_STANDBY,
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_CHANGED },
// TRANSITION_DENIED tests
// Check some important basic invalid transitions, these don't require special state in vehicle_status_t or safety_s
{ "no transition: init to armed",
{ vehicle_status_s::ARMING_STATE_INIT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_ARMED,
{ vehicle_status_s::ARMING_STATE_INIT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_DENIED },
{ "no transition: standby to armed error",
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_ARMED_ERROR,
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, TRANSITION_DENIED },
{ "no transition: armed to init",
{ vehicle_status_s::ARMING_STATE_ARMED, ATT_ARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_INIT,
{ vehicle_status_s::ARMING_STATE_ARMED, ATT_ARMED, ATT_READY_TO_ARM }, TRANSITION_DENIED },
{ "no transition: armed to reboot",
{ vehicle_status_s::ARMING_STATE_ARMED, ATT_ARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_REBOOT,
{ vehicle_status_s::ARMING_STATE_ARMED, ATT_ARMED, ATT_READY_TO_ARM }, TRANSITION_DENIED },
{ "no transition: armed error to armed",
{ vehicle_status_s::ARMING_STATE_ARMED_ERROR, ATT_ARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_ARMED,
{ vehicle_status_s::ARMING_STATE_ARMED_ERROR, ATT_ARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_DENIED },
{ "no transition: armed error to reboot",
{ vehicle_status_s::ARMING_STATE_ARMED_ERROR, ATT_ARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_REBOOT,
{ vehicle_status_s::ARMING_STATE_ARMED_ERROR, ATT_ARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_DENIED },
{ "no transition: standby error to armed",
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_ARMED,
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_DENIED },
{ "no transition: standby error to standby",
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_STANDBY,
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_DENIED },
{ "no transition: reboot to armed",
{ vehicle_status_s::ARMING_STATE_REBOOT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_ARMED,
{ vehicle_status_s::ARMING_STATE_REBOOT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_DENIED },
{ "no transition: in air restore to standby",
{ vehicle_status_s::ARMING_STATE_IN_AIR_RESTORE, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_STANDBY,
{ vehicle_status_s::ARMING_STATE_IN_AIR_RESTORE, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_DENIED },
// Sensor tests
{ "transition to standby error: init to standby - sensors not initialized",
{ vehicle_status_s::ARMING_STATE_INIT, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_NOT_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_STANDBY,
{ vehicle_status_s::ARMING_STATE_STANDBY_ERROR, ATT_DISARMED, ATT_NOT_READY_TO_ARM }, TRANSITION_DENIED },
// Safety switch arming tests
{ "no transition: init to standby, safety switch on",
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, vehicle_status_s::HIL_STATE_OFF, ATT_SENSORS_INITIALIZED, ATT_SAFETY_AVAILABLE, ATT_SAFETY_ON,
vehicle_status_s::ARMING_STATE_ARMED,
{ vehicle_status_s::ARMING_STATE_STANDBY, ATT_DISARMED, ATT_READY_TO_ARM }, TRANSITION_DENIED },
};
struct vehicle_status_s status;
struct safety_s safety;
struct actuator_armed_s armed;
size_t cArmingTransitionTests = sizeof(rgArmingTransitionTests) / sizeof(rgArmingTransitionTests[0]);
for (size_t i=0; i<cArmingTransitionTests; i++) {
const ArmingTransitionTest_t* test = &rgArmingTransitionTests[i];
// Setup initial machine state
status.arming_state = test->current_state.arming_state;
status.condition_system_sensors_initialized = test->condition_system_sensors_initialized;
status.hil_state = test->hil_state;
// The power status of the test unit is not relevant for the unit test
status.circuit_breaker_engaged_power_check = true;
safety.safety_switch_available = test->safety_switch_available;
safety.safety_off = test->safety_off;
armed.armed = test->current_state.armed;
armed.ready_to_arm = test->current_state.ready_to_arm;
// Attempt transition
transition_result_t result = arming_state_transition(&status, &safety, test->requested_state, &armed, false /* no pre-arm checks */, 0 /* no mavlink_fd */);
// Validate result of transition
ut_assert(test->assertMsg, test->expected_transition_result == result);
ut_assert(test->assertMsg, status.arming_state == test->expected_state.arming_state);
ut_assert(test->assertMsg, armed.armed == test->expected_state.armed);
ut_assert(test->assertMsg, armed.ready_to_arm == test->expected_state.ready_to_arm);
}
return true;
}
static int
Test_verifierParseBlock(void)
{
enum { file_size = 4 };
const char* file[file_size] = {
/* file 0 */
"$c |- wff S 0 $. "
"${ "
"$v x y z w $. "
"${ "
"$v a b c $. "
"$} "
"$v a b c $. "
"$} "
"$v x $. \n",
/* file 1 - parse two proofs */
"$c |- num 0 S $. "
"$v x $. "
"a.num.0 $a num 0 $. "
"num.x $f num x $. "
"a.num.succ $a num S x $. "
"thm.one $p num S 0 $= a.num.0 a.num.succ $. "
"thm.succ2 $p num S S x $= num.x a.num.succ a.num.succ $.\n",
/* file 2 - test compressed proof */
"$c |- num S 0 $. $v x y $. "
"numt.0 $a num 0 $. "
"num.0 $a |- num 0 $. "
"num.x $f num x $. "
"num.succ $a |- num S x $. "
"thm $p |- num S 0 $= ( numt.0 num.succ ) "
"AB $. \n",
/* file 3 - test disjoint variable restriction */
"$c | $. \n"
"$v x y B R $. \n"
"tx $f | x $. ty $f | y $. tB $f | B $. tR $f | R $. \n"
"${ $d x y $. $d y B $. $d y R $. $} \n",
/* to do: write test for compressed proof with Z tag */
};
const enum error errs[file_size] = {
error_none,
error_none,
error_none,
error_none,
};
const size_t errc[file_size] = {
0,
0,
0,
0,
};
const size_t dsymnum[file_size] = {
0,
0,
0,
3
};
size_t i;
for (i = 0; i < file_size; i++) {
LOG_DEBUG("testing file %lu", i);
struct verifier vrf;
verifierInit(&vrf);
verifierSetVerbosity(&vrf, 5);
struct reader r;
readerInitString(&r, file[i]);
verifierBeginReadingFile(&vrf, &r);
// verifierSetVerbosity(&vrf, 5);
verifierParseBlock(&vrf);
check_err(vrf.err, errs[i]);
ut_assert(vrf.symCount[symType_disjoint] == dsymnum[i],
"found %lu disjoint pairs, expected %lu", vrf.symCount[symType_disjoint],
dsymnum[i]);
ut_assert(vrf.errc == errc[i], "found %lu errors, expected %lu",
vrf.errc, errc[i]);
readerClean(&r);
verifierClean(&vrf);
}
return 0;
}
static int dm_test_children(struct dm_test_state *dms)
{
struct udevice *top[NODE_COUNT];
struct udevice *child[NODE_COUNT];
struct udevice *grandchild[NODE_COUNT];
struct udevice *dev;
int total;
int ret;
int i;
/* We don't care about the numbering for this test */
dms->skip_post_probe = 1;
ut_assert(NODE_COUNT > 5);
/* First create 10 top-level children */
ut_assertok(create_children(dms, dms->root, NODE_COUNT, 0, top));
/* Now a few have their own children */
ut_assertok(create_children(dms, top[2], NODE_COUNT, 2, NULL));
ut_assertok(create_children(dms, top[5], NODE_COUNT, 5, child));
/* And grandchildren */
for (i = 0; i < NODE_COUNT; i++)
ut_assertok(create_children(dms, child[i], NODE_COUNT, 50 * i,
i == 2 ? grandchild : NULL));
/* Check total number of devices */
total = NODE_COUNT * (3 + NODE_COUNT);
ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_BIND]);
/* Try probing one of the grandchildren */
ut_assertok(uclass_get_device(UCLASS_TEST,
NODE_COUNT * 3 + 2 * NODE_COUNT, &dev));
ut_asserteq_ptr(grandchild[0], dev);
/*
* This should have probed the child and top node also, for a total
* of 3 nodes.
*/
ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
/* Probe the other grandchildren */
for (i = 1; i < NODE_COUNT; i++)
ut_assertok(device_probe(grandchild[i]));
ut_asserteq(2 + NODE_COUNT, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
/* Probe everything */
for (ret = uclass_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_next_device(&dev))
;
ut_assertok(ret);
ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
/* Remove a top-level child and check that the children are removed */
ut_assertok(device_remove(top[2]));
ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
dm_testdrv_op_count[DM_TEST_OP_REMOVE] = 0;
/* Try one with grandchildren */
ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
ut_asserteq_ptr(dev, top[5]);
ut_assertok(device_remove(dev));
ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
/* Try the same with unbind */
ut_assertok(device_unbind(top[2]));
ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
dm_testdrv_op_count[DM_TEST_OP_UNBIND] = 0;
/* Try one with grandchildren */
ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
ut_asserteq_ptr(dev, top[6]);
ut_assertok(device_unbind(top[5]));
ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
return 0;
}
bool StateMachineHelperTest::mainStateTransitionTest(void)
{
// This structure represent a single test case for testing Main State transitions.
typedef struct {
const char* assertMsg; // Text to show when test case fails
uint8_t condition_bits; // Bits for various condition_* values
main_state_t from_state; // State prior to transition request
main_state_t to_state; // State to transition to
transition_result_t expected_transition_result; // Expected result from main_state_transition call
} MainTransitionTest_t;
// Bits for condition_bits
#define MTT_ALL_NOT_VALID 0
#define MTT_ROTARY_WING 1 << 0
#define MTT_LOC_ALT_VALID 1 << 1
#define MTT_LOC_POS_VALID 1 << 2
#define MTT_HOME_POS_VALID 1 << 3
#define MTT_GLOBAL_POS_VALID 1 << 4
static const MainTransitionTest_t rgMainTransitionTests[] = {
// TRANSITION_NOT_CHANGED tests
{ "no transition: identical states",
MTT_ALL_NOT_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_MANUAL, TRANSITION_NOT_CHANGED },
// TRANSITION_CHANGED tests
{ "transition: MANUAL to ACRO",
MTT_ALL_NOT_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_ACRO, TRANSITION_CHANGED },
{ "transition: ACRO to MANUAL",
MTT_ALL_NOT_VALID,
vehicle_status_s::MAIN_STATE_ACRO, vehicle_status_s::MAIN_STATE_MANUAL, TRANSITION_CHANGED },
{ "transition: MANUAL to AUTO_MISSION - global position valid, home position valid",
MTT_GLOBAL_POS_VALID | MTT_HOME_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_AUTO_MISSION, TRANSITION_CHANGED },
{ "transition: AUTO_MISSION to MANUAL - global position valid, home position valid",
MTT_GLOBAL_POS_VALID | MTT_HOME_POS_VALID,
vehicle_status_s::MAIN_STATE_AUTO_MISSION, vehicle_status_s::MAIN_STATE_MANUAL, TRANSITION_CHANGED },
{ "transition: MANUAL to AUTO_LOITER - global position valid",
MTT_GLOBAL_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_AUTO_LOITER, TRANSITION_CHANGED },
{ "transition: AUTO_LOITER to MANUAL - global position valid",
MTT_GLOBAL_POS_VALID,
vehicle_status_s::MAIN_STATE_AUTO_LOITER, vehicle_status_s::MAIN_STATE_MANUAL, TRANSITION_CHANGED },
{ "transition: MANUAL to AUTO_RTL - global position valid, home position valid",
MTT_GLOBAL_POS_VALID | MTT_HOME_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_AUTO_RTL, TRANSITION_CHANGED },
{ "transition: AUTO_RTL to MANUAL - global position valid, home position valid",
MTT_GLOBAL_POS_VALID | MTT_HOME_POS_VALID,
vehicle_status_s::MAIN_STATE_AUTO_RTL, vehicle_status_s::MAIN_STATE_MANUAL, TRANSITION_CHANGED },
{ "transition: MANUAL to DELIVERY - global position valid, home position valid",
MTT_GLOBAL_POS_VALID | MTT_HOME_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_DELIVERY, TRANSITION_CHANGED },
{ "transition: DELIVERY to MANUAL - global position valid, home position valid",
MTT_GLOBAL_POS_VALID | MTT_HOME_POS_VALID,
vehicle_status_s::MAIN_STATE_DELIVERY, vehicle_status_s::MAIN_STATE_MANUAL, TRANSITION_CHANGED },
{ "transition: MANUAL to ALTCTL - not rotary",
MTT_ALL_NOT_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_ALTCTL, TRANSITION_CHANGED },
{ "transition: MANUAL to ALTCTL - rotary, global position not valid, local altitude valid",
MTT_ROTARY_WING | MTT_LOC_ALT_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_ALTCTL, TRANSITION_CHANGED },
{ "transition: MANUAL to ALTCTL - rotary, global position valid, local altitude not valid",
MTT_ROTARY_WING | MTT_GLOBAL_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_ALTCTL, TRANSITION_CHANGED },
{ "transition: ALTCTL to MANUAL - local altitude valid",
MTT_LOC_ALT_VALID,
vehicle_status_s::MAIN_STATE_ALTCTL, vehicle_status_s::MAIN_STATE_MANUAL, TRANSITION_CHANGED },
{ "transition: MANUAL to POSCTL - local position not valid, global position valid",
MTT_GLOBAL_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_POSCTL, TRANSITION_CHANGED },
{ "transition: MANUAL to POSCTL - local position valid, global position not valid",
MTT_LOC_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_POSCTL, TRANSITION_CHANGED },
{ "transition: POSCTL to MANUAL - local position valid, global position valid",
MTT_LOC_POS_VALID,
vehicle_status_s::MAIN_STATE_POSCTL, vehicle_status_s::MAIN_STATE_MANUAL, TRANSITION_CHANGED },
// TRANSITION_DENIED tests
{ "no transition: MANUAL to AUTO_MISSION - global position not valid",
MTT_ALL_NOT_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_AUTO_MISSION, TRANSITION_DENIED },
{ "no transition: MANUAL to AUTO_LOITER - global position not valid",
MTT_ALL_NOT_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_AUTO_LOITER, TRANSITION_DENIED },
{ "no transition: MANUAL to AUTO_RTL - global position not valid, home position not valid",
MTT_ALL_NOT_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_AUTO_RTL, TRANSITION_DENIED },
{ "no transition: MANUAL to AUTO_RTL - global position not valid, home position valid",
MTT_HOME_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_AUTO_RTL, TRANSITION_DENIED },
{ "no transition: MANUAL to AUTO_RTL - global position valid, home position not valid",
MTT_GLOBAL_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_AUTO_RTL, TRANSITION_DENIED },
{ "no transition: MANUAL to DELIVERY - global position not valid, home position valid",
MTT_HOME_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_DELIVERY, TRANSITION_DENIED },
{ "no transition: MANUAL to DELIVERY - global position valid, home position not valid",
MTT_GLOBAL_POS_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_DELIVERY, TRANSITION_DENIED },
{ "no transition: MANUAL to ALTCTL - rotary, global position not valid, local altitude not valid",
MTT_ROTARY_WING,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_ALTCTL, TRANSITION_DENIED },
{ "no transition: MANUAL to POSCTL - local position not valid, global position not valid",
MTT_ALL_NOT_VALID,
vehicle_status_s::MAIN_STATE_MANUAL, vehicle_status_s::MAIN_STATE_POSCTL, TRANSITION_DENIED },
};
size_t cMainTransitionTests = sizeof(rgMainTransitionTests) / sizeof(rgMainTransitionTests[0]);
for (size_t i=0; i<cMainTransitionTests; i++) {
const MainTransitionTest_t* test = &rgMainTransitionTests[i];
// Setup initial machine state
struct vehicle_status_s current_state;
current_state.main_state = test->from_state;
current_state.is_rotary_wing = test->condition_bits & MTT_ROTARY_WING;
current_state.condition_local_altitude_valid = test->condition_bits & MTT_LOC_ALT_VALID;
current_state.condition_local_position_valid = test->condition_bits & MTT_LOC_POS_VALID;
current_state.condition_home_position_valid = test->condition_bits & MTT_HOME_POS_VALID;
current_state.condition_global_position_valid = test->condition_bits & MTT_GLOBAL_POS_VALID;
// Attempt transition
transition_result_t result = main_state_transition(¤t_state, test->to_state);
// Validate result of transition
ut_assert(test->assertMsg, test->expected_transition_result == result);
if (test->expected_transition_result == result) {
if (test->expected_transition_result == TRANSITION_CHANGED) {
ut_assert(test->assertMsg, test->to_state == current_state.main_state);
} else {
ut_assert(test->assertMsg, test->from_state == current_state.main_state);
}
}
}
return true;
}
/* Test that autoprobe finds all the expected devices */
static int dm_test_autoprobe(struct dm_test_state *dms)
{
int expected_base_add;
struct udevice *dev;
struct uclass *uc;
int i;
ut_assertok(uclass_get(UCLASS_TEST, &uc));
ut_assert(uc);
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]);
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
/* The root device should not be activated until needed */
ut_assert(dms->root->flags & DM_FLAG_ACTIVATED);
/*
* We should be able to find the three test devices, and they should
* all be activated as they are used (lazy activation, required by
* U-Boot)
*/
for (i = 0; i < 3; i++) {
ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
ut_assert(dev);
ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED),
"Driver %d/%s already activated", i, dev->name);
/* This should activate it */
ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));
ut_assert(dev);
ut_assert(dev->flags & DM_FLAG_ACTIVATED);
/* Activating a device should activate the root device */
if (!i)
ut_assert(dms->root->flags & DM_FLAG_ACTIVATED);
}
/*
* Our 3 dm_test_info children should be passed to pre_probe and
* post_probe
*/
ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]);
/* Also we can check the per-device data */
expected_base_add = 0;
for (i = 0; i < 3; i++) {
struct dm_test_uclass_perdev_priv *priv;
struct dm_test_pdata *pdata;
ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
ut_assert(dev);
priv = dev_get_uclass_priv(dev);
ut_assert(priv);
ut_asserteq(expected_base_add, priv->base_add);
pdata = dev->platdata;
expected_base_add += pdata->ping_add;
}
return 0;
}
static int dm_test_clk(struct unit_test_state *uts)
{
struct udevice *dev_fixed, *dev_clk, *dev_test;
ulong rate;
ut_assertok(uclass_get_device_by_name(UCLASS_CLK, "clk-fixed",
&dev_fixed));
ut_assertok(uclass_get_device_by_name(UCLASS_CLK, "clk-sbox",
&dev_clk));
ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
ut_asserteq(0, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_SPI));
ut_asserteq(0, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_I2C));
ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "clk-test",
&dev_test));
ut_assertok(sandbox_clk_test_get(dev_test));
ut_assertok(sandbox_clk_test_valid(dev_test));
ut_asserteq(1234,
sandbox_clk_test_get_rate(dev_test,
SANDBOX_CLK_TEST_ID_FIXED));
ut_asserteq(0, sandbox_clk_test_get_rate(dev_test,
SANDBOX_CLK_TEST_ID_SPI));
ut_asserteq(0, sandbox_clk_test_get_rate(dev_test,
SANDBOX_CLK_TEST_ID_I2C));
rate = sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_FIXED,
12345);
ut_assert(IS_ERR_VALUE(rate));
rate = sandbox_clk_test_get_rate(dev_test, SANDBOX_CLK_TEST_ID_FIXED);
ut_asserteq(1234, rate);
ut_asserteq(0, sandbox_clk_test_set_rate(dev_test,
SANDBOX_CLK_TEST_ID_SPI,
1000));
ut_asserteq(0, sandbox_clk_test_set_rate(dev_test,
SANDBOX_CLK_TEST_ID_I2C,
2000));
ut_asserteq(1000, sandbox_clk_test_get_rate(dev_test,
SANDBOX_CLK_TEST_ID_SPI));
ut_asserteq(2000, sandbox_clk_test_get_rate(dev_test,
SANDBOX_CLK_TEST_ID_I2C));
ut_asserteq(1000, sandbox_clk_test_set_rate(dev_test,
SANDBOX_CLK_TEST_ID_SPI,
10000));
ut_asserteq(2000, sandbox_clk_test_set_rate(dev_test,
SANDBOX_CLK_TEST_ID_I2C,
20000));
rate = sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_SPI, 0);
ut_assert(IS_ERR_VALUE(rate));
rate = sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_I2C, 0);
ut_assert(IS_ERR_VALUE(rate));
ut_asserteq(10000, sandbox_clk_test_get_rate(dev_test,
SANDBOX_CLK_TEST_ID_SPI));
ut_asserteq(20000, sandbox_clk_test_get_rate(dev_test,
SANDBOX_CLK_TEST_ID_I2C));
ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
ut_asserteq(10000, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_SPI));
ut_asserteq(20000, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_I2C));
ut_assertok(sandbox_clk_test_enable(dev_test, SANDBOX_CLK_TEST_ID_SPI));
ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
ut_assertok(sandbox_clk_test_enable(dev_test, SANDBOX_CLK_TEST_ID_I2C));
ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
ut_assertok(sandbox_clk_test_disable(dev_test,
SANDBOX_CLK_TEST_ID_SPI));
ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
ut_assertok(sandbox_clk_test_disable(dev_test,
SANDBOX_CLK_TEST_ID_I2C));
ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
ut_assertok(sandbox_clk_test_free(dev_test));
return 0;
}
static void
pve_is_invariant_satisfied_t (ut_test_t *const t)
{
PVEnv *pve;
pve_error_code_t error_code;
PVCell ***lines_segments_tmp;
PVCell ***lines_segments_head_tmp;
size_t lines_size_tmp;
PVCell **lines_segment_tmp;
ptrdiff_t active_lines_segments_count;
bool is_consistent = false;
switches_t check_mask = 0xFFFFFFFF;
GamePositionX *dummy_gpx = game_position_x_new(empty_square_set,
empty_square_set,
BLACK_PLAYER);
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
pve->lines_segments_size = 0; // 0 is a wrong value.
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == PVE_ERROR_CODE_LINES_SEGMENTS_SIZE_IS_INCORRECT));
pve_free(pve);
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
pve->lines_first_size = 0; // 0 is a wrong value.
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == PVE_ERROR_CODE_LINES_FIRST_SIZE_IS_INCORRECT));
pve_free(pve);
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
lines_segments_head_tmp = pve->lines_segments_head;
pve->lines_segments_head = NULL; // NULL is a wrong value.
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == PVE_ERROR_CODE_LINES_SEGMENTS_HEAD_IS_NULL));
pve->lines_segments_head = lines_segments_head_tmp;
pve_free(pve);
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
lines_segments_tmp = pve->lines_segments;
pve->lines_segments = NULL; // NULL is a wrong value.
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == PVE_ERROR_CODE_LINES_SEGMENTS_IS_NULL));
pve->lines_segments = lines_segments_tmp;
pve_free(pve);
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
lines_segments_tmp = pve->lines_segments;
lines_segments_head_tmp = pve->lines_segments_head;
pve->lines_segments = lines_segments_head_tmp;
pve->lines_segments_head = lines_segments_tmp;
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == PVE_ERROR_CODE_LINES_SEGMENTS_HEADS_PRECEDES_ARRAY_INDEX_0));
pve->lines_segments = lines_segments_tmp;
pve->lines_segments_head = lines_segments_head_tmp;
pve_free(pve);
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
lines_segments_head_tmp = pve->lines_segments_head;
pve->lines_segments_head = pve->lines_segments + pve->lines_segments_size + 1;
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == PVE_ERROR_CODE_ACTIVE_LINES_SEGMENTS_COUNT_EXCEEDS_BOUND));
pve->lines_segments_head = lines_segments_head_tmp;
pve_free(pve);
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
lines_size_tmp = pve->lines_size;
pve->lines_size++;
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == PVE_ERROR_CODE_LINES_SIZE_MISMATCH));
pve->lines_size = lines_size_tmp;
pve_free(pve);
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
lines_segment_tmp = *pve->lines_segments;
*pve->lines_segments = NULL;
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == PVE_ERROR_CODE_LINES_SEGMENTS_HAS_AN_INVALID_NULL_VALUE));
*pve->lines_segments = lines_segment_tmp;
pve_free(pve);
error_code = PVE_ERROR_CODE_OK;
PVCell *line_fake_value;
pve = pve_new(dummy_gpx);
active_lines_segments_count = pve->lines_segments_head - pve->lines_segments;
lines_segment_tmp = *(pve->lines_segments + active_lines_segments_count); // The first unused lines segment is saved, and then corrupted.
*(pve->lines_segments + active_lines_segments_count) = &line_fake_value;
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == PVE_ERROR_CODE_LINES_SEGMENTS_HAS_AN_INVALID_NOT_NULL_VALUE));
*(pve->lines_segments + active_lines_segments_count) = lines_segment_tmp;
pve_free(pve);
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
size_t size_tmp = *pve->lines_segments_sorted_sizes;
*pve->lines_segments_sorted_sizes = PVE_LINES_FIRST_SIZE * 4;
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == PVE_ERROR_CODE_LINES_SEGMENT_COMPUTED_INDEX_OUT_OF_RANGE));
*pve->lines_segments_sorted_sizes = size_tmp;
pve_free(pve);
/*
* These seven error codes are not tested. They require more than one active segment,
* and the api to increase the lines segments are not exported.
*
* PVE_ERROR_CODE_LINES_SEGMENTS_POS_0_AND_1_ANOMALY
* PVE_ERROR_CODE_LINES_SEGMENTS_SORTED_AND_UNSORTED_DO_NOT_MATCH
* PVE_ERROR_CODE_LINES_SEGMENTS_ARE_NOT_PROPERLY_SORTED
* PVE_ERROR_CODE_LINES_SIZE_DOESNT_MATCH_WITH_CUMULATED
* PVE_ERROR_CODE_LINES_SEGMENT_POSITION_0_NOT_FOUND
* PVE_ERROR_CODE_LINES_SEGMENT_POSITION_0_OR_1_NOT_FOUND
* PVE_ERROR_CODE_LINES_SEGMENTS_UNUSED_SEGMENT_HAS_SIZE
*/
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
pve->lines_stack_head = pve->lines_stack - 1;
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == 1004));
pve_free(pve);
error_code = PVE_ERROR_CODE_OK;
pve = pve_new(dummy_gpx);
pve->lines_stack_head = pve->lines_stack + pve->lines_size;
is_consistent = pve_is_invariant_satisfied(pve, &error_code, check_mask);
ut_assert(t, !is_consistent && (error_code == 1009));
pve_free(pve);
game_position_x_free(dummy_gpx);
}
bool ParameterTest::exportImportAll()
{
static constexpr float MAGIC_FLOAT_VAL = 0.217828f;
// backup current parameters
const char *param_file_name = PX4_STORAGEDIR "/param_backup";
int fd = open(param_file_name, O_WRONLY | O_CREAT, PX4_O_MODE_666);
if (fd < 0) {
PX4_ERR("open '%s' failed (%i)", param_file_name, errno);
return false;
}
int result = param_export(fd, false);
if (result != PX4_OK) {
PX4_ERR("param_export failed");
close(fd);
return false;
}
close(fd);
bool ret = true;
int N = param_count();
// set all params to corresponding param_t value
for (unsigned i = 0; i < N; i++) {
param_t p = param_for_index(i);
if (p == PARAM_INVALID) {
PX4_ERR("param invalid: %d(%d)", p, i);
break;
}
if (param_type(p) == PARAM_TYPE_INT32) {
const int32_t set_val = p;
if (param_set_no_notification(p, &set_val) != PX4_OK) {
PX4_ERR("param_set_no_notification failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
int32_t get_val = 0;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare("value for param doesn't match default value", p, get_val);
}
if (param_type(p) == PARAM_TYPE_FLOAT) {
const float set_val = (float)p + MAGIC_FLOAT_VAL;
if (param_set_no_notification(p, &set_val) != PX4_OK) {
PX4_ERR("param_set_no_notification failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
float get_val = 0.0f;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare("value for param doesn't match default value", p, (float)p + MAGIC_FLOAT_VAL);
}
}
// save
if (param_save_default() != PX4_OK) {
PX4_ERR("param_save_default failed");
return false;
}
// zero all params and verify, but don't save
for (unsigned i = 0; i < N; i++) {
param_t p = param_for_index(i);
if (param_type(p) == PARAM_TYPE_INT32) {
const int32_t set_val = 0;
if (param_set_no_notification(p, &set_val) != PX4_OK) {
PX4_ERR("param set failed: %d", p);
ut_assert("param_set_no_notification failed", false);
}
int32_t get_val = -1;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare("value for param doesn't match default value", set_val, get_val);
}
if (param_type(p) == PARAM_TYPE_FLOAT) {
float set_val = 0.0f;
if (param_set_no_notification(p, &set_val) != PX4_OK) {
PX4_ERR("param set failed: %d", p);
ut_assert("param_set_no_notification failed", false);
}
float get_val = -1.0f;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare("value for param doesn't match default value", set_val, get_val);
}
}
// load saved params
if (param_load_default() != PX4_OK) {
PX4_ERR("param_save_default failed");
ret = true;
}
// check every param
for (unsigned i = 0; i < N; i++) {
param_t p = param_for_index(i);
if (param_type(p) == PARAM_TYPE_INT32) {
int32_t get_val = 0;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare("value for param doesn't match default value", p, get_val);
}
if (param_type(p) == PARAM_TYPE_FLOAT) {
float get_val = 0.0f;
if (param_get(p, &get_val) != PX4_OK) {
PX4_ERR("param_get failed for: %d", p);
ut_assert("param_set_no_notification failed", false);
}
ut_compare("value for param doesn't match default value", p, (float)p + MAGIC_FLOAT_VAL);
}
}
param_reset_all();
// restore original params
fd = open(param_file_name, O_RDONLY);
if (fd < 0) {
PX4_ERR("open '%s' failed (%i)", param_file_name, errno);
return false;
}
result = param_import(fd);
close(fd);
if (result < 0) {
PX4_ERR("importing from '%s' failed (%i)", param_file_name, result);
return false;
}
// save
if (param_save_default() != PX4_OK) {
PX4_ERR("param_save_default failed");
return false;
}
return ret;
}
static int
Test_verifierMakeFrame(void)
{
size_t i;
enum {
cst_size = 5,
var_size = 4,
flt_size = 4,
ess_size = 1
};
const char* cstSyms[cst_size] = {"|-", "wff", "0", "1", "+"};
size_t cstIds[cst_size];
const char* varSyms[var_size] = {"x", "y", "z", "w"};
size_t varIds[var_size];
const char* fltSyms[flt_size] = {"wff_x", "wff_y", "wff_z", "wff_w"};
size_t fltIds[flt_size];
size_t fltSS[flt_size][2];
const char* essSyms[ess_size] = {"plus"};
// size_t essIds[ess_size];
struct verifier vrf;
verifierInit(&vrf);
/* make a mock file because verifierAdd... requires vrf->rId to be valid */
LOG_DEBUG("making mock file because verifierAdd...() requires valid "
"vrf->rId");
struct reader file;
readerInitString(&file, "");
verifierBeginReadingFile(&vrf, &file);
size_tArrayAdd(&vrf.disjointScope, 0);
LOG_DEBUG("adding constants");
for (i = 0; i < cst_size; i++) {
cstIds[i] = verifierAddConstant(&vrf, cstSyms[i]);
}
LOG_DEBUG("adding variables");
for (i = 0; i < var_size; i++) {
varIds[i] = verifierAddVariable(&vrf, varSyms[i]);
}
ut_assert(vrf.symCount[symType_variable] == var_size,
"added %lu variables, expected %d", vrf.symCount[symType_variable],
var_size);
LOG_DEBUG("preparing floats");
struct symstring wff[flt_size];
for (i = 0; i < flt_size; i++) {
fltSS[i][0] = cstIds[1];
fltSS[i][1] = varIds[i];
symstringInit(&wff[i]);
size_tArrayAppend(&wff[i], fltSS[i], 2);
}
LOG_DEBUG("preparing essentials");
struct symstring plus;
size_t ssplus[4] = {cstIds[0], varIds[0], cstIds[4], varIds[1]};
symstringInit(&plus);
size_tArrayAppend(&plus, ssplus, 4);
LOG_DEBUG("adding floats and essentials");
fltIds[0] = verifierAddFloating(&vrf, fltSyms[0], &wff[0]);
check_err(vrf.err, error_none);
fltIds[1] = verifierAddFloating(&vrf, fltSyms[1], &wff[1]);
check_err(vrf.err, error_none);
verifierAddEssential(&vrf, essSyms[0], &plus);
check_err(vrf.err, error_none);
fltIds[2] = verifierAddFloating(&vrf, fltSyms[2], &wff[2]);
check_err(vrf.err, error_none);
fltIds[3] = verifierAddFloating(&vrf, fltSyms[3], &wff[3]);
check_err(vrf.err, error_none);
ut_assert(vrf.symCount[symType_floating] == 4, "added %lu floating, "
"expected 4", vrf.symCount[symType_floating]);
ut_assert(vrf.symCount[symType_essential] == 1, "added %lu essential, "
"expected 1", vrf.symCount[symType_essential]);
ut_assert(vrf.hypotheses.size == 5, "added %lu "
"hypotheses, expected 5", vrf.hypotheses.size);
LOG_DEBUG("preparing disjoint");
struct symstring disjoint;
symstringInit(&disjoint);
symstringAdd(&disjoint, varIds[0]);
symstringAdd(&disjoint, varIds[1]);
LOG_DEBUG("adding disjoint");
verifierAddDisjoint(&vrf, &disjoint);
ut_assert(vrf.disjoint1.size == 1, "added %lu disjoints, "
"expected 1", vrf.disjoint1.size);
LOG_DEBUG("preparing assertion");
struct symstring asr;
symstringInit(&asr);
size_t ssasr[6] =
{cstIds[0], varIds[0], cstIds[4], varIds[1], cstIds[4], varIds[2]};
size_tArrayAppend(&asr, ssasr, 6);
LOG_DEBUG("making the frame");
struct frame frm;
frameInit(&frm);
LOG_DEBUG("calling verifierMakeFrame()");
verifierMakeFrame(&vrf, &frm, &asr);
check_err(vrf.err, error_none);
ut_assert(frm.disjoint1.size == 1, "%lu disjoints in frame, expected 1",
frm.disjoint1.size);
LOG_DEBUG("make sure frame is the right size");
ut_assert(frm.stmts.size == 4, "frame has size %lu, expected 4",
frm.stmts.size);
LOG_DEBUG("make sure wff_w has not been added to the frame");
for (i = 0; i < frm.stmts.size; i++) {
ut_assert(frm.stmts.vals[i] != fltIds[3],
"wff_w should not be in the frame");
}
LOG_DEBUG("cleaning up");
frameClean(&frm);
symstringClean(&asr);
readerClean(&file);
verifierClean(&vrf);
return 0;
}
/// @brief Tests for correct reponse to a Read command on an open session.
bool MavlinkFtpTest::_burst_test()
{
MavlinkFTP::PayloadHeader payload;
const MavlinkFTP::PayloadHeader *reply;
BurstInfo burst_info;
for (size_t i = 0; i < sizeof(_rgDownloadTestCases) / sizeof(_rgDownloadTestCases[0]); i++) {
struct stat st;
const DownloadTestCase *test = &_rgDownloadTestCases[i];
// Read in the file so we can compare it to what we get back
ut_compare("stat failed", stat(test->file, &st), 0);
uint8_t *bytes = new uint8_t[st.st_size];
ut_assert("new failed", bytes != nullptr);
int fd = ::open(test->file, O_RDONLY);
ut_assert("open failed", fd != -1);
int bytes_read = ::read(fd, bytes, st.st_size);
ut_compare("read failed", bytes_read, st.st_size);
::close(fd);
// Test case data files are created for specific boundary conditions
ut_compare("Test case data files are out of date", test->length, st.st_size);
payload.opcode = MavlinkFTP::kCmdOpenFileRO;
payload.offset = 0;
bool success = _send_receive_msg(&payload, // FTP payload header
strlen(test->file) + 1, // size in bytes of data
(uint8_t *)test->file, // Data to start into FTP message payload
&reply); // Payload inside FTP message response
if (!success) {
return false;
}
ut_compare("Didn't get Ack back", reply->opcode, MavlinkFTP::kRspAck);
// Setup for burst response handler
burst_info.burst_state = burst_state_first_ack;
burst_info.single_packet_file = test->singlePacketRead;
burst_info.file_size = st.st_size;
burst_info.file_bytes = bytes;
burst_info.ftp_test_class = this;
_ftp_server->set_unittest_worker(MavlinkFtpTest::receive_message_handler_burst, &burst_info);
// Send the burst command, message response will be handled by _receive_message_handler_stream
payload.opcode = MavlinkFTP::kCmdBurstReadFile;
payload.session = reply->session;
payload.offset = 0;
mavlink_message_t msg;
_setup_ftp_msg(&payload, 0, nullptr, &msg);
_ftp_server->handle_message(&msg);
// First packet is sent using stream mechanism, so we need to force it out ourselves
hrt_abstime t = 0;
_ftp_server->send(t);
ut_compare("Incorrect sequence of messages", burst_info.burst_state, burst_state_complete);
// Put back generic message handler
_ftp_server->set_unittest_worker(MavlinkFtpTest::receive_message_handler_generic, this);
// Terminate session
payload.opcode = MavlinkFTP::kCmdTerminateSession;
payload.session = reply->session;
payload.size = 0;
success = _send_receive_msg(&payload, // FTP payload header
0, // size in bytes of data
nullptr, // Data to start into FTP message payload
&reply); // Payload inside FTP message response
if (!success) {
return false;
}
ut_compare("Didn't get Ack back", reply->opcode, MavlinkFTP::kRspAck);
ut_compare("Incorrect payload size", reply->size, 0);
}
return true;
}
static int
Test_verifierIsValidDisjointPairSubstitution(void)
{
struct verifier vrf;
struct frame frm;
struct substitution sub;
verifierInit(&vrf);
struct reader r;
readerInitString(&r, "");
verifierBeginReadingFile(&vrf, &r);
size_tArrayAdd(&vrf.disjointScope, 0);
LOG_DEBUG("adding symbols");
size_t v1 = verifierAddSymbol(&vrf, "v1", symType_variable);
size_t v2 = verifierAddSymbol(&vrf, "v2", symType_variable);
size_t v3 = verifierAddSymbol(&vrf, "v3", symType_variable);
LOG_DEBUG("adding disjoints");
frameInit(&frm);
frameAddDisjoint(&frm, v1, v2);
LOG_DEBUG("building the substitution manually");
struct symstring str1, str2;
symstringInit(&str1);
symstringInit(&str2);
symstringAdd(&str1, v3);
symstringAdd(&str2, v3);
substitutionInit(&sub);
substitutionAdd(&sub, v1, &str1);
substitutionAdd(&sub, v2, &str2);
struct frame ctx;
frameInit(&ctx);
frameAddDisjoint(&ctx, v1, v2);
ut_assert(!verifierIsValidDisjointPairSubstitution(&vrf, &ctx, &frm, &sub,
0, 1), "sub should be invalid");
frameClean(&ctx);
/* str1 and str2 cleaned here */
substitutionClean(&sub);
frameClean(&frm);
frameInit(&frm);
frameAddDisjoint(&frm, v1, v2);
symstringInit(&str1);
symstringInit(&str2);
symstringAdd(&str1, v1);
symstringAdd(&str1, v2);
symstringAdd(&str2, v3);
substitutionInit(&sub);
substitutionAdd(&sub, v1, &str1);
substitutionAdd(&sub, v2, &str2);
frameInit(&ctx);
frameAddDisjoint(&ctx, v1, v2);
ut_assert(!verifierIsValidDisjointPairSubstitution(&vrf, &ctx, &frm, &sub,
0, 1), "sub should be invalid");
frameAddDisjoint(&frm, v1, v3);
frameAddDisjoint(&ctx, v1, v3);
ut_assert(!verifierIsValidDisjointPairSubstitution(&vrf, &ctx, &frm, &sub,
0, 1), "sub should be invalid");
frameAddDisjoint(&frm, v2, v3);
ut_assert(!verifierIsValidDisjointPairSubstitution(&vrf, &ctx, &frm, &sub,
0, 1), "sub should be invalid");
frameAddDisjoint(&ctx, v2, v3);
ut_assert(verifierIsValidDisjointPairSubstitution(&vrf, &ctx, &frm, &sub,
0, 1), "sub should be valid");
substitutionClean(&sub);
frameClean(&ctx);
frameClean(&frm);
readerClean(&r);
verifierClean(&vrf);
return 0;
}
/// @brief Tests for correct reponse to a Read command on an open session.
bool MavlinkFtpTest::_read_test(void)
{
MavlinkFTP::PayloadHeader payload;
mavlink_file_transfer_protocol_t ftp_msg;
MavlinkFTP::PayloadHeader *reply;
for (size_t i=0; i<sizeof(_rgReadTestCases)/sizeof(_rgReadTestCases[0]); i++) {
struct stat st;
const ReadTestCase *test = &_rgReadTestCases[i];
// Read in the file so we can compare it to what we get back
ut_compare("stat failed", stat(test->file, &st), 0);
uint8_t *bytes = new uint8_t[st.st_size];
ut_assert("new failed", bytes != nullptr);
int fd = ::open(test->file, O_RDONLY);
ut_assert("open failed", fd != -1);
int bytes_read = ::read(fd, bytes, st.st_size);
ut_compare("read failed", bytes_read, st.st_size);
::close(fd);
// Test case data files are created for specific boundary conditions
ut_compare("Test case data files are out of date", test->length, st.st_size);
payload.opcode = MavlinkFTP::kCmdOpenFileRO;
payload.offset = 0;
bool success = _send_receive_msg(&payload, // FTP payload header
strlen(test->file)+1, // size in bytes of data
(uint8_t*)test->file, // Data to start into FTP message payload
&ftp_msg, // Response from server
&reply); // Payload inside FTP message response
if (!success) {
return false;
}
ut_compare("Didn't get Ack back", reply->opcode, MavlinkFTP::kRspAck);
payload.opcode = MavlinkFTP::kCmdReadFile;
payload.session = reply->session;
payload.offset = 0;
success = _send_receive_msg(&payload, // FTP payload header
0, // size in bytes of data
nullptr, // Data to start into FTP message payload
&ftp_msg, // Response from server
&reply); // Payload inside FTP message response
if (!success) {
return false;
}
ut_compare("Didn't get Ack back", reply->opcode, MavlinkFTP::kRspAck);
ut_compare("Offset incorrect", reply->offset, 0);
if (test->length <= MAVLINK_MSG_FILE_TRANSFER_PROTOCOL_FIELD_PAYLOAD_LEN - sizeof(MavlinkFTP::PayloadHeader)) {
ut_compare("Payload size incorrect", reply->size, (uint32_t)st.st_size);
ut_compare("File contents differ", memcmp(reply->data, bytes, st.st_size), 0);
}
payload.opcode = MavlinkFTP::kCmdTerminateSession;
payload.session = reply->session;
payload.size = 0;
success = _send_receive_msg(&payload, // FTP payload header
0, // size in bytes of data
nullptr, // Data to start into FTP message payload
&ftp_msg, // Response from server
&reply); // Payload inside FTP message response
if (!success) {
return false;
}
ut_compare("Didn't get Ack back", reply->opcode, MavlinkFTP::kRspAck);
ut_compare("Incorrect payload size", reply->size, 0);
}
return true;
}
static int
Test_verifierApplyAssertion(void)
{
const size_t t = 1;
const size_t x = 2;
const size_t y = 3;
const size_t a = 4;
const size_t b = 5;
// const size_t tx = 6;
// const size_t ty = 7;
// const size_t txy = 8;
const size_t tyx = 9;
const size_t tx_f[2] = {t, x};
const size_t ty_f[2] = {t, y};
const size_t txy_e[3] = {t, x, y};
const size_t tyx_a[3] = {t, y, x};
// const size_t frame_a[3] = {tx, ty, txy};
const size_t stack1[2] = {t, a};
const size_t stack2[2] = {t, b};
const size_t stack3[3] = {t, a, b};
const size_t res[3] = {t, b, a};
struct verifier vrf;
verifierInit(&vrf);
struct reader r;
readerInitString(&r, "");
verifierBeginReadingFile(&vrf, &r);
struct symstring stmt;
LOG_DEBUG("add constant");
verifierAddConstant(&vrf, "t");
LOG_DEBUG("add variables");
verifierAddVariable(&vrf, "x");
verifierAddVariable(&vrf, "y");
verifierAddVariable(&vrf, "a");
verifierAddVariable(&vrf, "b");
LOG_DEBUG("add floatings");
symstringInit(&stmt);
size_tArrayAppend(&stmt, tx_f, 2);
verifierAddFloating(&vrf, "tx", &stmt);
symstringInit(&stmt);
size_tArrayAppend(&stmt, ty_f, 2);
verifierAddFloating(&vrf, "ty", &stmt);
LOG_DEBUG("add essential");
symstringInit(&stmt);
size_tArrayAppend(&stmt, txy_e, 3);
verifierAddEssential(&vrf, "txy", &stmt);
LOG_DEBUG("add assertion");
symstringInit(&stmt);
size_tArrayAppend(&stmt, tyx_a, 3);
verifierAddAssertion(&vrf, "tyx", &stmt);
LOG_DEBUG("prepare stack");
symstringInit(&stmt);
size_tArrayAppend(&stmt, stack1, 2);
symstringArrayAdd(&vrf.stack, stmt);
symstringInit(&stmt);
size_tArrayAppend(&stmt, stack2, 2);
symstringArrayAdd(&vrf.stack, stmt);
symstringInit(&stmt);
size_tArrayAppend(&stmt, stack3, 3);
symstringArrayAdd(&vrf.stack, stmt);
LOG_DEBUG("prepare context frame");
struct frame ctx;
frameInit(&ctx);
LOG_DEBUG("apply assertion");
verifierApplyAssertion(&vrf, &ctx, tyx);
ut_assert(!vrf.err, "assertion application failed");
symstringInit(&stmt);
size_tArrayAppend(&stmt, res, 3);
ut_assert(symstringIsEqual(&vrf.stack.vals[0], &stmt), "result of assertion "
"application is wrong");
LOG_DEBUG("clean up");
frameClean(&ctx);
symstringClean(&stmt);
readerClean(&r);
/* frm is cleaned here */
verifierClean(&vrf);
return 0;
}
static int test_bus_parent_platdata(struct unit_test_state *uts)
{
struct dm_test_parent_platdata *plat;
struct udevice *bus, *dev;
int child_count;
/* Check that the bus has no children */
ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
device_find_first_child(bus, &dev);
ut_asserteq_ptr(NULL, dev);
ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
for (device_find_first_child(bus, &dev), child_count = 0;
dev;
device_find_next_child(&dev)) {
/* Check that platform data is allocated */
plat = dev_get_parent_platdata(dev);
ut_assert(plat != NULL);
/*
* Check that it is not affected by the device being
* probed/removed
*/
plat->count++;
ut_asserteq(1, plat->count);
device_probe(dev);
device_remove(dev);
ut_asserteq_ptr(plat, dev_get_parent_platdata(dev));
ut_asserteq(1, plat->count);
ut_assertok(device_probe(dev));
child_count++;
}
ut_asserteq(3, child_count);
/* Removing the bus should also have no effect (it is still bound) */
device_remove(bus);
for (device_find_first_child(bus, &dev), child_count = 0;
dev;
device_find_next_child(&dev)) {
/* Check that platform data is allocated */
plat = dev_get_parent_platdata(dev);
ut_assert(plat != NULL);
ut_asserteq(1, plat->count);
child_count++;
}
ut_asserteq(3, child_count);
/* Unbind all the children */
do {
device_find_first_child(bus, &dev);
if (dev)
device_unbind(dev);
} while (dev);
/* Now the child platdata should be removed and re-added */
device_probe(bus);
for (device_find_first_child(bus, &dev), child_count = 0;
dev;
device_find_next_child(&dev)) {
/* Check that platform data is allocated */
plat = dev_get_parent_platdata(dev);
ut_assert(plat != NULL);
ut_asserteq(0, plat->count);
child_count++;
}
ut_asserteq(3, child_count);
return 0;
}
std::string _test_measure_vertical_node() {
struct LayoutProperties layoutProperties;
layoutPropertiesInitialize(&layoutProperties);
struct Element* element = createElement(vertical);
layoutProperties.width = {fixed, 100};
layoutProperties.height = {fixed, 100};
measureNodeForVerticalLayout(layoutProperties, element);
// width height rule
ut_assert("error, layout width coefficient x1", (*element)._layoutCoefficients.width.x1 == 0);
ut_assert("error, layout width coefficient x2", (*element)._layoutCoefficients.width.x2 == 100);
ut_assert("error, layout height coefficient x1", (*element)._layoutCoefficients.height.x1 == 0);
ut_assert("error, layout height coefficient x2", (*element)._layoutCoefficients.height.x2 == 100);
// min-width min-height rule
ut_assert("error, layout min width coefficient x1", isNaN((*element)._layoutCoefficients.minWidth.x1));
ut_assert("error, layout min width coefficient x2", isNaN((*element)._layoutCoefficients.minWidth.x2));
ut_assert("error, layout min width coefficient x3", isNaN((*element)._layoutCoefficients.minWidth.x3));
ut_assert("error, layout min height coefficient x1", isNaN((*element)._layoutCoefficients.minHeight.x1));
ut_assert("error, layout min height coefficient x2", isNaN((*element)._layoutCoefficients.minHeight.x2));
ut_assert("error, layout min height coefficient x3", isNaN((*element)._layoutCoefficients.minHeight.x3));
// top left rule
ut_assert("error, layout width coefficient x1", (*element)._layoutCoefficients.top.x1 == 0.5);
ut_assert("error, layout width coefficient x2", (*element)._layoutCoefficients.top.x2 == -0.5);
ut_assert("error, layout height coefficient x1", (*element)._layoutCoefficients.left.x1 == 0.5);
ut_assert("error, layout height coefficient x2", (*element)._layoutCoefficients.left.x2 == -0.5);
return "";
}
