/*
 * Copyright (c) 2011 The Chromium OS Authors.
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

/*
 * Bitfield test routines
 *
 */

#include <stdio.h>

#include "bitfield.h"


#define FULL_RANGE		31:0
#define HIGH_RANGE		31:30
#define MID_RANGE		23:16
#define LOW_RANGE		2:0
#define HIGH_SINGLE_RANGE	31:31
#define MID_SINGLE_RANGE	16:16
#define LOW_SINGLE_RANGE	0:0

static int test_count = 0;

#ifdef DEBUG
#define assert(x) 	\
	({ test_count++; if (!(x)) printf("Assertion failure '%s' %s line %d\n", \
		#x, __FILE__, __LINE__) })
#define asserteq(x, y) 	\
	({ int _x = x; int _y = y; test_count++; \
		if (_x != _y) \
		printf("Assertion failure at %s:%d: '%s' %#x != '%s' %#x\n", \
			__FILE__, __LINE__, #x, _x, #y, _y); })
#else
#define assert(x) test_count++
#define asserteq(x,y) test_count++
#endif


static void test_low_high(void)
{
	asserteq(BITFIELD_HIGHBIT(FULL_RANGE), 31);
	asserteq(BITFIELD_LOWBIT(FULL_RANGE), 0);
	asserteq(BITFIELD_HIGHBIT(HIGH_RANGE), 31);
	asserteq(BITFIELD_LOWBIT(HIGH_RANGE), 30);
	asserteq(BITFIELD_HIGHBIT(MID_RANGE), 23);
	asserteq(BITFIELD_LOWBIT(MID_RANGE), 16);
	asserteq(BITFIELD_HIGHBIT(LOW_RANGE), 2);
	asserteq(BITFIELD_LOWBIT(LOW_RANGE), 0);
	asserteq(BITFIELD_HIGHBIT(HIGH_SINGLE_RANGE), 31);
	asserteq(BITFIELD_LOWBIT(HIGH_SINGLE_RANGE), 31);
	asserteq(BITFIELD_HIGHBIT(MID_SINGLE_RANGE), 16);
	asserteq(BITFIELD_LOWBIT(MID_SINGLE_RANGE), 16);
	asserteq(BITFIELD_HIGHBIT(LOW_SINGLE_RANGE), 0);
	asserteq(BITFIELD_LOWBIT(LOW_SINGLE_RANGE), 0);
}

static void test_width(void)
{
	asserteq(BITFIELD_WIDTH(FULL_RANGE), 32);
	asserteq(BITFIELD_WIDTH(HIGH_RANGE), 2);
	asserteq(BITFIELD_WIDTH(MID_RANGE), 8);
	asserteq(BITFIELD_WIDTH(LOW_RANGE), 3);
	asserteq(BITFIELD_WIDTH(HIGH_SINGLE_RANGE), 1);
	asserteq(BITFIELD_WIDTH(MID_SINGLE_RANGE), 1);
	asserteq(BITFIELD_WIDTH(LOW_SINGLE_RANGE), 1);
}

static void test_shift(void)
{
	asserteq(bf_shift(FULL), 0);
	asserteq(bf_shift(HIGH), 30);
	asserteq(bf_shift(MID), 16);
	asserteq(bf_shift(LOW), 0);
	asserteq(bf_shift(HIGH_SINGLE), 31);
	asserteq(bf_shift(MID_SINGLE), 16);
	asserteq(bf_shift(LOW_SINGLE), 0);
}

static void test_rawmask(void)
{
	asserteq(bf_rawmask(FULL), 0xffffffffU);
	asserteq(bf_rawmask(HIGH), 0x3);
	asserteq(bf_rawmask(MID), 0xff);
	asserteq(bf_rawmask(LOW), 0x7);
	asserteq(bf_rawmask(HIGH_SINGLE), 0x1);
	asserteq(bf_rawmask(MID_SINGLE), 0x1);
	asserteq(bf_rawmask(LOW_SINGLE), 0x1);
}

static void test_mask(void)
{
	asserteq(bf_mask(FULL), 0xffffffffU);
	asserteq(bf_mask(HIGH), 0xc0000000);
	asserteq(bf_mask(MID), 0x00ff0000);
	asserteq(bf_mask(LOW), 0x7);
	asserteq(bf_mask(HIGH_SINGLE), 0x80000000U);
	asserteq(bf_mask(MID_SINGLE), 0x00010000);
	asserteq(bf_mask(LOW_SINGLE), 0x1);
}

static void test_unpack(void)
{
	asserteq(bf_unpack(FULL, 0), 0);
	asserteq(bf_unpack(FULL, -1U), -1U);
	asserteq(bf_unpack(FULL, 0x12345678), 0x12345678);
	asserteq(bf_unpack(FULL, 0x87654321), 0x87654321);
	asserteq(bf_unpack(FULL, 0xa5a5a5a6), 0xa5a5a5a6);

	asserteq(bf_unpack(HIGH, 0), 0);
	asserteq(bf_unpack(HIGH, -1U), 3);
	asserteq(bf_unpack(HIGH, 0x12345678), 0);
	asserteq(bf_unpack(HIGH, 0x87654321), 2);
	asserteq(bf_unpack(HIGH, 0xa5a5a5a6), 2);

	asserteq(bf_unpack(MID, 0), 0);
	asserteq(bf_unpack(MID, -1U), 0xff);
	asserteq(bf_unpack(MID, 0x12345678), 0x34);
	asserteq(bf_unpack(MID, 0x87654321), 0x65);
	asserteq(bf_unpack(MID, 0xa5a5a5a6), 0xa5);

	asserteq(bf_unpack(LOW, 0), 0);
	asserteq(bf_unpack(LOW, -1U), 7);
	asserteq(bf_unpack(LOW, 0x12345678), 0);
	asserteq(bf_unpack(LOW, 0x87654321), 1);
	asserteq(bf_unpack(LOW, 0xa5a5a5a6), 6);

	asserteq(bf_unpack(HIGH_SINGLE, 0), 0);
	asserteq(bf_unpack(HIGH_SINGLE, -1U), 1);
	asserteq(bf_unpack(HIGH_SINGLE, 0x12345678), 0);
	asserteq(bf_unpack(HIGH_SINGLE, 0x87654321), 1);
	asserteq(bf_unpack(HIGH_SINGLE, 0xa5a5a5a6), 1);

	asserteq(bf_unpack(MID_SINGLE, 0), 0);
	asserteq(bf_unpack(MID_SINGLE, -1U), 1);
	asserteq(bf_unpack(MID_SINGLE, 0x12345678), 0);
	asserteq(bf_unpack(MID_SINGLE, 0x87654321), 1);
	asserteq(bf_unpack(MID_SINGLE, 0xa5a5a5a6), 1);

	asserteq(bf_unpack(LOW_SINGLE, 0), 0);
	asserteq(bf_unpack(LOW_SINGLE, -1U), 1);
	asserteq(bf_unpack(LOW_SINGLE, 0x12345678), 0);
	asserteq(bf_unpack(LOW_SINGLE, 0x87654321), 1);
	asserteq(bf_unpack(LOW_SINGLE, 0xa5a5a5a6), 0);
}

static void test_pack(void)
{
	asserteq(bf_pack(FULL, 0), 0);
	asserteq(bf_pack(FULL, -1U), -1U);
	asserteq(bf_pack(FULL, 0x12345678), 0x12345678);
	asserteq(bf_pack(FULL, 0x87654321), 0x87654321);
	asserteq(bf_pack(FULL, 0xa5a5a5a6), 0xa5a5a5a6);

	asserteq(bf_pack(HIGH, 0), 0);
	asserteq(bf_pack(HIGH, -1U), 0xc0000000);
	asserteq(bf_pack(HIGH, 0x12345678), 0);
	asserteq(bf_pack(HIGH, 0x87654321), 0x40000000);
	asserteq(bf_pack(HIGH, 0xa5a5a5a6), 0x80000000);

	asserteq(bf_pack(MID, 0), 0);
	asserteq(bf_pack(MID, -1U), 0x00ff0000);
	asserteq(bf_pack(MID, 0x12345678), 0x00780000);
	asserteq(bf_pack(MID, 0x87654321), 0x00210000);
	asserteq(bf_pack(MID, 0xa5a5a5a6), 0x00a60000);

	asserteq(bf_pack(LOW, 0), 0);
	asserteq(bf_pack(LOW, -1U), 7);
	asserteq(bf_pack(LOW, 0x12345678), 0);
	asserteq(bf_pack(LOW, 0x87654321), 1);
	asserteq(bf_pack(LOW, 0xa5a5a5a6), 6);

	asserteq(bf_pack(HIGH_SINGLE, 0), 0);
	asserteq(bf_pack(HIGH_SINGLE, -1U), 0x80000000u);
	asserteq(bf_pack(HIGH_SINGLE, 0x12345678), 0);
	asserteq(bf_pack(HIGH_SINGLE, 0x87654321), 0x80000000u);
	asserteq(bf_pack(HIGH_SINGLE, 0xa5a5a5a6), 0x00000000u);

	asserteq(bf_pack(MID_SINGLE, 0), 0);
	asserteq(bf_pack(MID_SINGLE, -1U), 0x00010000);
	asserteq(bf_pack(MID_SINGLE, 0x12345678), 0);
	asserteq(bf_pack(MID_SINGLE, 0x87654321), 0x00010000);
	asserteq(bf_pack(MID_SINGLE, 0xa5a5a5a6), 0x00000000);

	asserteq(bf_pack(LOW_SINGLE, 0), 0);
	asserteq(bf_pack(LOW_SINGLE, -1U), 1);
	asserteq(bf_pack(LOW_SINGLE, 0x12345678), 0);
	asserteq(bf_pack(LOW_SINGLE, 0x87654321), 1);
	asserteq(bf_pack(LOW_SINGLE, 0xa5a5a5a6), 0);
}

static void test_set(void)
{
}

void bf_test(void)
{
	test_low_high();
	test_width();
	test_shift();
	test_rawmask();
	test_unpack();
	test_pack();
}

int main(int argc, char *argv[])
{
	bf_test();
	printf("%d tests run\n", test_count);
	return 0;
}