zrzk
/
px4_autopilot
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

uORBTest_UnitTest: astyle

sbg
Ban Siesta 10 years ago committed by Lorenz Meier
parent
45f5907716
commit
8be1b4f19c
2 changed files with 286 additions and 252 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 402
      src/modules/uORB/uORBTest_UnitTest.cpp
  2. 136
      src/modules/uORB/uORBTest_UnitTest.hpp

402
src/modules/uORB/uORBTest_UnitTest.cpp
Unescape View File

@ -45,245 +45,277 @@ uORBTest::UnitTest &uORBTest::UnitTest::instance() @@ -45,245 +45,277 @@ uORBTest::UnitTest &uORBTest::UnitTest::instance()
int uORBTest::UnitTest::pubsublatency_main(void)
{
/* poll on test topic and output latency */
float latency_integral = 0.0f;
/* wakeup source(s) */
px4_pollfd_struct_t fds[3];
int test_multi_sub = orb_subscribe_multi(ORB_ID(orb_test), 0);
int test_multi_sub_medium = orb_subscribe_multi(ORB_ID(orb_test_medium), 0);
int test_multi_sub_large = orb_subscribe_multi(ORB_ID(orb_test_large), 0);
struct orb_test_large t;
/* clear all ready flags */
orb_copy(ORB_ID(orb_test), test_multi_sub, &t);
orb_copy(ORB_ID(orb_test_medium), test_multi_sub_medium, &t);
orb_copy(ORB_ID(orb_test_large), test_multi_sub_large, &t);
fds[0].fd = test_multi_sub;
fds[0].events = POLLIN;
fds[1].fd = test_multi_sub_medium;
fds[1].events = POLLIN;
fds[2].fd = test_multi_sub_large;
fds[2].events = POLLIN;
const unsigned maxruns = 1000;
unsigned timingsgroup = 0;
unsigned *timings = new unsigned[maxruns];
for (unsigned i = 0; i < maxruns; i++) {
/* wait for up to 500ms for data */
int pret = px4_poll(&fds[0], (sizeof(fds) / sizeof(fds[0])), 500);
if (fds[0].revents & POLLIN) {
orb_copy(ORB_ID(orb_test), test_multi_sub, &t);
timingsgroup = 0;
} else if (fds[1].revents & POLLIN) {
orb_copy(ORB_ID(orb_test_medium), test_multi_sub_medium, &t);
timingsgroup = 1;
} else if (fds[2].revents & POLLIN) {
orb_copy(ORB_ID(orb_test_large), test_multi_sub_large, &t);
timingsgroup = 2;
}
if (pret < 0) {
warn("poll error %d, %d", pret, errno);
continue;
}
hrt_abstime elt = hrt_elapsed_time(&t.time);
latency_integral += elt;
timings[i] = elt;
}
orb_unsubscribe(test_multi_sub);
orb_unsubscribe(test_multi_sub_medium);
orb_unsubscribe(test_multi_sub_large);
if (pubsubtest_print) {
char fname[32];
sprintf(fname, PX4_ROOTFSDIR"/fs/microsd/timings%u.txt", timingsgroup);
FILE *f = fopen(fname, "w");
if (f == NULL) {
warnx("Error opening file!\n");
return uORB::ERROR;
}
for (unsigned i = 0; i < maxruns; i++) {
fprintf(f, "%u\n", timings[i]);
}
fclose(f);
}
delete[] timings;
warnx("mean: %8.4f", static_cast<double>(latency_integral / maxruns));
pubsubtest_passed = true;
if (static_cast<float>(latency_integral / maxruns) > 30.0f) {
pubsubtest_res = uORB::ERROR;
} else {
pubsubtest_res = PX4_OK;
}
return pubsubtest_res;
/* poll on test topic and output latency */
float latency_integral = 0.0f;
/* wakeup source(s) */
px4_pollfd_struct_t fds[3];
int test_multi_sub = orb_subscribe_multi(ORB_ID(orb_test), 0);
int test_multi_sub_medium = orb_subscribe_multi(ORB_ID(orb_test_medium), 0);
int test_multi_sub_large = orb_subscribe_multi(ORB_ID(orb_test_large), 0);
struct orb_test_large t;
/* clear all ready flags */
orb_copy(ORB_ID(orb_test), test_multi_sub, &t);
orb_copy(ORB_ID(orb_test_medium), test_multi_sub_medium, &t);
orb_copy(ORB_ID(orb_test_large), test_multi_sub_large, &t);
fds[0].fd = test_multi_sub;
fds[0].events = POLLIN;
fds[1].fd = test_multi_sub_medium;
fds[1].events = POLLIN;
fds[2].fd = test_multi_sub_large;
fds[2].events = POLLIN;
const unsigned maxruns = 1000;
unsigned timingsgroup = 0;
unsigned *timings = new unsigned[maxruns];
for (unsigned i = 0; i < maxruns; i++) {
/* wait for up to 500ms for data */
int pret = px4_poll(&fds[0], (sizeof(fds) / sizeof(fds[0])), 500);
if (fds[0].revents & POLLIN) {
orb_copy(ORB_ID(orb_test), test_multi_sub, &t);
timingsgroup = 0;
} else if (fds[1].revents & POLLIN) {
orb_copy(ORB_ID(orb_test_medium), test_multi_sub_medium, &t);
timingsgroup = 1;
} else if (fds[2].revents & POLLIN) {
orb_copy(ORB_ID(orb_test_large), test_multi_sub_large, &t);
timingsgroup = 2;
}
if (pret < 0) {
warn("poll error %d, %d", pret, errno);
continue;
}
hrt_abstime elt = hrt_elapsed_time(&t.time);
latency_integral += elt;
timings[i] = elt;
}
orb_unsubscribe(test_multi_sub);
orb_unsubscribe(test_multi_sub_medium);
orb_unsubscribe(test_multi_sub_large);
if (pubsubtest_print) {
char fname[32];
sprintf(fname, PX4_ROOTFSDIR"/fs/microsd/timings%u.txt", timingsgroup);
FILE *f = fopen(fname, "w");
if (f == NULL) {
warnx("Error opening file!\n");
return uORB::ERROR;
}
for (unsigned i = 0; i < maxruns; i++) {
fprintf(f, "%u\n", timings[i]);
}
fclose(f);
}
delete[] timings;
warnx("mean: %8.4f", static_cast<double>(latency_integral / maxruns));
pubsubtest_passed = true;
if (static_cast<float>(latency_integral / maxruns) > 30.0f) {
pubsubtest_res = uORB::ERROR;
} else {
pubsubtest_res = PX4_OK;
}
return pubsubtest_res;
}
int uORBTest::UnitTest::test()
{
struct orb_test t, u;
int sfd;
orb_advert_t ptopic;
bool updated;
struct orb_test t, u;
int sfd;
orb_advert_t ptopic;
bool updated;
t.val = 0;
ptopic = orb_advertise(ORB_ID(orb_test), &t);
if (ptopic == nullptr) {
return test_fail("advertise failed: %d", errno);
}
test_note("publish handle 0x%08x", ptopic);
sfd = orb_subscribe(ORB_ID(orb_test));
t.val = 0;
ptopic = orb_advertise(ORB_ID(orb_test), &t);
if (sfd < 0) {
return test_fail("subscribe failed: %d", errno);
}
if (ptopic == nullptr)
return test_fail("advertise failed: %d", errno);
test_note("subscribe fd %d", sfd);
u.val = 1;
test_note("publish handle 0x%08x", ptopic);
sfd = orb_subscribe(ORB_ID(orb_test));
if (PX4_OK != orb_copy(ORB_ID(orb_test), sfd, &u)) {
return test_fail("copy(1) failed: %d", errno);
}
if (sfd < 0)
return test_fail("subscribe failed: %d", errno);
if (u.val != t.val) {
return test_fail("copy(1) mismatch: %d expected %d", u.val, t.val);
}
test_note("subscribe fd %d", sfd);
u.val = 1;
if (PX4_OK != orb_check(sfd, &updated)) {
return test_fail("check(1) failed");
}
if (PX4_OK != orb_copy(ORB_ID(orb_test), sfd, &u))
return test_fail("copy(1) failed: %d", errno);
if (updated) {
return test_fail("spurious updated flag");
}
if (u.val != t.val)
return test_fail("copy(1) mismatch: %d expected %d", u.val, t.val);
t.val = 2;
test_note("try publish");
if (PX4_OK != orb_check(sfd, &updated))
return test_fail("check(1) failed");
if (PX4_OK != orb_publish(ORB_ID(orb_test), ptopic, &t)) {
return test_fail("publish failed");
}
if (updated)
return test_fail("spurious updated flag");
if (PX4_OK != orb_check(sfd, &updated)) {
return test_fail("check(2) failed");
}
t.val = 2;
test_note("try publish");
if (!updated) {
return test_fail("missing updated flag");
}
if (PX4_OK != orb_publish(ORB_ID(orb_test), ptopic, &t))
return test_fail("publish failed");
if (PX4_OK != orb_copy(ORB_ID(orb_test), sfd, &u)) {
return test_fail("copy(2) failed: %d", errno);
}
if (PX4_OK != orb_check(sfd, &updated))
return test_fail("check(2) failed");
if (u.val != t.val) {
return test_fail("copy(2) mismatch: %d expected %d", u.val, t.val);
}
if (!updated)
return test_fail("missing updated flag");
orb_unsubscribe(sfd);
if (PX4_OK != orb_copy(ORB_ID(orb_test), sfd, &u))
return test_fail("copy(2) failed: %d", errno);
/* this routine tests the multi-topic support */
test_note("try multi-topic support");
if (u.val != t.val)
return test_fail("copy(2) mismatch: %d expected %d", u.val, t.val);
int instance0;
orb_advert_t pfd0 = orb_advertise_multi(ORB_ID(orb_multitest), &t, &instance0, ORB_PRIO_MAX);
orb_unsubscribe(sfd);
test_note("advertised");
/* this routine tests the multi-topic support */
test_note("try multi-topic support");
int instance1;
orb_advert_t pfd1 = orb_advertise_multi(ORB_ID(orb_multitest), &t, &instance1, ORB_PRIO_MIN);
int instance0;
orb_advert_t pfd0 = orb_advertise_multi(ORB_ID(orb_multitest), &t, &instance0, ORB_PRIO_MAX);
if (instance0 != 0) {
return test_fail("mult. id0: %d", instance0);
}
test_note("advertised");
if (instance1 != 1) {
return test_fail("mult. id1: %d", instance1);
}
int instance1;
orb_advert_t pfd1 = orb_advertise_multi(ORB_ID(orb_multitest), &t, &instance1, ORB_PRIO_MIN);
t.val = 103;
if (instance0 != 0)
return test_fail("mult. id0: %d", instance0);
if (PX4_OK != orb_publish(ORB_ID(orb_multitest), pfd0, &t)) {
return test_fail("mult. pub0 fail");
}
if (instance1 != 1)
return test_fail("mult. id1: %d", instance1);
test_note("published");
t.val = 103;
if (PX4_OK != orb_publish(ORB_ID(orb_multitest), pfd0, &t))
return test_fail("mult. pub0 fail");
t.val = 203;
test_note("published");
if (PX4_OK != orb_publish(ORB_ID(orb_multitest), pfd1, &t)) {
return test_fail("mult. pub1 fail");
}
t.val = 203;
if (PX4_OK != orb_publish(ORB_ID(orb_multitest), pfd1, &t))
return test_fail("mult. pub1 fail");
/* subscribe to both topics and ensure valid data is received */
int sfd0 = orb_subscribe_multi(ORB_ID(orb_multitest), 0);
/* subscribe to both topics and ensure valid data is received */
int sfd0 = orb_subscribe_multi(ORB_ID(orb_multitest), 0);
if (PX4_OK != orb_copy(ORB_ID(orb_multitest), sfd0, &u)) {
return test_fail("sub #0 copy failed: %d", errno);
}
if (PX4_OK != orb_copy(ORB_ID(orb_multitest), sfd0, &u))
return test_fail("sub #0 copy failed: %d", errno);
if (u.val != 103) {
return test_fail("sub #0 val. mismatch: %d", u.val);
}
if (u.val != 103)
return test_fail("sub #0 val. mismatch: %d", u.val);
int sfd1 = orb_subscribe_multi(ORB_ID(orb_multitest), 1);
int sfd1 = orb_subscribe_multi(ORB_ID(orb_multitest), 1);
if (PX4_OK != orb_copy(ORB_ID(orb_multitest), sfd1, &u)) {
return test_fail("sub #1 copy failed: %d", errno);
}
if (PX4_OK != orb_copy(ORB_ID(orb_multitest), sfd1, &u))
return test_fail("sub #1 copy failed: %d", errno);
if (u.val != 203) {
return test_fail("sub #1 val. mismatch: %d", u.val);
}
if (u.val != 203)
return test_fail("sub #1 val. mismatch: %d", u.val);
/* test priorities */
int prio;
/* test priorities */
int prio;
if (PX4_OK != orb_priority(sfd0, &prio))
return test_fail("prio #0");
if (PX4_OK != orb_priority(sfd0, &prio)) {
return test_fail("prio #0");
}
if (prio != ORB_PRIO_MAX)
return test_fail("prio: %d", prio);
if (prio != ORB_PRIO_MAX) {
return test_fail("prio: %d", prio);
}
if (PX4_OK != orb_priority(sfd1, &prio))
return test_fail("prio #1");
if (PX4_OK != orb_priority(sfd1, &prio)) {
return test_fail("prio #1");
}
if (prio != ORB_PRIO_MIN)
return test_fail("prio: %d", prio);
if (prio != ORB_PRIO_MIN) {
return test_fail("prio: %d", prio);
}
if (PX4_OK != latency_test<struct orb_test>(ORB_ID(orb_test), false))
return test_fail("latency test failed");
if (PX4_OK != latency_test<struct orb_test>(ORB_ID(orb_test), false)) {
return test_fail("latency test failed");
}
return test_note("PASS");
return test_note("PASS");
}
int uORBTest::UnitTest::info()
{
return OK;
return OK;
}
int uORBTest::UnitTest::test_fail(const char *fmt, ...)
{
va_list ap;
fprintf(stderr, "uORB FAIL: ");
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "\n");
fflush(stderr);
return uORB::ERROR;
va_list ap;
fprintf(stderr, "uORB FAIL: ");
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "\n");
fflush(stderr);
return uORB::ERROR;
}
int uORBTest::UnitTest::test_note(const char *fmt, ...)
{
va_list ap;
fprintf(stderr, "uORB note: ");
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "\n");
fflush(stderr);
return OK;
va_list ap;
fprintf(stderr, "uORB note: ");
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "\n");
fflush(stderr);
return OK;
}
int uORBTest::UnitTest::pubsubtest_threadEntry(char* const argv[])
int uORBTest::UnitTest::pubsubtest_threadEntry(char *const argv[])
{
uORBTest::UnitTest &t = uORBTest::UnitTest::instance();
return t.pubsublatency_main();
uORBTest::UnitTest &t = uORBTest::UnitTest::instance();
return t.pubsublatency_main();
}

