package net.sourceforge.pain.db;

import junit.framework.*;

import java.io.*;

import net.sourceforge.pain.db.data.*;

/**
 * User: fmike * Date: Aug 24, 2003  * Time: 11:15:30 PM
 */
public final class AllTypesGetSetTest extends TestCase {

	private PainDB db;

	public AllTypesGetSetTest() {
		super("AllTypesGetSetTest");
	}

	protected void setUp() throws Exception {
		db = new PainDB(getName() + ".db");
		db.ALLOW_PLAIN_WRITE = true; // allow work without transactions
	}

	protected void tearDown() throws Exception {
		if (db != null) {
			File file = new File(db.getDbFileName());
			db.close();
			db = null;
			file.delete();
		}

	}


	public void testBOOLEAN() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertEquals(false, obj.getBOOLEAN());

		obj.setBOOLEAN(true);
		assertEquals(true, obj.getBOOLEAN());

		obj.setBOOLEAN(false);
		assertEquals(false, obj.getBOOLEAN());
	}


	public void testBYTE() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertEquals((byte) 0, obj.getBYTE());

		obj.setBYTE((byte) 100);
		assertEquals((byte) 100, obj.getBYTE());

		obj.setBYTE((byte) -100);
		assertEquals((byte) -100, obj.getBYTE());
	}

	public void testCHAR() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertEquals((char) 0, obj.getCHAR());

		obj.setCHAR('\t');
		assertEquals('\t', obj.getCHAR());

		obj.setCHAR('x');
		assertEquals('x', obj.getCHAR());
	}


	public void testDOUBLE() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertEquals(0D, obj.getDOUBLE(), 0D);

		obj.setDOUBLE(Math.PI);
		assertEquals(Math.PI, obj.getDOUBLE(), 0D);

		obj.setDOUBLE(Math.E);
		assertEquals(Math.E, obj.getDOUBLE(), 0D);

		obj.setDOUBLE(Double.NaN);
		assertTrue(Double.isNaN(obj.getDOUBLE()));

		obj.setDOUBLE(Double.POSITIVE_INFINITY);
		assertEquals(Double.POSITIVE_INFINITY, obj.getDOUBLE(), 0D);

		obj.setDOUBLE(Double.NEGATIVE_INFINITY);
		assertEquals(Double.NEGATIVE_INFINITY, obj.getDOUBLE(), 0D);

	}


	public void testFLOAT() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertEquals(0F, obj.getFLOAT(), 0F);

		obj.setFLOAT((float) Math.E);
		assertEquals((float) Math.E, obj.getFLOAT(), 0F);

		obj.setFLOAT((float) Math.PI);
		assertEquals((float) Math.PI, obj.getFLOAT(), 0F);

		obj.setFLOAT(Float.NaN);
		assertTrue(Float.isNaN(obj.getFLOAT()));

		obj.setFLOAT(Float.POSITIVE_INFINITY);
		assertEquals(Float.POSITIVE_INFINITY, obj.getFLOAT(), 0F);

		obj.setFLOAT(Float.NEGATIVE_INFINITY);
		assertEquals(Float.NEGATIVE_INFINITY, obj.getFLOAT(), 0F);

	}


	public void testINT() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertEquals(0, obj.getINT());

		obj.setINT(Integer.MAX_VALUE);
		assertEquals(Integer.MAX_VALUE, obj.getINT());

		obj.setINT(0);
		assertEquals(0, obj.getINT());
	}


	public void testLONG() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertEquals(0L, obj.getLONG());

		obj.setLONG(Long.MIN_VALUE);
		assertEquals(Long.MIN_VALUE, obj.getLONG());

		obj.setLONG(-1L);
		assertEquals(-1L, obj.getLONG());
	}


	public void testSHORT() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertEquals((short) 0, obj.getSHORT());

		obj.setSHORT(Short.MIN_VALUE);
		assertEquals(Short.MIN_VALUE, obj.getSHORT());

		obj.setSHORT((short) 1024);
		assertEquals((short) 1024, obj.getSHORT());
	}


	public void testSTRING() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertNull(obj.getSTRING());

		final String v1 = "some test string 1";
		obj.setSTRING(v1);
		assertEquals(v1, obj.getSTRING());

		final String v2 = "some test string 2";
		obj.setSTRING(v2);
		assertEquals(v2, obj.getSTRING());

		obj.setSTRING(null);
		assertNull(obj.getSTRING());
	}


	public void testREFERENCE() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertNull(obj.getREFERENCE());

		obj.setREFERENCE(obj);
		assertEquals(obj, obj.getREFERENCE());

		obj.setREFERENCE(null);
		assertNull(obj.getREFERENCE());
	}


	public void testARRAY_OF_BYTE() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertNull(obj.getARRAY_OF_BYTE());

		byte[] v1 = new byte[]{1, 2, 3, 4};
		obj.setARRAY_OF_BYTE(v1);
		assertEquals(v1, obj.getARRAY_OF_BYTE());
		assertTrue(v1 == obj.getARRAY_OF_BYTE());

		obj.setARRAY_OF_BYTE(null);
		assertNull(obj.getARRAY_OF_BYTE());
	}


	public void testARRAY_OF_CHAR() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertNull(obj.getARRAY_OF_CHAR());

		char[] v1 = new char[]{'H', 'e', 'l', 'l', 'o', '!'};
		obj.setARRAY_OF_CHAR(v1);
		assertEquals(v1, obj.getARRAY_OF_CHAR());
		assertTrue(v1 == obj.getARRAY_OF_CHAR());

		obj.setARRAY_OF_CHAR(null);
		assertNull(obj.getARRAY_OF_CHAR());
	}


	public void testARRAY_OF_INT() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertNull(obj.getARRAY_OF_INT());

		int[] v1 = new int[]{1, 2, 3, 4};
		obj.setARRAY_OF_INT(v1);
		assertEquals(v1, obj.getARRAY_OF_INT());
		assertTrue(v1 == obj.getARRAY_OF_INT());

		obj.setARRAY_OF_INT(null);
		assertNull(obj.getARRAY_OF_INT());
	}


	public void testARRAY_OF_STRING() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		assertNull(obj.getARRAY_OF_STRING());

		String[] v1 = new String[]{"1", null, "3", "456789"};
		obj.setARRAY_OF_STRING(v1);
		assertEquals(v1, obj.getARRAY_OF_STRING());
		assertTrue(v1 == obj.getARRAY_OF_STRING());

		obj.setARRAY_OF_STRING(null);
		assertNull(obj.getARRAY_OF_STRING());
	}


	public void testLINKED_LIST() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		DbLinkedList list = obj.getLINKED_LIST();
		assertNotNull(list);
		assertEquals(0, list.size());

		list.add(obj);
		assertEquals(1, list.size());

		list.add(obj);
		assertEquals(2, list.size());
		assertTrue(list.get(1) == obj);

		assertEquals(0, list.indexOf(obj));

		list.remove(obj);
		assertEquals(1, list.size());

		list.remove(obj);
		assertEquals(0, list.size());


		list.add(obj);
		list.add(obj);
		list.addAll(list);
		assertEquals(4, list.size());

		list.retainAll(list);
		assertEquals(4, list.size());
		assertTrue(list.get(3) == obj);

		assertTrue(list.contains(obj));
		assertFalse(list.contains(list));

		list.clear();
		assertTrue(list.isEmpty());
	}


	public void testARRAY_LIST() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		DbArrayList list = obj.getARRAY_LIST();
		assertNotNull(list);
		assertEquals(0, list.size());

		list.add(obj);
		assertEquals(1, list.size());

		list.add(obj);
		assertEquals(2, list.size());
		assertTrue(list.get(1) == obj);

		assertEquals(0, list.indexOf(obj));

		list.remove(obj);
		assertEquals(1, list.size());

		list.remove(obj);
		assertEquals(0, list.size());

		list.add(obj);
		list.add(obj);
		list.addAll(list);
		assertEquals(4, list.size());
		assertTrue(list.get(3) == obj);

		list.retainAll(list);
		assertEquals(4, list.size());

		assertTrue(list.contains(obj));
		assertFalse(list.contains(list));

		list.clear();
		assertTrue(list.isEmpty());
	}


	public void testINT_KEY_MAP() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		DbIntKeyMap map = obj.getINT_KEY_MAP();
		assertNotNull(map);
		assertEquals(0, map.size());

		map.put(1, obj);
		assertEquals(1, map.size());
		assertTrue(obj == map.get(1));
		assertNull(map.get(2));

		assertTrue(map.put(1, obj) == obj);
		assertEquals(1, map.size());
		map.put(2, obj);
		assertEquals(2, map.size());

		assertTrue(map.containsValue(obj));
		assertTrue(map.containsKey(2));
		assertFalse(map.containsKey(3));
		assertTrue(obj == map.remove(1));
		assertEquals(1, map.size());
		map.clear();
		assertEquals(0, map.size());
	}


	public void testSTRING_KEY_MAP() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		DbStringKeyMap map = obj.getSTRING_KEY_MAP();
		assertNotNull(map);
		assertEquals(0, map.size());

		final String key1 = "111";
		final String key2 = "222";
		final String key3 = "333";

		map.put(key1, obj);
		assertEquals(1, map.size());
		assertTrue(obj == map.get(key1));
		assertNull(map.get(key2));

		assertTrue(map.put(key1, obj) == obj);
		assertEquals(1, map.size());
		map.put(key2, obj);
		assertEquals(2, map.size());

		assertTrue(map.containsValue(obj));
		assertTrue(map.containsKey(key2));
		assertFalse(map.containsKey(key3));
		assertTrue(obj == map.remove(key1));
		assertEquals(1, map.size());
		map.clear();
		assertEquals(0, map.size());
	}


	public void testREFERENCE_SET() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		DbReferenceSet set = obj.getREFERENCE_SET();
		assertNotNull(set);
		assertEquals(0, set.size());

		set.add(obj);
		assertEquals(1, set.size());

		set.add(obj);
		assertEquals(1, set.size());


		set.remove(obj);
		assertEquals(0, set.size());


		set.add(obj);
		set.add(obj);
