diff --git a/base/src/test/util_mmio/main.cc b/base/src/test/util_mmio/main.cc
index dd1140c3fe..b0898ca96f 100644
--- a/base/src/test/util_mmio/main.cc
+++ b/base/src/test/util_mmio/main.cc
@@ -184,9 +184,9 @@ int compare_mem(uint8_t * base1, uint8_t * base2, size_t size)
 /**
  * End a failed test
  */
-int test_failed(unsigned test_id)
+int test_failed(unsigned line)
 {
-	printf("Test %i failed\n", test_id);
+	printf("Test in line %i failed\n", line);
 	printf("  mmio_mem:  0x ");
 	dump_mem(mmio_mem, sizeof(mmio_mem));
 	printf("\n  cpu_state: 0x%4X\n", cpu_state);
@@ -201,103 +201,76 @@ int main()
 	 ** 'Genode::Mmio::Register' tests **
 	 ************************************/
 
-	/**
-	 * Init fake MMIO
-	 */
+	/* use 'Bitfield::bits' with overflowing values */
 	Test_mmio mmio((addr_t)&mmio_mem[0]);
-
-	/**
-	 * Test 1, read/write whole reg, use 'Bitfield::bits' with overflowing values
-	 */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
-	mmio.write<Test_mmio::Reg>(Test_mmio::Reg::Bit_1::bits(7) |
-	                           Test_mmio::Reg::Area::bits(10) |
-	                           Test_mmio::Reg::Bit_2::bits(9) );
+	mmio.write<Test_mmio::Reg>(
+		Test_mmio::Reg::Bit_1::bits(7) |
+		Test_mmio::Reg::Area::bits(10) |
+		Test_mmio::Reg::Bit_2::bits(9) );
 
 	static uint8_t mmio_cmpr_1[MMIO_SIZE] = {0,0,0,0,0b00010101,0,0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_1, sizeof(mmio_mem)) ||
 	    mmio.read<Test_mmio::Reg>() != 0x15)
-	{ return test_failed(1); }
+	{ return test_failed(__LINE__); }
 
-	/**
-	 * Test 2, read/write bit appropriately
-	 */
+	/* read/write bit appropriately */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	mmio.write<Test_mmio::Reg::Bit_1>(1);
-
 	static uint8_t mmio_cmpr_2[MMIO_SIZE] = {0,0,0,0,0b00000001,0,0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_2, sizeof(mmio_mem)) ||
 	    mmio.read<Test_mmio::Reg::Bit_1>() != 1)
-	{ return test_failed(2); }
+	{ return test_failed(__LINE__); }
 
-	/**
-	 * Test 3, read/write bit overflowing
-	 */
+	/* read/write bit overflowing */
 	mmio.write<Test_mmio::Reg::Bit_2>(0xff);
 
 	static uint8_t mmio_cmpr_3[MMIO_SIZE] = {0,0,0,0,0b00010001,0,0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_3, sizeof(mmio_mem)) ||
 	    mmio.read<Test_mmio::Reg::Bit_2>() != 1)
-	{ return test_failed(3); }
+	{ return test_failed(__LINE__); }
 
-	/**
-	 * Test 4, read/write bitarea appropriately
-	 */
+	/* read/write bitarea appropriately */
 	mmio.write<Test_mmio::Reg::Area>(Test_mmio::Reg::Area::VALUE_3);
-
 	static uint8_t mmio_cmpr_4[MMIO_SIZE] = {0,0,0,0,0b00011011,0,0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_4, sizeof(mmio_mem)) ||
 	    mmio.read<Test_mmio::Reg::Area>() != Test_mmio::Reg::Area::VALUE_3)
-	{ return test_failed(4); }
+	{ return test_failed(__LINE__); }
 
-	/**
-	 * Test 5, read/write bitarea overflowing
-	 */
+	/* read/write bitarea overflowing */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	mmio.write<Test_mmio::Reg::Area>(0b11111101);
-
 	static uint8_t mmio_cmpr_5[MMIO_SIZE] = {0,0,0,0,0b00001010,0,0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_5, sizeof(mmio_mem)) ||
 	    mmio.read<Test_mmio::Reg::Area>() != 0b101)
