From d5a5ea1f3aef225538a7041cc1e7e494f91facce Mon Sep 17 00:00:00 2001 From: Lars Vogel Date: Sun, 11 Jan 2026 15:30:43 +0100 Subject: [PATCH] Migrate ConformanceTestSuite and dependencies to JUnit 5 - Migrate org.eclipse.jface.tests.databinding.conformance tests to JUnit 5. - Update ConformanceTestSuite to use @TestFactory. - Update MANIFEST.MF to import junit.jupiter.api.function. --- ...tableObservableCollectionContractTest.java | 48 +++--- .../MutableObservableListContractTest.java | 73 ++++---- .../MutableObservableSetContractTest.java | 60 ++++--- .../MutableObservableValueContractTest.java | 36 ++-- .../ObservableCollectionContractTest.java | 16 +- .../conformance/ObservableContractTest.java | 55 +++--- .../conformance/ObservableDelegateTest.java | 16 +- .../ObservableListContractTest.java | 6 +- .../ObservableStaleContractTest.java | 53 +++--- .../ObservableValueContractTest.java | 63 +++---- .../conformance/util/RealmTester.java | 10 +- .../META-INF/MANIFEST.MF | 1 + .../databinding/ConformanceTestSuite.java | 161 +++++++++++++----- 13 files changed, 321 insertions(+), 277 deletions(-) diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableCollectionContractTest.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableCollectionContractTest.java index 2ad5eb90c4cb..08b563877689 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableCollectionContractTest.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableCollectionContractTest.java @@ -16,9 +16,9 @@ package org.eclipse.jface.databinding.conformance; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Arrays; import java.util.Collections; @@ -30,8 +30,8 @@ import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker; import org.eclipse.jface.databinding.conformance.util.CurrentRealm; import org.eclipse.jface.databinding.conformance.util.RealmTester; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** * Mutability tests for IObservableCollection. @@ -58,7 +58,7 @@ public MutableObservableCollectionContractTest( } @Override - @Before + @BeforeEach public void setUp() throws Exception { super.setUp(); collection = (IObservableCollection) super.getObservable(); @@ -160,9 +160,8 @@ public void testRemoveAll_ChangeEventFiredAfterElementsAreRemoved() public void testRemoveAll_NoChange() throws Exception { ChangeEventTracker tracker = ChangeEventTracker.observe(collection); collection.removeAll(Collections.EMPTY_LIST); - assertEquals( - "List.removeAll on an empty list should not fire a list change event", - 0, tracker.count); + assertEquals(0, tracker.count, + "List.removeAll on an empty list should not fire a list change event"); } @Test @@ -205,20 +204,18 @@ public void testRetainAll_ChangeEventFiredAfterElementsAreRetained() listener2.contains = true; collection.retainAll(Arrays.asList(new Object[] { element1 })); - assertTrue( - formatFail("When Collection.retainAll(...) fires the change event the element should have been retained in the Collection."), - listener1.contains); - assertFalse( - formatFail("When Collection.retainAll(...) fires the change event the element should have been removed from the Collection."), - listener2.contains); + assertTrue(listener1.contains, + formatFail("When Collection.retainAll(...) fires the change event the element should have been retained in the Collection.")); + assertFalse(listener2.contains, + formatFail("When Collection.retainAll(...) fires the change event the element should have been removed from the Collection.")); } @Test public void testRetainAll_NoChangeFiresNoChangeEvent() throws Exception { ChangeEventTracker tracker = ChangeEventTracker.observe(collection); collection.retainAll(Collections.EMPTY_LIST); - assertEquals("List.retainAll should not have fired a change event:", 0, - tracker.count); + assertEquals(0, tracker.count, + "List.retainAll should not have fired a change event:"); } @Test @@ -253,12 +250,11 @@ public void testClear_ChangeEventFiredAfterElementIsRemoved() ChangeEventTracker listener = ChangeEventTracker.observe(collection); runnable.run(); - assertEquals(formatFail(methodName + " should fire one ChangeEvent."), - 1, listener.count); - assertEquals( + assertEquals(1, listener.count, + formatFail(methodName + " should fire one ChangeEvent.")); + assertEquals(collection, listener.event.getObservable(), formatFail(methodName - + "'s change event observable should be the created Collection."), - collection, listener.event.getObservable()); + + "'s change event observable should be the created Collection.")); } /** @@ -277,11 +273,11 @@ public void testClear_ChangeEventFiredAfterElementIsRemoved() elementNotContained).init(); listener.contains = true; collection.remove(elementNotContained); - assertFalse( + assertFalse(listener.contains, formatFail(new StringBuilder("When ") .append(methodName) .append(" fires a change event the element should have been removed from the Collection.") - .toString()), listener.contains); + .toString())); } /** @@ -299,11 +295,11 @@ public void testClear_ChangeEventFiredAfterElementIsRemoved() assertFalse(collection.contains(elementContained)); runnable.run(); - assertTrue( + assertTrue(listener.contains, formatFail(new StringBuilder("When ") .append(methodName) .append(" fires a change event the element should have been added to the Collection.") - .toString()), listener.contains); + .toString())); } /* package */static class ContainsListener implements IChangeListener { diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableListContractTest.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableListContractTest.java index e5d5d397c537..f43c96534458 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableListContractTest.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableListContractTest.java @@ -16,8 +16,8 @@ package org.eclipse.jface.databinding.conformance; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertSame; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; import java.util.ArrayList; import java.util.Arrays; @@ -30,9 +30,8 @@ import org.eclipse.jface.databinding.conformance.delegate.IObservableCollectionContractDelegate; import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker; import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** * Mutability tests for IObservableList. @@ -60,7 +59,7 @@ public MutableObservableListContractTest( } @Override - @Before + @BeforeEach public void setUp() throws Exception { super.setUp(); list = (IObservableList) getObservable(); @@ -186,7 +185,7 @@ public void testSet_ListChangeEvent() throws Exception { list.add(element0); final Object element1 = delegate.createElement(list); - assertListChangeEventFired(() -> assertSame(element0, list.set(0, element1)), "List.set(int, Object)", list, + assertListChangeEventFired(() -> assertSame(element0, list.set(0, element1), "List.set(int, Object)"), "List.set(int, Object)", list, Arrays.asList(new Object[] { element1 })); } @@ -196,7 +195,7 @@ public void testSet_ChangeEventFiredAfterElementIsSet() throws Exception { list.add(element1); final Object element2 = delegate.createElement(list); - assertContainsDuringChangeEvent(() -> assertSame(element1, list.set(0, element2)), "List.set(int, Object)", + assertContainsDuringChangeEvent(() -> assertSame(element1, list.set(0, element2), "List.set(int, Object)"), "List.set(int, Object)", list, element2); } @@ -229,13 +228,11 @@ public void testMove_NoChangeEventAtSameIndex() throws Exception { final Object movedElement = list.move(0, 0); - assertEquals( - formatFail("IObservableList.move(int,int) should return the moved element"), - element, movedElement); - assertEquals( + assertEquals(element, movedElement, + formatFail("IObservableList.move(int,int) should return the moved element")); + assertEquals(0, tracker.count, formatFail("IObservableLIst.move(int,int) should not fire a change event" - + "when the old and new indices are the same"), 0, - tracker.count); + + "when the old and new indices are the same")); } @Test @@ -245,7 +242,7 @@ public void testMove_ListChangeEvent() throws Exception { final Object element1 = delegate.createElement(list); list.add(element1); - assertListChangeEventFired(() -> assertSame(element0, list.move(0, 1)), "IObservableList.move(int, int)", list, + assertListChangeEventFired(() -> assertSame(element0, list.move(0, 1), "IObservableList.move(int, int)"), "IObservableList.move(int, int)", list, Arrays.asList(new Object[] { element1, element0 })); } @@ -398,9 +395,9 @@ public void testClear_ListDiffEntry() throws Exception { public void testClear_ClearsList() { Object element = delegate.createElement(list); list.add(element); - Assert.assertEquals(Collections.singletonList(element), list); + assertEquals(Collections.singletonList(element), list); list.clear(); - Assert.assertEquals(Collections.EMPTY_LIST, list); + assertEquals(Collections.EMPTY_LIST, list); } private void assertListChangeEventFired(Runnable runnable, @@ -416,32 +413,30 @@ private void assertListChangeEventFired(Runnable runnable, runnable.run(); - assertEquals(formatFail(methodName - + " should fire one ListChangeEvent."), 1, listListener.count); - assertEquals(formatFail(methodName - + "'s change event observable should be the created List."), - list, listListener.event.getObservable()); - - assertEquals( - formatFail("Two notifications should have been received."), 2, - queue.size()); - assertEquals("ChangeEvent of " + methodName - + " should have fired before the ListChangeEvent.", - changeListener, queue.get(0)); - assertEquals("ListChangeEvent of " + methodName - + " should have fired after the ChangeEvent.", listListener, - queue.get(1)); - - assertEquals(formatFail(methodName - + " did not leave observable list with the expected contents"), - newList, list); + assertEquals(1, listListener.count, formatFail(methodName + + " should fire one ListChangeEvent.")); + assertEquals(list, listListener.event.getObservable(), + formatFail(methodName + + "'s change event observable should be the created List.")); + + assertEquals(2, queue.size(), + formatFail("Two notifications should have been received.")); + assertEquals(changeListener, queue.get(0), + "ChangeEvent of " + methodName + + " should have fired before the ListChangeEvent."); + assertEquals(listListener, queue.get(1), + "ListChangeEvent of " + methodName + + " should have fired after the ChangeEvent."); + + assertEquals(newList, list, + formatFail(methodName + + " did not leave observable list with the expected contents")); ListDiff diff = listListener.event.diff; diff.applyTo(oldList); - assertEquals( + assertEquals(newList, oldList, formatFail(methodName - + " fired a diff which does not represent the expected list change"), - newList, oldList); + + " fired a diff which does not represent the expected list change")); } } diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableSetContractTest.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableSetContractTest.java index 277d76192090..a1c2d58301fb 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableSetContractTest.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableSetContractTest.java @@ -16,8 +16,8 @@ package org.eclipse.jface.databinding.conformance; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; import java.util.Arrays; @@ -30,8 +30,8 @@ import org.eclipse.jface.databinding.conformance.delegate.IObservableCollectionContractDelegate; import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker; import org.eclipse.jface.databinding.conformance.util.SetChangeEventTracker; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; public class MutableObservableSetContractTest extends MutableObservableCollectionContractTest { @@ -46,7 +46,7 @@ public MutableObservableSetContractTest( } @Override - @Before + @BeforeEach public void setUp() throws Exception { super.setUp(); set = (IObservableSet) getObservable(); @@ -206,22 +206,20 @@ private void assertSetChangeEventFired(Runnable runnable, runnable.run(); - assertEquals( - formatFail(methodName + " should fire one SetChangeEvent."), 1, - setListener.count); - assertEquals(formatFail(methodName - + "'s change event observable should be the created Set."), - set, setListener.event.getObservable()); - - assertEquals( - formatFail("Two notifications should have been received."), 2, - queue.size()); - assertEquals(formatFail("ChangeEvent of " + methodName - + " should have fired before the SetChangeEvent."), - changeListener, queue.get(0)); - assertEquals(formatFail("SetChangeEvent of " + methodName - + " should have fired after the ChangeEvent."), setListener, - queue.get(1)); + assertEquals(1, setListener.count, + formatFail(methodName + " should fire one SetChangeEvent.")); + assertEquals(set, setListener.event.getObservable(), + formatFail(methodName + + "'s change event observable should be the created Set.")); + + assertEquals(2, queue.size(), + formatFail("Two notifications should have been received.")); + assertEquals(changeListener, queue.get(0), + formatFail("ChangeEvent of " + methodName + + " should have fired before the SetChangeEvent.")); + assertEquals(setListener, queue.get(1), + formatFail("SetChangeEvent of " + methodName + + " should have fired after the ChangeEvent.")); } /** @@ -235,12 +233,12 @@ private void assertAddDiffEntry(Runnable runnable, String methodName, runnable.run(); Set entries = listener.event.diff.getAdditions(); - assertEquals(formatFail(methodName - + " should result in one diff entry."), 1, entries.size()); + assertEquals(1, entries.size(), formatFail(methodName + + " should result in one diff entry.")); - assertTrue(formatFail(methodName - + " should result in a diff entry that is an addition."), - entries.contains(element)); + assertTrue(entries.contains(element), + formatFail(methodName + + " should result in a diff entry that is an addition.")); } /** @@ -254,11 +252,11 @@ private void assertRemoveDiffEntry(Runnable runnable, String methodName, runnable.run(); Set entries = listener.event.diff.getRemovals(); - assertEquals(formatFail(methodName - + " should result in one diff entry."), 1, entries.size()); + assertEquals(1, entries.size(), formatFail(methodName + + " should result in one diff entry.")); - assertTrue(formatFail(methodName - + " should result in a diff entry that is a removal."), - entries.contains(element)); + assertTrue(entries.contains(element), + formatFail(methodName + + " should result in a diff entry that is a removal.")); } } diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableValueContractTest.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableValueContractTest.java index 52580f2549e0..76f50c55fc78 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableValueContractTest.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/MutableObservableValueContractTest.java @@ -16,7 +16,7 @@ package org.eclipse.jface.databinding.conformance; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import org.eclipse.core.databinding.observable.value.IObservableValue; import org.eclipse.jface.databinding.conformance.delegate.IObservableValueContractDelegate; @@ -24,8 +24,8 @@ import org.eclipse.jface.databinding.conformance.util.CurrentRealm; import org.eclipse.jface.databinding.conformance.util.RealmTester; import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** * Mutability tests for IObservableValue. @@ -51,7 +51,7 @@ public MutableObservableValueContractTest(IObservableValueContractDelegate deleg } @Override - @Before + @BeforeEach public void setUp() throws Exception { super.setUp(); this.observable = (IObservableValue) getObservable(); @@ -62,9 +62,8 @@ public void testSetValue_SetsValue() throws Exception { Object value = delegate.createValue(observable); observable.setValue(value); - assertEquals( - formatFail("IObservableValue.setValue(Object) should set the value of the observable."), - value, observable.getValue()); + assertEquals(value, observable.getValue(), + formatFail("IObservableValue.setValue(Object) should set the value of the observable.")); } @Test @@ -73,14 +72,11 @@ public void testSetValue_ChangeEvent() throws Exception { observable.setValue(delegate.createValue(observable)); - assertEquals(formatFail("Change event listeners were not notified"), 1, - listener.count); - assertEquals( - formatFail("IObservableValue.setValue(Object) should fire one ChangeEvent."), - 1, listener.count); - assertEquals( - formatFail("IObservableValue.setValue(Object)'s change event observable should be the created observable."), - observable, listener.event.getObservable()); + assertEquals(1, listener.count, formatFail("Change event listeners were not notified")); + assertEquals(1, listener.count, + formatFail("IObservableValue.setValue(Object) should fire one ChangeEvent.")); + assertEquals(observable, listener.event.getObservable(), + formatFail("IObservableValue.setValue(Object)'s change event observable should be the created observable.")); } @Test @@ -95,12 +91,10 @@ public void testSetValue_SameValue() throws Exception { Object value = observable.getValue(); observable.setValue(value); - assertEquals( - formatFail("IObservableValue.setValue() should not fire a value change event when the value has not change."), - 0, valueChangeListener.count); - assertEquals( - formatFail("IObservableValue.setValue() should not fire a change event when the value has not change."), - 0, changeListener.count); + assertEquals(0, valueChangeListener.count, + formatFail("IObservableValue.setValue() should not fire a value change event when the value has not change.")); + assertEquals(0, changeListener.count, + formatFail("IObservableValue.setValue() should not fire a change event when the value has not change.")); } @Test diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableCollectionContractTest.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableCollectionContractTest.java index fa8876feefe3..6a033875953d 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableCollectionContractTest.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableCollectionContractTest.java @@ -16,8 +16,8 @@ package org.eclipse.jface.databinding.conformance; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Arrays; @@ -25,8 +25,8 @@ import org.eclipse.jface.databinding.conformance.delegate.IObservableCollectionContractDelegate; import org.eclipse.jface.databinding.conformance.util.CurrentRealm; import org.eclipse.jface.databinding.conformance.util.RealmTester; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** * Tests for IObservableCollection that don't mutate the collection. @@ -52,7 +52,7 @@ public ObservableCollectionContractTest( } @Override - @Before + @BeforeEach public void setUp() throws Exception { super.setUp(); collection = (IObservableCollection) getObservable(); @@ -163,9 +163,7 @@ public void testHashCode_RealmCheck() throws Exception { @Test public void testGetElementType_ReturnsType() throws Exception { - assertEquals( - "Element type of the collection should be returned from IObservableCollection.getElementType()", - delegate.getElementType(collection), - collection.getElementType()); + assertEquals(delegate.getElementType(collection), collection.getElementType(), + "Element type of the collection should be returned from IObservableCollection.getElementType()"); } } diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableContractTest.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableContractTest.java index 7339290f4fc7..1980cc7d0256 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableContractTest.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableContractTest.java @@ -16,11 +16,11 @@ package org.eclipse.jface.databinding.conformance; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; import org.eclipse.core.databinding.observable.ChangeEvent; import org.eclipse.core.databinding.observable.IChangeListener; @@ -31,8 +31,8 @@ import org.eclipse.jface.databinding.conformance.util.CurrentRealm; import org.eclipse.jface.databinding.conformance.util.DisposeEventTracker; import org.eclipse.jface.databinding.conformance.util.RealmTester; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** * Tests for IObservable that don't require mutating the observable. @@ -57,7 +57,7 @@ public ObservableContractTest(IObservableContractDelegate delegate) { } @Override - @Before + @BeforeEach public void setUp() throws Exception { super.setUp(); observable = getObservable(); @@ -81,8 +81,8 @@ public void testConstruction_CallsObservableCreated() { @Test public void testGetRealm_NotNull() throws Exception { - assertNotNull(formatFail("The observable's realm should not be null."), - observable.getRealm()); + assertNotNull(observable.getRealm(), + formatFail("The observable's realm should not be null.")); } @Test @@ -92,9 +92,8 @@ public void testChange_ChangeEvent() throws Exception { observable.addChangeListener(listener); delegate.change(observable); - assertEquals( - formatFail("A change in the observable should notify change listeners."), - 1, listener.count); + assertEquals(1, listener.count, + formatFail("A change in the observable should notify change listeners.")); } @Test @@ -105,11 +104,10 @@ public void testChange_EventObservable() throws Exception { delegate.change(observable); ChangeEvent event = listener.event; - assertNotNull(formatFail("change event was null"), event); + assertNotNull(event, formatFail("change event was null")); - assertSame( - formatFail("In the change event the source of the change should be the observable."), - observable, event.getObservable()); + assertSame(observable, event.getObservable(), + formatFail("In the change event the source of the change should be the observable.")); } @Test @@ -123,9 +121,8 @@ public void testChange_ObservableRealmIsTheCurrentRealm() throws Exception { observable.addChangeListener(listener); delegate.change(observable); - assertTrue( - formatFail("On change the current realm should be the realm of the observable."), - listener.isCurrentRealm); + assertTrue(listener.isCurrentRealm, + formatFail("On change the current realm should be the realm of the observable.")); } @Test @@ -136,23 +133,20 @@ public void testRemoveChangeListener_RemovesListener() throws Exception { delegate.change(observable); // precondition check - assertEquals(formatFail("change did not notify listeners"), 1, - listener.count); + assertEquals(1, listener.count, formatFail("change did not notify listeners")); observable.removeChangeListener(listener); delegate.change(observable); - assertEquals( - formatFail("When a change listener is removed it should not still receive change events."), - 1, listener.count); + assertEquals(1, listener.count, + formatFail("When a change listener is removed it should not still receive change events.")); } @Test public void testIsStale_NotStale() throws Exception { delegate.setStale(observable, false); - assertFalse( - formatFail("When an observable is not stale isStale() should return false."), - observable.isStale()); + assertFalse(observable.isStale(), + formatFail("When an observable is not stale isStale() should return false.")); } @Test @@ -201,9 +195,8 @@ public void testDispose_RemovesListeners() throws Exception { observable = delegate.createObservable(realm); delegate.change(observable); - assertEquals( - formatFail("After being disposed listeners should not receive change events."), - 0, disposedObservableListener.count); + assertEquals(0, disposedObservableListener.count, + formatFail("After being disposed listeners should not receive change events.")); } @Test diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableDelegateTest.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableDelegateTest.java index 700ec37c4ee6..901a4b291468 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableDelegateTest.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableDelegateTest.java @@ -16,7 +16,7 @@ package org.eclipse.jface.databinding.conformance; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import org.eclipse.core.databinding.observable.IObservable; import org.eclipse.core.databinding.observable.ObservableTracker; @@ -24,8 +24,8 @@ import org.eclipse.jface.databinding.conformance.delegate.IObservableContractDelegate; import org.eclipse.jface.databinding.conformance.util.CurrentRealm; import org.eclipse.jface.databinding.conformance.util.RealmTester; -import org.junit.After; -import org.junit.Before; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; /** * TestCase that provides the standard behavior expected for delegating test @@ -45,7 +45,7 @@ public ObservableDelegateTest(IObservableContractDelegate delegate) { this.delegate = delegate; } - @Before + @BeforeEach public void setUp() throws Exception { previousRealm = Realm.getDefault(); @@ -53,7 +53,7 @@ public void setUp() throws Exception { observable = doCreateObservable(); } - @After + @AfterEach public void tearDown() throws Exception { delegate.tearDown(); observable.dispose(); @@ -130,8 +130,8 @@ protected void assertGetterCalled(Runnable runnable, String methodName, } } - assertEquals(formatFail(methodName - + " should invoke ObservableTracker.getterCalled() once."), 1, - count); + assertEquals(1, + count, formatFail(methodName + + " should invoke ObservableTracker.getterCalled() once.")); } } diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableListContractTest.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableListContractTest.java index ffa02952d0d6..d075a0e0c912 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableListContractTest.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableListContractTest.java @@ -19,8 +19,8 @@ import org.eclipse.core.databinding.observable.list.IObservableList; import org.eclipse.jface.databinding.conformance.delegate.IObservableCollectionContractDelegate; import org.eclipse.jface.databinding.conformance.util.CurrentRealm; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** * Tests for IObservableList that don't require mutating the collection. @@ -47,7 +47,7 @@ public ObservableListContractTest( } @Override - @Before + @BeforeEach public void setUp() throws Exception { super.setUp(); list = (IObservableList) getObservable(); diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableStaleContractTest.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableStaleContractTest.java index ce423fc600dd..47b8779c9848 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableStaleContractTest.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableStaleContractTest.java @@ -16,17 +16,17 @@ package org.eclipse.jface.databinding.conformance; -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.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import org.eclipse.core.databinding.observable.IObservable; import org.eclipse.core.databinding.observable.IStaleListener; import org.eclipse.core.databinding.observable.StaleEvent; import org.eclipse.jface.databinding.conformance.delegate.IObservableContractDelegate; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** * @since 3.3 @@ -41,7 +41,7 @@ public ObservableStaleContractTest(IObservableContractDelegate delegate) { } @Override - @Before + @BeforeEach public void setUp() throws Exception { super.setUp(); observable = getObservable(); @@ -50,16 +50,15 @@ public void setUp() throws Exception { @Test public void testIsStale_TrueWhenStale() throws Exception { delegate.setStale(observable, true); - assertTrue(formatFail("When stale isStale() should return true."), - observable.isStale()); + assertTrue(observable.isStale(), + formatFail("When stale isStale() should return true.")); } @Test public void testIsStale_FalseWhenNotStale() throws Exception { delegate.setStale(observable, false); - assertFalse( - formatFail("When not stale isStale() should return false."), - observable.isStale()); + assertFalse(observable.isStale(), + formatFail("When not stale isStale() should return false.")); } @Test @@ -72,9 +71,8 @@ public void testBecomingStaleFiresStaleEvent() throws Exception { observable.addStaleListener(listener); delegate.setStale(observable, true); - assertEquals( - formatFail("When becoming stale listeners should be notified."), - 1, listener.count); + assertEquals(1, listener.count, + formatFail("When becoming stale listeners should be notified.")); } @Test @@ -88,10 +86,9 @@ public void testStaleEventObservable() throws Exception { delegate.setStale(observable, true); StaleEvent event = listener.event; - assertNotNull(formatFail("stale event was null"), event); - assertEquals( - formatFail("When notifying listeners of becoming stale the observable should be the source of the event."), - observable, event.getObservable()); + assertNotNull(event, formatFail("stale event was null")); + assertEquals(observable, event.getObservable(), + formatFail("When notifying listeners of becoming stale the observable should be the source of the event.")); } @Test @@ -103,16 +100,14 @@ public void testRemoveStaleListener_RemovesListener() throws Exception { delegate.setStale(observable, true); // precondition check - assertEquals(formatFail("set stale did not notify listeners"), 1, - listener.count); + assertEquals(1, listener.count, formatFail("set stale did not notify listeners")); observable.removeStaleListener(listener); ensureStale(observable, false); delegate.setStale(observable, true); - assertEquals( - formatFail("Once removed stale listeners should not be notified of becoming stale."), - 1, listener.count); + assertEquals(1, listener.count, + formatFail("Once removed stale listeners should not be notified of becoming stale.")); } @Test @@ -124,9 +119,8 @@ public void testStaleListenersAreNotNotifiedWhenObservableIsNoLongerStale() observable.addStaleListener(listener); delegate.setStale(observable, false); - assertEquals( - formatFail("Stale listeners should not be notified when the stale state changes from true to false."), - 0, listener.count); + assertEquals(0, listener.count, + formatFail("Stale listeners should not be notified when the stale state changes from true to false.")); } @Test @@ -137,9 +131,8 @@ public void testObservableRealmIsCurrentOnStale() throws Exception { observable.addStaleListener(listener); delegate.setStale(observable, true); - assertTrue( - formatFail("When notifying listeners of becoming stale the observable's realm should be the current realm."), - listener.isCurrentRealm); + assertTrue(listener.isCurrentRealm, + formatFail("When notifying listeners of becoming stale the observable's realm should be the current realm.")); } /** diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableValueContractTest.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableValueContractTest.java index 182aeb9e075f..5f1546112f65 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableValueContractTest.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/ObservableValueContractTest.java @@ -16,8 +16,8 @@ package org.eclipse.jface.databinding.conformance; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; import java.util.List; @@ -32,8 +32,8 @@ import org.eclipse.jface.databinding.conformance.util.CurrentRealm; import org.eclipse.jface.databinding.conformance.util.RealmTester; import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; /** * @since 3.2 @@ -48,7 +48,7 @@ public ObservableValueContractTest(IObservableValueContractDelegate delegate) { } @Override - @Before + @BeforeEach public void setUp() throws Exception { super.setUp(); observable = (IObservableValue) getObservable(); @@ -60,16 +60,14 @@ public void testChange_ValueChangeEvent() throws Exception { .observe(observable); delegate.change(observable); - assertEquals( - formatFail("On change value change listeners should be notified."), - 1, listener.count); + assertEquals(1, listener.count, + formatFail("On change value change listeners should be notified.")); } @Test public void testGetValueType_ExpectedType() throws Exception { - assertEquals( - formatFail("Type of the value should be returned from getType()."), - delegate.getValueType(observable), observable.getValueType()); + assertEquals(delegate.getValueType(observable), observable.getValueType(), + formatFail("Type of the value should be returned from getType().")); } @Test @@ -94,17 +92,15 @@ public void handleValueChange(ValueChangeEvent event) { delegate.change(observable); - assertTrue(formatFail("Change Listeners were not notified on change."), - listeners.size() > 0); + assertTrue(listeners.size() > 0, + formatFail("Change Listeners were not notified on change.")); // not asserting the fact that both are notified as this is asserted in // other tests - assertEquals( - formatFail("Change listeners should be notified before value change listeners."), - changeListener, listeners.get(0)); - assertEquals( - formatFail("Value change listeners should be notified after change listeners."), - valueChangeListener, listeners.get(1)); + assertEquals(changeListener, listeners.get(0), + formatFail("Change listeners should be notified before value change listeners.")); + assertEquals(valueChangeListener, listeners.get(1), + formatFail("Value change listeners should be notified after change listeners.")); } @Test @@ -117,15 +113,13 @@ public void testChange_ValueChangeEventDiff() throws Exception { ValueChangeEvent event = listener.event; - assertTrue(formatFail("Change Listeners were not notified on change."), - listener.count > 0); + assertTrue(listener.count > 0, + formatFail("Change Listeners were not notified on change.")); - assertEquals( - formatFail("When a value change event is fired the old value should be the previous value of the observable value."), - oldValue, event.diff.getOldValue()); - assertEquals( - formatFail("When a value change event is fired the new value should be the same as the current value of the observable value."), - observable.getValue(), event.diff.getNewValue()); + assertEquals(oldValue, event.diff.getOldValue(), + formatFail("When a value change event is fired the old value should be the previous value of the observable value.")); + assertEquals(observable.getValue(), event.diff.getNewValue(), + formatFail("When a value change event is fired the new value should be the same as the current value of the observable value.")); } @Test @@ -143,9 +137,8 @@ public void handleValueChange(ValueChangeEvent event) { ValueChangeListener listener = new ValueChangeListener(); observable.addValueChangeListener(listener); delegate.change(observable); - assertEquals( - formatFail("When a value change event is fired the new value should be applied before firing the change event."), - listener.value, observable.getValue()); + assertEquals(listener.value, observable.getValue(), + formatFail("When a value change event is fired the new value should be applied before firing the change event.")); } @Test @@ -156,16 +149,14 @@ public void testRemoveValueChangeListener_RemovesListener() delegate.change(observable); // precondition - assertEquals( - formatFail("Value change listeners should be notified on change."), - 1, listener.count); + assertEquals(1, listener.count, + formatFail("Value change listeners should be notified on change.")); observable.removeValueChangeListener(listener); delegate.change(observable); - assertEquals( - formatFail("Value change listeners should not be notified after they've been removed from the observable."), - 1, listener.count); + assertEquals(1, listener.count, + formatFail("Value change listeners should not be notified after they've been removed from the observable.")); } @Test diff --git a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/util/RealmTester.java b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/util/RealmTester.java index 40046bed05e6..c642c3b1229b 100644 --- a/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/util/RealmTester.java +++ b/tests/org.eclipse.jface.tests.databinding.conformance/src/org/eclipse/jface/databinding/conformance/util/RealmTester.java @@ -17,7 +17,7 @@ import org.eclipse.core.databinding.observable.Realm; import org.eclipse.core.runtime.AssertionFailedException; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; /** * Aids in the testing of Realms. @@ -56,7 +56,7 @@ public static void exerciseCurrent(Runnable runnable) { try { runnable.run(); } catch (AssertionFailedException e) { - Assert.fail("Correct realm, exception should not have been thrown"); + Assertions.fail("Correct realm, exception should not have been thrown"); } realm.setCurrent(false); @@ -66,7 +66,7 @@ public static void exerciseCurrent(Runnable runnable) { try { runnable.run(); - Assert.fail("Incorrect realm, exception should have been thrown"); + Assertions.fail("Incorrect realm, exception should have been thrown"); } catch (AssertionFailedException e) { } } finally { @@ -85,14 +85,14 @@ public static void exerciseCurrent(Runnable runnable, CurrentRealm realm) { try { runnable.run(); } catch (AssertionFailedException e) { - Assert.fail("Correct realm, exception should not have been thrown"); + Assertions.fail("Correct realm, exception should not have been thrown"); } realm.setCurrent(false); try { runnable.run(); - Assert.fail("Incorrect realm, exception should have been thrown"); + Assertions.fail("Incorrect realm, exception should have been thrown"); } catch (AssertionFailedException e) { } } diff --git a/tests/org.eclipse.jface.tests.databinding/META-INF/MANIFEST.MF b/tests/org.eclipse.jface.tests.databinding/META-INF/MANIFEST.MF index 83cbd5acac98..653a2b27c333 100644 --- a/tests/org.eclipse.jface.tests.databinding/META-INF/MANIFEST.MF +++ b/tests/org.eclipse.jface.tests.databinding/META-INF/MANIFEST.MF @@ -16,6 +16,7 @@ Require-Bundle: org.eclipse.core.databinding;bundle-version="[1.3.0,2.0.0)", org.eclipse.jface.tests.databinding.conformance, org.eclipse.core.databinding.property Import-Package: org.junit.jupiter.api;version="[5.14.0,6.0.0)", + org.junit.jupiter.api.function;version="[5.14.0,6.0.0)", org.junit.platform.suite.api;version="[1.14.0,2.0.0)" Bundle-RequiredExecutionEnvironment: JavaSE-21 Eclipse-BundleShape: dir diff --git a/tests/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/databinding/ConformanceTestSuite.java b/tests/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/databinding/ConformanceTestSuite.java index ecf89674d2fe..31a58924b393 100644 --- a/tests/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/databinding/ConformanceTestSuite.java +++ b/tests/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/databinding/ConformanceTestSuite.java @@ -27,7 +27,12 @@ package org.eclipse.jface.tests.databinding; import java.lang.annotation.Annotation; +import java.lang.reflect.Constructor; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; import java.util.List; +import java.util.stream.Stream; import org.eclipse.core.tests.databinding.observable.AbstractObservableTest; import org.eclipse.core.tests.databinding.observable.list.AbstractObservableListTest; @@ -85,24 +90,128 @@ import org.eclipse.jface.tests.internal.databinding.swt.TextObservableValueFocusOutTest; import org.eclipse.jface.tests.internal.databinding.swt.TextObservableValueModifyTest; import org.eclipse.jface.tests.internal.databinding.viewers.ObservableViewerElementSetTest; -import org.junit.runner.RunWith; -import org.junit.runner.Runner; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameters; -import org.junit.runners.model.InitializationError; -import org.junit.runners.model.TestClass; -import org.junit.runners.parameterized.BlockJUnit4ClassRunnerWithParameters; -import org.junit.runners.parameterized.ParametersRunnerFactory; -import org.junit.runners.parameterized.TestWithParameters; - -@RunWith(Parameterized.class) -@Parameterized.UseParametersRunnerFactory(ConformanceTestSuite.RunnerFactory.class) +import org.junit.jupiter.api.DynamicContainer; +import org.junit.jupiter.api.DynamicTest; +import org.junit.jupiter.api.TestFactory; + public class ConformanceTestSuite { + @TestFactory + public Stream conformanceTests() { + List containers = new ArrayList<>(); + Iterable data = data(); + + for (Object[] params : data) { + Class testClass = (Class) params[0]; + Object delegate = params[1]; + String testName = testClass.getSimpleName() + " for " + delegate; + + List tests = new ArrayList<>(); + // Find all test methods (JUnit 4 and 5 support) + List testMethods = getTestMethods(testClass); + + for (Method method : testMethods) { + tests.add(DynamicTest.dynamicTest(method.getName(), () -> { + Object instance = instantiate(testClass, delegate); + runBefore(instance); + try { + method.invoke(instance); + } finally { + runAfter(instance); + } + })); + } + + containers.add(DynamicContainer.dynamicContainer(testName, tests)); + } + + return containers.stream(); + } + + private Object instantiate(Class testClass, Object delegate) throws Exception { + Constructor[] constructors = testClass.getConstructors(); + for (Constructor constructor : constructors) { + if (constructor.getParameterCount() == 1) { + return constructor.newInstance(delegate); + } + } + throw new RuntimeException("Could not find a constructor with one argument for " + testClass.getName()); + } + + private List getTestMethods(Class testClass) { + List methods = new ArrayList<>(); + Class clazz = testClass; + while (clazz != null) { + for (Method method : clazz.getDeclaredMethods()) { + if (isTest(method)) { + methods.add(method); + } + } + clazz = clazz.getSuperclass(); + } + return methods; + } + + private boolean isTest(Method method) { + return hasAnnotation(method, "org.junit.Test") || hasAnnotation(method, "org.junit.jupiter.api.Test"); + } + + private boolean isBefore(Method method) { + return hasAnnotation(method, "org.junit.Before") || hasAnnotation(method, "org.junit.jupiter.api.BeforeEach"); + } + + private boolean isAfter(Method method) { + return hasAnnotation(method, "org.junit.After") || hasAnnotation(method, "org.junit.jupiter.api.AfterEach"); + } + + private boolean hasAnnotation(Method method, String annotationName) { + for (Annotation annotation : method.getAnnotations()) { + if (annotation.annotationType().getName().equals(annotationName)) { + return true; + } + } + return false; + } + + private void runBefore(Object instance) throws Exception { + List befores = new ArrayList<>(); + Class clazz = instance.getClass(); + while (clazz != null) { + for (Method m : clazz.getDeclaredMethods()) { + if (isBefore(m)) { + befores.add(m); + } + } + clazz = clazz.getSuperclass(); + } + Collections.reverse(befores); // Superclass first + for (Method m : befores) { + m.setAccessible(true); + m.invoke(instance); + } + } + + private void runAfter(Object instance) throws Exception { + List afters = new ArrayList<>(); + Class clazz = instance.getClass(); + while (clazz != null) { + for (Method m : clazz.getDeclaredMethods()) { + if (isAfter(m)) { + afters.add(m); + } + } + clazz = clazz.getSuperclass(); + } + // Subclass first (default order of walking up) + for (Method m : afters) { + m.setAccessible(true); + m.invoke(instance); + } + } + /** * Returns a list of all test classes and delegates. */ - @Parameters public static Iterable data() { TestCollection suite = new TestCollection(); AbstractObservableListTest.addConformanceTest(suite); @@ -162,28 +271,4 @@ public static Iterable data() { WritableValueTest.addConformanceTest(suite); return suite.getDataForParameterizedRunner(); } - - /** - * Creates a test runner from each entry in the list that is returned from - * {@link #data}. - */ - public static class RunnerFactory implements ParametersRunnerFactory { - @Override - public Runner createRunnerForTestWithParameters(TestWithParameters test) throws InitializationError { - Class testClass = (Class) test.getParameters().get(0); - List parameters = test.getParameters().subList(1, test.getParameters().size()); - String testName = testClass.getSimpleName() + " for " + parameters.get(0); - return new BlockJUnit4ClassRunnerWithParameters( - new TestWithParameters(testName, new TestClass(testClass), parameters)) { - @Override - protected Annotation[] getRunnerAnnotations() { - /* - * The overridden method expects the test class to have at least one annotation, - * otherwise the Array will be created with a negative length. - */ - return new Annotation[0]; - } - }; - } - } -} \ No newline at end of file +}