Author: dlanglais Date: 2010-01-28 00:45:23 +0100 (Thu, 28 Jan 2010) New Revision: 27 Modified: trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/StructureTest.java Log: Tests de la classe StructureImpl termin?\195?\169s. Modified: trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/StructureTest.java =================================================================== --- trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/StructureTest.java 2010-01-27 23:23:49 UTC (rev 26) +++ trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/StructureTest.java 2010-01-27 23:45:23 UTC (rev 27) @@ -2,6 +2,7 @@ import java.lang.reflect.Field; import java.util.HashMap; +import java.util.HashSet; import java.util.Map; import java.util.Set; import java.util.logging.Level; @@ -26,32 +27,96 @@ Map < String, Class < ? > > structureExpected = new HashMap<String, Class<?>>(); - + try { Structure s = new StructureImpl(); - + Field fStructure = s.getClass().getDeclaredField("structure"); fStructure.setAccessible(true); Map < String, Class < ? > > structureActual = (Map < String, Class < ? > >) fStructure.get(s); - s.addColumn("Test", String.class); - structureExpected.put("Test", String.class); + s.addColumn("Test1", String.class); + structureExpected.put("Test1", String.class); assertEquals(structureExpected, structureActual); - s.addColumn("Test2", Object.class); structureExpected.put("Test2", Object.class); + assertEquals(structureExpected, structureActual); + s.addColumn("Test3", Map.class); + structureExpected.put("Test3", Map.class); assertEquals(structureExpected, structureActual); - + } catch (IllegalArgumentException ex) { + Logger.getLogger(StructureTest.class.getName()).log(Level.SEVERE, null, ex); + } catch (IllegalAccessException ex) { + Logger.getLogger(StructureTest.class.getName()).log(Level.SEVERE, null, ex); + } catch (NoSuchFieldException ex) { + Logger.getLogger(StructureTest.class.getName()).log(Level.SEVERE, null, ex); + } catch (SecurityException ex) { + Logger.getLogger(StructureTest.class.getName()).log(Level.SEVERE, null, ex); + } + } + + /** + * we add a column with name and class. + * We use reflexivity to verify that the map of the structure is like we + * want. + * We remove column, and we continue to verify that the map of the structure + * is always good. + */ + public void testRemoveColumn() { + + Map < String, Class < ? > > structureExpected = + new HashMap<String, Class<?>>(); + + try { + Structure s = new StructureImpl(); + + Field fStructure = s.getClass().getDeclaredField("structure"); + fStructure.setAccessible(true); + Map < String, Class < ? > > structureActual = + (Map < String, Class < ? > >) fStructure.get(s); + + + s.addColumn("Test1", String.class); + structureExpected.put("Test1", String.class); + s.addColumn("Test2", Object.class); + structureExpected.put("Test2", Object.class); s.addColumn("Test3", Map.class); structureExpected.put("Test3", Map.class); + assertEquals(structureExpected, structureActual); + s.removeColumn("Test1"); + structureExpected.remove("Test1"); assertEquals(structureExpected, structureActual); - + + /** + * the key "Test1TOTO" is not in the structure. + */ + s.removeColumn("Test1TOTO"); + structureExpected.remove("Test1TOTO"); + assertEquals(structureExpected, structureActual); + + s.removeColumn("Test2"); + structureExpected.remove("Test2"); + assertEquals(structureExpected, structureActual); + + s.removeColumn("Test3"); + structureExpected.remove("Test3"); + assertEquals(structureExpected, structureActual); + + /** + * We try to remove an other key, but the map is empty. + */ + s.removeColumn("Test4"); + structureExpected.remove("Test4"); + + assertEquals(structureExpected, structureActual); + + } catch (IllegalArgumentException ex) { Logger.getLogger(StructureTest.class.getName()).log(Level.SEVERE, null, ex); } catch (IllegalAccessException ex) { @@ -62,4 +127,149 @@ Logger.getLogger(StructureTest.class.getName()).log(Level.SEVERE, null, ex); } } + + /** + * we add a column with name and class. + * We use reflexivity to verify that the columsNames returned are goods. + * We remove column, and we continue to verify that the columsNames is + * always good. + */ + public void testGetColumnsNames() { + + Structure s = new StructureImpl(); + + Set<String> columsNamesExpected = new HashSet<String>(); + Set<String> columnsNamesActual = s.getColumnsNames(); + + + s.addColumn("Test1", String.class); + columsNamesExpected.add("Test1"); + assertEquals(columsNamesExpected, columnsNamesActual); + + s.addColumn("Test2", Object.class); + columsNamesExpected.add("Test2"); + assertEquals(columsNamesExpected, columnsNamesActual); + + s.addColumn("Test3", Map.class); + columsNamesExpected.add("Test3"); + assertEquals(columsNamesExpected, columnsNamesActual); + + s.removeColumn("Test1"); + columsNamesExpected.remove("Test1"); + assertEquals(columsNamesExpected, columnsNamesActual); + + /** + * the key "Test1TOTO" is not in the structure. + */ + s.removeColumn("Test1TOTO"); + columsNamesExpected.remove("Test1TOTO"); + assertEquals(columsNamesExpected, columnsNamesActual); + + s.removeColumn("Test2"); + columsNamesExpected.remove("Test2"); + assertEquals(columsNamesExpected, columnsNamesActual); + + s.removeColumn("Test3"); + columsNamesExpected.remove("Test3"); + assertEquals(columsNamesExpected, columnsNamesActual); + + /** + * We try to remove an other key, but the map is empty. + */ + s.removeColumn("Test4"); + columsNamesExpected.remove("Test4"); + + assertEquals(columsNamesExpected, columnsNamesActual); + + } + + /** + * we add a column with name and class. + * We use reflexivity to verify that the columsNames returned are goods. + * We remove column, and we continue to verify that the columsNames is + * always good. + */ + public void testGetColumnClass() { + + Structure s = new StructureImpl(); + + Class<?> columsClassExpected; + Class<?> columsClassActual; + + + s.addColumn("Test1", String.class); + columsClassActual = s.getColumnClass("Test1"); + columsClassExpected = String.class; + assertEquals(columsClassExpected, columsClassActual); + + s.addColumn("Test2", Object.class); + columsClassActual = s.getColumnClass("Test1"); + columsClassExpected = String.class; + assertEquals(columsClassExpected, columsClassActual); + columsClassActual = s.getColumnClass("Test2"); + columsClassExpected = Object.class; + assertEquals(columsClassExpected, columsClassActual); + + s.addColumn("Test3", Map.class); + columsClassActual = s.getColumnClass("Test1"); + columsClassExpected = String.class; + assertEquals(columsClassExpected, columsClassActual); + columsClassActual = s.getColumnClass("Test2"); + columsClassExpected = Object.class; + assertEquals(columsClassExpected, columsClassActual); + columsClassActual = s.getColumnClass("Test3"); + columsClassExpected = Map.class; + assertEquals(columsClassExpected, columsClassActual); + + s.removeColumn("Test1"); + columsClassActual = s.getColumnClass("Test1"); + columsClassExpected = null; + assertEquals(columsClassExpected, columsClassActual); + columsClassActual = s.getColumnClass("Test2"); + columsClassExpected = Object.class; + assertEquals(columsClassExpected, columsClassActual); + columsClassActual = s.getColumnClass("Test3"); + columsClassExpected = Map.class; + assertEquals(columsClassExpected, columsClassActual); + + /** + * the key "Test1TOTO" is not in the structure. + */ + s.removeColumn("Test1TOTO"); + columsClassActual = s.getColumnClass("Test1TOTO"); + columsClassExpected = null; + assertEquals(columsClassExpected, columsClassActual); + assertEquals(columsClassExpected, columsClassActual); + columsClassActual = s.getColumnClass("Test2"); + columsClassExpected = Object.class; + assertEquals(columsClassExpected, columsClassActual); + columsClassActual = s.getColumnClass("Test3"); + columsClassExpected = Map.class; + assertEquals(columsClassExpected, columsClassActual); + + s.removeColumn("Test2"); + assertEquals(columsClassExpected, columsClassActual); + columsClassActual = s.getColumnClass("Test2"); + columsClassExpected = null; + assertEquals(columsClassExpected, columsClassActual); + columsClassActual = s.getColumnClass("Test3"); + columsClassExpected = Map.class; + assertEquals(columsClassExpected, columsClassActual); + + s.removeColumn("Test3"); + assertEquals(columsClassExpected, columsClassActual); + columsClassActual = s.getColumnClass("Test3"); + columsClassExpected = null; + assertEquals(columsClassExpected, columsClassActual); + + /** + * We try to remove an other key, but the map is empty. + */ + s.removeColumn("Test4"); + columsClassActual = s.getColumnClass("Test4"); + columsClassExpected = null; + + assertEquals(columsClassExpected, columsClassActual); + + } }