Function test_rdev_wrap

tests/commonlib/region-test.c:194–229

}

static void test_rdev_wrap(void **state)
{
	struct region_device child;
	const size_t offs = VAL(0xf);
	const size_t wrap_size = VAL(2);
	/* Known API limitation -- can't exactly touch address space limit from below. */
	const size_t fit_size = VAL(1) - 1;

	/* For the 'wrap' cases, the underlying rdev_ops aren't even called, so only add
	   expectations for the 'fit' cases. */
	expect_value(mock_mmap, offset, offs);
	expect_value(mock_readat, offset, offs);
	expect_value(mock_writeat, offset, offs);
	expect_value(mock_eraseat, offset, offs);

	expect_value(mock_mmap, size, fit_size);
	expect_value(mock_readat, size, fit_size);
	expect_value(mock_writeat, size, fit_size);
	expect_value(mock_eraseat, size, fit_size);

	rdev_mock_defaults();

	/* Accesses to regions that wrap around the end of the address space should fail. */
	assert_null(rdev_mmap(&mock_rdev, offs, wrap_size));
	assert_int_equal(rdev_readat(&mock_rdev, mock_buffer, offs, wrap_size), -1);
	assert_int_equal(rdev_writeat(&mock_rdev, mock_buffer, offs, wrap_size), -1);
	assert_int_equal(rdev_eraseat(&mock_rdev, offs, wrap_size), -1);
	assert_int_equal(rdev_chain(&child, &mock_rdev, offs, wrap_size), -1);

	/* Just barely touching the end of the address space (and the rdev) should be fine. */
	assert_ptr_equal(rdev_mmap(&mock_rdev, offs, fit_size), mmap_result);
	assert_int_equal(rdev_readat(&mock_rdev, mock_buffer, offs, fit_size), fit_size);
	assert_int_equal(rdev_writeat(&mock_rdev, mock_buffer, offs, fit_size), fit_size);
	assert_int_equal(rdev_eraseat(&mock_rdev, offs, fit_size), fit_size);
	assert_int_equal(rdev_chain(&child, &mock_rdev, offs, fit_size), 0);
}

static void test_rdev_chain(void **state)
{