diff --git a/src/main/java/com/nativelibs4java/jalico/AdaptedCollection.java b/src/main/java/com/nativelibs4java/jalico/AdaptedCollection.java index a8150bb..de649ee 100644 --- a/src/main/java/com/nativelibs4java/jalico/AdaptedCollection.java +++ b/src/main/java/com/nativelibs4java/jalico/AdaptedCollection.java @@ -137,12 +137,14 @@ public boolean remove(Object value) { } return false; } else { - return removeWithoutBackWardAdapter(value); + return removeWithBackwardAdapter(value); } } @SuppressWarnings("unchecked") - protected boolean removeWithoutBackWardAdapter(Object value) { + protected boolean removeWithBackwardAdapter(Object value) { + if(backwardAdapter==null) + throw new UnsupportedOperationException("Cannot perform operation with a null backward Adapter."); try { currentlyCausingChange = true; if (collection.remove(backwardAdapter.adapt((V)value))) { diff --git a/src/test/java/com/nativelibs4java/jalico/AbstractAdaptedCollectionBiDiTest.java b/src/test/java/com/nativelibs4java/jalico/AbstractAdaptedCollectionBiDiTest.java new file mode 100644 index 0000000..6e6428f --- /dev/null +++ b/src/test/java/com/nativelibs4java/jalico/AbstractAdaptedCollectionBiDiTest.java @@ -0,0 +1,23 @@ +package com.nativelibs4java.jalico; + +import org.junit.After; +import org.junit.Before; + +public abstract class AbstractAdaptedCollectionBiDiTest extends + AbstractAdaptedCollectionTest { + + @Before + public void setUp() throws Exception { + super.setUp(); + } + + @After + public void tearDown() throws Exception { + } + + @Override + protected AdaptedCollection constructSubject() { + return new AdaptedCollection(mockedDelegate, FORWARD, BACKWARD); + } + +}//end AbstractBiDiAdaptedCollectionTest diff --git a/src/test/java/com/nativelibs4java/jalico/AbstractAdaptedCollectionForwardTest.java b/src/test/java/com/nativelibs4java/jalico/AbstractAdaptedCollectionForwardTest.java new file mode 100644 index 0000000..0b1623b --- /dev/null +++ b/src/test/java/com/nativelibs4java/jalico/AbstractAdaptedCollectionForwardTest.java @@ -0,0 +1,22 @@ +package com.nativelibs4java.jalico; + +import org.junit.After; +import org.junit.Before; + +public abstract class AbstractAdaptedCollectionForwardTest extends + AbstractAdaptedCollectionTest { + + @Before + public void setUp() throws Exception { + super.setUp(); + } + + @After + public void tearDown() throws Exception { + } + + @Override + protected AdaptedCollection constructSubject() { + return new AdaptedCollection(mockedDelegate,FORWARD); + } +}//end AbstractAdaptedCollectionForwardTest diff --git a/src/test/java/com/nativelibs4java/jalico/AbstractAdaptedCollectionTest.java b/src/test/java/com/nativelibs4java/jalico/AbstractAdaptedCollectionTest.java new file mode 100644 index 0000000..42e2546 --- /dev/null +++ b/src/test/java/com/nativelibs4java/jalico/AbstractAdaptedCollectionTest.java @@ -0,0 +1,42 @@ +package com.nativelibs4java.jalico; + +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; + +import org.junit.Before; +import org.mockito.Mock; + + +public abstract class AbstractAdaptedCollectionTest { + ////FIELDS + protected AdaptedCollection subject; + protected @Mock CollectionListener mockedListener; + protected @Mock Collection mockedDelegate; + protected Collection iteratorSource; + + //// ADAPTERS + protected static final Adapter FORWARD = new Adapter(){ + public String adapt(Integer value) { + return value.toString(); + }}; + protected static final Adapter BACKWARD = new Adapter(){ + public Integer adapt(String value) { + return Integer.parseInt(value); + }}; + + //// PREP + @Before + public void setUp() throws Exception { + subject = constructSubject(); + subject . addCollectionListener (mockedListener); + //Going with traditional way instead of over-engineering with mocks. + iteratorSource = new ArrayList(Arrays.asList(0,1,2)); + when(mockedDelegate.iterator()).thenReturn(iteratorSource.iterator()); + }//end setUp() + + protected abstract AdaptedCollection constructSubject(); + +}//end AbstractAdaptedCollectionTest diff --git a/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionBiDiIteratorTest.java b/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionBiDiIteratorTest.java new file mode 100644 index 0000000..a8b172e --- /dev/null +++ b/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionBiDiIteratorTest.java @@ -0,0 +1,86 @@ +package com.nativelibs4java.jalico; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +import java.util.Iterator; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.runners.MockitoJUnitRunner; + +import com.nativelibs4java.jalico.CollectionEvent.EventType; + +@RunWith(MockitoJUnitRunner.class) +public class AdaptedCollectionBiDiIteratorTest extends + AbstractAdaptedCollectionBiDiTest { + protected Iterator subjectIterator; + + @Before + public void setUp() throws Exception { + super.setUp(); + subjectIterator = subject.iterator(); + } + + @Test + public void testHasNextTrue() { + assertTrue(subjectIterator.hasNext()); + verifyZeroInteractions(mockedListener); + subjectIterator.next(); + subjectIterator.next(); + assertTrue(subjectIterator.hasNext()); + } + + @Test + public void testHasNextFalse() { + subjectIterator.next(); + subjectIterator.next(); + subjectIterator.next(); + assertFalse(subjectIterator.hasNext()); + verifyZeroInteractions(mockedListener); + } + + @Test + public void testNext(){ + assertEquals("0",subjectIterator.next()); + assertEquals("1",subjectIterator.next()); + assertEquals("2",subjectIterator.next()); + verifyZeroInteractions(mockedListener); + } + + @Test + public void testNextFail(){ + assertEquals("0",subjectIterator.next()); + assertEquals("1",subjectIterator.next()); + assertEquals("2",subjectIterator.next()); + } + + @Test + public void testRemove(){ + when(mockedDelegate.remove(0)).thenReturn(true); + subjectIterator .next(); + subjectIterator .remove(); + assertEquals(2,iteratorSource.size()); + ArgumentCaptor arg + = ArgumentCaptor.forClass(CollectionEvent.class); + verify(mockedListener).collectionChanged(arg.capture()); + CollectionEvent evt = arg.getValue(); + assertEquals(-1,evt.getFirstIndex()); + assertEquals(-1,evt.getLastIndex()); + assertTrue (evt.getElements().contains("0")); + assertEquals(1,evt.getElements().size()); + assertEquals(subject,evt.getSource()); + assertEquals(EventType.REMOVED,evt.getType()); + } + + @Test(expected=IllegalStateException.class) + public void testRemoveIllegalState(){ + subjectIterator.remove(); + } +}//end AdaptedCollectionIteratorTest diff --git a/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionBiDiTest.java b/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionBiDiTest.java new file mode 100644 index 0000000..2b190bb --- /dev/null +++ b/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionBiDiTest.java @@ -0,0 +1,150 @@ +package com.nativelibs4java.jalico; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +import java.util.Collection; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.runners.MockitoJUnitRunner; + +import com.nativelibs4java.jalico.CollectionEvent.EventType; + +@RunWith(MockitoJUnitRunner.class) +public class AdaptedCollectionBiDiTest extends AbstractAdaptedCollectionTest { + @Test + public void testSize() { + when (mockedDelegate.size()).thenReturn(5); + assertEquals(5,subject .size()); + verifyZeroInteractions(mockedListener); + }//end testSize() + + @Test + public void testIsEmpty() { + when (mockedDelegate .isEmpty()).thenReturn(true); + assertTrue (subject .isEmpty()); + verify (mockedDelegate).isEmpty(); + when (mockedDelegate .isEmpty()).thenReturn(false); + assertFalse(subject .isEmpty()); + verify (mockedDelegate, times(2)).isEmpty(); + verifyZeroInteractions(mockedListener); + }//end testIsEmpty() + + private CollectionEvent expectEvent(){ + ArgumentCaptor arg + = ArgumentCaptor.forClass(CollectionEvent.class); + verify(mockedListener).collectionChanged(arg.capture()); + return arg.getValue(); + } + + @Test + public void testClear() { + subject .clear(); + verify (mockedDelegate).clear(); + final CollectionEvent evt = expectEvent(); + assertEquals(0,evt.getFirstIndex()); + assertEquals(2,evt.getLastIndex()); + assertEquals(EventType.REMOVED,evt.getType()); + assertEquals(subject,evt.getSource()); + final Collection elements = evt.getElements(); + assertNotNull(elements); + assertEquals (3,elements.size()); + assertTrue (elements.contains("0")); + assertTrue (elements.contains("1")); + assertTrue (elements.contains("2")); + }//end testClear() + + @Test + public void testAdaptedCollectionCollectionOfUAdapterOfUVAdapterOfVU() { + assertNotNull(subject); + } + + @Test + public void testGetForwardAdapter() { + assertEquals(subject.getForwardAdapter(),FORWARD); + } + + @Test + public void testGetBackwardAdapter() { + assertEquals(subject.getBackwardAdapter(),BACKWARD); + } + + @Test + public void testIterator() { + assertNotNull(subject.iterator()); + } + + @Test + public void testAddV() { + when (mockedDelegate.add(5)).thenReturn(true); + assertTrue(subject.add("5")); + verify (mockedDelegate).add(5); + final CollectionEvent evt = expectEvent(); + assertEquals (-1,evt.getFirstIndex()); + assertEquals (-1,evt.getLastIndex()); + assertEquals (EventType.ADDED,evt.getType()); + assertEquals (subject,evt.getSource()); + Collection elements = evt.getElements(); + assertEquals(1,elements.size()); + assertTrue (elements.contains("5")); + }//end testAddV() + + @Test + public void testSuccessfulRemoveObject() { + when (mockedDelegate.remove(5)).thenReturn(true); + assertTrue(subject.remove("5")); + verify (mockedDelegate).remove(5); + final CollectionEvent evt = expectEvent(); + assertEquals (-1,evt.getFirstIndex()); + assertEquals (-1,evt.getLastIndex()); + assertEquals (EventType.REMOVED,evt.getType()); + assertEquals (subject,evt.getSource()); + Collection elements = evt.getElements(); + assertEquals(1,elements.size()); + assertTrue (elements.contains("5")); + }//end testSuccessfulRemoveObject() + + @Test + public void testFailedRemoveObject() { + when (mockedDelegate.remove(5)).thenReturn(false); + assertFalse (subject.remove("5")); + verify (mockedDelegate).remove(5); + verifyZeroInteractions(mockedListener); + }//end testFailedRemoveObject() + + @Test + public void testRemoveWithoutBackWardAdapter() { + when (mockedDelegate .remove(0)).thenReturn(true); + subject.removeWithBackwardAdapter("0"); + verify (mockedDelegate).remove(0); + }//end testRemoveWithoutBackWardAdapter() + + @Test + public void testContainsObject() { + when (mockedDelegate.contains(0)).thenReturn(true); + when (mockedDelegate.contains(7)).thenReturn(false); + assertTrue (subject.contains("0")); + assertFalse(subject.contains("7")); + verifyZeroInteractions(mockedListener); + }//end testContainsObject() + + @Test + public void testRemoveCollectionListener() { + subject.removeCollectionListener(mockedListener); + subject.add("9"); + verifyZeroInteractions(mockedListener); + }//end testRemoveCollectionListener() + + @Override + protected AdaptedCollection constructSubject() { + return new AdaptedCollection(mockedDelegate, FORWARD, BACKWARD); + } +}//end AdaptedCollectionTest diff --git a/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionForwardIteratorTest.java b/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionForwardIteratorTest.java new file mode 100644 index 0000000..0742ea1 --- /dev/null +++ b/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionForwardIteratorTest.java @@ -0,0 +1,58 @@ +package com.nativelibs4java.jalico; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.Iterator; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.runners.MockitoJUnitRunner; + +import com.nativelibs4java.jalico.CollectionEvent.EventType; + +@RunWith(MockitoJUnitRunner.class) +public class AdaptedCollectionForwardIteratorTest extends + AbstractAdaptedCollectionForwardTest { + protected Iterator subjectIterator; + + @Before + public void setUp() throws Exception { + super.setUp(); + subjectIterator = subject.iterator(); + } + + @After + public void tearDown() throws Exception { + super.tearDown(); + } + + @Test + public void testRemove(){ + when(mockedDelegate.remove(0)).thenReturn(true); + subjectIterator.next(); + subjectIterator.remove(); + assertEquals(2,iteratorSource.size()); + ArgumentCaptor arg + = ArgumentCaptor.forClass(CollectionEvent.class); + verify(mockedListener).collectionChanged(arg.capture()); + CollectionEvent evt = arg.getValue(); + assertEquals(-1,evt.getFirstIndex()); + assertEquals(-1,evt.getLastIndex()); + assertTrue(evt.getElements().contains("0")); + assertEquals(1,evt.getElements().size()); + assertEquals(subject,evt.getSource()); + assertEquals(EventType.REMOVED,evt.getType()); + } + + @Test(expected=IllegalStateException.class) + public void testRemoveIllegalState(){ + subjectIterator.remove(); + } + +}//end AdaptedcollectionForwardIteratorTest diff --git a/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionForwardTest.java b/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionForwardTest.java new file mode 100644 index 0000000..aa9b9a9 --- /dev/null +++ b/src/test/java/com/nativelibs4java/jalico/AdaptedCollectionForwardTest.java @@ -0,0 +1,141 @@ +package com.nativelibs4java.jalico; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +import java.util.Collection; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.runners.MockitoJUnitRunner; + +import com.nativelibs4java.jalico.CollectionEvent.EventType; + +@RunWith(MockitoJUnitRunner.class) +public class AdaptedCollectionForwardTest extends + AbstractAdaptedCollectionForwardTest { + + @Before + public void setUp() throws Exception { + super.setUp(); + } + + @After + public void tearDown() throws Exception { + super.tearDown(); + } + + @Test + public void testSize() { + when (mockedDelegate.size()).thenReturn(5); + assertEquals(5,subject .size()); + verifyZeroInteractions(mockedListener); + }//end testSize() + + @Test + public void testIsEmpty() { + when (mockedDelegate .isEmpty()).thenReturn(true); + assertTrue (subject .isEmpty()); + verify (mockedDelegate).isEmpty(); + when (mockedDelegate .isEmpty()).thenReturn(false); + assertFalse(subject .isEmpty()); + verify (mockedDelegate, times(2)).isEmpty(); + verifyZeroInteractions(mockedListener); + }//end testIsEmpty() + + private CollectionEvent expectEvent(){ + ArgumentCaptor arg + = ArgumentCaptor.forClass(CollectionEvent.class); + verify(mockedListener).collectionChanged(arg.capture()); + return arg.getValue(); + } + + @Test + public void testClear() { + subject .clear(); + verify (mockedDelegate).clear(); + final CollectionEvent evt = expectEvent(); + assertEquals(0,evt.getFirstIndex()); + assertEquals(2,evt.getLastIndex()); + assertEquals(EventType.REMOVED,evt.getType()); + assertEquals(subject,evt.getSource()); + final Collection elements = evt.getElements(); + assertNotNull(elements); + assertEquals (3,elements.size()); + assertTrue (elements.contains("0")); + assertTrue (elements.contains("1")); + assertTrue (elements.contains("2")); + }//end testClear() + + @Test + public void testAdaptedCollectionCollectionOfUAdapterOfUVAdapterOfVU() { + assertNotNull(subject); + } + + @Test + public void testGetForwardAdapter() { + assertEquals(subject.getForwardAdapter(),FORWARD); + } + + @Test + public void testGetBackwardAdapter() { + assertNull(subject.getBackwardAdapter()); + } + + @Test + public void testIterator() { + assertNotNull(subject.iterator()); + } + + @Test(expected=UnsupportedOperationException.class) + public void testAddV() { + subject.add("0"); + }//end testAddV() + + @Test + public void testSuccessfulRemoveObject() { + when (mockedDelegate.remove(0)).thenReturn(true); + assertTrue (subject.remove("0")); + final CollectionEvent evt = expectEvent(); + assertEquals(0,evt.getFirstIndex()); + assertEquals(0,evt.getLastIndex()); + assertEquals(EventType.REMOVED,evt.getType()); + assertEquals(subject,evt.getSource()); + Collection elements = evt.getElements(); + assertEquals(1,elements.size()); + assertTrue (elements.contains("0")); + }//end testSuccessfulRemoveObject() + + @Test + public void testFailedRemoveObject() { + when (mockedDelegate.remove(5)).thenReturn(false); + assertFalse (subject.remove("5")); + verifyZeroInteractions(mockedListener); + }//end testFailedRemoveObject() + + @Test(expected=UnsupportedOperationException.class) + public void testRemoveWithoutBackWardAdapter() { + subject.removeWithBackwardAdapter("0"); + }//end testRemoveWithoutBackWardAdapter() + + @Test + public void testContainsObject() { + when (mockedDelegate.contains(0)).thenReturn(true); + when (mockedDelegate.contains(7)).thenReturn(false); + assertTrue (subject.contains("0")); + assertFalse(subject.contains("7")); + verifyZeroInteractions(mockedListener); + }//end testContainsObject() + + @Test + public void testRemoveCollectionListener() { + subject.removeCollectionListener(mockedListener); + //Cannot use add() due to lack of backward adapter but remove() has a nifty brute-force fallback. + subject.remove("9"); + verifyZeroInteractions(mockedListener); + }//end testRemoveCollectionListener() + +}//end AdaptedCollectionForwardTest