-	{ return test_failed(5); }
+	{ return test_failed(__LINE__); }
 
-	/**
-	 * Test 6, read/write bit out of regrange
-	 */
+	/* read/write bit out of regrange */
 	mmio.write<Test_mmio::Reg::Invalid_bit>(1);
-
 	if (compare_mem(mmio_mem, mmio_cmpr_5, sizeof(mmio_mem)) ||
 	    mmio.read<Test_mmio::Reg::Invalid_bit>() != 0)
-	{ return test_failed(6); }
+	{ return test_failed(__LINE__); }
 
-	/**
-	 * Test 7, read/write bitarea that exceeds regrange
-	 */
+	/* read/write bitarea that exceeds regrange */
 	mmio.write<Test_mmio::Reg::Invalid_area>(0xff);
-
 	static uint8_t mmio_cmpr_7[MMIO_SIZE] = {0,0,0,0,0b11001010,0,0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_7, sizeof(mmio_mem)) ||
 	    mmio.read<Test_mmio::Reg::Invalid_area>() != 0b11)
-	{ return test_failed(7); }
+	{ return test_failed(__LINE__); }
 
-	/**
-	 * Test 8, read/write bitarea that overlaps other bitfields
-	 */
+	/* read/write bitarea that overlaps other bitfields */
 	mmio.write<Test_mmio::Reg::Overlapping_area>(0b00110011);
-
 	static uint8_t mmio_cmpr_8[MMIO_SIZE] = {0,0,0,0,0b11110011,0,0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_8, sizeof(mmio_mem)) ||
 	    mmio.read<Test_mmio::Reg::Overlapping_area>() != 0b110011)
-	{ return test_failed(8); }
+	{ return test_failed(__LINE__); }
 
 
 	/******************************
 	 ** 'Genode::Register' tests **
 	 ******************************/
 
-	/**
-	 * Test 9, read/write bitfields appropriately, overflowing and out of range
-	 */
+	/* overflowing and out of range */
 	Cpu_state::access_t state = Cpu_state::read();
 	Cpu_state::Mode::set(state, Cpu_state::Mode::MONITOR);
 	Cpu_state::A::set(state, 1);
@@ -307,7 +280,6 @@ int main()
 	Cpu_state::Invalid_bit::set(state, 0xdddd);
 	Cpu_state::Invalid_area::set(state, 0xdddd);
 	Cpu_state::write(state);
-
 	state = Cpu_state::read();
 	if (cpu_state != 0b1101010101001010
 	    || Cpu_state::Mode::get(state)         != Cpu_state::Mode::MONITOR
@@ -317,36 +289,30 @@ int main()
 	    || Cpu_state::Irq::get(state)          != 0b101
 	    || Cpu_state::Invalid_bit::get(state)  != 0
 	    || Cpu_state::Invalid_area::get(state) != 1)
-	{ return test_failed(9); }
+	{ return test_failed(__LINE__); }
 
-	/**
-	 * Test 10, clear bitfields
-	 */
+	/* clear bitfields */
 	Cpu_state::B::clear(state);
 	Cpu_state::Irq::clear(state);
 	Cpu_state::write(state);
-
 	state = Cpu_state::read();
 	if (cpu_state != 0b1000010001001010
 	    || Cpu_state::B::get(state)   != 0
 	    || Cpu_state::Irq::get(state) != 0)
-	{ return test_failed(10); }
+	{ return test_failed(__LINE__); }
 
 
 	/******************************************
 	 ** 'Genode::Mmio::Register_array' tests **
 	 ******************************************/
 
-	/**
-	 * Test 11, read/write register array items with array- and item overflows
-	 */
+	/* read/write register array items with array- and item overflows */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	mmio.write<Test_mmio::Array>(0xa,  0);
 	mmio.write<Test_mmio::Array>(0xb,  4);
 	mmio.write<Test_mmio::Array>(0xc,  5);
 	mmio.write<Test_mmio::Array>(0xdd, 9);
 	mmio.write<Test_mmio::Array>(0xff, 11);
