ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-04-12 13:48:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

util_mmio: replace test_failed by error

Browse Source 
ref #1095
This commit is contained in:
Martin Stein 2014-03-13 13:35:30 +01:00 committed by Norman Feske
parent db8957562f
commit 76668f0774
1 changed files with 34 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
base/src/test/util_mmio/main.cc
View File

@ -192,14 +192,12 @@ int compare_mem(uint8_t * base1, uint8_t * base2, size_t size)
/**
* End a failed test
*/
int test_failed(unsigned line)
void error(unsigned line)
{
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);
printf("Test done\n");
return -1;
}
@ -220,7 +218,7 @@ int main()
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(__LINE__); }
{ error(__LINE__); }
/* read/write bit appropriately */
zero_mem(mmio_mem, sizeof(mmio_mem));
@ -228,7 +226,7 @@ int main()
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(__LINE__); }
{ error(__LINE__); }
/* read/write bit overflowing */
mmio.write<Test_mmio::Reg::Bit_2>(0xff);
@ -236,14 +234,14 @@ int main()
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(__LINE__); }
{ error(__LINE__); }
/* 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(__LINE__); }
{ error(__LINE__); }
/* read/write bitarea overflowing */
zero_mem(mmio_mem, sizeof(mmio_mem));
@ -251,27 +249,27 @@ int main()
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(__LINE__); }
{ error(__LINE__); }
/* 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(__LINE__); }
{ error(__LINE__); }
/* 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(__LINE__); }
{ error(__LINE__); }
/* 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(__LINE__); }
{ error(__LINE__); }
/******************************
@ -297,7 +295,7 @@ 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(__LINE__); }
{ error(__LINE__); }
/* clear bitfields */
Cpu_state::B::clear(state);
@ -307,7 +305,7 @@ int main()
if (cpu_state != 0b1000010001001010
|| Cpu_state::B::get(state) != 0
|| Cpu_state::Irq::get(state) != 0)
{ return test_failed(__LINE__); }
{ error(__LINE__); }
/******************************************
@ -328,7 +326,7 @@ 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(__LINE__); }
{ error(__LINE__); }
/* item- and bitfield overflows - also test overlapping bitfields */
zero_mem(mmio_mem, sizeof(mmio_mem));
@ -354,7 +352,7 @@ 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(__LINE__); }
{ error(__LINE__); }
/* writing to registers with 'STRICT_WRITE' set */
zero_mem(mmio_mem, sizeof(mmio_mem));
@ -363,7 +361,7 @@ int main()
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(__LINE__); }
error(__LINE__); }
/* writing to register array items with 'STRICT_WRITE' set */
zero_mem(mmio_mem, sizeof(mmio_mem));
@ -375,7 +373,7 @@ 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(__LINE__); }
error(__LINE__); }
/* writing to register array bitfields with 'STRICT_WRITE' set */
zero_mem(mmio_mem, sizeof(mmio_mem));
@ -384,7 +382,7 @@ int main()
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(__LINE__); }
error(__LINE__); }
/* writing to simple register array */
zero_mem(mmio_mem, sizeof(mmio_mem));
@ -396,47 +394,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(__LINE__); }
error(__LINE__); }
/* 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(__LINE__);
error(__LINE__);
if (mmio.read<Test_mmio::My_bitset_2>() != 0x234)
return test_failed(__LINE__);
error(__LINE__);
/* 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(__LINE__);
error(__LINE__);
if (mmio.read<Test_mmio::My_bitset_3>() != 0x345678)
return test_failed(__LINE__);
error(__LINE__);
/* 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(__LINE__);
error(__LINE__);
if (mmio.read<Test_mmio::My_bitset_4>() != 0x5679)
return test_failed(__LINE__);
error(__LINE__);
/* bitfield methods at bitsets */
Test_mmio::Reg_1::access_t bs5 =
Test_mmio::My_bitset_5::bits(0b1011110010110);
if (bs5 != 0b1100000010001010) {
return test_failed(__LINE__);
error(__LINE__);
}
if (Test_mmio::My_bitset_5::get(bs5) != 0b110010110) {
return test_failed(__LINE__);
error(__LINE__);
}
Test_mmio::My_bitset_5::set(bs5, 0b1011101101001);
if (bs5 != 0b1011000001000100) {
return test_failed(__LINE__);
error(__LINE__);
}
/**********************************
@ -450,8 +448,8 @@ int main()
0xef, 0xcd, 0xab, 0x89, 0x67, 0x45, 0x23, 0x01 };
zero_mem(mmio_mem, MMIO_SIZE);
mmio.write<Reg>(REG);
if (mmio.read<Reg>() != REG) { return test_failed(__LINE__); }
if (compare_mem(mmio_mem, cmp_mem, MMIO_SIZE)) { return test_failed(__LINE__); }
if (mmio.read<Reg>() != REG) { error(__LINE__); }
if (compare_mem(mmio_mem, cmp_mem, MMIO_SIZE)) { error(__LINE__); }
/* bitfields in a register */
enum {
@ -459,18 +457,18 @@ int main()
BITS_1 = 0x56789,
BITS_2 = 0x4,
BITS_3 = 0xabcdef,
BITS_TRASH = 0xf000000
BITS_TRASH = 0xf000000,
};
zero_mem(mmio_mem, MMIO_SIZE);
mmio.write<Reg::Bits_0>(BITS_0 | BITS_TRASH);
mmio.write<Reg::Bits_1>(BITS_1 | BITS_TRASH);
mmio.write<Reg::Bits_2>(BITS_2 | BITS_TRASH);
mmio.write<Reg::Bits_3>(BITS_3 | BITS_TRASH);
if (mmio.read<Reg::Bits_0>() != BITS_0) { return test_failed(__LINE__); }
if (mmio.read<Reg::Bits_1>() != BITS_1) { return test_failed(__LINE__); }
if (mmio.read<Reg::Bits_2>() != BITS_2) { return test_failed(__LINE__); }
if (mmio.read<Reg::Bits_3>() != BITS_3) { return test_failed(__LINE__); }
if (compare_mem(mmio_mem, cmp_mem, MMIO_SIZE)) { return test_failed(__LINE__); }
if (mmio.read<Reg::Bits_0>() != BITS_0) { error(__LINE__); }
if (mmio.read<Reg::Bits_1>() != BITS_1) { error(__LINE__); }
if (mmio.read<Reg::Bits_2>() != BITS_2) { error(__LINE__); }
if (mmio.read<Reg::Bits_3>() != BITS_3) { error(__LINE__); }
if (compare_mem(mmio_mem, cmp_mem, MMIO_SIZE)) { error(__LINE__); }
}
printf("Test done\n");