diff --git a/tools/unit-tests/unit-common.c b/tools/unit-tests/unit-common.c index c8b21e97..0224ab55 100644 --- a/tools/unit-tests/unit-common.c +++ b/tools/unit-tests/unit-common.c @@ -94,12 +94,12 @@ int ext_flash_erase(uintptr_t address, int len) { void ext_flash_unlock(void) { - fail_unless(elocked, "Double ext unlock detected\n"); + ck_assert_msg(elocked, "Double ext unlock detected\n"); elocked--; } void ext_flash_lock(void) { - fail_if(elocked, "Double ext lock detected\n"); + ck_assert_msg(!elocked, "Double ext lock detected\n"); elocked++; } diff --git a/tools/unit-tests/unit-enc-nvm.c b/tools/unit-tests/unit-enc-nvm.c index 1c1562c7..d5e361a6 100644 --- a/tools/unit-tests/unit-enc-nvm.c +++ b/tools/unit-tests/unit-enc-nvm.c @@ -57,53 +57,53 @@ START_TEST (test_nvm_update_with_encryption) ret = mmap_file("/tmp/wolfboot-unit-file.bin", (void *)MOCK_ADDRESS, WOLFBOOT_PARTITION_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); #ifdef FLAGS_HOME ret = mmap_file("/tmp/wolfboot-unit-int-file.bin", (void *)MOCK_ADDRESS_BOOT, WOLFBOOT_PARTITION_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); part = PART_BOOT; base_addr = WOLFBOOT_PARTITION_BOOT_ADDRESS; home_off = PART_BOOT_ENDFLAGS - PART_UPDATE_ENDFLAGS; #endif ret = mmap_file("/tmp/wolfboot-unit-swap.bin", (void *)MOCK_ADDRESS_SWAP, WOLFBOOT_SECTOR_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); /* Sanity */ - fail_if(home_off > WOLFBOOT_SECTOR_SIZE); + ck_assert(home_off <= WOLFBOOT_SECTOR_SIZE); /* unlock the flash to allow operations */ hal_flash_unlock(); /* Check swap erase */ wolfBoot_erase_partition(PART_SWAP); - fail_if(erased_swap != 1); + ck_assert(erased_swap == 1); for (i = 0; i < WOLFBOOT_SECTOR_SIZE; i+=4) { uint32_t *word = ((uint32_t *)((uintptr_t)WOLFBOOT_PARTITION_SWAP_ADDRESS + i)); - fail_if(*word != 0xFFFFFFFF); + ck_assert(*word == 0xFFFFFFFF); } erased_update = 0; wolfBoot_erase_partition(part); #ifndef FLAGS_HOME - fail_if(erased_update != 1); + ck_assert(erased_update == 1); #else - fail_if(erased_boot != 1); + ck_assert(erased_boot == 1); #endif /* Erased flag sectors: select '0' by default */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select default fresh sector\n"); + ck_assert_msg(ret == 0, "Failed to select default fresh sector\n"); /* Force a good 'magic' at the end of sector 1 by setting the magic word */ wolfBoot_set_partition_state(PART_UPDATE, IMG_STATE_NEW); magic = get_partition_magic(PART_UPDATE); - fail_if(*magic != *boot_word, + ck_assert_msg(*magic == *boot_word, "Failed to read back 'BOOT' trailer at the end of the partition"); /* Current selected should now be 1 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select good fresh sector\n"); + ck_assert_msg(ret == 1, "Failed to select good fresh sector\n"); erased_nvm_bank1 = 0; erased_nvm_bank0 = 0; @@ -113,37 +113,37 @@ START_TEST (test_nvm_update_with_encryption) /* Current selected should now be 0 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank1 > 0, "Did not erase the non-selected bank"); erased_nvm_bank1 = 0; erased_nvm_bank0 = 0; /* Check state is read back correctly */ ret = wolfBoot_get_partition_state(PART_UPDATE, &st); - fail_if(ret != 0, "Failed to read back state\n"); - fail_if(st != IMG_STATE_UPDATING, "Bootloader in the wrong state\n"); + ck_assert_msg(ret == 0, "Failed to read back state\n"); + ck_assert_msg(st == IMG_STATE_UPDATING, "Bootloader in the wrong state\n"); /* Check that reading did not change the current sector */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select right sector after reading\n"); + ck_assert_msg(ret == 0, "Failed to select right sector after reading\n"); /* Update one sector flag, it should change nvm sector */ wolfBoot_set_update_sector_flag(0, SECT_FLAG_SWAPPING); /* Current selected should now be 1 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank0 != 0, "Did not erase the non-selected bank"); /* Check sector state is read back correctly */ ret = wolfBoot_get_update_sector_flag(0, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); /* Check that reading did not change the current sector (1) */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select right sector after reading sector state\n"); + ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n"); /* Update sector flag, again. it should change nvm sector */ erased_nvm_bank1 = 0; @@ -152,17 +152,17 @@ START_TEST (test_nvm_update_with_encryption) /* Current selected should now be 0 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank1 != 0, "Did not erase the non-selected bank"); /* Check sector state is read back correctly */ ret = wolfBoot_get_update_sector_flag(0, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n"); /* Check that reading did not change the current sector (0) */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select right sector after reading sector state\n"); + ck_assert_msg(ret == 0, "Failed to select right sector after reading sector state\n"); /* Update sector flag, again. it should change nvm sector */ erased_nvm_bank1 = 0; @@ -171,17 +171,17 @@ START_TEST (test_nvm_update_with_encryption) /* Current selected should now be 1 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank0 > 0, "Did not erase the non-selected bank"); /* Check sector state is read back correctly */ ret = wolfBoot_get_update_sector_flag(1, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); /* Check that reading did not change the current sector (1) */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select right sector after reading sector state\n"); + ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n"); /* Update sector flag, again. it should change nvm sector */ erased_nvm_bank1 = 0; @@ -202,7 +202,7 @@ START_TEST (test_nvm_update_with_encryption) /* This should fall back to 1 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select most recent sector after deleting flags\n"); + ck_assert_msg(ret == 1, "Failed to select most recent sector after deleting flags\n"); /* Start over, update some sector flags */ wolfBoot_erase_partition(PART_UPDATE); @@ -216,23 +216,23 @@ START_TEST (test_nvm_update_with_encryption) /* Current selected should now be 1 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank0 > 0, "Did not erase the non-selected bank"); /* Check sector state is read back correctly */ for (i = 0; i < 4; i++) { ret = wolfBoot_get_update_sector_flag(i, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n"); } ret = wolfBoot_get_update_sector_flag(4, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); /* Check that reading did not change the current sector (1) */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select right sector after reading sector state\n"); + ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n"); /* Copy flags from 1 to 0 */ src = (uint8_t *)((uintptr_t)base_addr + WOLFBOOT_PARTITION_SIZE - (2 * WOLFBOOT_SECTOR_SIZE)); @@ -247,12 +247,12 @@ START_TEST (test_nvm_update_with_encryption) /* Check if still there */ ret = wolfBoot_get_update_sector_flag(4, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n"); /* This should fall back to 0 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select most recent sector after deleting flags\n"); + ck_assert_msg(ret == 0, "Failed to select most recent sector after deleting flags\n"); /* Erase partition and start over */ @@ -260,13 +260,13 @@ START_TEST (test_nvm_update_with_encryption) erased_boot = 0; wolfBoot_erase_partition(part); #ifndef FLAGS_HOME - fail_if(erased_update != 1); + ck_assert(erased_update == 1); #else - fail_if(erased_boot != 1); + ck_assert(erased_boot == 1); #endif ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select right sector after reading sector state\n"); + ck_assert_msg(ret == 0, "Failed to select right sector after reading sector state\n"); /* re-lock the flash: update_trigger implies unlocking/locking */ hal_flash_lock(); @@ -276,15 +276,15 @@ START_TEST (test_nvm_update_with_encryption) /* Current selected should now be 0 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank1 != 0, "Did not erase the non-selected bank"); magic = get_partition_magic(PART_UPDATE); - fail_if(*magic != *boot_word, + ck_assert_msg(*magic == *boot_word, "Failed to read back 'BOOT' trailer at the end of the partition"); /* Sanity check at the end of the operations. */ - fail_unless(locked, "The FLASH was left unlocked.\n"); + ck_assert_msg(locked, "The FLASH was left unlocked.\n"); } diff --git a/tools/unit-tests/unit-extflash.c b/tools/unit-tests/unit-extflash.c index 627e2400..d698b344 100644 --- a/tools/unit-tests/unit-extflash.c +++ b/tools/unit-tests/unit-extflash.c @@ -75,12 +75,12 @@ int hal_flash_erase(haladdr_t address, int len) } void hal_flash_unlock(void) { - fail_unless(locked, "Double unlock detected\n"); + ck_assert_msg(locked, "Double unlock detected\n"); locked--; } void hal_flash_lock(void) { - fail_if(locked, "Double lock detected\n"); + ck_assert_msg(!locked, "Double lock detected\n"); locked++; } diff --git a/tools/unit-tests/unit-mock-flash.c b/tools/unit-tests/unit-mock-flash.c index c6b072ee..54963088 100644 --- a/tools/unit-tests/unit-mock-flash.c +++ b/tools/unit-tests/unit-mock-flash.c @@ -42,7 +42,7 @@ int hal_flash_write(haladdr_t address, const uint8_t *data, int len) { int i; uint8_t *a = (uint8_t *)(uintptr_t)address; - fail_if(locked, "Attempting to write to a locked FLASH"); + ck_assert_msg(!locked, "Attempting to write to a locked FLASH"); if ((address >= WOLFBOOT_PARTITION_SWAP_ADDRESS) && (address < WOLFBOOT_PARTITION_UPDATE_ADDRESS + WOLFBOOT_SECTOR_SIZE)) { for (i = 0; i < len; i++) { @@ -72,7 +72,7 @@ int hal_flash_write(haladdr_t address, const uint8_t *data, int len) } int hal_flash_erase(haladdr_t address, int len) { - fail_if(locked, "Attempting to erase a locked FLASH"); + ck_assert_msg(!locked, "Attempting to erase a locked FLASH"); if ((address >= WOLFBOOT_PARTITION_BOOT_ADDRESS) && (address < WOLFBOOT_PARTITION_BOOT_ADDRESS + WOLFBOOT_PARTITION_SIZE)) { erased_boot++; @@ -109,12 +109,12 @@ int hal_flash_erase(haladdr_t address, int len) } void hal_flash_unlock(void) { - fail_unless(locked, "Double unlock detected\n"); + ck_assert_msg(locked, "Double unlock detected\n"); locked--; } void hal_flash_lock(void) { - fail_if(locked, "Double lock detected\n"); + ck_assert_msg(!locked, "Double lock detected\n"); locked++; } @@ -160,7 +160,7 @@ int ext_flash_write(uintptr_t address, const uint8_t *data, int len) { int i; uint8_t *a = (uint8_t *)address; - fail_if(ext_locked, "Attempting to write to a locked FLASH"); + ck_assert_msg(!ext_locked, "Attempting to write to a locked FLASH"); for (i = 0; i < len; i++) { a[i] = data[i]; } @@ -179,12 +179,12 @@ int ext_flash_read(uintptr_t address, uint8_t *data, int len) void ext_flash_unlock(void) { - fail_unless(ext_locked, "Double ext unlock detected\n"); + ck_assert_msg(ext_locked, "Double ext unlock detected\n"); ext_locked--; } void ext_flash_lock(void) { - fail_if(ext_locked, "Double ext lock detected\n"); + ck_assert_msg(!ext_locked, "Double ext lock detected\n"); ext_locked++; } diff --git a/tools/unit-tests/unit-mock-state.c b/tools/unit-tests/unit-mock-state.c index df26910c..4db199a5 100644 --- a/tools/unit-tests/unit-mock-state.c +++ b/tools/unit-tests/unit-mock-state.c @@ -47,6 +47,7 @@ #include #include "user_settings.h" #include "wolfboot/wolfboot.h" + static uint8_t* get_trailer_at(uint8_t part, uint32_t at); static void set_trailer_at(uint8_t part, uint32_t at, uint8_t val); static void set_partition_magic(uint8_t part); @@ -185,12 +186,12 @@ int ext_flash_erase(uintptr_t address, int len) } void ext_flash_unlock(void) { - fail_unless(ext_locked, "Double unlock detected (ext)\n"); + ck_assert_msg(ext_locked, "Double unlock detected (ext)\n"); ext_locked--; } void ext_flash_lock(void) { - fail_if(ext_locked, "Double lock detected(ext)\n"); + ck_assert_msg(!ext_locked, "Double lock detected(ext)\n"); ext_locked++; } diff --git a/tools/unit-tests/unit-nvm.c b/tools/unit-tests/unit-nvm.c index ce1c07aa..774dc642 100644 --- a/tools/unit-tests/unit-nvm.c +++ b/tools/unit-tests/unit-nvm.c @@ -54,53 +54,53 @@ START_TEST (test_nvm_select_fresh_sector) ret = mmap_file("/tmp/wolfboot-unit-file.bin", (void *)MOCK_ADDRESS, WOLFBOOT_PARTITION_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); #ifdef FLAGS_HOME ret = mmap_file("/tmp/wolfboot-unit-int-file.bin", (void *)MOCK_ADDRESS_BOOT, WOLFBOOT_PARTITION_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); part = PART_BOOT; base_addr = WOLFBOOT_PARTITION_BOOT_ADDRESS; home_off = PART_BOOT_ENDFLAGS - PART_UPDATE_ENDFLAGS; #endif ret = mmap_file("/tmp/wolfboot-unit-swap.bin", (void *)MOCK_ADDRESS_SWAP, WOLFBOOT_SECTOR_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); /* Sanity */ - fail_if(home_off > WOLFBOOT_SECTOR_SIZE); + ck_assert(home_off <= WOLFBOOT_SECTOR_SIZE); /* unlock the flash to allow operations */ hal_flash_unlock(); /* Check swap erase */ wolfBoot_erase_partition(PART_SWAP); - fail_if(erased_swap != 1); + ck_assert(erased_swap == 1); for (i = 0; i < WOLFBOOT_SECTOR_SIZE; i+=4) { uint32_t *word = ((uint32_t *)((uintptr_t)WOLFBOOT_PARTITION_SWAP_ADDRESS + i)); - fail_if(*word != 0xFFFFFFFF); + ck_assert(*word == 0xFFFFFFFF); } erased_update = 0; wolfBoot_erase_partition(part); #ifndef FLAGS_HOME - fail_if(erased_update != 1); + ck_assert(erased_update == 1); #else - fail_if(erased_boot != 1); + ck_assert(erased_boot == 1); #endif /* Erased flag sectors: select '0' by default */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select default fresh sector\n"); + ck_assert_msg(ret == 0, "Failed to select default fresh sector\n"); /* Force a good 'magic' at the end of sector 1 by setting the magic word */ wolfBoot_set_partition_state(PART_UPDATE, IMG_STATE_NEW); magic = get_partition_magic(PART_UPDATE); - fail_if(*magic != *boot_word, + ck_assert_msg(*magic == *boot_word, "Failed to read back 'BOOT' trailer at the end of the partition"); /* Current selected should now be 1 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select good fresh sector\n"); + ck_assert_msg(ret == 1, "Failed to select good fresh sector\n"); erased_nvm_bank1 = 0; erased_nvm_bank0 = 0; @@ -110,37 +110,37 @@ START_TEST (test_nvm_select_fresh_sector) /* Current selected should now be 0 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank1 > 0, "Did not erase the non-selected bank"); erased_nvm_bank1 = 0; erased_nvm_bank0 = 0; /* Check state is read back correctly */ ret = wolfBoot_get_partition_state(PART_UPDATE, &st); - fail_if(ret != 0, "Failed to read back state\n"); - fail_if(st != IMG_STATE_UPDATING, "Bootloader in the wrong state\n"); + ck_assert_msg(ret == 0, "Failed to read back state\n"); + ck_assert_msg(st == IMG_STATE_UPDATING, "Bootloader in the wrong state\n"); /* Check that reading did not change the current sector */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select right sector after reading\n"); + ck_assert_msg(ret == 0, "Failed to select right sector after reading\n"); /* Update one sector flag, it should change nvm sector */ wolfBoot_set_update_sector_flag(0, SECT_FLAG_SWAPPING); /* Current selected should now be 1 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank0 > 0, "Did not erase the non-selected bank"); /* Check sector state is read back correctly */ ret = wolfBoot_get_update_sector_flag(0, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); /* Check that reading did not change the current sector (1) */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select right sector after reading sector state\n"); + ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n"); /* Update sector flag, again. it should change nvm sector */ erased_nvm_bank1 = 0; @@ -149,17 +149,17 @@ START_TEST (test_nvm_select_fresh_sector) /* Current selected should now be 0 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank1 > 0, "Did not erase the non-selected bank"); /* Check sector state is read back correctly */ ret = wolfBoot_get_update_sector_flag(0, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n"); /* Check that reading did not change the current sector (0) */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select right sector after reading sector state\n"); + ck_assert_msg(ret == 0, "Failed to select right sector after reading sector state\n"); /* Update sector flag, again. it should change nvm sector */ erased_nvm_bank1 = 0; @@ -168,17 +168,17 @@ START_TEST (test_nvm_select_fresh_sector) /* Current selected should now be 1 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank0 > 0, "Did not erase the non-selected bank"); /* Check sector state is read back correctly */ ret = wolfBoot_get_update_sector_flag(1, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); /* Check that reading did not change the current sector (1) */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select right sector after reading sector state\n"); + ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n"); /* Update sector flag, again. it should change nvm sector */ erased_nvm_bank1 = 0; @@ -198,7 +198,7 @@ START_TEST (test_nvm_select_fresh_sector) /* This should fall back to 1 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select most recent sector after deleting flags\n"); + ck_assert_msg(ret == 1, "Failed to select most recent sector after deleting flags\n"); /* Start over, update some sector flags */ wolfBoot_erase_partition(PART_UPDATE); @@ -212,23 +212,23 @@ START_TEST (test_nvm_select_fresh_sector) /* Current selected should now be 1 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank0 > 0, "Did not erase the non-selected bank"); /* Check sector state is read back correctly */ for (i = 0; i < 4; i++) { ret = wolfBoot_get_update_sector_flag(i, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n"); } ret = wolfBoot_get_update_sector_flag(4, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n"); /* Check that reading did not change the current sector (1) */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 1, "Failed to select right sector after reading sector state\n"); + ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n"); /* Copy flags from 1 to 0 */ src = (uint8_t *)((uintptr_t)base_addr + WOLFBOOT_PARTITION_SIZE - (8 + home_off + WOLFBOOT_SECTOR_SIZE)); @@ -242,12 +242,12 @@ START_TEST (test_nvm_select_fresh_sector) /* Check if still there */ ret = wolfBoot_get_update_sector_flag(4, &st); - fail_if (ret != 0, "Failed to read sector flag state\n"); - fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n"); + ck_assert_msg(ret == 0, "Failed to read sector flag state\n"); + ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n"); /* This should fall back to 0 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select most recent sector after deleting flags\n"); + ck_assert_msg(ret == 0, "Failed to select most recent sector after deleting flags\n"); /* Erase partition and start over */ @@ -255,13 +255,13 @@ START_TEST (test_nvm_select_fresh_sector) erased_boot = 0; wolfBoot_erase_partition(part); #ifndef FLAGS_HOME - fail_if(erased_update != 1); + ck_assert(erased_update == 1); #else - fail_if(erased_boot != 1); + ck_assert(erased_boot == 1); #endif ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select right sector after reading sector state\n"); + ck_assert_msg(ret == 0, "Failed to select right sector after reading sector state\n"); /* re-lock the flash: update_trigger implies unlocking/locking */ hal_flash_lock(); @@ -271,15 +271,15 @@ START_TEST (test_nvm_select_fresh_sector) /* Current selected should now be 0 */ ret = nvm_select_fresh_sector(PART_UPDATE); - fail_if(ret != 0, "Failed to select updating fresh sector\n"); - fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank"); + ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n"); + ck_assert_msg(erased_nvm_bank1 > 0, "Did not erase the non-selected bank"); magic = get_partition_magic(PART_UPDATE); - fail_if(*magic != *boot_word, + ck_assert_msg(*magic == *boot_word, "Failed to read back 'BOOT' trailer at the end of the partition"); /* Sanity check at the end of the operations. */ - fail_unless(locked, "The FLASH was left unlocked.\n"); + ck_assert_msg(locked, "The FLASH was left unlocked.\n"); } diff --git a/tools/unit-tests/unit-parser.c b/tools/unit-tests/unit-parser.c index bd285a11..5532f108 100644 --- a/tools/unit-tests/unit-parser.c +++ b/tools/unit-tests/unit-parser.c @@ -47,12 +47,12 @@ int hal_flash_erase(haladdr_t address, int len) } void hal_flash_unlock(void) { - fail_unless(locked, "Double unlock detected\n"); + ck_assert_msg(locked, "Double unlock detected\n"); locked--; } void hal_flash_lock(void) { - fail_if(locked, "Double lock detected\n"); + ck_assert_msg(!locked, "Double lock detected\n"); locked++; } @@ -181,21 +181,21 @@ START_TEST (test_parser_sunny) int i; /* Check version */ - fail_if(wolfBoot_find_header(test_buffer + 8, HDR_VERSION, &p) != 4, "Parser error: cannot locate version"); - fail_if((p[0] != 0x0d) || (p[1] != 0x0c) || (p[2] != 0x0b) || (p[3] != 0x0a), "Parser error: version doesn't match"); + ck_assert_msg(wolfBoot_find_header(test_buffer + 8, HDR_VERSION, &p) == 4, "Parser error: cannot locate version"); + ck_assert_msg((p[0] == 0x0d) && (p[1] == 0x0c) && (p[2] == 0x0b) && (p[3] == 0x0a), "Parser error: version doesn't match"); /* Check timestamp */ - fail_if(wolfBoot_find_header(test_buffer + 8, HDR_TIMESTAMP, &p) != 8, "Parser error: cannot locate timestamp"); - fail_if((p[0] != 0x07) || (p[1] != 0x06) || (p[2] != 0x05) || (p[3] != 0x04), "Parser error: timestamp doesn't match"); - fail_if((p[4] != 0x03) || (p[5] != 0x02) || (p[6] != 0x01) || (p[7] != 0x00), "Parser error: timestamp doesn't match"); + ck_assert_msg(wolfBoot_find_header(test_buffer + 8, HDR_TIMESTAMP, &p) == 8, "Parser error: cannot locate timestamp"); + ck_assert_msg((p[0] == 0x07) && (p[1] == 0x06) && (p[2] == 0x05) && (p[3] == 0x04), "Parser error: timestamp doesn't match"); + ck_assert_msg((p[4] == 0x03) && (p[5] == 0x02) && (p[6] == 0x01) && (p[7] == 0x00), "Parser error: timestamp doesn't match"); /* Check sha256 field */ - fail_if(wolfBoot_find_header(test_buffer + 8, HDR_SHA256, &p) != 32, "Parser error: cannot locate hash"); + ck_assert_msg(wolfBoot_find_header(test_buffer + 8, HDR_SHA256, &p) == 32, "Parser error: cannot locate hash"); for (i = 0; i < 32; i++) - fail_unless(p[i] == i, "Parser error: hash does not match"); + ck_assert_msg(p[i] == i, "Parser error: hash does not match"); /* Check non-existing field */ - fail_if(wolfBoot_find_header(test_buffer + 8, HDR_SHA3_384, &p) != 0, "Parser error: found a non-existing field"); + ck_assert_msg(wolfBoot_find_header(test_buffer + 8, HDR_SHA3_384, &p) == 0, "Parser error: found a non-existing field"); } END_TEST @@ -211,14 +211,14 @@ START_TEST (test_parser_borders) bad_buff[257] = 0x00; bad_buff[258] = 0x04; bad_buff[259] = 0x00; - fail_if(wolfBoot_find_header(bad_buff + 8, HDR_VERSION, &p) != 0, "Parser error: accessing version field out of bounds"); + ck_assert_msg(wolfBoot_find_header(bad_buff + 8, HDR_VERSION, &p) == 0, "Parser error: accessing version field out of bounds"); /* Single field too large */ bad_buff[8] = 0x02; bad_buff[9] = 0x00; bad_buff[10] = 0xF8; bad_buff[11] = 0x00; - fail_if(wolfBoot_find_header(bad_buff + 8, HDR_VERSION, &p) != 0, "Parser error: accessing version field out of bounds"); + ck_assert_msg(wolfBoot_find_header(bad_buff + 8, HDR_VERSION, &p) == 0, "Parser error: accessing version field out of bounds"); /* Second field too large */ bad_buff[8] = 0x01; @@ -233,11 +233,11 @@ START_TEST (test_parser_borders) bad_buff[17] = 0x00; bad_buff[18] = 0xf0; /** Timestamp field too large **/ bad_buff[19] = 0x00; - fail_if(wolfBoot_find_header(bad_buff + 8, HDR_TIMESTAMP, &p) != 0, "Parser error: accessing version field out of bounds"); + ck_assert_msg(wolfBoot_find_header(bad_buff + 8, HDR_TIMESTAMP, &p) == 0, "Parser error: accessing version field out of bounds"); /* High memory access */ - fail_if(wolfBoot_find_header(((void *)(0 - 0xF8)), HDR_VERSION, &p) != 0); - fail_if(wolfBoot_find_header(((void *)(0 - 0x10)), HDR_VERSION, &p) != 0); + ck_assert(!wolfBoot_find_header(((void *)(0 - 0xF8)), HDR_VERSION, &p) != 0); + ck_assert(!wolfBoot_find_header(((void *)(0 - 0x10)), HDR_VERSION, &p) != 0); } END_TEST @@ -247,15 +247,15 @@ START_TEST (test_parser_blobs) uint32_t ver; uint16_t type; ver = wolfBoot_get_blob_version(test_buffer); - fail_unless(ver == 0x0a0b0c0d, "Parser error: version does not match"); + ck_assert_msg(ver == 0x0a0b0c0d, "Parser error: version does not match"); type = wolfBoot_get_blob_type(test_buffer_with_type); - fail_unless(type == 0xDDEE, "Wrong image type"); + ck_assert_msg(type == 0xDDEE, "Wrong image type"); type = wolfBoot_get_blob_type(test_buffer); - fail_unless(type == 0, "Reading non-existing version: failed to report error"); + ck_assert_msg(type == 0, "Reading non-existing version: failed to report error"); ver = wolfBoot_get_blob_diffbase_version(test_buffer_with_diffbase); - fail_unless(ver == 0x01020304, "Wrong delta base version parsed"); + ck_assert_msg(ver == 0x01020304, "Wrong delta base version parsed"); } END_TEST diff --git a/tools/unit-tests/unit-pkcs11_store.c b/tools/unit-tests/unit-pkcs11_store.c index cdae6348..0dd06686 100644 --- a/tools/unit-tests/unit-pkcs11_store.c +++ b/tools/unit-tests/unit-pkcs11_store.c @@ -89,14 +89,14 @@ START_TEST (test_store_and_load_objs) { readonly = 0; ret = mmap_file("/tmp/wolfboot-unit-keyvault.bin", vault_base, keyvault_size, NULL); - fail_if(ret != 0); + ck_assert(ret == 0); memset(vault_base, 0xEE, keyvault_size); /* Open the vault, create the object */ fprintf(stderr, "Opening the vault\n"); printf("Flash Keyvault: %p\n", vault_base); ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_unless(ret == 0, "Failed to open the vault: %d", ret); - fail_if(store == NULL, "Did not receive a store address"); + ck_assert_msg(ret == 0, "Failed to open the vault: %d", ret); + ck_assert_msg(store != NULL, "Did not receive a store address"); fprintf(stderr, "open successful\n"); /* Test two subsequent writes */ @@ -110,13 +110,13 @@ START_TEST (test_store_and_load_objs) { /* Reopen for reading */ readonly = 1; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_if(ret != 0, "Failed to reopen the vault in read-only mode: %d", ret); + ck_assert_msg(ret == 0, "Failed to reopen the vault in read-only mode: %d", ret); /* Read out the content */ ret = wolfPKCS11_Store_Read(store, secret_rd, 128); - fail_if(ret != strlen(secret1) + strlen(secret2) + 2); - fail_if(strcmp(secret1, secret_rd) != 0); - fail_if(strcmp(secret2, secret_rd + 1 + strlen(secret1)) != 0); + ck_assert(ret == strlen(secret1) + strlen(secret2) + 2); + ck_assert(strcmp(secret1, secret_rd) == 0); + ck_assert(strcmp(secret2, secret_rd + 1 + strlen(secret1)) == 0); wolfPKCS11_Store_Close(store); /* Create a second object with same Ids, different type*/ @@ -125,8 +125,8 @@ START_TEST (test_store_and_load_objs) { fprintf(stderr, "Opening the second vault\n"); printf("Flash Keyvault: %p\n", vault_base); ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_unless(ret == 0, "Failed to open the 2nd vault: %d", ret); - fail_if(store == NULL, "Did not receive a store address for 2nd vault"); + ck_assert_msg(ret == 0, "Failed to open the 2nd vault: %d", ret); + ck_assert_msg(store != NULL, "Did not receive a store address for 2nd vault"); fprintf(stderr, "open 2 successful\n"); ret = wolfPKCS11_Store_Write(store, secret2, strlen(secret2) + 1); wolfPKCS11_Store_Close(store); @@ -134,11 +134,11 @@ START_TEST (test_store_and_load_objs) { /* Reopen for reading */ readonly = 1; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_if(ret != 0, "Failed to reopen the vault in read-only mode: %d", ret); + ck_assert_msg(ret == 0, "Failed to reopen the vault in read-only mode: %d", ret); /* Read out the content */ ret = wolfPKCS11_Store_Read(store, secret_rd, 128); - fail_if(ret != strlen(secret2) + 1); - fail_if(strcmp(secret2, secret_rd) != 0); + ck_assert(ret == strlen(secret2) + 1); + ck_assert(strcmp(secret2, secret_rd) == 0); wolfPKCS11_Store_Close(store); /* Create more similar objects, different secret */ @@ -148,8 +148,8 @@ START_TEST (test_store_and_load_objs) { readonly = 0; fprintf(stderr, "Creating one more vault\n"); ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_unless(ret == 0, "Failed to create vault: %d", ret); - fail_if(store == NULL, "Did not receive a store address for vault"); + ck_assert_msg(ret == 0, "Failed to create vault: %d", ret); + ck_assert_msg(store != NULL, "Did not receive a store address for vault"); fprintf(stderr, "open 2 successful\n"); ret = wolfPKCS11_Store_Write(store, secret1, strlen(secret1) + 1); @@ -158,8 +158,8 @@ START_TEST (test_store_and_load_objs) { readonly = 0; fprintf(stderr, "Creating one more vault\n"); ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_unless(ret == 0, "Failed to create vault: %d", ret); - fail_if(store == NULL, "Did not receive a store address for vault"); + ck_assert_msg(ret == 0, "Failed to create vault: %d", ret); + ck_assert_msg(store != NULL, "Did not receive a store address for vault"); fprintf(stderr, "open 2 successful\n"); ret = wolfPKCS11_Store_Write(store, secret1, strlen(secret1) + 1); wolfPKCS11_Store_Close(store); @@ -169,27 +169,27 @@ START_TEST (test_store_and_load_objs) { id_obj = 12; readonly = 1; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_if(ret != 0, "Failed to reopen the vault in read-only mode: %d", ret); + ck_assert_msg(ret == 0, "Failed to reopen the vault in read-only mode: %d", ret); /* Read out the content */ ret = wolfPKCS11_Store_Read(store, secret_rd, 128); - fail_if(ret != strlen(secret2) + 1); - fail_if(strcmp(secret2, secret_rd) != 0); + ck_assert(ret == strlen(secret2) + 1); + ck_assert(strcmp(secret2, secret_rd) == 0); wolfPKCS11_Store_Close(store); /* Open non-existing vaults */ id_tok = 5; readonly = 1; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_if(ret == 0, "Returned with success with invalid id_tok %d", id_tok); + ck_assert_msg(ret != 0, "Returned with success with invalid id_tok %d", id_tok); id_tok = 2; id_obj = 0; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_if(ret == 0, "Returned with success with invalid id_obj %d", id_obj); + ck_assert_msg(ret != 0, "Returned with success with invalid id_obj %d", id_obj); type = 0xFF; id_tok = 2; id_obj = 23; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_if(ret == 0, "Returned with success with invalid type %d", type); + ck_assert_msg(ret != 0, "Returned with success with invalid type %d", type); /* Test backup recovery for allocation table */ memset(vault_base, 0xEE, WOLFBOOT_SECTOR_SIZE); @@ -198,11 +198,11 @@ START_TEST (test_store_and_load_objs) { id_obj = 12; readonly = 1; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_if(ret != 0, "Failed to reopen the vault recovering from alloc table backup: %d", ret); + ck_assert_msg(ret == 0, "Failed to reopen the vault recovering from alloc table backup: %d", ret); /* Read out the content */ ret = wolfPKCS11_Store_Read(store, secret_rd, 128); - fail_if(ret != strlen(secret2) + 1); - fail_if(strcmp(secret2, secret_rd) != 0); + ck_assert(ret == strlen(secret2) + 1); + ck_assert(strcmp(secret2, secret_rd) == 0); wolfPKCS11_Store_Close(store); /* Test backup recovery for object sector */ @@ -214,11 +214,11 @@ START_TEST (test_store_and_load_objs) { id_obj = 12; readonly = 1; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_if(ret != 0, "Failed to reopen the vault recovering from object sector backup: %d", ret); + ck_assert_msg(ret == 0, "Failed to reopen the vault recovering from object sector backup: %d", ret); /* Read out the content */ ret = wolfPKCS11_Store_Read(store, secret_rd, 128); - fail_if(ret != strlen(secret2) + 1); - fail_if(strcmp(secret2, secret_rd) != 0); + ck_assert(ret == strlen(secret2) + 1); + ck_assert(strcmp(secret2, secret_rd) == 0); wolfPKCS11_Store_Close(store); /* Test with very large payload */ @@ -228,8 +228,8 @@ START_TEST (test_store_and_load_objs) { readonly = 0; fprintf(stderr, "Creating one BIG vault\n"); ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_unless(ret == 0, "Failed to create vault: %d", ret); - fail_if(store == NULL, "Did not receive a store address for vault"); + ck_assert_msg(ret == 0, "Failed to create vault: %d", ret); + ck_assert_msg(store != NULL, "Did not receive a store address for vault"); fprintf(stderr, "open 3.33 successful\n"); ret = wolfPKCS11_Store_Write(store, dante_filler, strlen(dante_filler) + 1); wolfPKCS11_Store_Close(store); @@ -237,19 +237,19 @@ START_TEST (test_store_and_load_objs) { /* Reopen for reading */ readonly = 1; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_if(ret != 0, "Failed to reopen the vault in read-only mode: %d", ret); + ck_assert_msg(ret == 0, "Failed to reopen the vault in read-only mode: %d", ret); /* Read out the content */ memset(secret_rd, 0, KEYVAULT_OBJ_SIZE); ret = wolfPKCS11_Store_Read(store, secret_rd, KEYVAULT_OBJ_SIZE); - fail_if(ret != KEYVAULT_OBJ_SIZE - 8); - fail_if(strncmp(dante_filler, secret_rd, KEYVAULT_OBJ_SIZE - 8) != 0); + ck_assert(ret == KEYVAULT_OBJ_SIZE - 8); + ck_assert(strncmp(dante_filler, secret_rd, KEYVAULT_OBJ_SIZE - 8) == 0); wolfPKCS11_Store_Close(store); /* Reopen for writing, test truncate */ readonly = 0; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_unless(ret == 0, "Failed to create vault: %d", ret); - fail_if(store == NULL, "Did not receive a store address for vault"); + ck_assert_msg(ret == 0, "Failed to create vault: %d", ret); + ck_assert_msg(store != NULL, "Did not receive a store address for vault"); fprintf(stderr, "open 3.33 successful\n"); ret = wolfPKCS11_Store_Write(store, short_string, strlen(short_string) + 1); wolfPKCS11_Store_Close(store); @@ -257,12 +257,12 @@ START_TEST (test_store_and_load_objs) { /* Reopen for reading */ readonly = 1; ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store); - fail_if(ret != 0, "Failed to reopen the vault in read-only mode: %d", ret); + ck_assert_msg(ret == 0, "Failed to reopen the vault in read-only mode: %d", ret); /* Read out the content */ memset(secret_rd, 0, KEYVAULT_OBJ_SIZE); ret = wolfPKCS11_Store_Read(store, secret_rd, KEYVAULT_OBJ_SIZE); - fail_if(ret != strlen(short_string) + 1); - fail_if(strcmp(short_string, secret_rd) != 0); + ck_assert(ret == strlen(short_string) + 1); + ck_assert(strcmp(short_string, secret_rd) == 0); wolfPKCS11_Store_Close(store); } END_TEST diff --git a/tools/unit-tests/unit-sectorflags.c b/tools/unit-tests/unit-sectorflags.c index daaf1f14..d2570879 100644 --- a/tools/unit-tests/unit-sectorflags.c +++ b/tools/unit-tests/unit-sectorflags.c @@ -59,23 +59,23 @@ int hal_flash_erase(uint32_t address, int len) } void hal_flash_unlock(void) { - fail_unless(locked, "Double unlock detected\n"); + ck_assert_msg(locked, "Double unlock detected\n"); locked--; } void hal_flash_lock(void) { - fail_if(locked, "Double lock detected\n"); + ck_assert_msg(!locked, "Double lock detected\n"); locked++; } void ext_flash_unlock(void) { - //fail_unless(ext_locked, "Double unlock detected\n"); + //ck_assert_msg(ext_locked, "Double unlock detected\n"); ext_locked--; } void ext_flash_lock(void) { - //fail_if(ext_locked, "Double lock detected\n"); + //ck_assert_msg(!ext_locked, "Double lock detected\n"); ext_locked++; } diff --git a/tools/unit-tests/unit-update-flash.c b/tools/unit-tests/unit-update-flash.c index 9f63a1f8..c37fa768 100644 --- a/tools/unit-tests/unit-update-flash.c +++ b/tools/unit-tests/unit-update-flash.c @@ -75,13 +75,13 @@ static void prepare_flash(void) int ret; ret = mmap_file("/tmp/wolfboot-unit-ext-file.bin", (void *)MOCK_ADDRESS_UPDATE, WOLFBOOT_PARTITION_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); ret = mmap_file("/tmp/wolfboot-unit-int-file.bin", (void *)MOCK_ADDRESS_BOOT, WOLFBOOT_PARTITION_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); ret = mmap_file("/tmp/wolfboot-unit-swap.bin", (void *)MOCK_ADDRESS_SWAP, WOLFBOOT_SECTOR_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); hal_flash_unlock(); hal_flash_erase(WOLFBOOT_PARTITION_BOOT_ADDRESS, WOLFBOOT_PARTITION_SIZE); hal_flash_erase(WOLFBOOT_PARTITION_UPDATE_ADDRESS, WOLFBOOT_PARTITION_SIZE); @@ -180,8 +180,8 @@ START_TEST (test_empty_panic) reset_mock_stats(); prepare_flash(); wolfBoot_start(); - fail_if(wolfBoot_staged_ok); - fail_unless(wolfBoot_panicked); + ck_assert(!wolfBoot_staged_ok); + ck_assert(wolfBoot_panicked); cleanup_flash(); } @@ -194,9 +194,9 @@ START_TEST (test_sunnyday_noupdate) prepare_flash(); add_payload(PART_BOOT, 1, TEST_SIZE_SMALL); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 1); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 1); cleanup_flash(); } @@ -208,9 +208,9 @@ START_TEST (test_forward_update_samesize_notrigger) { add_payload(PART_BOOT, 1, TEST_SIZE_SMALL); add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 1); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 1); cleanup_flash(); } END_TEST @@ -222,9 +222,9 @@ START_TEST (test_forward_update_samesize) { add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL); wolfBoot_update_trigger(); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 2); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 2); cleanup_flash(); } END_TEST @@ -236,9 +236,9 @@ START_TEST (test_forward_update_tolarger) { add_payload(PART_UPDATE, 2, TEST_SIZE_LARGE); wolfBoot_update_trigger(); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 2); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 2); cleanup_flash(); } END_TEST @@ -250,9 +250,9 @@ START_TEST (test_forward_update_tosmaller) { add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL); wolfBoot_update_trigger(); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 2); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 2); cleanup_flash(); } END_TEST @@ -264,10 +264,10 @@ START_TEST (test_forward_update_sameversion_denied) { add_payload(PART_UPDATE, 1, TEST_SIZE_LARGE); wolfBoot_update_trigger(); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 1); - fail_if(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) != TEST_SIZE_SMALL); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 1); + ck_assert(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) == TEST_SIZE_SMALL); cleanup_flash(); } END_TEST @@ -279,10 +279,10 @@ START_TEST (test_update_oldversion_denied) { add_payload(PART_UPDATE, 1, TEST_SIZE_LARGE); wolfBoot_update_trigger(); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 2); - fail_if(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) != TEST_SIZE_SMALL); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 2); + ck_assert(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) == TEST_SIZE_SMALL); cleanup_flash(); } @@ -297,9 +297,9 @@ START_TEST (test_invalid_update_type) { ext_flash_lock(); wolfBoot_update_trigger(); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 1); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 1); cleanup_flash(); } @@ -316,9 +316,9 @@ START_TEST (test_update_toolarge) { wolfBoot_update_trigger(); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 1); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 1); cleanup_flash(); } @@ -335,9 +335,9 @@ START_TEST (test_invalid_sha) { ext_flash_lock(); wolfBoot_update_trigger(); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 1); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 1); cleanup_flash(); } @@ -354,9 +354,9 @@ START_TEST (test_emergency_rollback) { hal_flash_lock(); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 1); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 1); cleanup_flash(); } @@ -379,9 +379,9 @@ START_TEST (test_emergency_rollback_failure_due_to_bad_update) { ext_flash_lock(); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 2); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 2); cleanup_flash(); } @@ -390,9 +390,9 @@ START_TEST (test_empty_boot_partition_update) { prepare_flash(); add_payload(PART_UPDATE, 5, TEST_SIZE_SMALL); wolfBoot_start(); - fail_if(wolfBoot_panicked); - fail_unless(wolfBoot_staged_ok); - fail_if(wolfBoot_current_firmware_version() != 5); + ck_assert(!wolfBoot_panicked); + ck_assert(wolfBoot_staged_ok); + ck_assert(wolfBoot_current_firmware_version() == 5); cleanup_flash(); } @@ -407,8 +407,8 @@ START_TEST (test_empty_boot_but_update_sha_corrupted_denied) { ext_flash_lock(); wolfBoot_start(); /* We expect to panic */ - fail_unless(wolfBoot_panicked); - fail_if(wolfBoot_staged_ok); + ck_assert(wolfBoot_panicked); + ck_assert(!wolfBoot_staged_ok); cleanup_flash(); } diff --git a/tools/unit-tests/unit-update-ram.c b/tools/unit-tests/unit-update-ram.c index 1414e2ac..8706666e 100644 --- a/tools/unit-tests/unit-update-ram.c +++ b/tools/unit-tests/unit-update-ram.c @@ -95,10 +95,10 @@ static void prepare_flash(void) int ret; ret = mmap_file("/tmp/wolfboot-unit-ext-file.bin", (void *)(uintptr_t)MOCK_ADDRESS_UPDATE, WOLFBOOT_PARTITION_SIZE + IMAGE_HEADER_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); ret = mmap_file("/tmp/wolfboot-unit-int-file.bin", (void *)(uintptr_t)MOCK_ADDRESS_BOOT, WOLFBOOT_PARTITION_SIZE + IMAGE_HEADER_SIZE, NULL); - fail_if(ret < 0); + ck_assert(ret >= 0); ext_flash_unlock(); ext_flash_erase(WOLFBOOT_PARTITION_BOOT_ADDRESS, WOLFBOOT_PARTITION_SIZE + IMAGE_HEADER_SIZE); ext_flash_erase(WOLFBOOT_PARTITION_UPDATE_ADDRESS, WOLFBOOT_PARTITION_SIZE + IMAGE_HEADER_SIZE); @@ -196,7 +196,7 @@ START_TEST (test_empty_panic) reset_mock_stats(); prepare_flash(); wolfBoot_start(); - fail_if(wolfBoot_staged_ok); + ck_assert(!wolfBoot_staged_ok); cleanup_flash(); } @@ -211,8 +211,8 @@ START_TEST (test_sunnyday_noupdate) printf("*** MEM: %p\n", WOLFBOOT_LOAD_ADDRESS); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 1); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 1); cleanup_flash(); } @@ -224,8 +224,8 @@ START_TEST (test_forward_update_samesize_notrigger) { add_payload(PART_BOOT, 1, TEST_SIZE_SMALL); add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 1); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 1); cleanup_flash(); } END_TEST @@ -237,8 +237,8 @@ START_TEST (test_forward_update_samesize) { add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL); wolfBoot_update_trigger(); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 2); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 2); cleanup_flash(); } END_TEST @@ -250,8 +250,8 @@ START_TEST (test_forward_update_tolarger) { add_payload(PART_UPDATE, 2, TEST_SIZE_LARGE); wolfBoot_update_trigger(); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 2); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 2); cleanup_flash(); } END_TEST @@ -263,8 +263,8 @@ START_TEST (test_forward_update_tosmaller) { add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL); wolfBoot_update_trigger(); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 2); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 2); cleanup_flash(); } END_TEST @@ -276,9 +276,9 @@ START_TEST (test_forward_update_sameversion_denied) { add_payload(PART_UPDATE, 1, TEST_SIZE_LARGE); wolfBoot_update_trigger(); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 1); - fail_if(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) != TEST_SIZE_SMALL); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 1); + ck_assert(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) == TEST_SIZE_SMALL); cleanup_flash(); } END_TEST @@ -290,9 +290,9 @@ START_TEST (test_update_oldversion_denied) { add_payload(PART_UPDATE, 1, TEST_SIZE_LARGE); wolfBoot_update_trigger(); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 2); - fail_if(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) != TEST_SIZE_SMALL); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 2); + ck_assert(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) == TEST_SIZE_SMALL); cleanup_flash(); } @@ -307,8 +307,8 @@ START_TEST (test_invalid_update_type) { ext_flash_lock(); wolfBoot_update_trigger(); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 1); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 1); cleanup_flash(); } @@ -325,8 +325,8 @@ START_TEST (test_update_toolarge) { wolfBoot_update_trigger(); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 1); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 1); cleanup_flash(); } @@ -343,8 +343,8 @@ START_TEST (test_invalid_sha) { ext_flash_lock(); wolfBoot_update_trigger(); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 1); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 1); cleanup_flash(); } @@ -361,8 +361,8 @@ START_TEST (test_emergency_rollback) { ext_flash_lock(); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 1); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 1); cleanup_flash(); } @@ -385,8 +385,8 @@ START_TEST (test_emergency_rollback_failure_due_to_bad_update) { ext_flash_lock(); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 2); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 2); cleanup_flash(); } @@ -395,8 +395,8 @@ START_TEST (test_empty_boot_partition_update) { prepare_flash(); add_payload(PART_UPDATE, 5, TEST_SIZE_SMALL); wolfBoot_start(); - fail_unless(wolfBoot_staged_ok); - fail_if(get_version_ramloaded() != 5); + ck_assert(wolfBoot_staged_ok); + ck_assert(get_version_ramloaded() == 5); cleanup_flash(); } @@ -411,7 +411,7 @@ START_TEST (test_empty_boot_but_update_sha_corrupted_denied) { ext_flash_lock(); wolfBoot_start(); /* We expect to panic */ - fail_if(wolfBoot_staged_ok); + ck_assert(!wolfBoot_staged_ok); cleanup_flash(); }