//		set.addAll(set); unsupported -> todo
		assertEquals(1, set.size());

//		set.retainAll(set); unsupported -> todo
//		assertEquals(1, set.size());

		assertTrue(set.contains(obj));
		ClassCastException e = null;
		try {
			set.contains(set);
		} catch (ClassCastException ex) {
			e = ex;
		}
		assertNotNull(e);

		set.clear();
		assertTrue(set.isEmpty());
	}

	public void testSTRING_SET() {
		AllFieldTypesObject obj = new AllFieldTypesObject(db);
		DbStringSet set = obj.getSTRING_SET();
		assertNotNull(set);
		assertEquals(0, set.size());

		final String obj1 = "lalala";
		set.add(obj1);
		assertEquals(1, set.size());

		set.add(obj1);
		assertEquals(1, set.size());


		set.remove(obj1);
		assertEquals(0, set.size());


		set.add(obj1);
		set.add(obj1);
//		set.addAll(set); unsupported -> todo
		assertEquals(1, set.size());

//		set.retainAll(set); unsupported -> todo
//		assertEquals(1, set.size());

		assertTrue(set.contains(obj1));
		assertFalse(set.contains(set));

		set.clear();
		assertTrue(set.isEmpty());
	}


	public void testSTRING_MAP() {
			AllFieldTypesObject obj = new AllFieldTypesObject(db);
			DbStringMap map = obj.getSTRING_MAP();
			assertNotNull(map);
			assertEquals(0, map.size());

			final String key1 = "key1";
			final String obj1 = "lalala";
			map.put(key1, obj1);
			assertEquals(1, map.size());

			map.put(key1, obj1);
			assertEquals(1, map.size());


			map.remove(key1);
			assertEquals(0, map.size());


			map.put(key1, obj1);
			map.put(key1, obj1);
//		map.addAll(map); unsupported -> todo
			assertEquals(1, map.size());

//		map.retainAll(map); unsupported -> todo
//		assertEquals(1, map.size());

			assertTrue(map.containsKey(key1));
			assertTrue(map.containsValue(obj1));

			map.clear();
			assertTrue(map.isEmpty());
		}

}