openwrt/flashrom
1
0
Fork 0
mirror of https://review.coreboot.org/flashrom.git synced 2025-04-28 15:33:42 +02:00
Code Issues Releases Wiki Activity

tests: Add run_probe_lifecycle and add dummyflasher probe test

Browse Source 
This patch implements run_probe_lifecycle and adds dummyflasher
test to run probing lifecycle.

A lifecycle consists of 3 steps: 1) init programmer 2) do some action
3) shutdown programmer. Step 2 can be "do nothing", and this is
named "basic lifecycle", i.e. the simplest. This patch implements
"probe lifecycle" which probes a chip as Step 2.

Internally there is one run_lifecycle function which performs steps
1, 2, 3. run_lifecycle is operating via libflashrom API. Long term
goal for cli_classic is to operate via libflashrom API, so the test
aligns with this approach.

BUG=b:181803212
TEST=ninja test

Change-Id: I9eb7fe3a436fbba5e70db957139fd26e00efec36
Signed-off-by: Anastasia Klimchuk <aklm@chromium.org>
Reviewed-on: https://review.coreboot.org/c/flashrom/+/59741
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Thomas Heijligen <src@posteo.de>
This commit is contained in:
Anastasia Klimchuk 2021-11-29 17:00:27 +11:00
parent 0f51f62c62
commit e539d112cd
3 changed files with 56 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
tests/lifecycle.c
View File

@ -16,26 +16,64 @@
#include <include/test.h> #include <include/test.h>
#include <string.h> #include <string.h>
#include "libflashrom.h"
#include "io_mock.h" #include "io_mock.h"
#include "programmer.h" #include "programmer.h"
#include "spi.h"
static void run_basic_lifecycle(void **state, const struct programmer_entry *prog, const char *param) static void probe_chip(const struct programmer_entry *prog,
struct flashrom_programmer *flashprog,
const char *const chip_name)
{
struct flashrom_flashctx *flashctx;
printf("Testing flashrom_flash_probe for programmer=%s, chip=%s ... \n", prog->name, chip_name);
assert_int_equal(0, flashrom_flash_probe(&flashctx, flashprog, chip_name));
printf("... flashrom_flash_probe for programmer=%s successful\n", prog->name);
flashrom_flash_release(flashctx); /* cleanup */
}
static void run_lifecycle(void **state, const struct programmer_entry *prog,
const char *param, const char *const chip_name,
void (*action)(const struct programmer_entry *prog,
struct flashrom_programmer *flashprog,
const char *const chip_name))
{ {
(void) state; /* unused */ (void) state; /* unused */
struct flashrom_programmer *flashprog;
char *param_dup = strdup(param); char *param_dup = strdup(param);
printf("Testing programmer_init for programmer=%s ...\n", prog->name); printf("Testing flashrom_programmer_init for programmer=%s ...\n", prog->name);
assert_int_equal(0, programmer_init(prog, param_dup)); assert_int_equal(0, flashrom_programmer_init(&flashprog, prog->name, param_dup));
printf("... programmer_init for programmer=%s successful\n", prog->name); printf("... flashrom_programmer_init for programmer=%s successful\n", prog->name);
printf("Testing programmer_shutdown for programmer=%s ...\n", prog->name); if (action)
assert_int_equal(0, programmer_shutdown()); action(prog, flashprog, chip_name);
printf("... programmer_shutdown for programmer=%s successful\n", prog->name);
printf("Testing flashrom_programmer_shutdown for programmer=%s ...\n", prog->name);
assert_int_equal(0, flashrom_programmer_shutdown(flashprog));
printf("... flashrom_programmer_shutdown for programmer=%s successful\n", prog->name);
free(param_dup); free(param_dup);
} }
static void run_basic_lifecycle(void **state, const struct programmer_entry *prog, const char *param)
{
/* Basic lifecycle only does init and shutdown,
* so neither chip name nor action is needed. */
run_lifecycle(state, prog, param, NULL /* chip_name */, NULL /* action */);
}
static void run_probe_lifecycle(void **state, const struct programmer_entry *prog,
const char *param, const char *const chip_name)
{
/* Each probe lifecycle should run independently, without cache. */
clear_spi_id_cache();
run_lifecycle(state, prog, param, chip_name, &probe_chip);
}
void dummy_basic_lifecycle_test_success(void **state) void dummy_basic_lifecycle_test_success(void **state)
{ {
#if CONFIG_DUMMY == 1 #if CONFIG_DUMMY == 1
@ -45,6 +83,15 @@ void dummy_basic_lifecycle_test_success(void **state)
#endif #endif
} }
void dummy_probe_lifecycle_test_success(void **state)
{
#if CONFIG_DUMMY == 1
run_probe_lifecycle(state, &programmer_dummy, "bus=spi,emulate=W25Q128FV", "W25Q128.V");
#else
skip();
#endif
}
void nicrealtek_basic_lifecycle_test_success(void **state) void nicrealtek_basic_lifecycle_test_success(void **state)
{ {
#if CONFIG_NICREALTEK == 1 #if CONFIG_NICREALTEK == 1

1
tests/tests.c
View File

@ -364,6 +364,7 @@ int main(void)
const struct CMUnitTest lifecycle_tests[] = { const struct CMUnitTest lifecycle_tests[] = {
cmocka_unit_test(dummy_basic_lifecycle_test_success), cmocka_unit_test(dummy_basic_lifecycle_test_success),
cmocka_unit_test(dummy_probe_lifecycle_test_success),
cmocka_unit_test(nicrealtek_basic_lifecycle_test_success), cmocka_unit_test(nicrealtek_basic_lifecycle_test_success),
cmocka_unit_test(raiden_debug_basic_lifecycle_test_success), cmocka_unit_test(raiden_debug_basic_lifecycle_test_success),
cmocka_unit_test(dediprog_basic_lifecycle_test_success), cmocka_unit_test(dediprog_basic_lifecycle_test_success),

1
tests/tests.h
View File

@ -42,6 +42,7 @@ void probe_spi_st95_test_success(void **state); /* spi95.c */
/* lifecycle.c */ /* lifecycle.c */
void dummy_basic_lifecycle_test_success(void **state); void dummy_basic_lifecycle_test_success(void **state);
void dummy_probe_lifecycle_test_success(void **state);
void nicrealtek_basic_lifecycle_test_success(void **state); void nicrealtek_basic_lifecycle_test_success(void **state);
void raiden_debug_basic_lifecycle_test_success(void **state); void raiden_debug_basic_lifecycle_test_success(void **state);
void dediprog_basic_lifecycle_test_success(void **state); void dediprog_basic_lifecycle_test_success(void **state);