Author: dlanglais Date: 2010-01-28 19:01:26 +0100 (Thu, 28 Jan 2010) New Revision: 34 Modified: trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/CellTest.java trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/ColumnTest.java trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/RowTest.java trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/StructureTest.java Log: refactoring dans les classes de Test ... (*Expected / *Actual) Modified: trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/CellTest.java =================================================================== --- trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/CellTest.java 2010-01-28 17:31:48 UTC (rev 33) +++ trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/CellTest.java 2010-01-28 18:01:26 UTC (rev 34) @@ -14,13 +14,18 @@ */ public final class CellTest extends TestCase { + Cell < Object > cellActual; + Object objectExcepted; + Object object2Excepted; + Object object3Excepted; + /** * On teste le comportement de get avec une cellule vide. */ public void testGetVoid() { - Cell < Object > cell = new CellImpl < Object > (); + cellActual = new CellImpl < Object > (); try { - assertNull(cell.get()); + assertNull(cellActual.get()); Assert.fail(); } catch (NoSuchElementException e) { System.out.println("Exception levée correctement"); @@ -33,19 +38,19 @@ */ public void testPut() { - Cell < Object > cell = new CellImpl < Object > (); + cellActual = new CellImpl < Object > (); - Object obj1 = new Object(); + objectExcepted = new Object(); try { - assertNull(cell.get()); + assertNull(cellActual.get()); Assert.fail(); } catch (NoSuchElementException e) { System.out.println("Exception levée correctement"); } - cell.put(obj1); + cellActual.put(objectExcepted); - assertEquals(cell.get(), obj1); + assertEquals(cellActual.get(), objectExcepted); } /** @@ -56,30 +61,30 @@ */ public void testPutReput() { - Cell < Object > cell = new CellImpl < Object > (); + cellActual = new CellImpl < Object > (); - Object obj1 = new Object(); + objectExcepted = new Object(); try { - assertNull(cell.get()); + assertNull(cellActual.get()); Assert.fail(); } catch (NoSuchElementException e) { System.out.println("Exception levée correctement"); } - cell.put(obj1); + cellActual.put(objectExcepted); - assertEquals(cell.get(), obj1); + assertEquals(cellActual.get(), objectExcepted); - Object obj2 = new Object(); + object2Excepted = new Object(); - cell.put(obj2); + cellActual.put(object2Excepted); - assertEquals(cell.get(), obj2); + assertEquals(cellActual.get(), object2Excepted); - Object obj3 = new Object(); + object3Excepted = new Object(); - cell.put(obj3); + cellActual.put(object3Excepted); - assertEquals(cell.get(), obj3); + assertEquals(cellActual.get(), object3Excepted); } } Modified: trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/ColumnTest.java =================================================================== --- trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/ColumnTest.java 2010-01-28 17:31:48 UTC (rev 33) +++ trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/ColumnTest.java 2010-01-28 18:01:26 UTC (rev 34) @@ -7,13 +7,15 @@ public final class ColumnTest extends TestCase { + Column columnActual; + Object objectExpected; /** * On teste le comportement de get avec une cellule vide. */ public void testGetVoid() { - Column < Object > col = new ColumnImpl < Object > (); + columnActual = new ColumnImpl < Object > (); try { - col.get("test"); + columnActual.get("test"); Assert.fail(); } catch (NoSuchElementException e) { System.out.println("Exception levée correctement"); @@ -25,20 +27,20 @@ * On tente de récupérer celui-ci. */ public void testPut() { - Column < Object > col = new ColumnImpl < Object > (); + columnActual = new ColumnImpl < Object > (); - Object obj1 = new Object(); + objectExpected = new Object(); try { - col.get("object 1"); + columnActual.get("object 1"); Assert.fail(); } catch (NoSuchElementException e) { System.out.println("Exception levée correctement"); } - col.put("object 1", obj1); + columnActual.put("object 1", objectExpected); - assertEquals(col.get("object 1"), obj1); + assertEquals(columnActual.get("object 1"), objectExpected); } } Modified: trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/RowTest.java =================================================================== --- trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/RowTest.java 2010-01-28 17:31:48 UTC (rev 33) +++ trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/RowTest.java 2010-01-28 18:01:26 UTC (rev 34) @@ -6,145 +6,145 @@ public class RowTest extends TestCase { - Structure structure; - Map<String,Object> content; - Row r; + Structure structureExpected; + Map<String,Object> contentExpected; + Row rowActual; public void testToString() { { - structure = new StructureImpl(); - content = new HashMap<String, Object>(); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + contentExpected = new HashMap<String, Object>(); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.toString(), content.values().toString()); + assertEquals(rowActual.toString(), contentExpected.values().toString()); } { - structure = new StructureImpl(); - structure.addColumn("Test", String.class); - content = new HashMap<String, Object>(); - content.put("Test", "StringDeTest"); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + structureExpected.addColumn("Test", String.class); + contentExpected = new HashMap<String, Object>(); + contentExpected.put("Test", "StringDeTest"); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.toString(), content.values().toString()); + assertEquals(rowActual.toString(), contentExpected.values().toString()); } { - structure = new StructureImpl(); - structure.addColumn("Test1", String.class); - structure.addColumn("Test2", Integer.class); - structure.addColumn("Test3", Double.class); - content = new HashMap<String, Object>(); - content.put("Test1", "StringDeTest"); - content.put("Test2", new Integer(1)); - content.put("Test3", new Double(0.07)); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + structureExpected.addColumn("Test1", String.class); + structureExpected.addColumn("Test2", Integer.class); + structureExpected.addColumn("Test3", Double.class); + contentExpected = new HashMap<String, Object>(); + contentExpected.put("Test1", "StringDeTest"); + contentExpected.put("Test2", new Integer(1)); + contentExpected.put("Test3", new Double(0.07)); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.toString(), content.values().toString()); + assertEquals(rowActual.toString(), contentExpected.values().toString()); } } public void testGetRowContent() { { - structure = new StructureImpl(); - content = new HashMap<String, Object>(); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + contentExpected = new HashMap<String, Object>(); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.getRowContent(), content); + assertEquals(rowActual.getRowContent(), contentExpected); } { - structure = new StructureImpl(); - structure.addColumn("Test", String.class); - content = new HashMap<String, Object>(); - content.put("Test", "StringDeTest"); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + structureExpected.addColumn("Test", String.class); + contentExpected = new HashMap<String, Object>(); + contentExpected.put("Test", "StringDeTest"); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.getRowContent(), content); + assertEquals(rowActual.getRowContent(), contentExpected); } { - structure = new StructureImpl(); - structure.addColumn("Test1", String.class); - structure.addColumn("Test2", Integer.class); - structure.addColumn("Test3", Double.class); - content = new HashMap<String, Object>(); - content.put("Test1", "StringDeTest"); - content.put("Test2", new Integer(1)); - content.put("Test3", new Double(0.07)); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + structureExpected.addColumn("Test1", String.class); + structureExpected.addColumn("Test2", Integer.class); + structureExpected.addColumn("Test3", Double.class); + contentExpected = new HashMap<String, Object>(); + contentExpected.put("Test1", "StringDeTest"); + contentExpected.put("Test2", new Integer(1)); + contentExpected.put("Test3", new Double(0.07)); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.getRowContent(), content); + assertEquals(rowActual.getRowContent(), contentExpected); } } public void testGetRowStructure() { { - structure = new StructureImpl(); - content = new HashMap<String, Object>(); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + contentExpected = new HashMap<String, Object>(); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.getRowStructure(), structure); + assertEquals(rowActual.getRowStructure(), structureExpected); } { - structure = new StructureImpl(); - structure.addColumn("Test", String.class); - content = new HashMap<String, Object>(); - content.put("Test", "StringDeTest"); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + structureExpected.addColumn("Test", String.class); + contentExpected = new HashMap<String, Object>(); + contentExpected.put("Test", "StringDeTest"); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.getRowStructure(), structure); + assertEquals(rowActual.getRowStructure(), structureExpected); } { - structure = new StructureImpl(); - structure.addColumn("Test1", String.class); - structure.addColumn("Test2", Integer.class); - structure.addColumn("Test3", Double.class); - content = new HashMap<String, Object>(); - content.put("Test1", "StringDeTest"); - content.put("Test2", new Integer(1)); - content.put("Test3", new Double(0.07)); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + structureExpected.addColumn("Test1", String.class); + structureExpected.addColumn("Test2", Integer.class); + structureExpected.addColumn("Test3", Double.class); + contentExpected = new HashMap<String, Object>(); + contentExpected.put("Test1", "StringDeTest"); + contentExpected.put("Test2", new Integer(1)); + contentExpected.put("Test3", new Double(0.07)); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.getRowStructure(), structure); + assertEquals(rowActual.getRowStructure(), structureExpected); } } public void testGetContent() { { - structure = new StructureImpl(); - content = new HashMap<String, Object>(); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + contentExpected = new HashMap<String, Object>(); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.getContent(""), null); + assertEquals(rowActual.getContent(""), null); } { - structure = new StructureImpl(); - structure.addColumn("Test", String.class); - content = new HashMap<String, Object>(); - content.put("Test", "StringDeTest"); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + structureExpected.addColumn("Test", String.class); + contentExpected = new HashMap<String, Object>(); + contentExpected.put("Test", "StringDeTest"); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.getContent("Test"), "StringDeTest"); + assertEquals(rowActual.getContent("Test"), "StringDeTest"); } { - structure = new StructureImpl(); - structure.addColumn("Test1", String.class); - structure.addColumn("Test2", Integer.class); - structure.addColumn("Test3", Double.class); - content = new HashMap<String, Object>(); - content.put("Test1", "StringDeTest"); - content.put("Test2", new Integer(1)); - content.put("Test3", new Double(0.07)); - r = new RowImpl(structure, content); + structureExpected = new StructureImpl(); + structureExpected.addColumn("Test1", String.class); + structureExpected.addColumn("Test2", Integer.class); + structureExpected.addColumn("Test3", Double.class); + contentExpected = new HashMap<String, Object>(); + contentExpected.put("Test1", "StringDeTest"); + contentExpected.put("Test2", new Integer(1)); + contentExpected.put("Test3", new Double(0.07)); + rowActual = new RowImpl(structureExpected, contentExpected); - assertEquals(r.getContent("Test1"), "StringDeTest"); - assertEquals(r.getContent("Test2"), new Integer(1)); - assertEquals(r.getContent("Test3"), new Double(0.07)); + assertEquals(rowActual.getContent("Test1"), "StringDeTest"); + assertEquals(rowActual.getContent("Test2"), new Integer(1)); + assertEquals(rowActual.getContent("Test3"), new Double(0.07)); } } } 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-28 17:31:48 UTC (rev 33) +++ trunk/src/test/java/org/nuiton/mapstoragemanager/plugins/bighashmap/StructureTest.java 2010-01-28 18:01:26 UTC (rev 34) @@ -12,9 +12,19 @@ public class StructureTest extends TestCase { + Structure structureActual; + Map < String, Class < ? > > structureContentActual; + Map < String, Class < ? > > structureContentExpected; + + Class < ? > columnsClassActual; + Class < ? > columnsClassExpected; + + Set < String > columnsNamesActual; + Set < String > columnsNamesExpected; + public void testGetColumnsNamesVoid() { - Structure s = new StructureImpl(); - Set < String > columnNames = s.getColumnsNames(); + structureActual = new StructureImpl(); + Set < String > columnNames = structureActual.getColumnsNames(); assertEquals(0, columnNames.size()); } @@ -25,29 +35,28 @@ */ public void testAddColumn() { - Map < String, Class < ? > > structureExpected = - new HashMap<String, Class<?>>(); + structureContentExpected = new HashMap<String, Class<?>>(); try { - Structure s = new StructureImpl(); + structureActual = new StructureImpl(); - Field fStructure = s.getClass().getDeclaredField("structure"); + Field fStructure = structureActual.getClass().getDeclaredField("structure"); fStructure.setAccessible(true); - Map < String, Class < ? > > structureActual = - (Map < String, Class < ? > >) fStructure.get(s); + Map < String, Class < ? > > structureContentActual = + (Map < String, Class < ? > >) fStructure.get(structureActual); - s.addColumn("Test1", String.class); - structureExpected.put("Test1", String.class); - assertEquals(structureExpected, structureActual); + structureActual.addColumn("Test1", String.class); + structureContentExpected.put("Test1", String.class); + assertEquals(structureContentExpected, structureContentActual); - s.addColumn("Test2", Object.class); - structureExpected.put("Test2", Object.class); - assertEquals(structureExpected, structureActual); + structureActual.addColumn("Test2", Object.class); + structureContentExpected.put("Test2", Object.class); + assertEquals(structureContentExpected, structureContentActual); - s.addColumn("Test3", Map.class); - structureExpected.put("Test3", Map.class); - assertEquals(structureExpected, structureActual); + structureActual.addColumn("Test3", Map.class); + structureContentExpected.put("Test3", Map.class); + assertEquals(structureContentExpected, structureContentActual); } catch (IllegalArgumentException ex) { Logger.getLogger(StructureTest.class.getName()).log(Level.SEVERE, null, ex); @@ -69,52 +78,51 @@ */ public void testRemoveColumn() { - Map < String, Class < ? > > structureExpected = - new HashMap<String, Class<?>>(); + structureContentExpected = new HashMap<String, Class<?>>(); try { - Structure s = new StructureImpl(); + structureActual = new StructureImpl(); - Field fStructure = s.getClass().getDeclaredField("structure"); + Field fStructure = structureActual.getClass().getDeclaredField("structure"); fStructure.setAccessible(true); - Map < String, Class < ? > > structureActual = - (Map < String, Class < ? > >) fStructure.get(s); + Map < String, Class < ? > > structureContentActual = + (Map < String, Class < ? > >) fStructure.get(structureActual); - 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); + structureActual.addColumn("Test1", String.class); + structureContentExpected.put("Test1", String.class); + structureActual.addColumn("Test2", Object.class); + structureContentExpected.put("Test2", Object.class); + structureActual.addColumn("Test3", Map.class); + structureContentExpected.put("Test3", Map.class); + assertEquals(structureContentExpected, structureContentActual); - s.removeColumn("Test1"); - structureExpected.remove("Test1"); - assertEquals(structureExpected, structureActual); + structureActual.removeColumn("Test1"); + structureContentExpected.remove("Test1"); + assertEquals(structureContentExpected, structureContentActual); /** * the key "Test1TOTO" is not in the structure. */ - s.removeColumn("Test1TOTO"); - structureExpected.remove("Test1TOTO"); - assertEquals(structureExpected, structureActual); + structureActual.removeColumn("Test1TOTO"); + structureContentExpected.remove("Test1TOTO"); + assertEquals(structureContentExpected, structureContentActual); - s.removeColumn("Test2"); - structureExpected.remove("Test2"); - assertEquals(structureExpected, structureActual); + structureActual.removeColumn("Test2"); + structureContentExpected.remove("Test2"); + assertEquals(structureContentExpected, structureContentActual); - s.removeColumn("Test3"); - structureExpected.remove("Test3"); - assertEquals(structureExpected, structureActual); + structureActual.removeColumn("Test3"); + structureContentExpected.remove("Test3"); + assertEquals(structureContentExpected, structureContentActual); /** * We try to remove an other key, but the map is empty. */ - s.removeColumn("Test4"); - structureExpected.remove("Test4"); + structureActual.removeColumn("Test4"); + structureContentExpected.remove("Test4"); - assertEquals(structureExpected, structureActual); + assertEquals(structureContentExpected, structureContentActual); } catch (IllegalArgumentException ex) { @@ -136,50 +144,50 @@ */ public void testGetColumnsNames() { - Structure s = new StructureImpl(); + structureActual = new StructureImpl(); - Set<String> columsNamesExpected = new HashSet<String>(); - Set<String> columnsNamesActual = s.getColumnsNames(); + columnsNamesExpected = new HashSet<String>(); + columnsNamesActual = structureActual.getColumnsNames(); - s.addColumn("Test1", String.class); - columsNamesExpected.add("Test1"); - assertEquals(columsNamesExpected, columnsNamesActual); + structureActual.addColumn("Test1", String.class); + columnsNamesExpected.add("Test1"); + assertEquals(columnsNamesExpected, columnsNamesActual); - s.addColumn("Test2", Object.class); - columsNamesExpected.add("Test2"); - assertEquals(columsNamesExpected, columnsNamesActual); + structureActual.addColumn("Test2", Object.class); + columnsNamesExpected.add("Test2"); + assertEquals(columnsNamesExpected, columnsNamesActual); - s.addColumn("Test3", Map.class); - columsNamesExpected.add("Test3"); - assertEquals(columsNamesExpected, columnsNamesActual); + structureActual.addColumn("Test3", Map.class); + columnsNamesExpected.add("Test3"); + assertEquals(columnsNamesExpected, columnsNamesActual); - s.removeColumn("Test1"); - columsNamesExpected.remove("Test1"); - assertEquals(columsNamesExpected, columnsNamesActual); + structureActual.removeColumn("Test1"); + columnsNamesExpected.remove("Test1"); + assertEquals(columnsNamesExpected, columnsNamesActual); /** * the key "Test1TOTO" is not in the structure. */ - s.removeColumn("Test1TOTO"); - columsNamesExpected.remove("Test1TOTO"); - assertEquals(columsNamesExpected, columnsNamesActual); + structureActual.removeColumn("Test1TOTO"); + columnsNamesExpected.remove("Test1TOTO"); + assertEquals(columnsNamesExpected, columnsNamesActual); - s.removeColumn("Test2"); - columsNamesExpected.remove("Test2"); - assertEquals(columsNamesExpected, columnsNamesActual); + structureActual.removeColumn("Test2"); + columnsNamesExpected.remove("Test2"); + assertEquals(columnsNamesExpected, columnsNamesActual); - s.removeColumn("Test3"); - columsNamesExpected.remove("Test3"); - assertEquals(columsNamesExpected, columnsNamesActual); + structureActual.removeColumn("Test3"); + columnsNamesExpected.remove("Test3"); + assertEquals(columnsNamesExpected, columnsNamesActual); /** * We try to remove an other key, but the map is empty. */ - s.removeColumn("Test4"); - columsNamesExpected.remove("Test4"); + structureActual.removeColumn("Test4"); + columnsNamesExpected.remove("Test4"); - assertEquals(columsNamesExpected, columnsNamesActual); + assertEquals(columnsNamesExpected, columnsNamesActual); } @@ -193,83 +201,101 @@ Structure s = new StructureImpl(); - Class<?> columsClassExpected; - Class<?> columsClassActual; +// columnsClassExpected; +// columnsClassActual; + /** + * We put "Test1" + */ s.addColumn("Test1", String.class); - columsClassActual = s.getColumnClass("Test1"); - columsClassExpected = String.class; - assertEquals(columsClassExpected, columsClassActual); + columnsClassActual = s.getColumnClass("Test1"); + columnsClassExpected = String.class; + assertEquals(columnsClassExpected, columnsClassActual); + /** + * We put "Test2" + */ 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); + columnsClassActual = s.getColumnClass("Test1"); + columnsClassExpected = String.class; + assertEquals(columnsClassExpected, columnsClassActual); + columnsClassActual = s.getColumnClass("Test2"); + columnsClassExpected = Object.class; + assertEquals(columnsClassExpected, columnsClassActual); + /** + * We put "Test3" + */ 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); + columnsClassActual = s.getColumnClass("Test1"); + columnsClassExpected = String.class; + assertEquals(columnsClassExpected, columnsClassActual); + columnsClassActual = s.getColumnClass("Test2"); + columnsClassExpected = Object.class; + assertEquals(columnsClassExpected, columnsClassActual); + columnsClassActual = s.getColumnClass("Test3"); + columnsClassExpected = Map.class; + assertEquals(columnsClassExpected, columnsClassActual); + /** + * we remove "Test1" + */ 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); + columnsClassActual = s.getColumnClass("Test1"); + columnsClassExpected = null; + assertEquals(columnsClassExpected, columnsClassActual); + columnsClassActual = s.getColumnClass("Test2"); + columnsClassExpected = Object.class; + assertEquals(columnsClassExpected, columnsClassActual); + columnsClassActual = s.getColumnClass("Test3"); + columnsClassExpected = Map.class; + assertEquals(columnsClassExpected, columnsClassActual); /** * the key "Test1TOTO" is not in the structure. + * We try to remove it. */ 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); + columnsClassActual = s.getColumnClass("Test1TOTO"); + columnsClassExpected = null; + assertEquals(columnsClassExpected, columnsClassActual); + columnsClassActual = s.getColumnClass("Test2"); + columnsClassExpected = Object.class; + assertEquals(columnsClassExpected, columnsClassActual); + columnsClassActual = s.getColumnClass("Test3"); + columnsClassExpected = Map.class; + assertEquals(columnsClassExpected, columnsClassActual); + /** + * We remove "Test2" + */ 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); + assertEquals(columnsClassExpected, columnsClassActual); + columnsClassActual = s.getColumnClass("Test2"); + columnsClassExpected = null; + assertEquals(columnsClassExpected, columnsClassActual); + columnsClassActual = s.getColumnClass("Test3"); + columnsClassExpected = Map.class; + assertEquals(columnsClassExpected, columnsClassActual); + /** + * We remove "Test3" + */ s.removeColumn("Test3"); - assertEquals(columsClassExpected, columsClassActual); - columsClassActual = s.getColumnClass("Test3"); - columsClassExpected = null; - assertEquals(columsClassExpected, columsClassActual); + assertEquals(columnsClassExpected, columnsClassActual); + columnsClassActual = s.getColumnClass("Test3"); + columnsClassExpected = null; + assertEquals(columnsClassExpected, columnsClassActual); /** * We try to remove an other key, but the map is empty. */ s.removeColumn("Test4"); - columsClassActual = s.getColumnClass("Test4"); - columsClassExpected = null; + columnsClassActual = s.getColumnClass("Test4"); + columnsClassExpected = null; - assertEquals(columsClassExpected, columsClassActual); + assertEquals(columnsClassExpected, columnsClassActual); } }