diff --git a/src/modules/uORB/uORBTest_UnitTest.cpp b/src/modules/uORB/uORBTest_UnitTest.cpp
index 495633e217..f8e60a2154 100644
--- a/src/modules/uORB/uORBTest_UnitTest.cpp
+++ b/src/modules/uORB/uORBTest_UnitTest.cpp
@@ -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;
+	/* poll on test topic and output latency */
+	float latency_integral = 0.0f;
 
-  /* wakeup source(s) */
-  px4_pollfd_struct_t fds[3];
+	/* 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);
+	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;
+	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);
+	/* 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;
+	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;
+	const unsigned maxruns = 1000;
+	unsigned timingsgroup = 0;
 
-  unsigned *timings = new unsigned[maxruns];
+	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;
-    }
+	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 (pret < 0) {
-      warn("poll error %d, %d", pret, errno);
-      continue;
-    }
+		if (fds[0].revents & POLLIN) {
+			orb_copy(ORB_ID(orb_test), test_multi_sub, &t);
+			timingsgroup = 0;
 
-    hrt_abstime elt = hrt_elapsed_time(&t.time);
-    latency_integral += elt;
-    timings[i] = elt;
-  }
+		} else if (fds[1].revents & POLLIN) {
+			orb_copy(ORB_ID(orb_test_medium), test_multi_sub_medium, &t);
+			timingsgroup = 1;
 
-  orb_unsubscribe(test_multi_sub);
-  orb_unsubscribe(test_multi_sub_medium);
-  orb_unsubscribe(test_multi_sub_large);
+		} else if (fds[2].revents & POLLIN) {
+			orb_copy(ORB_ID(orb_test_large), test_multi_sub_large, &t);
+			timingsgroup = 2;
+		}
 
-  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;
-        }
+		if (pret < 0) {
+			warn("poll error %d, %d", pret, errno);
+			continue;
+		}
 
-    for (unsigned i = 0; i < maxruns; i++) {
-      fprintf(f, "%u\n", timings[i]);
-    }
+		hrt_abstime elt = hrt_elapsed_time(&t.time);
+		latency_integral += elt;
+		timings[i] = elt;
+	}
 
-    fclose(f);
-  }
+	orb_unsubscribe(test_multi_sub);
+	orb_unsubscribe(test_multi_sub_medium);
+	orb_unsubscribe(test_multi_sub_large);
 
-  delete[] timings;
+	if (pubsubtest_print) {
+		char fname[32];
+		sprintf(fname, PX4_ROOTFSDIR"/fs/microsd/timings%u.txt", timingsgroup);
+		FILE *f = fopen(fname, "w");
 
-  warnx("mean: %8.4f", static_cast<double>(latency_integral / maxruns));
+		if (f == NULL) {
+			warnx("Error opening file!\n");
+			return uORB::ERROR;
+		}
 
-  pubsubtest_passed = true;
+		for (unsigned i = 0; i < maxruns; i++) {
+			fprintf(f, "%u\n", timings[i]);
+		}
 
-  if (static_cast<float>(latency_integral / maxruns) > 30.0f) {
-    pubsubtest_res = uORB::ERROR;
-  } else {
-    pubsubtest_res = PX4_OK;
-  }
+		fclose(f);
+	}
 
-  return pubsubtest_res;
+	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);
+	t.val = 0;
+	ptopic = orb_advertise(ORB_ID(orb_test), &t);
 
-  if (ptopic == nullptr)
-    return test_fail("advertise failed: %d", errno);
+	if (ptopic == nullptr) {
+		return test_fail("advertise failed: %d", errno);
+	}
 
-  test_note("publish handle 0x%08x", ptopic);
-  sfd = orb_subscribe(ORB_ID(orb_test));
+	test_note("publish handle 0x%08x", ptopic);
+	sfd = orb_subscribe(ORB_ID(orb_test));
 
-  if (sfd < 0)
-    return test_fail("subscribe failed: %d", errno);
+	if (sfd < 0) {
+		return test_fail("subscribe failed: %d", errno);
+	}
 
-  test_note("subscribe fd %d", sfd);
-  u.val = 1;
+	test_note("subscribe fd %d", sfd);
+	u.val = 1;
 
-  if (PX4_OK != orb_copy(ORB_ID(orb_test), sfd, &u))
-    return test_fail("copy(1) failed: %d", errno);
+	if (PX4_OK != orb_copy(ORB_ID(orb_test), sfd, &u)) {
+		return test_fail("copy(1) failed: %d", errno);
+	}
 
-  if (u.val != t.val)
-    return test_fail("copy(1) mismatch: %d expected %d", u.val, t.val);
+	if (u.val != t.val) {
+		return test_fail("copy(1) mismatch: %d expected %d", u.val, t.val);
+	}
 
-  if (PX4_OK != orb_check(sfd, &updated))
-    return test_fail("check(1) failed");
+	if (PX4_OK != orb_check(sfd, &updated)) {
+		return test_fail("check(1) failed");
+	}
 
-  if (updated)
-    return test_fail("spurious updated flag");
+	if (updated) {
+		return test_fail("spurious updated flag");
+	}
 
-  t.val = 2;
-  test_note("try publish");
+	t.val = 2;
+	test_note("try publish");
 
-  if (PX4_OK != orb_publish(ORB_ID(orb_test), ptopic, &t))
-    return test_fail("publish failed");
+	if (PX4_OK != orb_publish(ORB_ID(orb_test), ptopic, &t)) {
+		return test_fail("publish failed");
+	}
 
-  if (PX4_OK != orb_check(sfd, &updated))
-    return test_fail("check(2) failed");
+	if (PX4_OK != orb_check(sfd, &updated)) {
+		return test_fail("check(2) failed");
+	}
 
-  if (!updated)
-    return test_fail("missing updated flag");
+	if (!updated) {
+		return test_fail("missing updated flag");
+	}
 
-  if (PX4_OK != orb_copy(ORB_ID(orb_test), sfd, &u))
-    return test_fail("copy(2) failed: %d", errno);
+	if (PX4_OK != orb_copy(ORB_ID(orb_test), sfd, &u)) {
+		return test_fail("copy(2) failed: %d", errno);
+	}
 
-  if (u.val != t.val)
-    return test_fail("copy(2) mismatch: %d expected %d", u.val, t.val);
+	if (u.val != t.val) {
+		return test_fail("copy(2) mismatch: %d expected %d", u.val, t.val);
+	}
 
-  orb_unsubscribe(sfd);
+	orb_unsubscribe(sfd);
 
-  /* this routine tests the multi-topic support */
-  test_note("try multi-topic support");
+	/* this routine tests the multi-topic support */
+	test_note("try multi-topic support");
 