-
 	static uint8_t mmio_cmpr_11[MMIO_SIZE] = {0,0,0x0a,0,0xcb,0,0xd0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_11, sizeof(mmio_mem)) ||
 	    mmio.read<Test_mmio::Array>(0) != 0xa ||
@@ -354,12 +320,9 @@ int main()
 	    mmio.read<Test_mmio::Array>(5) != 0xc ||
 	    mmio.read<Test_mmio::Array>(9) != 0xd ||
 	    mmio.read<Test_mmio::Array>(11) !=  0 )
-	{ return test_failed(11); }
+	{ return test_failed(__LINE__); }
 
-	/**
-	 * Test 12, read/write bitfields of register array items with array-, item- and bitfield overflows
-	 *          also test overlappng bitfields
-	 */
+	/* item- and bitfield overflows - also test overlapping bitfields */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	mmio.write<Test_mmio::Array::A>(0x1, 0);
 	mmio.write<Test_mmio::Array::B>(0x2, 0);
@@ -371,7 +334,6 @@ int main()
 	mmio.write<Test_mmio::Array::C>(0x1, 8);
 	mmio.write<Test_mmio::Array::D>(0x3, 8);
 	mmio.write<Test_mmio::Array::A>(0xf, 11);
-
 	static uint8_t mmio_cmpr_12[MMIO_SIZE] = {0,0,0b00110101,0,0b10100101,0,0b00000110,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_12, sizeof(mmio_mem)) ||
 		mmio.read<Test_mmio::Array::A>(0)  != 0x1 ||
@@ -384,22 +346,18 @@ int main()
 		mmio.read<Test_mmio::Array::C>(8)  != 0x0 ||
 		mmio.read<Test_mmio::Array::D>(8)  != 0x3 ||
 		mmio.read<Test_mmio::Array::A>(11) != 0   )
-	{ return test_failed(12); }
+	{ return test_failed(__LINE__); }
 
-	/**
-	 * Test 13, writing to registers with 'STRICT_WRITE' set
-	 */
+	/* writing to registers with 'STRICT_WRITE' set */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	*(uint8_t*)((addr_t)mmio_mem + sizeof(uint32_t)) = 0xaa;
 	mmio.write<Test_mmio::Strict_reg::A>(0xff);
 	mmio.write<Test_mmio::Strict_reg::B>(0xff);
 	static uint8_t mmio_cmpr_13[MMIO_SIZE] = {0,0,0,0b11000000,0b10101010,0,0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_13, sizeof(mmio_mem))) {
-		return test_failed(13); }
+		return test_failed(__LINE__); }
 
-	/**
-	 * Test 14, writing to register array items with 'STRICT_WRITE' set
-	 */
+	/* writing to register array items with 'STRICT_WRITE' set */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	*(uint8_t*)((addr_t)mmio_mem + sizeof(uint16_t)) = 0xaa;
 	mmio.write<Test_mmio::Strict_array>(0b1010, 0);
@@ -409,22 +367,18 @@ int main()
 	mmio.write<Test_mmio::Strict_array>(0b110011, 3);
 	static uint8_t mmio_cmpr_14[MMIO_SIZE] = {0,0b00110000,0b10101010,0,0,0,0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_14, sizeof(mmio_mem))) {
-		return test_failed(14); }
+		return test_failed(__LINE__); }
 
-	/**
-	 * Test 15, writing to register array bitfields with 'STRICT_WRITE' set
-	 */
+	/* writing to register array bitfields with 'STRICT_WRITE' set */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	*(uint8_t*)((addr_t)mmio_mem + sizeof(uint16_t)) = 0xaa;
 	mmio.write<Test_mmio::Strict_array::A>(0xff, 3);
 	mmio.write<Test_mmio::Strict_array::B>(0xff, 3);
 	static uint8_t mmio_cmpr_15[MMIO_SIZE] = {0,0b11000000,0b10101010,0,0,0,0,0};
 	if (compare_mem(mmio_mem, mmio_cmpr_15, sizeof(mmio_mem))) {
-		return test_failed(15); }
+		return test_failed(__LINE__); }
 
