intf/io_unittest.c - chromiumos/platform/mosys - Git at Google

 /*
  * Copyright 2012, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *    * Redistributions of source code must retain the above copyright
  *      notice, this list of conditions and the following disclaimer.
  *    * Redistributions in binary form must reproduce the above
  *      copyright notice, this list of conditions and the following
  *      disclaimer in the documentation and/or other materials provided
  *      with the distribution.
  *    * Neither the name of Google Inc. nor the names of its
  *      contributors may be used to endorse or promote products derived
  *      from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include <limits.h>
 #include <setjmp.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>

 // cmocka doesn't include some headers it uses, e.g. setjmp. Prevent
 // clang-format from putting the headers in order, so it gets the above
 // includes.
 // clang-format off
 #include <cmocka.h>
 // clang-format on

 #include "mosys/file_backed_range.h"
 #include "mosys/platform.h"

 #include "mosys/globals.h"

 #include "intf/io.h"

 // Storage for the file_backed_range names (see fn. comment for
 // build_test_intf).
 static char file_backed_range_path_buf[PATH_MAX];

 // Build a struct platform_intf for use in tests. The first file_backed_range
 // can be configured with params
 // - <file_backed_range_size>: The size of the range (it is assumed the range
 // starts at 0).
 // - <file_backed_range_file_name>: The name of the file in the
 // "unittests/testdata/io_unittest" directory. E.g. if the arg is "/dev/port",
 // the "unittests/testdata/io_unittest/dev/port" file will be used.
 static struct platform_intf
 build_test_intf(uint64_t file_backed_range_size,
 		const char *file_backed_range_file_name)
 {
 	const char *test_ids[] = {
 	    "TEST",
 	    NULL,
 	};
 	struct platform_op test_ops = {
 	    .io = &io_intf,
 	};
 	struct platform_cb test_cbs;

 	struct platform_intf intf = {
 	    .type = PLATFORM_DEFAULT,
 	    .name = "UNITTEST",
 	    .id_list = test_ids,
 	    .op = &test_ops,
 	    .cb = &test_cbs,
 	};

 	assert_int_equal(0, intf.op->io->setup(&intf));

 	char *src = getenv("SRC");
 	assert_non_null(src);

 	// Note that the leading / needs to be removed for the file_backed_range
 	// file_name; thus, cwd[1] is used.
 	snprintf(file_backed_range_path_buf, PATH_MAX,
 		 "%s/unittests/testdata/io_unittest%s", &src[1],
 		 file_backed_range_file_name);

 	struct file_backed_range *first_range = &intf.op->io->ranges[0];
 	first_range->range.end = file_backed_range_size;
 	first_range->file_name = file_backed_range_path_buf;

 	return intf;
 }

 /* Test a range with an address out of bounds */
 static void bad_address(void **state)
 {
 	struct platform_intf intf =
 	    build_test_intf(/*file_backed_range_size=*/0x10,
 			    /*file_backed_range_file_name=*/"/dev/port");
 	uint8_t data;

 	// A read / write within the range works.
 	assert_int_equal(0, intf.op->io->read(&intf, 0x01, IO_ACCESS_8, &data));

 	assert_int_equal(0,
 			 intf.op->io->write(&intf, 0x01, IO_ACCESS_8, &data));

 	// A read / write outside the range fails.
 	assert_int_equal(-1,
 			 intf.op->io->read(&intf, 0x20, IO_ACCESS_8, &data));

 	assert_int_equal(-1,
 			 intf.op->io->write(&intf, 0x20, IO_ACCESS_8, &data));
 }

 /* Test a non-existing dev file */
 static void open_nonexistent_file(void **state)
 {
 	struct platform_intf intf =
 	    build_test_intf(/*file_backed_range_size=*/0x10000,
 			    /*file_backed_range_file_name=*/"/dev/nonexistent");
 	uint8_t data;

 	assert_int_equal(-1, intf.op->io->read(&intf, 0, IO_ACCESS_8, &data));
 }

 /* Test a bad read by having a range larger than the actual dev file */
 static void read_eof(void **state)
 {
 	struct platform_intf intf =
 	    build_test_intf(/*file_backed_range_size=*/0x10000,
 			    /*file_backed_range_file_name=*/"/dev/port");
 	uint8_t data;

 	// The test file is 4 bytes. A read a 3 bytes works, a read beyond that
 	// fails.
 	assert_int_equal(0, intf.op->io->read(&intf, 0x03, IO_ACCESS_8, &data));

 	assert_int_equal(-1,
 			 intf.op->io->read(&intf, 0xffff, IO_ACCESS_8, &data));
 }

 static void io_read_test(void **state)
 {
 	struct platform_intf intf =
 	    build_test_intf(/*file_backed_range_size=*/0x10000,
 			    /*file_backed_range_file_name=*/"/dev/port");

 	int ret;
 	uint8_t data8;
 	uint16_t data16;
 	uint32_t data32;

 	/* 8 bit read */
 	data8 = 0xff;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_8, &data8);
 	assert_int_equal(0, ret);
 	assert_int_equal(0x00, (int)data8);
 	/* now through inlines */
 	data8 = 0xff;
 	ret = io_read(&intf, 0, IO_ACCESS_8, &data8);
 	assert_int_equal(0, ret);
 	assert_int_equal(0x00, (int)data8);
 	data8 = 0xff;
 	ret = io_read8(&intf, 0, &data8);
 	assert_int_equal(0, ret);
 	assert_int_equal(0x00, (int)data8);

 	/* 16 bit read */
 	data16 = 0xffff;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_16, &data16);
 	assert_int_equal(0, ret);
 	assert_int_equal(0x0100, data16);
 	/* now through inlines */
 	data16 = 0xffff;
 	ret = io_read16(&intf, 0, &data16);
 	assert_int_equal(0, ret);
 	assert_int_equal(0x0100, data16);

 	/* 32 bit read */
 	data32 = 0xffffffff;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_32, &data32);
 	assert_int_equal(0, ret);
 	assert_int_equal(0x03020100, data32);
 	/* now through inlines */
 	data32 = 0xffffffff;
 	ret = io_read32(&intf, 0, &data32);
 	assert_int_equal(0, ret);
 	assert_int_equal(0x03020100, data32);
 }

 static void io_write_test(void **state)
 {
 	struct platform_intf intf =
 	    build_test_intf(/*file_backed_range_size=*/0x10000,
 			    /*file_backed_range_file_name=*/"/dev/port");

 	int ret;
 	uint8_t data8, orig8;
 	uint16_t data16, orig16;
 	uint32_t data32, orig32;

 	/* 8 bit write */
 	data8 = 0xff;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_8, &orig8);
 	assert_int_equal(0, ret);
 	ret = intf.op->io->write(&intf, 0, IO_ACCESS_8, &data8);
 	assert_int_equal(0, ret);
 	data8 = 0;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_8, &data8);
 	assert_int_equal(0, ret);
 	assert_int_equal(0xff, (int)data8);
 	ret = intf.op->io->write(&intf, 0, IO_ACCESS_8, &orig8);
 	assert_int_equal(0, ret);
 	/* now through inlines */
 	data8 = 0xff;
 	ret = io_write(&intf, 0, IO_ACCESS_8, &data8);
 	assert_int_equal(0, ret);
 	data8 = 0;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_8, &data8);
 	assert_int_equal(0, ret);
 	assert_int_equal(0xff, (int)data8);
 	ret = intf.op->io->write(&intf, 0, IO_ACCESS_8, &orig8);
 	assert_int_equal(0, ret);
 	data8 = 0xff;
 	ret = io_write8(&intf, 0, data8);
 	assert_int_equal(0, ret);
 	data8 = 0;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_8, &data8);
 	assert_int_equal(0, ret);
 	assert_int_equal(0xff, (int)data8);
 	ret = intf.op->io->write(&intf, 0, IO_ACCESS_8, &orig8);
 	assert_int_equal(0, ret);

 	/* 16 bit write */
 	data16 = 0xffff;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_16, &orig16);
 	assert_int_equal(0, ret);
 	ret = intf.op->io->write(&intf, 0, IO_ACCESS_16, &data16);
 	assert_int_equal(0, ret);
 	data16 = 0;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_16, &data16);
 	assert_int_equal(0, ret);
 	assert_int_equal(0xffff, data16);
 	ret = intf.op->io->write(&intf, 0, IO_ACCESS_16, &orig16);
 	assert_int_equal(0, ret);
 	/* now through inlines */
 	data16 = 0xffff;
 	ret = io_write16(&intf, 0, data16);
 	assert_int_equal(0, ret);
 	data16 = 0;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_16, &data16);
 	assert_int_equal(0, ret);
 	assert_int_equal(0xffff, data16);
 	ret = intf.op->io->write(&intf, 0, IO_ACCESS_16, &orig16);
 	assert_int_equal(0, ret);

 	/* 32 bit write */
 	data32 = 0xffffffff;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_32, &orig32);
 	assert_int_equal(0, ret);
 	ret = intf.op->io->write(&intf, 0, IO_ACCESS_32, &data32);
 	assert_int_equal(0, ret);
 	data32 = 0;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_32, &data32);
 	assert_int_equal(0, ret);
 	assert_int_equal(0xffffffff, data32);
 	ret = intf.op->io->write(&intf, 0, IO_ACCESS_32, &orig32);
 	assert_int_equal(0, ret);
 	/* now through inlines */
 	data32 = 0xffffffff;
 	ret = io_write32(&intf, 0, data32);
 	assert_int_equal(0, ret);
 	data32 = 0;
 	ret = intf.op->io->read(&intf, 0, IO_ACCESS_32, &data32);
 	assert_int_equal(0, ret);
 	assert_int_equal(0xffffffff, data32);
 	ret = intf.op->io->write(&intf, 0, IO_ACCESS_32, &orig32);
 	assert_int_equal(0, ret);
 }

 int main(void)
 {
 	const struct CMUnitTest tests[] = {
 	    cmocka_unit_test(bad_address),
 	    cmocka_unit_test(open_nonexistent_file),
 	    cmocka_unit_test(read_eof),
 	    cmocka_unit_test(io_read_test),
 	    cmocka_unit_test(io_write_test),
 	};

 	return cmocka_run_group_tests(tests, /*group_setup=*/NULL,
 				      /*group_teardown=*/NULL);
 }
	/*
	* Copyright 2012, Google Inc.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	*
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials provided
	* with the distribution.
	* * Neither the name of Google Inc. nor the names of its
	* contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <limits.h>
	#include <setjmp.h>
	#include <stdarg.h>
	#include <stddef.h>
	#include <stdio.h>
	#include <string.h>
	#include <unistd.h>

	// cmocka doesn't include some headers it uses, e.g. setjmp. Prevent
	// clang-format from putting the headers in order, so it gets the above
	// includes.
	// clang-format off
	#include <cmocka.h>
	// clang-format on

	#include "mosys/file_backed_range.h"
	#include "mosys/platform.h"

	#include "mosys/globals.h"

	#include "intf/io.h"

	// Storage for the file_backed_range names (see fn. comment for
	// build_test_intf).
	static char file_backed_range_path_buf[PATH_MAX];

	// Build a struct platform_intf for use in tests. The first file_backed_range
	// can be configured with params
	// - <file_backed_range_size>: The size of the range (it is assumed the range
	// starts at 0).
	// - <file_backed_range_file_name>: The name of the file in the
	// "unittests/testdata/io_unittest" directory. E.g. if the arg is "/dev/port",
	// the "unittests/testdata/io_unittest/dev/port" file will be used.
	static struct platform_intf
	build_test_intf(uint64_t file_backed_range_size,
	const char *file_backed_range_file_name)
	{
	const char *test_ids[] = {
	"TEST",
	NULL,
	};
	struct platform_op test_ops = {
	.io = &io_intf,
	};
	struct platform_cb test_cbs;

	struct platform_intf intf = {
	.type = PLATFORM_DEFAULT,
	.name = "UNITTEST",
	.id_list = test_ids,
	.op = &test_ops,
	.cb = &test_cbs,
	};

	assert_int_equal(0, intf.op->io->setup(&intf));

	char *src = getenv("SRC");
	assert_non_null(src);

	// Note that the leading / needs to be removed for the file_backed_range
	// file_name; thus, cwd[1] is used.
	snprintf(file_backed_range_path_buf, PATH_MAX,
	"%s/unittests/testdata/io_unittest%s", &src[1],
	file_backed_range_file_name);

	struct file_backed_range *first_range = &intf.op->io->ranges[0];
	first_range->range.end = file_backed_range_size;
	first_range->file_name = file_backed_range_path_buf;

	return intf;
	}

	/* Test a range with an address out of bounds */
	static void bad_address(void **state)
	{
	struct platform_intf intf =
	build_test_intf(/file_backed_range_size=/0x10,
	/file_backed_range_file_name=/"/dev/port");
	uint8_t data;

	// A read / write within the range works.
	assert_int_equal(0, intf.op->io->read(&intf, 0x01, IO_ACCESS_8, &data));

	assert_int_equal(0,
	intf.op->io->write(&intf, 0x01, IO_ACCESS_8, &data));

	// A read / write outside the range fails.
	assert_int_equal(-1,
	intf.op->io->read(&intf, 0x20, IO_ACCESS_8, &data));

	assert_int_equal(-1,
	intf.op->io->write(&intf, 0x20, IO_ACCESS_8, &data));
	}

	/* Test a non-existing dev file */
	static void open_nonexistent_file(void **state)
	{
	struct platform_intf intf =
	build_test_intf(/file_backed_range_size=/0x10000,
	/file_backed_range_file_name=/"/dev/nonexistent");
	uint8_t data;

	assert_int_equal(-1, intf.op->io->read(&intf, 0, IO_ACCESS_8, &data));
	}

	/* Test a bad read by having a range larger than the actual dev file */
	static void read_eof(void **state)
	{
	struct platform_intf intf =
	build_test_intf(/file_backed_range_size=/0x10000,
	/file_backed_range_file_name=/"/dev/port");
	uint8_t data;

	// The test file is 4 bytes. A read a 3 bytes works, a read beyond that
	// fails.
	assert_int_equal(0, intf.op->io->read(&intf, 0x03, IO_ACCESS_8, &data));

	assert_int_equal(-1,
	intf.op->io->read(&intf, 0xffff, IO_ACCESS_8, &data));
	}

	static void io_read_test(void **state)
	{
	struct platform_intf intf =
	build_test_intf(/file_backed_range_size=/0x10000,
	/file_backed_range_file_name=/"/dev/port");

	int ret;
	uint8_t data8;
	uint16_t data16;
	uint32_t data32;

	/* 8 bit read */
	data8 = 0xff;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_8, &data8);
	assert_int_equal(0, ret);
	assert_int_equal(0x00, (int)data8);
	/* now through inlines */
	data8 = 0xff;
	ret = io_read(&intf, 0, IO_ACCESS_8, &data8);
	assert_int_equal(0, ret);
	assert_int_equal(0x00, (int)data8);
	data8 = 0xff;
	ret = io_read8(&intf, 0, &data8);
	assert_int_equal(0, ret);
	assert_int_equal(0x00, (int)data8);

	/* 16 bit read */
	data16 = 0xffff;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_16, &data16);
	assert_int_equal(0, ret);
	assert_int_equal(0x0100, data16);
	/* now through inlines */
	data16 = 0xffff;
	ret = io_read16(&intf, 0, &data16);
	assert_int_equal(0, ret);
	assert_int_equal(0x0100, data16);

	/* 32 bit read */
	data32 = 0xffffffff;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_32, &data32);
	assert_int_equal(0, ret);
	assert_int_equal(0x03020100, data32);
	/* now through inlines */
	data32 = 0xffffffff;
	ret = io_read32(&intf, 0, &data32);
	assert_int_equal(0, ret);
	assert_int_equal(0x03020100, data32);
	}

	static void io_write_test(void **state)
	{
	struct platform_intf intf =
	build_test_intf(/file_backed_range_size=/0x10000,
	/file_backed_range_file_name=/"/dev/port");

	int ret;
	uint8_t data8, orig8;
	uint16_t data16, orig16;
	uint32_t data32, orig32;

	/* 8 bit write */
	data8 = 0xff;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_8, &orig8);
	assert_int_equal(0, ret);
	ret = intf.op->io->write(&intf, 0, IO_ACCESS_8, &data8);
	assert_int_equal(0, ret);
	data8 = 0;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_8, &data8);
	assert_int_equal(0, ret);
	assert_int_equal(0xff, (int)data8);
	ret = intf.op->io->write(&intf, 0, IO_ACCESS_8, &orig8);
	assert_int_equal(0, ret);
	/* now through inlines */
	data8 = 0xff;
	ret = io_write(&intf, 0, IO_ACCESS_8, &data8);
	assert_int_equal(0, ret);
	data8 = 0;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_8, &data8);
	assert_int_equal(0, ret);
	assert_int_equal(0xff, (int)data8);
	ret = intf.op->io->write(&intf, 0, IO_ACCESS_8, &orig8);
	assert_int_equal(0, ret);
	data8 = 0xff;
	ret = io_write8(&intf, 0, data8);
	assert_int_equal(0, ret);
	data8 = 0;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_8, &data8);
	assert_int_equal(0, ret);
	assert_int_equal(0xff, (int)data8);
	ret = intf.op->io->write(&intf, 0, IO_ACCESS_8, &orig8);
	assert_int_equal(0, ret);

	/* 16 bit write */
	data16 = 0xffff;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_16, &orig16);
	assert_int_equal(0, ret);
	ret = intf.op->io->write(&intf, 0, IO_ACCESS_16, &data16);
	assert_int_equal(0, ret);
	data16 = 0;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_16, &data16);
	assert_int_equal(0, ret);
	assert_int_equal(0xffff, data16);
	ret = intf.op->io->write(&intf, 0, IO_ACCESS_16, &orig16);
	assert_int_equal(0, ret);
	/* now through inlines */
	data16 = 0xffff;
	ret = io_write16(&intf, 0, data16);
	assert_int_equal(0, ret);
	data16 = 0;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_16, &data16);
	assert_int_equal(0, ret);
	assert_int_equal(0xffff, data16);
	ret = intf.op->io->write(&intf, 0, IO_ACCESS_16, &orig16);
	assert_int_equal(0, ret);

	/* 32 bit write */
	data32 = 0xffffffff;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_32, &orig32);
	assert_int_equal(0, ret);
	ret = intf.op->io->write(&intf, 0, IO_ACCESS_32, &data32);
	assert_int_equal(0, ret);
	data32 = 0;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_32, &data32);
	assert_int_equal(0, ret);
	assert_int_equal(0xffffffff, data32);
	ret = intf.op->io->write(&intf, 0, IO_ACCESS_32, &orig32);
	assert_int_equal(0, ret);
	/* now through inlines */
	data32 = 0xffffffff;
	ret = io_write32(&intf, 0, data32);
	assert_int_equal(0, ret);
	data32 = 0;
	ret = intf.op->io->read(&intf, 0, IO_ACCESS_32, &data32);
	assert_int_equal(0, ret);
	assert_int_equal(0xffffffff, data32);
	ret = intf.op->io->write(&intf, 0, IO_ACCESS_32, &orig32);
	assert_int_equal(0, ret);
	}

	int main(void)
	{
	const struct CMUnitTest tests[] = {
	cmocka_unit_test(bad_address),
	cmocka_unit_test(open_nonexistent_file),
	cmocka_unit_test(read_eof),
	cmocka_unit_test(io_read_test),
	cmocka_unit_test(io_write_test),
	};

	return cmocka_run_group_tests(tests, /group_setup=/NULL,
	/group_teardown=/NULL);
	}