-  int instance0;
-  orb_advert_t pfd0 = orb_advertise_multi(ORB_ID(orb_multitest), &t, &instance0, ORB_PRIO_MAX);
+	int instance0;
+	orb_advert_t pfd0 = orb_advertise_multi(ORB_ID(orb_multitest), &t, &instance0, ORB_PRIO_MAX);
 
-  test_note("advertised");
+	test_note("advertised");
 
-  int instance1;
-  orb_advert_t pfd1 = orb_advertise_multi(ORB_ID(orb_multitest), &t, &instance1, ORB_PRIO_MIN);
+	int instance1;
+	orb_advert_t pfd1 = orb_advertise_multi(ORB_ID(orb_multitest), &t, &instance1, ORB_PRIO_MIN);
 
-  if (instance0 != 0)
-    return test_fail("mult. id0: %d", instance0);
+	if (instance0 != 0) {
+		return test_fail("mult. id0: %d", instance0);
+	}
 
-  if (instance1 != 1)
-    return test_fail("mult. id1: %d", instance1);
+	if (instance1 != 1) {
+		return test_fail("mult. id1: %d", instance1);
+	}
 
-  t.val = 103;
-  if (PX4_OK != orb_publish(ORB_ID(orb_multitest), pfd0, &t))
-    return test_fail("mult. pub0 fail");
+	t.val = 103;
 
-  test_note("published");
+	if (PX4_OK != orb_publish(ORB_ID(orb_multitest), pfd0, &t)) {
+		return test_fail("mult. pub0 fail");
+	}
 
-  t.val = 203;
-  if (PX4_OK != orb_publish(ORB_ID(orb_multitest), pfd1, &t))
-    return test_fail("mult. pub1 fail");
+	test_note("published");
 
-  /* subscribe to both topics and ensure valid data is received */
-  int sfd0 = orb_subscribe_multi(ORB_ID(orb_multitest), 0);
+	t.val = 203;
 
