tests: Add tests to read from chip

Two tests cover the code which performs do_read operation.

First one works with fake chip and dummy programmer. Fake chip has all
operations defined, and a buffer to emulate chip memory.

Second one uses the chip which is closer to the real one, because
read/write/unlock/erase operations are real. The tests takes the
advantage of dummyflasher's capability of emulating a W25Q128.V chip.

BUG=b:181803212
TEST=builds and ninja test

Change-Id: Ia57781ebc670c7bd6197e56fe8a20651a425c756
Signed-off-by: Anastasia Klimchuk <aklm@chromium.org>
Reviewed-on: https://review.coreboot.org/c/flashrom/+/57326
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Nico Huber <nico.h@gmx.de>

5 files changed, 146 insertions, 0 deletions

diff --git a/tests/chip.c b/tests/chip.c
index 4a61ff8a..2f6581fb 100644
--- a/tests/chip.c
+++ b/tests/chip.c
@@ -216,3 +216,100 @@ void erase_chip_with_dummyflasher_test_success(void **state)
 
 	free(param_dup);
 }
+
+void read_chip_test_success(void **state)
+{
+	(void) state; /* unused */
+
+	struct flashchip chip = {
+		.vendor		= "aklm",
+		/*
+		 * Total size less than 16 to skip some steps
+		 * in flashrom.c#prepare_flash_access.
+		 */
+		.total_size	= 8,
+		.tested		= TEST_OK_PREW,
+		.read		= read_chip,
+		.write		= write_chip,
+		.unlock		= unlock_chip,
+		.block_erasers	=
+		{{
+			 /* All blocks within total size of the chip. */
+			.eraseblocks = { {2 * 1024, 4} },
+			.block_erase = block_erase_chip,
+		 }},
+	};
+
+	struct flashrom_flashctx flash = { 0 };
+	struct flashrom_layout *layout;
+	const char *param = ""; /* Default values for all params. */
+
+	setup_chip(&flash, &layout, &chip, param);
+
+	const char *const filename = "read_chip.test";
+
+	printf("Read chip operation started.\n");
+	assert_int_equal(0, do_read(&flash, filename));
+	printf("Read chip operation done.\n");
+
+	teardown(&layout);
+}
+
+void read_chip_with_dummyflasher_test_success(void **state)
+{
+	(void) state; /* unused */
+
+	struct flashchip chip = {
+		.vendor		= "aklm&dummyflasher",
+		/*
+		 * Setup the values for W25Q128.V because we ask dummyflasher
+		 * to emulate this chip. All operations: read/write/unlock/erase
+		 * are real, not mocks, and they are expected to be handled by
+		 * dummyflasher.
+		 */
+		.total_size	= 16 * 1024,
+		.tested		= TEST_OK_PREW,
+		.read		= spi_chip_read,
+		.write		= spi_chip_write_256,
+		.unlock         = spi_disable_blockprotect,
+		.block_erasers  =
+		{
+			{
+				.eraseblocks = { {4 * 1024, 4096} },
+				.block_erase = spi_block_erase_20,
+			}, {
+				.eraseblocks = { {32 * 1024, 512} },
+				.block_erase = spi_block_erase_52,
+			}, {
+				.eraseblocks = { {64 * 1024, 256} },
+				.block_erase = spi_block_erase_d8,
+			}, {
+				.eraseblocks = { {16 * 1024 * 1024, 1} },
+				.block_erase = spi_block_erase_60,
+			}, {
+				.eraseblocks = { {16 * 1024 * 1024, 1} },
+				.block_erase = spi_block_erase_c7,
+			}
+		},
+	};
+
+	struct flashrom_flashctx flash = { 0 };
+	struct flashrom_layout *layout;
+	/*
+	 * Dummyflasher is capable to emulate a chip, so we ask it to do this.
+	 * Nothing to mock, dummy is taking care of this already.
+	 */
+	char *param_dup = strdup("bus=spi,emulate=W25Q128FV");
+
+	setup_chip(&flash, &layout, &chip, param_dup);
+
+	const char *const filename = "read_chip.test";
+
+	printf("Read chip operation started.\n");
+	assert_int_equal(0, do_read(&flash, filename));
+	printf("Read chip operation done.\n");
+
+	teardown(&layout);
+
+	free(param_dup);
+}
diff --git a/tests/io_mock.h b/tests/io_mock.h
index adb5f3b3..a285e534 100644
--- a/tests/io_mock.h
+++ b/tests/io_mock.h
@@ -53,6 +53,9 @@ struct pci_dev {
 /* Linux I2C interface constants, avoiding linux/i2c-dev.h */
 #define I2C_SLAVE 0x0703
 
+/* Always return success for tests. */
+#define S_ISREG(x) 0
+
 struct io_mock {
 	void *state;
 
diff --git a/tests/meson.build b/tests/meson.build
index 53885a83..8019bd37 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -39,8 +39,14 @@ mocks = [
   '-Wl,--wrap=write',
   '-Wl,--wrap=fopen',
   '-Wl,--wrap=fopen64',
+  '-Wl,--wrap=fwrite',
+  '-Wl,--wrap=fflush',
   '-Wl,--wrap=stat',
   '-Wl,--wrap=stat64',
+  '-Wl,--wrap=fstat',
+  '-Wl,--wrap=fstat64',
+  '-Wl,--wrap=fileno',
+  '-Wl,--wrap=fsync',
   '-Wl,--wrap=fread',
   '-Wl,--wrap=fgets',
   '-Wl,--wrap=fclose',
diff --git a/tests/tests.c b/tests/tests.c
index 5ca5b66d..ac594707 100644
--- a/tests/tests.c
+++ b/tests/tests.c
@@ -154,6 +154,18 @@ int __wrap_stat64(const char *path, void *buf)
 	return 0;
 }
 
+int __wrap_fstat(int fd, void *buf)
+{
+	LOG_ME;
+	return 0;
+}
+
+int __wrap_fstat64(int fd, void *buf)
+{
+	LOG_ME;
+	return 0;
+}
+
 char *__wrap_fgets(char *buf, int len, FILE *fp)
 {
 	LOG_ME;
@@ -170,6 +182,30 @@ size_t __wrap_fread(void *ptr, size_t size, size_t len, FILE *fp)
 	return 0;
 }
 
+size_t __wrap_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *fp)
+{
+	LOG_ME;
+	return nmemb;
+}
+
+int __wrap_fflush(FILE *fp)
+{
+	LOG_ME;
+	return 0;
+}
+
+int __wrap_fileno(FILE *fp)
+{
+	LOG_ME;
+	return MOCK_HANDLE;
+}
+
+int __wrap_fsync(int fd)
+{
+	LOG_ME;
+	return 0;
+}
+
 int __wrap_setvbuf(FILE *fp, char *buf, int type, size_t size)
 {
 	LOG_ME;
@@ -357,6 +393,8 @@ int main(void)
 	const struct CMUnitTest chip_tests[] = {
 		cmocka_unit_test(erase_chip_test_success),
 		cmocka_unit_test(erase_chip_with_dummyflasher_test_success),
+		cmocka_unit_test(read_chip_test_success),
+		cmocka_unit_test(read_chip_with_dummyflasher_test_success),
 	};
 	ret |= cmocka_run_group_tests_name("chip.c tests", chip_tests, NULL, NULL);
 
diff --git a/tests/tests.h b/tests/tests.h
index 8e1b6da6..c142b45f 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -59,5 +59,7 @@ void layout_region_invalid_range_test_success(void **state);
 /* chip.c */
 void erase_chip_test_success(void **state);
 void erase_chip_with_dummyflasher_test_success(void **state);
+void read_chip_test_success(void **state);
+void read_chip_with_dummyflasher_test_success(void **state);
 
 #endif /* TESTS_H */