-	/**
-	 * Test 16, writing to simple register array
-	 */
+	/* writing to simple register array */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	*(uint8_t*)((addr_t)mmio_mem + sizeof(uint16_t)) = 0xaa;
 	mmio.write<Test_mmio::Simple_array_1>(0x12345678, 0);
@@ -434,55 +388,47 @@ int main()
 	mmio.write<Test_mmio::Simple_array_2>(0xabcd, 2);
 	static uint8_t mmio_cmpr_16[MMIO_SIZE] = {0x78,0x56,0xdc,0xfe,0x21,0x43,0xcd,0xab};
 	if (compare_mem(mmio_mem, mmio_cmpr_16, sizeof(mmio_mem))) {
-		return test_failed(16); }
+		return test_failed(__LINE__); }
 
-	/**
-	 * Test 17, write and read a bitset with 2 parts
-	 */
+	/* write and read a bitset with 2 parts */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	mmio.write<Test_mmio::My_bitset_2>(0x1234);
 	static uint8_t mmio_cmpr_17[MMIO_SIZE] = {0x00,0x46,0x08,0x00,0x00,0x00,0x00,0x00};
 	if (compare_mem(mmio_mem, mmio_cmpr_17, sizeof(mmio_mem)))
-		return test_failed(17);
+		return test_failed(__LINE__);
 	if (mmio.read<Test_mmio::My_bitset_2>() != 0x234)
-		return test_failed(17);
+		return test_failed(__LINE__);
 
-	/**
-	 * Test 18, write and read a bitset with 3 parts
-	 */
+	/* write and read a bitset with 3 parts */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	mmio.write<Test_mmio::My_bitset_3>(0x12345678);
 	static uint8_t mmio_cmpr_18[MMIO_SIZE] = {0x00,0x78,0x00,0x00,0x30,0x00,0xac,0x08};
 	if (compare_mem(mmio_mem, mmio_cmpr_18, sizeof(mmio_mem)))
-		return test_failed(18);
+		return test_failed(__LINE__);
 	if (mmio.read<Test_mmio::My_bitset_3>() != 0x345678)
-		return test_failed(18);
+		return test_failed(__LINE__);
 
-	/**
-	 * Test 19, write and read a nested bitset
-	 */
+	/* write and read a nested bitset */
 	zero_mem(mmio_mem, sizeof(mmio_mem));
 	mmio.write<Test_mmio::My_bitset_4>(0x5679);
 	static uint8_t mmio_cmpr_19[MMIO_SIZE] = {0x00,0xcf,0x02,0x00,0xa0,0x00,0x00,0x00};
 	if (compare_mem(mmio_mem, mmio_cmpr_19, sizeof(mmio_mem)))
-		return test_failed(19);
+		return test_failed(__LINE__);
 	if (mmio.read<Test_mmio::My_bitset_4>() != 0x5679)
-		return test_failed(19);
+		return test_failed(__LINE__);
 
-	/**
-	 * Test 20, bitfield methods at bitsets
-	 */
+	/* bitfield methods at bitsets */
 	Test_mmio::Reg_1::access_t bs5 =
 		Test_mmio::My_bitset_5::bits(0b1011110010110);
 	if (bs5 != 0b1100000010001010) {
-		return test_failed(20);
+		return test_failed(__LINE__);
 	}
 	if (Test_mmio::My_bitset_5::get(bs5) != 0b110010110) {
-		return test_failed(20);
+		return test_failed(__LINE__);
 	}
 	Test_mmio::My_bitset_5::set(bs5, 0b1011101101001);
 	if (bs5 != 0b1011000001000100) {
-		return test_failed(20);
+		return test_failed(__LINE__);
 	}
 
 	printf("Test done\n");