-  if (PX4_OK != orb_copy(ORB_ID(orb_multitest), sfd0, &u))
-    return test_fail("sub #0 copy failed: %d", errno);
+	if (PX4_OK != orb_publish(ORB_ID(orb_multitest), pfd1, &t)) {
+		return test_fail("mult. pub1 fail");
+	}
 
-  if (u.val != 103)
-    return test_fail("sub #0 val. mismatch: %d", u.val);
+	/* subscribe to both topics and ensure valid data is received */
+	int sfd0 = orb_subscribe_multi(ORB_ID(orb_multitest), 0);
 
-  int sfd1 = orb_subscribe_multi(ORB_ID(orb_multitest), 1);
+	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), sfd1, &u))
-    return test_fail("sub #1 copy failed: %d", errno);
+	if (u.val != 103) {
+		return test_fail("sub #0 val. mismatch: %d", u.val);
+	}
 
-  if (u.val != 203)
-    return test_fail("sub #1 val. mismatch: %d", u.val);
+	int sfd1 = orb_subscribe_multi(ORB_ID(orb_multitest), 1);
 
-  /* test priorities */
-  int prio;
-  if (PX4_OK != orb_priority(sfd0, &prio))
-    return test_fail("prio #0");
+	if (PX4_OK != orb_copy(ORB_ID(orb_multitest), sfd1, &u)) {
+		return test_fail("sub #1 copy failed: %d", errno);
+	}
 
-  if (prio != ORB_PRIO_MAX)
-    return test_fail("prio: %d", prio);
+	if (u.val != 203) {
+		return test_fail("sub #1 val. mismatch: %d", u.val);
+	}
 
-  if (PX4_OK != orb_priority(sfd1, &prio))
-    return test_fail("prio #1");
+	/* test priorities */
+	int prio;
 
-  if (prio != ORB_PRIO_MIN)
-    return test_fail("prio: %d", prio);
+	if (PX4_OK != orb_priority(sfd0, &prio)) {
+		return test_fail("prio #0");
+	}
 
-  if (PX4_OK != latency_test<struct orb_test>(ORB_ID(orb_test), false))
-    return test_fail("latency test failed");
+	if (prio != ORB_PRIO_MAX) {
+		return test_fail("prio: %d", prio);
+	}
 
-  return test_note("PASS");
+	if (PX4_OK != orb_priority(sfd1, &prio)) {
+		return test_fail("prio #1");
+	}
+
+	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");
+	}
+
+	return test_note("PASS");
 }
 
 int uORBTest::UnitTest::info()
 {
-  return OK;
+	return OK;
 }
 
 int uORBTest::UnitTest::test_fail(const char *fmt, ...)
 {
-  va_list ap;
+	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;
+	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;
+	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;
+	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();
 }
diff --git a/src/modules/uORB/uORBTest_UnitTest.hpp b/src/modules/uORB/uORBTest_UnitTest.hpp
index 93399f734f..4957427c06 100644
--- a/src/modules/uORB/uORBTest_UnitTest.hpp
+++ b/src/modules/uORB/uORBTest_UnitTest.hpp
@@ -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) {}
+	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;
+	// 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, ...);
+	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();
+	test_note("---------------- LATENCY TEST ------------------");
+	S t;
+	t.val = 308;
+	t.time = hrt_absolute_time();
 
-  orb_advert_t pfd0 = orb_advertise(T, &t);
+	orb_advert_t pfd0 = orb_advertise(T, &t);
 
-  char * const args[1] = { NULL };
+	char *const args[1] = { NULL };
 
-  pubsubtest_print = print;
-  pubsubtest_passed = false;
+	pubsubtest_print = print;
+	pubsubtest_passed = false;
 
-  /* test pub / sub latency */
+	/* 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);
+	// 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");
+	/* give the test task some data */
+	while (!pubsubtest_passed) {
+		t.val = 308;
+		t.time = hrt_absolute_time();
 
-    /* simulate >800 Hz system operation */
-    usleep(1000);
-  }
+		if (PX4_OK != orb_publish(T, pfd0, &t)) {
+			return test_fail("mult. pub0 timing fail");
+		}
 
-  if (pubsub_task < 0) {
-    return test_fail("failed launching task");
-  }
+		/* simulate >800 Hz system operation */
+		usleep(1000);
+	}
 
-  return pubsubtest_res;
+	if (pubsub_task < 0) {
+		return test_fail("failed launching task");
+	}
+
+	return pubsubtest_res;
 }
 
 #endif // _uORBTest_UnitTest_hpp_