/*******************************************************************************
 * Copyright (c) 2006, 2010 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0, which accompanies this distribution
 * and is available at http://www.eclipse.org/legal/epl-v10.html.
 * 
 * Contributors:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.common.utility.tests.internal;

import java.lang.reflect.InvocationTargetException;

import junit.framework.TestCase;

import org.eclipse.jpt.common.utility.internal.BitTools;
import org.eclipse.jpt.common.utility.internal.ReflectionTools;

public class BitToolsTests extends TestCase {

	public BitToolsTests(String name) {
		super(name);
	}

	public void testFlagIsSetIntInt() {
		assertTrue(BitTools.flagIsSet(0x0003, 0x0001));
		assertTrue(BitTools.flagIsSet(0x0303, 0x0001));
		assertTrue(BitTools.flagIsSet(0x0303, 0x0101));
		assertTrue(BitTools.flagIsSet(0x0303, 0x0103));

		assertFalse(BitTools.flagIsSet(0x0303, 0x1103));
		assertFalse(BitTools.flagIsSet(0x0000, 0x1103));
	}

	public void testFlagIsOffIntInt() {
		assertFalse(BitTools.flagIsOff(0x0003, 0x0001));
		assertFalse(BitTools.flagIsOff(0x0303, 0x0001));
		assertFalse(BitTools.flagIsOff(0x0303, 0x0101));
		assertFalse(BitTools.flagIsOff(0x0303, 0x0103));

		assertTrue(BitTools.flagIsOff(0x2204, 0x1103));
		assertTrue(BitTools.flagIsOff(0x0000, 0x1103));
	}

	public void testOnlyFlagIsSetIntInt() {
		assertFalse(BitTools.onlyFlagIsSet(0x0003, 0x0001));
		assertTrue(BitTools.onlyFlagIsSet(0x0001, 0x0001));

		assertFalse(BitTools.onlyFlagIsSet(0x0303, 0x0001));
		assertTrue(BitTools.onlyFlagIsSet(0x0001, 0x0001));

		assertFalse(BitTools.onlyFlagIsSet(0x0303, 0x0101));
		assertTrue(BitTools.onlyFlagIsSet(0x0101, 0x0101));

		assertFalse(BitTools.onlyFlagIsSet(0x0303, 0x0103));
		assertTrue(BitTools.onlyFlagIsSet(0x0103, 0x0103));

		assertFalse(BitTools.onlyFlagIsSet(0x0303, 0x1103));
		assertTrue(BitTools.onlyFlagIsSet(0x1103, 0x1103));

		assertFalse(BitTools.onlyFlagIsSet(0x0000, 0x1103));
		assertTrue(BitTools.onlyFlagIsSet(0x0103, 0x0103));
	}

	public void testOnlyFlagIsOffIntInt() {
		assertFalse(BitTools.onlyFlagIsOff(0x0003, 0x0001));
		assertFalse(BitTools.onlyFlagIsOff(0x0303, 0x0001));
		assertTrue(BitTools.onlyFlagIsOff(0xFFFFFFFE, 0x0001));

		assertFalse(BitTools.onlyFlagIsOff(0x0303, 0x0101));
		assertTrue(BitTools.onlyFlagIsOff(0xFFFFFEFE, 0x0101));

		assertFalse(BitTools.onlyFlagIsOff(0x0303, 0x0103));
		assertTrue(BitTools.onlyFlagIsOff(0xFFFFFEFC, 0x0103));

		assertFalse(BitTools.onlyFlagIsOff(0x0303, 0x1103));
		assertTrue(BitTools.onlyFlagIsOff(0xFFFFEEFC, 0x1103));
	}

	public void testAllFlagsAreSetIntInt() {
		assertTrue(BitTools.allFlagsAreSet(0x0003, 0x0001));
		assertTrue(BitTools.allFlagsAreSet(0x0303, 0x0001));
		assertTrue(BitTools.allFlagsAreSet(0x0303, 0x0101));
		assertTrue(BitTools.allFlagsAreSet(0x0303, 0x0103));

		assertFalse(BitTools.allFlagsAreSet(0x0303, 0x1103));
		assertFalse(BitTools.allFlagsAreSet(0x0000, 0x1103));
	}

	public void testAllFlagsAreOffIntInt() {
		assertFalse(BitTools.allFlagsAreOff(0x0003, 0x0001));
		assertFalse(BitTools.allFlagsAreOff(0x0303, 0x0001));
		assertFalse(BitTools.allFlagsAreOff(0x0303, 0x0101));
		assertFalse(BitTools.allFlagsAreOff(0x0303, 0x0103));

		assertTrue(BitTools.allFlagsAreOff(0x2204, 0x1103));
		assertTrue(BitTools.allFlagsAreOff(0x0000, 0x1103));
	}

	public void testOnlyFlagsAreSetIntInt() {
		assertFalse(BitTools.onlyFlagsAreSet(0x0003, 0x0001));
		assertTrue(BitTools.onlyFlagsAreSet(0x0001, 0x0001));

		assertFalse(BitTools.onlyFlagsAreSet(0x0303, 0x0001));
		assertTrue(BitTools.onlyFlagsAreSet(0x0001, 0x0001));

		assertFalse(BitTools.onlyFlagsAreSet(0x0303, 0x0101));
		assertTrue(BitTools.onlyFlagsAreSet(0x0101, 0x0101));

		assertFalse(BitTools.onlyFlagsAreSet(0x0303, 0x0103));
		assertTrue(BitTools.onlyFlagsAreSet(0x0103, 0x0103));

		assertFalse(BitTools.onlyFlagsAreSet(0x0303, 0x1103));
		assertTrue(BitTools.onlyFlagsAreSet(0x1103, 0x1103));

		assertFalse(BitTools.onlyFlagsAreSet(0x0000, 0x1103));
		assertTrue(BitTools.onlyFlagsAreSet(0x0103, 0x0103));
	}

	public void testOnlyFlagsAreOffIntInt() {
		assertFalse(BitTools.onlyFlagsAreOff(0x0003, 0x0001));
		assertFalse(BitTools.onlyFlagsAreOff(0x0303, 0x0001));
		assertTrue(BitTools.onlyFlagsAreOff(0xFFFFFFFE, 0x0001));

		assertFalse(BitTools.onlyFlagsAreOff(0x0303, 0x0101));
		assertTrue(BitTools.onlyFlagsAreOff(0xFFFFFEFE, 0x0101));

		assertFalse(BitTools.onlyFlagsAreOff(0x0303, 0x0103));
		assertTrue(BitTools.onlyFlagsAreOff(0xFFFFFEFC, 0x0103));

		assertFalse(BitTools.onlyFlagsAreOff(0x0303, 0x1103));
		assertTrue(BitTools.onlyFlagsAreOff(0xFFFFEEFC, 0x1103));
	}

	public void testAnyFlagsAreSetIntInt() {
		assertTrue(BitTools.anyFlagsAreSet(0x0003, 0x0001));
		assertTrue(BitTools.anyFlagsAreSet(0xFFFF, 0x0001));
		assertTrue(BitTools.anyFlagsAreSet(0x0003, 0xFFFF));

		assertFalse(BitTools.anyFlagsAreSet(0x0303, 0x1010));
		assertFalse(BitTools.anyFlagsAreSet(0x0000, 0xFFFF));
	}

	public void testAnyFlagsAreOffIntInt() {
		assertTrue(BitTools.anyFlagsAreOff(0x333E, 0x0001));
		assertTrue(BitTools.anyFlagsAreOff(0xFFFE, 0x0001));
		assertTrue(BitTools.anyFlagsAreOff(0x0003, 0xFFFF));

		assertFalse(BitTools.anyFlagsAreOff(0x7373, 0x1010));
		assertFalse(BitTools.anyFlagsAreOff(0xFFFF, 0xFFFF));
	}

	public void testAllFlagsAreSetIntIntArray() {
		assertTrue(BitTools.allFlagsAreSet(0x0003, new int[] { 0x0001 }));
		assertTrue(BitTools.allFlagsAreSet(0x0303, new int[] { 0x0001 }));
		assertTrue(BitTools.allFlagsAreSet(0x0303, new int[] { 0x0100, 0x0001 }));
		assertTrue(BitTools.allFlagsAreSet(0x0303, new int[] { 0x0100, 0x0002, 0x0001 }));

		assertFalse(BitTools.allFlagsAreSet(0x0303, new int[] { 0x1000, 0x0100, 0x0002, 0x0001 }));
		assertFalse(BitTools.allFlagsAreSet(0x0000, new int[] { 0x1000, 0x0100, 0x0002, 0x0001 }));
	}

	public void testAllFlagsAreOffIntIntArray() {
		assertFalse(BitTools.allFlagsAreOff(0x0003, new int[] { 0x0001 }));
		assertFalse(BitTools.allFlagsAreOff(0x0303, new int[] { 0x0001 }));
		assertFalse(BitTools.allFlagsAreOff(0x0303, new int[] { 0x0100, 0x0001 }));
		assertFalse(BitTools.allFlagsAreOff(0x0303, new int[] { 0x0100, 0x0002, 0x0001 }));

		assertTrue(BitTools.allFlagsAreOff(0x0303, new int[] { 0x1000, 0x0400, 0x0020, 0x0000 }));
		assertTrue(BitTools.allFlagsAreOff(0x0000, new int[] { 0x1000, 0x0100, 0x0002, 0x0001 }));
	}

	public void testOnlyFlagsAreSetIntIntArray() {
		assertFalse(BitTools.onlyFlagsAreSet(0x0003, new int[] { 0x001, 0x0000, 0x0000, 0x0001 }));
		assertTrue(BitTools.onlyFlagsAreSet(0x0001, new int[] { 0x001, 0x0000, 0x0000, 0x0001 }));

		assertFalse(BitTools.onlyFlagsAreSet(0x0303, new int[] { 0x001, 0x0000, 0x0000, 0x0001 }));
		assertTrue(BitTools.onlyFlagsAreSet(0x0001, new int[] { 0x001, 0x0000, 0x0000, 0x0001 }));

		assertFalse(BitTools.onlyFlagsAreSet(0x0303, new int[] { 0x001, 0x0100, 0x0000, 0x0001 }));
		assertTrue(BitTools.onlyFlagsAreSet(0x0101, new int[] { 0x001, 0x0100, 0x0000, 0x0001 }));

		assertFalse(BitTools.onlyFlagsAreSet(0x0303, new int[] { 0x001, 0x0100, 0x0002, 0x0001 }));
		assertTrue(BitTools.onlyFlagsAreSet(0x0103, new int[] { 0x001, 0x0100, 0x0002, 0x0001 }));

		assertFalse(BitTools.onlyFlagsAreSet(0x0303, new int[] { 0x011, 0x0100, 0x0002, 0x0001 }));
		assertTrue(BitTools.onlyFlagsAreSet(0x1103, new int[] { 0x1100, 0x0100, 0x0002, 0x0001 }));

		assertFalse(BitTools.onlyFlagsAreSet(0x0000, new int[] { 0x011, 0x0100, 0x0002, 0x0001 }));
		assertTrue(BitTools.onlyFlagsAreSet(0x0103, new int[] { 0x0101, 0x0100, 0x0002, 0x0001 }));
	}

	public void testOnlyFlagsAreOffIntIntArray() {
		assertFalse(BitTools.onlyFlagsAreOff(0x0003, new int[] { 0x001, 0x0000, 0x0000, 0x0001 }));
		assertFalse(BitTools.onlyFlagsAreOff(0x0303, new int[] { 0x001, 0x0000, 0x0000, 0x0001 }));
		assertTrue(BitTools.onlyFlagsAreOff(0xFFFFFFFE, new int[] { 0x001, 0x0000, 0x0000, 0x0001 }));

		assertFalse(BitTools.onlyFlagsAreOff(0x0303, new int[] { 0x001, 0x0100, 0x0000, 0x0001 }));
		assertTrue(BitTools.onlyFlagsAreOff(0xFFFFFEFE, new int[] { 0x001, 0x0100, 0x0000, 0x0001 }));

		assertFalse(BitTools.onlyFlagsAreOff(0x0303, new int[] { 0x001, 0x0100, 0x0002, 0x0001 }));
		assertTrue(BitTools.onlyFlagsAreOff(0xFFFFFEFC, new int[] { 0x001, 0x0100, 0x0002, 0x0001 }));

		assertFalse(BitTools.onlyFlagsAreOff(0x0303, new int[] { 0x1100, 0x0100, 0x0002, 0x0001 }));
		assertTrue(BitTools.onlyFlagsAreOff(0xFFFFEEFC, new int[] { 0x1100, 0x0100, 0x0002, 0x0001 }));
	}

	public void testAnyFlagsAreSetIntIntArray() {
		assertTrue(BitTools.anyFlagsAreSet(0x0003, new int[] { 0x0001 }));
		assertTrue(BitTools.anyFlagsAreSet(0xFFFF, new int[] { 0x0001 }));
		assertTrue(BitTools.anyFlagsAreSet(0x0303, new int[] { 0xF000, 0x0F00, 0x00F0, 0x000F }));

		assertFalse(BitTools.anyFlagsAreSet(0x0303, new int[] { 0x1000, 0x0010 }));
		assertFalse(BitTools.anyFlagsAreSet(0x0000, new int[] { 0xF000, 0x0F00, 0x00F0, 0x000F }));
	}

	public void testAnyFlagsAreOffIntIntArray() {
		assertFalse(BitTools.anyFlagsAreOff(0x0003, new int[] { 0x0001 }));
		assertFalse(BitTools.anyFlagsAreOff(0xFFFF, new int[] { 0x0001 }));
		assertFalse(BitTools.anyFlagsAreOff(0x0303, new int[] { 0x0100, 0x0200, 0x0003, 0x0002 }));

		assertTrue(BitTools.anyFlagsAreOff(0x0303, new int[] { 0x0100, 0x0010 }));
		assertTrue(BitTools.anyFlagsAreOff(0x0000, new int[] { 0xF000, 0x0F00, 0x00F0, 0x000F }));
	}

	public void testOrFlags() {
		assertEquals(0x0001, BitTools.orFlags(new int[] { 0x0001, 0x0000 }));
		assertEquals(0x0011, BitTools.orFlags(new int[] { 0x0001, 0x0011 }));
		assertEquals(0xF011, BitTools.orFlags(new int[] { 0x0001, 0x0011, 0xF000 }));
	}

	public void testAndFlags() {
		assertEquals(0x0001, BitTools.andFlags(new int[] { 0x0001, 0x0001 }));
		assertEquals(0x0001, BitTools.andFlags(new int[] { 0x0001, 0x0011 }));
		assertEquals(0x0000, BitTools.andFlags(new int[] { 0x0001, 0x0011, 0xF000 }));
		assertEquals(0x0001, BitTools.andFlags(new int[] { 0x0001, 0x0011, 0xF001 }));
	}

	public void testXorFlags() {
		assertEquals(0x0001, BitTools.xorFlags(new int[] { 0x0001, 0x0000 }));
		assertEquals(0x0010, BitTools.xorFlags(new int[] { 0x0001, 0x0011 }));
		assertEquals(0xF010, BitTools.xorFlags(new int[] { 0x0001, 0x0011, 0xF000 }));
		assertEquals(0xFF11, BitTools.xorFlags(new int[] { 0x0001, 0x0011, 0xF000, 0x0F01 }));
		assertEquals(0xF010, BitTools.xorFlags(new int[] { 0x0001, 0x0011, 0xF000, 0x0F01, 0x0F01 }));
	}

	public void testConstructor() {
		boolean exCaught = false;
		try {
			Object at = ReflectionTools.newInstance(BitTools.class);
			fail("bogus: " + at); //$NON-NLS-1$
		} catch (RuntimeException ex) {
			if (ex.getCause() instanceof InvocationTargetException) {
				if (ex.getCause().getCause() instanceof UnsupportedOperationException) {
					exCaught = true;
				}
			}
		}
		assertTrue(exCaught);
	}

}