package BitwiseTests
import Bitwise

@Test
function byteTestsNegative()
	let bytes = 0xFABCDE10.bytes()

	bytes.b1.assertEquals(0x10)
	bytes.b2.assertEquals(0xDE)
	bytes.b3.assertEquals(0xBC)
	bytes.b4.assertEquals(0xFA)

@Test
function byteTestsPositive()
	let bytes = 0x0FBCDE10.bytes()

	bytes.b1.assertEquals(0x10)
	bytes.b2.assertEquals(0xDE)
	bytes.b3.assertEquals(0xBC)
	bytes.b4.assertEquals(0x0F)

@Test
function bitStringTests()
	"1".fromBitString().assertEquals(1)
	"01".fromBitString().assertEquals(1)
	"0001".fromBitString().assertEquals(1)
	"1000".fromBitString().assertEquals(8)
	"1001".fromBitString().assertEquals(9)
	"10000000 00000000 00000000 00000000".fromBitString().assertEquals(INT_MIN)
	"11111111 11111111 11111111 11111111".fromBitString().assertEquals(-1)

@Test
function shiftTests()
	0xFF.shiftl(4).assertEquals(0xFF0)
	0xFF.shiftl(8).assertEquals(0xFF00)
	0xFF.shiftl(12).assertEquals(0xFF000)
	0xFF.shiftl(16).assertEquals(0xFF0000)
	0xFF.shiftl(24).assertEquals(0xFF000000)
	0xFF00FF.shiftr(4).assertEquals(0xFF00F)
	0xFF00FF.shiftr(8).assertEquals(0xFF00)
	0xFF00FF.shiftr(12).assertEquals(0xFF0)
	0xFF00FF.shiftr(16).assertEquals(0xFF)
	0xFF0000FF.shiftr(16).assertEquals(0xFF00)
	0xFF0000FF.shiftr(24).assertEquals(0xFF)

@Test
function shiftByZeroTests()
	// powShift[31] overflows to 0x80000000, and the two's complement wrap makes
	// a zero shift exact for negative inputs too
	let five = 5
	let zero = 0
	let minusOne = -1
	let negative = -12345
	five.shiftr(0).assertEquals(5)
	zero.shiftr(0).assertEquals(0)
	minusOne.shiftr(0).assertEquals(-1)
	negative.shiftr(0).assertEquals(-12345)
	INT_MIN.shiftr(0).assertEquals(INT_MIN)
	five.shiftl(0).assertEquals(5)
	minusOne.shiftl(0).assertEquals(-1)

@Test
function shiftBoundsTests()
	let one = 1
	let minusOne = -1
	// powShift[31] wraps to 0x80000000 and powShift[32] overflows to 0, so a
	// left shift of 32 correctly discards every bit
	one.shiftl(31).assertEquals(INT_MIN)
	one.shiftl(32).assertEquals(0)
	// 31 is the largest amount shiftr supports: at 32 it would divide by
	// powShift[32] == 0
	minusOne.shiftr(31).assertEquals(1)
	INT_MIN.shiftr(31).assertEquals(1)

@Test
function toBitStringTests()
	let zero = 0
	let one = 1
	let eight = 8
	let nine = 9
	let minusOne = -1
	let negative = -12345
	zero.toBitString().assertEquals("0")
	one.toBitString().assertEquals("1")
	eight.toBitString().assertEquals("1000")
	nine.toBitString().assertEquals("1001")
	minusOne.toBitString().assertEquals("11111111111111111111111111111111")
	// round trips through fromBitString
	zero.toBitString().fromBitString().assertEquals(0)
	negative.toBitString().fromBitString().assertEquals(-12345)
	INT_MIN.toBitString().fromBitString().assertEquals(INT_MIN)

@Test
function tests32()
	"1001 0001 0100 0010".fromBitString().and32("1000 0100 0010 0110".fromBitString()).assertEquals("1000 0000 0000 0010".fromBitString())
	"1000 0000 0000 0000 1001 0001 0100 0010".fromBitString().and32("1000 0000 0000 0000 1000 0100 0010 0110".fromBitString()).assertEquals("1000 0000 0000 0000 1000 0000 0000 0010".fromBitString())
	"1001 0001 0100 0010".fromBitString().or32("1000 0100 0010 0110".fromBitString()).assertEquals("1001 0101 0110 0110".fromBitString())
	"1000 0000 0000 0000 1001 0001 0100 0010".fromBitString().or32("1000 0000 0000 0000 1000 0100 0010 0110".fromBitString()).assertEquals("1000 0000 0000 0000 1001 0101 0110 0110".fromBitString())
	"1001 0001 0100 0010".fromBitString().xor32("1000 0100 0010 0110".fromBitString()).assertEquals("0001 0101 0110 0100".fromBitString())
	"1000 0000 0000 0000 1001 0001 0100 0010".fromBitString().xor32("1000 0000 0000 0000 1000 0100 0010 0110".fromBitString()).assertEquals("0000 0000 0000 0000 0001 0101 0110 0100".fromBitString())
	"1000 0000 0000 0000 1001 0001 0100 0010".fromBitString().xor32("0000 0000 0000 0000 1000 0100 0010 0110".fromBitString()).assertEquals("1000 0000 0000 0000 0001 0101 0110 0100".fromBitString())