@Test public void checkIterator() { int size = 20; IElement singleDummy; ArrayList<IElement> dummies = new ArrayList<>(); for (int i = 0; i < size; i++) { singleDummy = mock(this.elementClass); /* * Nodes are stored with an index, so set it please! */ if (singleDummy instanceof Node) { when(((Node) singleDummy).getIndex()).thenReturn(i); } if (singleDummy instanceof Edge) { when(((Edge) singleDummy).getHashString()).thenReturn("" + i); } dataStructure.add(singleDummy); dummies.add(singleDummy); } Iterator<IElement> elemIterator = dataStructure.iterator(); while (elemIterator.hasNext()) { singleDummy = elemIterator.next(); assertTrue(dummies.contains(singleDummy)); dummies.remove(singleDummy); } assertTrue(dummies.isEmpty()); }
@Test public void checkResizement() { int initialSize = dataStructure.getDefaultSize(); int goalSize = 10 * initialSize; assertEquals(0, dataStructure.size()); IElement singleDummy; for (int i = 0; i < goalSize; i++) { singleDummy = mock(this.elementClass); /* * Nodes are stored with an index, so set it please! */ if (singleDummy instanceof Node) { when(((Node) singleDummy).getIndex()).thenReturn(i); } if (singleDummy instanceof Edge) { when(((Edge) singleDummy).getHashString()).thenReturn("" + i); } dataStructure.add(singleDummy); } assertEquals(goalSize, dataStructure.size()); }
@Test public void checkDuplicateCalls() { IElement dummy = getDummy(elementClass); assertTrue(dataStructure.add(dummy)); assertFalse(dataStructure.add(dummy)); assertTrue(dataStructure.remove(dummy)); assertFalse(dataStructure.remove(dummy)); }
@Test public void checkNullsInIterator() { IElement singleDummy; dataStructure.reinitializeWithSize(10); Iterator<IElement> elemIterator = dataStructure.iterator(); while (elemIterator.hasNext()) { singleDummy = elemIterator.next(); assertNotNull(singleDummy); } }
@Test public void checkCorrectSize() { IElement[] dummies = new IElement[10]; for (int i = 0; i < dummies.length; i++) { dummies[i] = mock(this.elementClass); if (Node.class.isAssignableFrom(this.elementClass)) when(((Node) dummies[i]).getIndex()).thenReturn(i); if (dummies[i] instanceof Edge) when(((Edge) dummies[i]).getHashString()).thenReturn("" + i); assertTrue(dataStructure.add(dummies[i])); } assertEquals(dummies.length, dataStructure.size()); }
@Test public void checkNullsInGetElements() { assumeTrue(dataStructure instanceof INodeListDatastructureReadable); INodeListDatastructureReadable tempDS = (INodeListDatastructureReadable) dataStructure; dataStructure.reinitializeWithSize(10); for (IElement singleDummy : tempDS.getElements()) { assertNotNull(singleDummy); } }
@Test public void checkAddAndRemove() { IElement dummy = mock(elementClass); if (dummy instanceof Edge) { when(((Edge) dummy).getHashString()).thenReturn("1"); } assertFalse(dataStructure.contains(dummy)); assertEquals(0, dataStructure.size()); assertTrue(dataStructure.add(dummy)); assertTrue(dataStructure.contains(dummy)); assertEquals(1, dataStructure.size()); assertTrue(dataStructure.remove(dummy)); assertFalse(dataStructure.contains(dummy)); assertEquals(0, dataStructure.size()); }
@SuppressWarnings("unchecked") @Test public void checkOnlyOneDatatype() { IElement dummy; int exceptionCounter = 0; /* * Checking whether add() throws the exception we want it to throw does * not cover all cases here - we want to ensure that really only * instances of one single element class can be stored, and *all* other * instance types are rejected * * The exception counter will be increased for each *allowed* class and * each *rejected* class. There should be no gap in between... */ for (Class otherElementClass : GlobalTestParameters.elementClasses) { if (elementClass.isAssignableFrom(otherElementClass)) { assertTrue( "Datastructure " + dataStructure.getClass() + "[" + this.elementClass + "] can't store " + otherElementClass + " even if it should", dataStructure.canStore(otherElementClass)); exceptionCounter++; continue; } dummy = (IElement) mock(otherElementClass); boolean exceptionThrown = false; assertFalse( "Datastructure " + dataStructure.getClass() + "[" + this.elementClass + "/" + dataStructure.getDataType() + "] can store " + otherElementClass + " even if it shouldn't", dataStructure.canStore(otherElementClass)); try { dataStructure.add(dummy); } catch (RuntimeException e) { exceptionCounter++; exceptionThrown = true; } assertTrue("Whoopsie - whats up with " + otherElementClass, exceptionThrown); /* * So, this is thrown when the datastructure is not allowed to be * added to that list, but no exception is thrown. Common error: * add() has not called canAdd() */ } assertEquals(GlobalTestParameters.elementClasses.length, exceptionCounter); }