136
src/modules/uORB/uORBTest_UnitTest.hpp
Unescape View File

@ -38,101 +38,103 @@ @@ -38,101 +38,103 @@
#include <px4_time.h>
struct orb_test {
int val;
hrt_abstime time;
int val;
hrt_abstime time;
};
ORB_DEFINE(orb_test, struct orb_test);
ORB_DEFINE(orb_multitest, struct orb_test);
struct orb_test_medium {
int val;
hrt_abstime time;
char junk[64];
int val;
hrt_abstime time;
char junk[64];
};
ORB_DEFINE(orb_test_medium, struct orb_test_medium);
struct orb_test_large {
int val;
hrt_abstime time;
char junk[512];
int val;
hrt_abstime time;
char junk[512];
};
ORB_DEFINE(orb_test_large, struct orb_test_large);
namespace uORBTest
{
class UnitTest;
class UnitTest;
}
class uORBTest::UnitTest
{
public:
// Singleton pattern
static uORBTest::UnitTest &instance();
~UnitTest() {}
int test();
template<typename S> int latency_test(orb_id_t T, bool print);
int info();
// Singleton pattern
static uORBTest::UnitTest &instance();
~UnitTest() {}
int test();
template<typename S> int latency_test(orb_id_t T, bool print);
int info();
private:
UnitTest() : pubsubtest_passed(false), pubsubtest_print(false) {}
// Disallow copy
UnitTest(const uORBTest::UnitTest &) {};
static int pubsubtest_threadEntry(char* const argv[]);
int pubsublatency_main(void);
bool pubsubtest_passed;
bool pubsubtest_print;
int pubsubtest_res = OK;
int test_fail(const char *fmt, ...);
int test_note(const char *fmt, ...);
UnitTest() : pubsubtest_passed(false), pubsubtest_print(false) {}
// Disallow copy
UnitTest(const uORBTest::UnitTest &) {};
static int pubsubtest_threadEntry(char *const argv[]);
int pubsublatency_main(void);
bool pubsubtest_passed;
bool pubsubtest_print;
int pubsubtest_res = OK;
int test_fail(const char *fmt, ...);
int test_note(const char *fmt, ...);
};
template<typename S>
int uORBTest::UnitTest::latency_test(orb_id_t T, bool print)
{
test_note("---------------- LATENCY TEST ------------------");
S t;
t.val = 308;
t.time = hrt_absolute_time();
orb_advert_t pfd0 = orb_advertise(T, &t);
char * const args[1] = { NULL };
pubsubtest_print = print;
pubsubtest_passed = false;
/* test pub / sub latency */
// Can't pass a pointer in args, must be a null terminated
// array of strings because the strings are copied to
// prevent access if the caller data goes out of scope
int pubsub_task = px4_task_spawn_cmd("uorb_latency",
SCHED_DEFAULT,
SCHED_PRIORITY_MAX - 5,
1500,
(px4_main_t)&uORBTest::UnitTest::pubsubtest_threadEntry,
args);
/* give the test task some data */
while (!pubsubtest_passed) {
t.val = 308;
t.time = hrt_absolute_time();
if (PX4_OK != orb_publish(T, pfd0, &t))
return test_fail("mult. pub0 timing fail");
/* simulate >800 Hz system operation */
usleep(1000);
}
if (pubsub_task < 0) {
return test_fail("failed launching task");
}
return pubsubtest_res;
test_note("---------------- LATENCY TEST ------------------");
S t;
t.val = 308;
t.time = hrt_absolute_time();
orb_advert_t pfd0 = orb_advertise(T, &t);
char *const args[1] = { NULL };
pubsubtest_print = print;
pubsubtest_passed = false;
/* test pub / sub latency */
// Can't pass a pointer in args, must be a null terminated
// array of strings because the strings are copied to
// prevent access if the caller data goes out of scope
int pubsub_task = px4_task_spawn_cmd("uorb_latency",
SCHED_DEFAULT,
SCHED_PRIORITY_MAX - 5,
1500,
(px4_main_t)&uORBTest::UnitTest::pubsubtest_threadEntry,
args);
/* give the test task some data */
while (!pubsubtest_passed) {
t.val = 308;
t.time = hrt_absolute_time();
if (PX4_OK != orb_publish(T, pfd0, &t)) {
return test_fail("mult. pub0 timing fail");
}
/* simulate >800 Hz system operation */
usleep(1000);
}
if (pubsub_task < 0) {
return test_fail("failed launching task");
}
return pubsubtest_res;
}
#endif // _uORBTest_UnitTest_hpp_

Write Preview
Loading…
Cancel
Save