Bug 578297 - Modernize o.e.core.tests.runtime bundle Convert some tests to JUnit 4 style. Change-Id: Ib7ebe3f94e992fa9034845948ce283adfc5f4dbe Reviewed-on: https://git.eclipse.org/r/c/platform/eclipse.platform.runtime/+/189824 Tested-by: Platform Bot <platform-bot@eclipse.org> Reviewed-by: Alexander Kurtakov <akurtako@redhat.com>
diff --git a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/DeadlockDetectionTest.java b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/DeadlockDetectionTest.java index 1b44d09..6de59db 100644 --- a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/DeadlockDetectionTest.java +++ b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/DeadlockDetectionTest.java
@@ -13,34 +13,35 @@ *******************************************************************************/ package org.eclipse.core.tests.runtime.jobs; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + import java.util.*; -import junit.framework.TestCase; import org.eclipse.core.internal.jobs.*; import org.eclipse.core.runtime.*; import org.eclipse.core.runtime.jobs.*; import org.eclipse.core.tests.harness.FussyProgressMonitor; import org.eclipse.core.tests.harness.TestBarrier; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TestName; /** * Tests implementation of ILock objects */ -public class DeadlockDetectionTest extends TestCase { +public class DeadlockDetectionTest { private final IJobManager manager = Job.getJobManager(); - public DeadlockDetectionTest() { - super(null); - } - - public DeadlockDetectionTest(String name) { - super(name); - } + @Rule + public TestName name = new TestName(); /** * Creates n runnables on the given lock and adds them to the given list. */ private void createRunnables(ILock[] locks, int n, ArrayList<RandomTestRunnable> allRunnables, boolean cond) { for (int i = 0; i < n; i++) { - allRunnables.add(new RandomTestRunnable(locks, getName() + " # " + (allRunnables.size() + 1), cond)); + allRunnables + .add(new RandomTestRunnable(locks, name.getMethodName() + " # " + (allRunnables.size() + 1), cond)); try { Thread.sleep(10); } catch (InterruptedException e) { @@ -66,6 +67,7 @@ * Test that deadlock between locks is detected and resolved. * Test with 6 threads competing for 3 locks from a set of 6. */ + @Test public void testComplex() { ArrayList<RandomTestRunnable> allRunnables = new ArrayList<>(); LockManager lockManager = new LockManager(); @@ -104,6 +106,7 @@ /** * Test simplest deadlock case (2 threads, 2 locks). */ + @Test public void testSimpleDeadlock() { ArrayList<RandomTestRunnable> allRunnables = new ArrayList<>(); LockManager localManager = new LockManager(); @@ -136,6 +139,7 @@ /** * Test a more complicated scenario with 3 threads and 3 locks. */ + @Test public void testThreeLocks() { ArrayList<RandomTestRunnable> allRunnables = new ArrayList<>(); LockManager lockManager = new LockManager(); @@ -170,6 +174,7 @@ /** * Test simple deadlock with 2 threads trying to get 1 rule and 1 lock. */ + @Test public void testRuleLockInteraction() { final ILock lock = manager.newLock(); final ISchedulingRule rule = new IdentityRule(); @@ -229,6 +234,7 @@ /** * Test the interaction between jobs with rules and the acquisition of locks. */ + @Test public void testJobRuleLockInteraction() { final int[] status = {TestBarrier.STATUS_WAIT_FOR_START, TestBarrier.STATUS_WAIT_FOR_START}; final ISchedulingRule rule1 = new IdentityRule(); @@ -302,6 +308,7 @@ /** * Regression test for bug 46894. Stale entries left over in graph. */ + @Test public void testRuleHierarchyWaitReplace() { final int NUM_JOBS = 3; final int[] status = new int[NUM_JOBS]; @@ -412,6 +419,7 @@ /** * Regression test for bug 46894. Deadlock was not detected (before). */ + @Test public void testDetectDeadlock() { final int NUM_JOBS = 3; final int[] status = new int[NUM_JOBS]; @@ -517,6 +525,7 @@ /** * Test that when 3 columns and 1 row are empty, they are correctly removed from the graph. */ + @Test public void testMultipleColumnRemoval() { final int NUM_JOBS = 3; final int[] status = new int[NUM_JOBS]; @@ -611,6 +620,7 @@ /** * Test that the graph is cleared after a thread stops waiting for a rule. */ + @Test public void testBeginRuleCancelAfterWait() { final ISchedulingRule rule1 = new PathRule("/testBeginRuleCancelAfterWait"); final ISchedulingRule rule2 = new PathRule("/testBeginRuleCancelAfterWait/B"); @@ -677,6 +687,7 @@ /** * Test that implicit rules do not create extraneous entries */ + @Test public void testImplicitRules() { final int NUM_JOBS = 4; final int[] status = new int[NUM_JOBS]; @@ -963,6 +974,7 @@ * Test that the deadlock detector resolves deadlock correctly. * 60 threads are competing for 6 locks (need to acquire 3 locks at the same time). */ + @Test public void testVeryComplex() { ArrayList<RandomTestRunnable> allRunnables = new ArrayList<>(); LockManager lockManager = new LockManager();
diff --git a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/JobQueueTest.java b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/JobQueueTest.java index 5182b67..bd64383 100644 --- a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/JobQueueTest.java +++ b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/JobQueueTest.java
@@ -13,16 +13,19 @@ *******************************************************************************/ package org.eclipse.core.tests.runtime.jobs; -import junit.framework.TestCase; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + import org.eclipse.core.internal.jobs.InternalJob; import org.eclipse.core.internal.jobs.JobQueue; import org.eclipse.core.runtime.*; import org.eclipse.core.runtime.jobs.Job; +import org.junit.Before; +import org.junit.Test; -/** - * - */ -public class JobQueueTest extends TestCase { +public class JobQueueTest { class Entry extends InternalJob { Entry(int value) { super("Entry"); @@ -37,16 +40,12 @@ private JobQueue queue; - public JobQueueTest(String name) { - super(name); - } - - @Override - protected void setUp() throws Exception { - super.setUp(); + @Before + public void setUp() throws Exception { this.queue = new JobQueue(false); } + @Test public void testEqualValues() { //if several equal values are entered, they should come out in FIFO order final int NUM_ENTRIES = 10; @@ -61,23 +60,25 @@ } } + @Test public void testBasic() { Entry[] entries = createEntries(); assertTrue("1.0", queue.isEmpty()); - assertTrue("1.1", queue.dequeue() == null); - assertTrue("1.2", queue.peek() == null); + assertNull("1.1", queue.dequeue()); + assertNull("1.2", queue.peek()); for (Entry entry : entries) { queue.enqueue(entry); - assertTrue("1.3", queue.peek() != null); + assertNotNull("1.3", queue.peek()); } for (int i = 0; i < entries.length; i++) { queue.remove(entries[i]); - if (i + 1 < entries.length) - assertTrue("1.4." + i, queue.peek() != null); + if (i + 1 < entries.length) { + assertNotNull("1.4." + i, queue.peek()); + } } assertTrue("2.0", queue.isEmpty()); - assertTrue("2.1", queue.dequeue() == null); - assertTrue("2.2", queue.peek() == null); + assertNull("2.1", queue.dequeue()); + assertNull("2.2", queue.peek()); for (Entry entry : entries) { queue.enqueue(entry); }
diff --git a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/OrderedLockTest.java b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/OrderedLockTest.java index baf5b82..27a3bf3 100644 --- a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/OrderedLockTest.java +++ b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/OrderedLockTest.java
@@ -13,32 +13,28 @@ *******************************************************************************/ package org.eclipse.core.tests.runtime.jobs; +import static org.junit.Assert.assertTrue; + import java.util.ArrayList; -import junit.framework.TestCase; import org.eclipse.core.internal.jobs.LockManager; import org.eclipse.core.internal.jobs.OrderedLock; import org.eclipse.core.runtime.jobs.ILock; import org.eclipse.core.runtime.jobs.LockListener; import org.eclipse.core.tests.harness.TestBarrier; +import org.junit.Test; /** * Tests implementation of ILock objects */ -public class OrderedLockTest extends TestCase { - public OrderedLockTest() { - super(null); - } - - public OrderedLockTest(String name) { - super(name); - } +public class OrderedLockTest { /** * Creates n runnables on the given lock and adds them to the given list. */ private void createRunnables(ILock[] locks, int n, ArrayList<LockAcquiringRunnable> allRunnables) { - for (int i = 0; i < n; i++) + for (int i = 0; i < n; i++) { allRunnables.add(new LockAcquiringRunnable(locks)); + } } private void kill(ArrayList<LockAcquiringRunnable> allRunnables) { @@ -47,6 +43,7 @@ } } + @Test public void testComplex() { ArrayList<LockAcquiringRunnable> allRunnables = new ArrayList<>(); LockManager manager = new LockManager(); @@ -70,6 +67,7 @@ assertTrue("Locks not removed from graph.", manager.isEmpty()); } + @Test public void testSimple() { ArrayList<LockAcquiringRunnable> allRunnables = new ArrayList<>(); LockManager manager = new LockManager(); @@ -91,6 +89,7 @@ assertTrue("Locks not removed from graph.", manager.isEmpty()); } + @Test public void testLockAcquireInterrupt() throws InterruptedException { final TestBarrier barrier = new TestBarrier(); LockManager manager = new LockManager(); @@ -126,6 +125,7 @@ * test that an acquire call that times out does not * become the lock owner (regression test) */ + @Test public void testLockTimeout() { //create a new lock manager and 1 lock final LockManager manager = new LockManager(); @@ -181,6 +181,7 @@ * test that when a Lock Listener forces the Lock Manager to grant a lock * to a waiting thread, that other threads in the queue don't get disposed (regression test) */ + @Test public void testLockRequestDisappearence() { //create a new lock manager and 1 lock final LockManager manager = new LockManager();
diff --git a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/WorkerPoolTest.java b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/WorkerPoolTest.java index 91ee844..498c506 100644 --- a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/WorkerPoolTest.java +++ b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/WorkerPoolTest.java
@@ -13,14 +13,16 @@ *******************************************************************************/ package org.eclipse.core.tests.runtime.jobs; +import static org.junit.Assert.assertTrue; + import java.util.concurrent.*; -import junit.framework.TestCase; import org.eclipse.core.internal.jobs.Worker; import org.eclipse.core.runtime.*; import org.eclipse.core.runtime.jobs.Job; +import org.junit.Test; -public class WorkerPoolTest extends TestCase { - +public class WorkerPoolTest { + @Test public void testIdleWorkerCap() throws Exception { // See org.eclipse.core.internal.jobs.WorkerPool.MAX_THREADS final int MAX_THREADS = 50;
diff --git a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/perf/StartupTest.java b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/perf/StartupTest.java index 9ffab2e..2d126e4 100644 --- a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/perf/StartupTest.java +++ b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/perf/StartupTest.java
@@ -13,17 +13,15 @@ *******************************************************************************/ package org.eclipse.core.tests.runtime.perf; -import junit.framework.TestCase; import org.eclipse.test.performance.*; +import org.junit.Test; -public class StartupTest extends TestCase { +public class StartupTest { - public StartupTest(String methodName) { - super(methodName); - } - + @Test public void testApplicationStartup() { - PerformanceMeter meter = Performance.getDefault().createPerformanceMeter(getClass().getName() + '.' + getName()); + PerformanceMeter meter = Performance.getDefault() + .createPerformanceMeter(getClass().getName() + '.' + StartupTest.class.getName()); try { meter.stop(); // tag for showing in the performance fingerprint graph
diff --git a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/perf/UIStartupTest.java b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/perf/UIStartupTest.java index 095e123..dc7b401 100644 --- a/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/perf/UIStartupTest.java +++ b/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/perf/UIStartupTest.java
@@ -13,17 +13,15 @@ *******************************************************************************/ package org.eclipse.core.tests.runtime.perf; -import junit.framework.TestCase; import org.eclipse.test.performance.*; +import org.junit.Test; -public class UIStartupTest extends TestCase { +public class UIStartupTest { - public UIStartupTest(String methodName) { - super(methodName); - } - + @Test public void testUIApplicationStartup() { - PerformanceMeter meter = Performance.getDefault().createPerformanceMeter(getClass().getName() + '.' + getName()); + PerformanceMeter meter = Performance.getDefault() + .createPerformanceMeter(getClass().getName() + '.' + UIStartupTest.class.getName()); try { meter.stop(); Performance performance = Performance.getDefault();