/*******************************************************************************
- * Copyright (c) 2009, 2010 Ericsson
+ * Copyright (c) 2009, 2010, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4, enable CTF and statistics tests
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests;
-import junit.framework.Test;
-import junit.framework.TestSuite;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
- * <b><u>AllTmfCoreTests</u></b>
- * <p>
* Master test suite for TMF Core.
*/
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TmfCorePluginTest.class,
+ org.eclipse.linuxtools.tmf.core.tests.component.AllTests.class,
+ //org.eclipse.linuxtools.tmf.core.tests.ctfadaptor.AllTests.class,
+ org.eclipse.linuxtools.tmf.core.tests.event.AllTests.class,
+ org.eclipse.linuxtools.tmf.core.tests.request.AllTests.class,
+ org.eclipse.linuxtools.tmf.core.tests.statesystem.AllTests.class,
+ //org.eclipse.linuxtools.tmf.core.tests.statistics.AllTests.class,
+ org.eclipse.linuxtools.tmf.core.tests.trace.AllTests.class,
+ org.eclipse.linuxtools.tmf.core.tests.uml2sd.AllTests.class,
+ org.eclipse.linuxtools.tmf.core.tests.util.AllTests.class
+})
public class AllTmfCoreTests {
- /**
- * @return the TMF Core test suite
- */
- public static Test suite() {
- TestSuite suite = new TestSuite(AllTmfCoreTests.class.getName());
- //$JUnit-BEGIN$
- suite.addTestSuite(TmfCorePluginTest.class);
- suite.addTest(org.eclipse.linuxtools.tmf.core.tests.event.AllTests.suite());
- suite.addTest(org.eclipse.linuxtools.tmf.core.tests.request.AllTests.suite());
- suite.addTest(org.eclipse.linuxtools.tmf.core.tests.component.AllTests.suite());
- suite.addTest(org.eclipse.linuxtools.tmf.core.tests.statesystem.AllTests.suite());
- suite.addTest(org.eclipse.linuxtools.tmf.core.tests.trace.AllTests.suite());
- suite.addTest(org.eclipse.linuxtools.tmf.core.tests.uml2sd.AllTests.suite());
- suite.addTest(org.eclipse.linuxtools.tmf.core.tests.util.AllTests.suite());
- //$JUnit-END$
- return suite;
- }
}
/*******************************************************************************
- * Copyright (c) 2009, 2010 Ericsson
+ * Copyright (c) 2009, 2010, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
import org.eclipse.linuxtools.internal.tmf.core.Activator;
+import org.junit.Test;
/**
- * <b><u>TmfCorePluginTest</u></b>
- * <p>
* Test the TMF core plug-in activator
*/
-@SuppressWarnings({ "nls" })
-public class TmfCorePluginTest extends TestCase {
+@SuppressWarnings("nls")
+public class TmfCorePluginTest {
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
// Attributes
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
- // Plug-in instantiation
- static final Activator fPlugin = new Activator();
+ // Plug-in instantiation
+ static final Activator fPlugin = new Activator();
- // ------------------------------------------------------------------------
- // Housekeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfCorePluginTest(String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
// Test cases
- // ------------------------------------------------------------------------
-
- /**
- *
- */
- public void testTmfCorePluginId() {
- assertEquals("Plugin ID", "org.eclipse.linuxtools.tmf.core", Activator.PLUGIN_ID);
- }
-
- /**
- *
- */
- public void testGetDefault() {
- Activator plugin = Activator.getDefault();
- assertEquals("getDefault()", plugin, fPlugin);
- }
+ // ------------------------------------------------------------------------
+
+ /**
+ * Test the plugin ID.
+ */
+ @Test
+ public void testTmfCorePluginId() {
+ assertEquals("Plugin ID", "org.eclipse.linuxtools.tmf.core", Activator.PLUGIN_ID);
+ }
+
+ /**
+ * Test the getDefault() static method.
+ */
+ @Test
+ public void testGetDefault() {
+ Activator plugin = Activator.getDefault();
+ assertEquals("getDefault()", plugin, fPlugin);
+ }
}
+/*******************************************************************************
+ * Copyright (c) 2013 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Alexandre Montplaisir - Initial API and implementation
+ *******************************************************************************/
+
package org.eclipse.linuxtools.tmf.core.tests.component;
-import junit.framework.Test;
-import junit.framework.TestSuite;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
- * <b><u>AllTests</u></b>
- * <p>
- * Implement me. Please.
- * <p>
+ * Unit tests for the component package.
*/
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TmfEventProviderTest.class,
+ TmfProviderManagerTest.class
+})
public class AllTests {
- /**
- * @return the TMF Core Component test suite
- */
- public static Test suite() {
- TestSuite suite = new TestSuite(AllTests.class.getName());
- //$JUnit-BEGIN$
- suite.addTestSuite(TmfProviderManagerTest.class);
- suite.addTestSuite(TmfEventProviderTest.class);
- //$JUnit-END$
- return suite;
- }
-
}
/*******************************************************************************
- * Copyright (c) 2009, 2010 Ericsson
+ * Copyright (c) 2009, 2010, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.component;
-import java.util.Vector;
+import static org.junit.Assert.*;
-import junit.framework.TestCase;
+import java.io.IOException;
+import java.util.Vector;
import org.eclipse.linuxtools.internal.tmf.core.component.TmfProviderManager;
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
import org.eclipse.linuxtools.tmf.tests.stubs.component.TmfSyntheticEventProviderStub;
import org.eclipse.linuxtools.tmf.tests.stubs.event.TmfSyntheticEventStub;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
/**
- * <b><u>TmfClientTest</u></b>
- * <p>
* Test suite for the TmfEventProvider class.
*/
-@SuppressWarnings({ "nls" })
-public class TmfEventProviderTest extends TestCase {
+@SuppressWarnings("nls")
+public class TmfEventProviderTest {
- TmfEventProviderStub fEventProvider;
- TmfSyntheticEventProviderStub fSyntheticEventProvider;
+ private TmfEventProviderStub fEventProvider;
+ private TmfSyntheticEventProviderStub fSyntheticEventProvider;
/**
- * @param name the test anme
+ * Initialization
+ *
+ * @throws IOException
+ * If we can't find the test trace (they are committed in the
+ * tree, so it shouldn't happen).
*/
- public TmfEventProviderTest(String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
+ @Before
+ public void setUp() throws IOException {
fEventProvider = new TmfEventProviderStub();
fSyntheticEventProvider = new TmfSyntheticEventProviderStub();
}
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
+ /**
+ * Clean-up
+ */
+ @After
+ public void tearDown() {
fEventProvider.dispose();
fSyntheticEventProvider.dispose();
}
// ------------------------------------------------------------------------
/**
- *
+ * Test getProviders
*/
+ @Test
public void testGetProviders() {
-
// There should be 2 TmfEvent providers: a TmfTraceStub and a
// TmfEventProviderStub
ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class);
// ------------------------------------------------------------------------
/**
- *
+ * Test getPlainEvents
*/
+ @Test
public void testGetPlainEvents() {
-
final int BLOCK_SIZE = 100;
final int NB_EVENTS = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
}
/**
- *
+ * Test canceling requests.
*/
+ @Test
public void testCancelRequests() {
final int BLOCK_SIZE = 100;
}
/**
- *
+ * Test getSyntheticEvents for equal block sizes.
*/
- // The following tests are the same but for the size of the requested blocks
- // with regards to the size of the TmfSyntheticEventProviderStub block
+ @Test
public void testGetSyntheticEvents_EqualBlockSizes() {
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
try {
}
/**
- *
+ * Test getSyntheticEvents for smaller block sizes.
*/
+ @Test
public void testGetSyntheticEvents_SmallerBlock() {
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
try {
}
/**
- *
+ * Test getSyntheticEvents for larger block sizes.
*/
+ @Test
public void testGetSyntheticEvents_LargerBlock() {
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
try {
}
/**
- *
+ * Test getSyntheticEvents
*/
+ @Test
public void testGetSyntheticEvents_TimeRange() {
TmfTimestamp start = new TmfTimestamp(1, (byte) -3, 0);
TmfTimestamp end = new TmfTimestamp(1000, (byte) -3, 0);
// }
// }
- // ------------------------------------------------------------------------
- // getProviders (more a sanity check than a test)
- // ------------------------------------------------------------------------
-
/**
- *
+ * Test getProviders (more a sanity check than a test)
*/
+ @Test
public void testGetProviders2() {
// There should be 2 TmfEvent providers: a TmfTraceStub and a
/*******************************************************************************
- * Copyright (c) 2009, 2010 Ericsson
+ * Copyright (c) 2009, 2010, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.component;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import org.eclipse.linuxtools.internal.tmf.core.component.TmfProviderManager;
import org.eclipse.linuxtools.tmf.core.component.TmfDataProvider;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
+import org.junit.Test;
+
/**
- * <b><u>TmfProviderManagerTest</u></b>
- * <p>
* Test suite for the TmfProviderManager class.
*/
-@SuppressWarnings({ "nls" })
-public class TmfProviderManagerTest extends TestCase {
-
- /**
- * @param name the test anme
- */
- public TmfProviderManagerTest(String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
- // ------------------------------------------------------------------------
- // Dummy Providers
- // ------------------------------------------------------------------------
-
- private class TestProvider1 extends TmfDataProvider {
- public TestProvider1(Class<ITmfEvent> type) {
- super("TestProvider1", type);
- }
- @Override
- public ITmfContext armRequest(ITmfDataRequest request) {
- return null;
- }
- @Override
- public ITmfEvent getNext(ITmfContext context) {
- return null;
- }
- @Override
- public boolean isCompleted(ITmfDataRequest request, ITmfEvent data, int nbRead) {
- return false;
- }
- }
-
- private class TestProvider2 extends TmfDataProvider {
- public TestProvider2(Class<ITmfEvent> type) {
- super("TestProvider2", type);
- }
- @Override
- public ITmfContext armRequest(ITmfDataRequest request) {
- return null;
- }
- @Override
- public ITmfEvent getNext(ITmfContext context) {
- return null;
- }
- @Override
- public boolean isCompleted(ITmfDataRequest request, ITmfEvent data, int nbRead) {
- return false;
- }
- }
-
- private class TmfEvent3 extends TmfEvent {
- @SuppressWarnings("unused")
+@SuppressWarnings("nls")
+public class TmfProviderManagerTest {
+
+ // ------------------------------------------------------------------------
+ // Dummy Providers
+ // ------------------------------------------------------------------------
+
+ private class TestProvider1 extends TmfDataProvider {
+ public TestProvider1(Class<ITmfEvent> type) {
+ super("TestProvider1", type);
+ }
+
+ @Override
+ public ITmfContext armRequest(ITmfDataRequest request) {
+ return null;
+ }
+
+ @Override
+ public ITmfEvent getNext(ITmfContext context) {
+ return null;
+ }
+
+ @Override
+ public boolean isCompleted(ITmfDataRequest request, ITmfEvent data, int nbRead) {
+ return false;
+ }
+ }
+
+ private class TestProvider2 extends TmfDataProvider {
+ public TestProvider2(Class<ITmfEvent> type) {
+ super("TestProvider2", type);
+ }
+
+ @Override
+ public ITmfContext armRequest(ITmfDataRequest request) {
+ return null;
+ }
+
+ @Override
+ public ITmfEvent getNext(ITmfContext context) {
+ return null;
+ }
+
+ @Override
+ public boolean isCompleted(ITmfDataRequest request, ITmfEvent data, int nbRead) {
+ return false;
+ }
+ }
+
+ private class TmfEvent3 extends TmfEvent {
+ @SuppressWarnings("unused")
public TmfEvent3(TmfEvent3 other) {
- super(other);
- }
- }
-
- private class TestProvider3 extends TmfDataProvider {
- public TestProvider3(Class<TmfEvent3> type) {
- super("TestProvider3", type);
- }
- @Override
- public ITmfContext armRequest(ITmfDataRequest request) {
- return null;
- }
- @Override
- public TmfEvent3 getNext(ITmfContext context) {
- return null;
- }
- @Override
- public boolean isCompleted(ITmfDataRequest request, ITmfEvent data, int nbRead) {
- return false;
- }
- }
-
- // ------------------------------------------------------------------------
- // register/dispose
- // ------------------------------------------------------------------------
-
- /**
- *
- */
- public void testRegister_0() {
- TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
- assertEquals("getProviders", 0, providers.length);
- }
-
- /**
- *
- */
- public void testRegister_Unregister_1() {
-
- // Register a single provider
- TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
-
- TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider1, providers[0]);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider1, providers[0]);
-
- // Unregister it
- testProvider1.dispose();
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
- assertEquals("getProviders", 0, providers.length);
- }
-
- /**
- *
- */
- public void testRegister_Unregister_2() {
-
- // Register 2 providers, same data type
- TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
- TestProvider2 testProvider2 = new TestProvider2(ITmfEvent.class);
-
- TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
- assertEquals("getProviders", 2, providers.length);
- assertTrue(providers.length == 2);
- if (providers[0] == testProvider1) {
- assertEquals("getProviders", testProvider2, providers[1]);
- }
- else {
- assertEquals("getProviders", testProvider2, providers[0]);
- assertEquals("getProviders", testProvider1, providers[1]);
- }
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider1, providers[0]);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider2, providers[0]);
-
- // Remove one
- testProvider1.dispose();
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider2, providers[0]);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider2, providers[0]);
-
- // Remove the other
- testProvider2.dispose();
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
- assertEquals("getProviders", 0, providers.length);
- }
-
- /**
- *
- */
- public void testRegister_Unregister_3() {
-
- // Register 3 providers, mixed data types
- TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
- TestProvider2 testProvider2 = new TestProvider2(ITmfEvent.class);
- TestProvider3 testProvider3 = new TestProvider3(TmfEvent3.class);
-
- TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
- assertEquals("getProviders", 2, providers.length);
- if (providers[0] == testProvider1) {
- assertEquals("getProviders", testProvider2, providers[1]);
- }
- else {
- assertEquals("getProviders", testProvider2, providers[0]);
- assertEquals("getProviders", testProvider1, providers[1]);
- }
-
- TmfDataProvider[] providers3 = TmfProviderManager.getProviders(TmfEvent3.class);
- assertEquals("getProviders", 1, providers3.length);
- assertEquals("getProviders", testProvider3, providers3[0]);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider1, providers[0]);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider2, providers[0]);
-
- providers3 = TmfProviderManager.getProviders(TmfEvent3.class, TestProvider3.class);
- assertEquals("getProviders", 1, providers3.length);
- assertEquals("getProviders", testProvider3, providers3[0]);
-
- // Remove one
- testProvider1.dispose();
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider2, providers[0]);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider2, providers[0]);
-
- providers3 = TmfProviderManager.getProviders(TmfEvent3.class);
- assertEquals("getProviders", 1, providers3.length);
- assertEquals("getProviders", testProvider3, providers3[0]);
-
- providers3 = TmfProviderManager.getProviders(TmfEvent3.class, TestProvider3.class);
- assertEquals("getProviders", 1, providers3.length);
- assertEquals("getProviders", testProvider3, providers3[0]);
-
- // Remove another one
- testProvider2.dispose();
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers3 = TmfProviderManager.getProviders(TmfEvent3.class);
- assertTrue(providers3.length == 1);
- assertTrue(providers3[0] == testProvider3);
-
- providers3 = TmfProviderManager.getProviders(TmfEvent3.class, TestProvider3.class);
- assertEquals("getProviders", 1, providers3.length);
- assertEquals("getProviders", testProvider3, providers3[0]);
-
- // Remove the last one
- testProvider3.dispose();
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers3 = TmfProviderManager.getProviders(TmfEvent3.class);
- assertEquals("getProviders", 0, providers.length);
-
- providers3 = TmfProviderManager.getProviders(TmfEvent3.class, TestProvider3.class);
- assertEquals("getProviders", 0, providers.length);
- }
-
- /**
- *
- */
- public void testGetProvider() {
-
- // Register 3 providers, mixed data types
- TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
- TestProvider2 testProvider2 = new TestProvider2(ITmfEvent.class);
- TestProvider3 testProvider3 = new TestProvider3(TmfEvent3.class);
-
- TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, null);
- assertEquals("getProviders", 2, providers.length);
- if (providers[0] == testProvider1) {
- assertEquals("getProviders", testProvider2, providers[1]);
- }
- else {
- assertEquals("getProviders", testProvider2, providers[0]);
- assertEquals("getProviders", testProvider1, providers[1]);
- }
+ super(other);
+ }
+ }
+
+ private class TestProvider3 extends TmfDataProvider {
+ public TestProvider3(Class<TmfEvent3> type) {
+ super("TestProvider3", type);
+ }
+
+ @Override
+ public ITmfContext armRequest(ITmfDataRequest request) {
+ return null;
+ }
+
+ @Override
+ public TmfEvent3 getNext(ITmfContext context) {
+ return null;
+ }
+
+ @Override
+ public boolean isCompleted(ITmfDataRequest request, ITmfEvent data, int nbRead) {
+ return false;
+ }
+ }
+
+ // ------------------------------------------------------------------------
+ // register/dispose
+ // ------------------------------------------------------------------------
+
+ /**
+ * Test registering
+ */
+ @Test
+ public void testRegister_0() {
+ TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
+ assertEquals("getProviders", 0, providers.length);
+ }
+
+ /**
+ * Test unregistering
+ */
+ @Test
+ public void testRegister_Unregister_1() {
+
+ // Register a single provider
+ TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
+
+ TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider1, providers[0]);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider1, providers[0]);
+
+ // Unregister it
+ testProvider1.dispose();
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
+ assertEquals("getProviders", 0, providers.length);
+ }
+
+ /**
+ * Test unregistering
+ */
+ @Test
+ public void testRegister_Unregister_2() {
+
+ // Register 2 providers, same data type
+ TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
+ TestProvider2 testProvider2 = new TestProvider2(ITmfEvent.class);
+
+ TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
+ assertEquals("getProviders", 2, providers.length);
+ assertTrue(providers.length == 2);
+ if (providers[0] == testProvider1) {
+ assertEquals("getProviders", testProvider2, providers[1]);
+ }
+ else {
+ assertEquals("getProviders", testProvider2, providers[0]);
+ assertEquals("getProviders", testProvider1, providers[1]);
+ }
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider1, providers[0]);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider2, providers[0]);
+
+ // Remove one
+ testProvider1.dispose();
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider2, providers[0]);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider2, providers[0]);
+
+ // Remove the other
+ testProvider2.dispose();
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
+ assertEquals("getProviders", 0, providers.length);
+ }
+
+ /**
+ * Test unregistering
+ */
+ @Test
+ public void testRegister_Unregister_3() {
+
+ // Register 3 providers, mixed data types
+ TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
+ TestProvider2 testProvider2 = new TestProvider2(ITmfEvent.class);
+ TestProvider3 testProvider3 = new TestProvider3(TmfEvent3.class);
+
+ TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
+ assertEquals("getProviders", 2, providers.length);
+ if (providers[0] == testProvider1) {
+ assertEquals("getProviders", testProvider2, providers[1]);
+ }
+ else {
+ assertEquals("getProviders", testProvider2, providers[0]);
+ assertEquals("getProviders", testProvider1, providers[1]);
+ }
+
+ TmfDataProvider[] providers3 = TmfProviderManager.getProviders(TmfEvent3.class);
+ assertEquals("getProviders", 1, providers3.length);
+ assertEquals("getProviders", testProvider3, providers3[0]);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider1, providers[0]);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider2, providers[0]);
+
+ providers3 = TmfProviderManager.getProviders(TmfEvent3.class, TestProvider3.class);
+ assertEquals("getProviders", 1, providers3.length);
+ assertEquals("getProviders", testProvider3, providers3[0]);
+
+ // Remove one
+ testProvider1.dispose();
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider2, providers[0]);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider2, providers[0]);
+
+ providers3 = TmfProviderManager.getProviders(TmfEvent3.class);
+ assertEquals("getProviders", 1, providers3.length);
+ assertEquals("getProviders", testProvider3, providers3[0]);
+
+ providers3 = TmfProviderManager.getProviders(TmfEvent3.class, TestProvider3.class);
+ assertEquals("getProviders", 1, providers3.length);
+ assertEquals("getProviders", testProvider3, providers3[0]);
+
+ // Remove another one
+ testProvider2.dispose();
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers3 = TmfProviderManager.getProviders(TmfEvent3.class);
+ assertTrue(providers3.length == 1);
+ assertTrue(providers3[0] == testProvider3);
+
+ providers3 = TmfProviderManager.getProviders(TmfEvent3.class, TestProvider3.class);
+ assertEquals("getProviders", 1, providers3.length);
+ assertEquals("getProviders", testProvider3, providers3[0]);
+
+ // Remove the last one
+ testProvider3.dispose();
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers3 = TmfProviderManager.getProviders(TmfEvent3.class);
+ assertEquals("getProviders", 0, providers.length);
+
+ providers3 = TmfProviderManager.getProviders(TmfEvent3.class, TestProvider3.class);
+ assertEquals("getProviders", 0, providers.length);
+ }
+
+ /**
+ * Test getProviders method
+ */
+ @Test
+ public void testGetProvider() {
+
+ // Register 3 providers, mixed data types
+ TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
+ TestProvider2 testProvider2 = new TestProvider2(ITmfEvent.class);
+ TestProvider3 testProvider3 = new TestProvider3(TmfEvent3.class);
+
+ TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, null);
+ assertEquals("getProviders", 2, providers.length);
+ if (providers[0] == testProvider1) {
+ assertEquals("getProviders", testProvider2, providers[1]);
+ }
+ else {
+ assertEquals("getProviders", testProvider2, providers[0]);
+ assertEquals("getProviders", testProvider1, providers[1]);
+ }
- providers = TmfProviderManager.getProviders(TmfEvent3.class, null);
- assertEquals("getProviders", 1, providers.length);
- assertEquals("getProviders", testProvider3, providers[0]);
+ providers = TmfProviderManager.getProviders(TmfEvent3.class, null);
+ assertEquals("getProviders", 1, providers.length);
+ assertEquals("getProviders", testProvider3, providers[0]);
- // Remove the providers
- testProvider1.dispose();
- testProvider2.dispose();
- testProvider3.dispose();
- }
+ // Remove the providers
+ testProvider1.dispose();
+ testProvider2.dispose();
+ testProvider3.dispose();
+ }
}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2012 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Matthew Khouzam - Initial generation with CodePro tools
+ * Alexandre Montplaisir - Clean up, consolidate redundant tests
+ *******************************************************************************/
+
+package org.eclipse.linuxtools.tmf.core.tests.ctfadaptor;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * The class <code>TestAll</code> builds a suite that can be used to run all
+ * of the tests within its package as well as within any subpackages of its
+ * package.
+ *
+ * @author ematkho
+ * @version 1.0
+ */
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ CtfIteratorTest.class,
+ CtfLocationDataTest.class,
+ CtfLocationTest.class,
+ CtfTmfLightweightContextTest.class,
+ CtfTmfEventFieldTest.class,
+ CtfTmfEventTest.class,
+ CtfTmfEventTypeTest.class,
+ CtfTmfTimestampTest.class,
+ CtfTmfTraceTest.class,
+})
+public class AllTests {
+
+}
private CtfIterator fixture;
- /**
- * Launch the test.
- *
- * @param args
- * the command line arguments
- */
- public static void main(String[] args) {
- new org.junit.runner.JUnitCore().run(CtfIteratorTest.class);
- }
-
/**
* Perform pre-test initialization.
*
import static org.junit.Assert.assertTrue;
import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfLocationData;
-import org.junit.After;
import org.junit.Before;
import org.junit.Test;
private CtfLocationData fixture;
- /**
- * Launch the test.
- *
- * @param args
- * the command line arguments
- */
- public static void main(String[] args) {
- new org.junit.runner.JUnitCore().run(CtfLocationDataTest.class);
- }
-
/**
* Perform pre-test initialization.
*/
fixture = new CtfLocationData(1, 0);
}
- /**
- * Perform post-test clean-up.
- */
- @After
- public void tearDown() {
- // Add additional tear down code here
- }
-
-
/**
* Test for the .getTimestamp() and .getIndex() methods
*/
import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfLocationData;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
-import org.junit.After;
import org.junit.Before;
import org.junit.Test;
private CtfLocation fixture;
- /**
- * Launch the test.
- *
- * @param args
- * the command line arguments
- */
- public static void main(String[] args) {
- new org.junit.runner.JUnitCore().run(CtfLocationTest.class);
- }
-
/**
* Perform pre-test initialization.
*/
fixture = new CtfLocation(new CtfLocationData(1, 0));
}
- /**
- * Perform post-test clean-up.
- */
- @After
- public void tearDown() {
- // Add additional tear down code here
- }
-
-
/**
* Run the CtfLocation(Long) constructor test.
*/
import org.eclipse.linuxtools.ctf.core.event.types.StructDeclaration;
import org.eclipse.linuxtools.ctf.core.event.types.StructDefinition;
import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfTmfEventField;
-import org.junit.After;
import org.junit.Before;
import org.junit.Test;
private StructDefinition fixture;
- /**
- * Launch the test.
- *
- * @param args
- * the command line arguments
- */
- public static void main(String[] args) {
- new org.junit.runner.JUnitCore().run(CtfTmfEventFieldTest.class);
- }
-
/**
* Perform pre-test initialization.
*/
fixture.read(new BitBuffer(bb));
}
- /**
- * Perform post-test clean-up.
- */
- @After
- public void tearDown() {
- // Add additional tear down code here
- }
-
/**
* Run the CtfTmfEventField parseField(Definition,String) method test.
*/
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
-import org.junit.After;
import org.junit.Before;
import org.junit.Test;
private CtfTmfEvent fixture;
- /**
- * Launch the test.
- *
- * @param args
- * the command line arguments
- */
- public static void main(String[] args) {
- new org.junit.runner.JUnitCore().run(CtfTmfEventTest.class);
- }
-
/**
* Perform pre-test initialization.
*
fixture = tr.getCurrentEvent();
}
- /**
- * Perform post-test clean-up.
- */
- @After
- public void tearDown() {
- // Add additional tear down code here
- }
-
/**
* Run the CTFEvent(EventDefinition,StreamInputReader) constructor test.
*/
import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfTmfEventType;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
-import org.junit.After;
-import org.junit.Before;
import org.junit.Test;
/**
* @author ematkho
* @version 1.0
*/
+@SuppressWarnings("nls")
public class CtfTmfEventTypeTest {
- /**
- * Launch the test.
- *
- * @param args the command line arguments
- */
- public static void main(String[] args) {
- new org.junit.runner.JUnitCore().run(CtfTmfEventTypeTest.class);
- }
-
- /**
- * Perform pre-test initialization.
- */
- @Before
- public void setUp() {
- // add additional set up code here
- }
-
- /**
- * Perform post-test clean-up.
- */
- @After
- public void tearDown() {
- // Add additional tear down code here
- }
-
-
/**
* Run the CtfTmfEventType(String,String,ITmfEventField) constructor test.
*/
@Test
public void testCtfTmfEventType() {
- String eventName = ""; //$NON-NLS-1$
- ITmfEventField content = new TmfEventField("", new ITmfEventField[] {}); //$NON-NLS-1$
+ String eventName = "";
+ ITmfEventField content = new TmfEventField("", new ITmfEventField[] {});
CtfTmfEventType result = new CtfTmfEventType( eventName, content);
assertNotNull(result);
- assertEquals("", result.toString()); //$NON-NLS-1$
- assertEquals("", result.getName()); //$NON-NLS-1$
- assertEquals("Ctf Event", result.getContext()); //$NON-NLS-1$
+ assertEquals("", result.toString());
+ assertEquals("", result.getName());
+ assertEquals("Ctf Event", result.getContext());
}
/**
*/
@Test
public void testToString() {
- ITmfEventField emptyField = new TmfEventField("", new ITmfEventField[] {}); //$NON-NLS-1$
- CtfTmfEventType fixture = new CtfTmfEventType("", emptyField); //$NON-NLS-1$
+ ITmfEventField emptyField = new TmfEventField("", new ITmfEventField[] {});
+ CtfTmfEventType fixture = new CtfTmfEventType("", emptyField);
String result = fixture.toString();
- assertEquals("", result); //$NON-NLS-1$
+ assertEquals("", result);
}
}
\ No newline at end of file
*/
public class CtfTmfTimestampTest {
- /**
- * Launch the test.
- *
- * @param args the command line arguments
- */
- public static void main(String[] args) {
- new org.junit.runner.JUnitCore().run(CtfTmfTimestampTest.class);
- }
-
/**
* Run the CtfTmfTimestamp(long) constructor test.
*/
CtfTmfTimestamp result = new CtfTmfTimestamp(timestamp);
assertNotNull(result);
- assertEquals("00:00:00.000 000 001", result.toString()); //$NON-NLS-1$
+ //assertEquals("00:00:00.000 000 001", result.toString()); //$NON-NLS-1$
assertEquals(0, result.getPrecision());
assertEquals(-9, result.getScale());
assertEquals(1L, result.getValue());
private CtfTmfTrace fixture;
- /**
- * Launch the test.
- *
- * @param args
- * the command line arguments
- */
- public static void main(String[] args) {
- new org.junit.runner.JUnitCore().run(CtfTmfTraceTest.class);
- }
-
/**
* Perform pre-test initialization.
*
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2012 Ericsson
- *
- * All rights reserved. This program and the accompanying materials are
- * made available under the terms of the Eclipse Public License v1.0 which
- * accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * Matthew Khouzam - Initial generation with CodePro tools
- * Alexandre Montplaisir - Clean up, consolidate redundant tests
- *******************************************************************************/
-
-package org.eclipse.linuxtools.tmf.core.tests.ctfadaptor;
-
-import org.junit.runner.JUnitCore;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-
-/**
- * The class <code>TestAll</code> builds a suite that can be used to run all
- * of the tests within its package as well as within any subpackages of its
- * package.
- *
- * @author ematkho
- * @version 1.0
- */
-@RunWith(Suite.class)
-@Suite.SuiteClasses({
- CtfIteratorTest.class,
- CtfLocationDataTest.class,
- CtfLocationTest.class,
- CtfTmfEventFieldTest.class,
- CtfTmfEventTest.class,
- CtfTmfEventTypeTest.class,
- CtfTmfTimestampTest.class,
- CtfTmfTraceTest.class,
- CtfTmfLightweightContextTest.class
-})
-public class TestAll {
-
- /**
- * Launch the test.
- *
- * @param args
- * the command line arguments
- */
- public static void main(String[] args) {
- JUnitCore.runClasses(new Class[] { TestAll.class });
- }
-}
/*******************************************************************************
- * Copyright (c) 2009, 2012 Ericsson
+ * Copyright (c) 2009, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adjusted for new Event Model
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.event;
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-import org.eclipse.linuxtools.internal.tmf.core.Activator;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
* Test suite for org.eclipse.linuxtools.tmf.core.event
*/
-@SuppressWarnings({ "nls" })
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TmfEventFieldTest.class,
+ TmfEventTest.class,
+ TmfEventTypeManagerTest.class,
+ TmfEventTypeTest.class,
+ TmfSimpleTimestampTest.class,
+ TmfTimeRangeTest.class,
+ TmfTimestampDeltaTest.class,
+ TmfTimestampTest.class
+})
public class AllTests {
- /**
- * @return the CTF COre Event test suite
- */
- public static Test suite() {
- final TestSuite suite = new TestSuite("Test suite for " + Activator.PLUGIN_ID + ".event"); //$NON-NLS-1$;
- //$JUnit-BEGIN$
- suite.addTestSuite(TmfTimestampTest.class);
- suite.addTestSuite(TmfSimpleTimestampTest.class);
- suite.addTestSuite(TmfTimestampDeltaTest.class);
- suite.addTestSuite(TmfTimeRangeTest.class);
- suite.addTestSuite(TmfEventFieldTest.class);
- suite.addTestSuite(TmfEventTypeTest.class);
- suite.addTestSuite(TmfEventTest.class);
- suite.addTestSuite(TmfEventTypeManagerTest.class);
- //$JUnit-END$
- return suite;
- }
-
}
/*******************************************************************************
- * Copyright (c) 2009, 2012 Ericsson
+ * Copyright (c) 2009, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adjusted for new Event Model
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.event;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
+import org.junit.Test;
/**
* Test suite for the TmfEventField class.
*/
-@SuppressWarnings("nls")
-public class TmfEventFieldTest extends TestCase {
+@SuppressWarnings({"nls", "javadoc"})
+public class TmfEventFieldTest {
// ------------------------------------------------------------------------
// Variables
private final TmfEventField fRootField = new TmfEventField(fRootFieldName,
new ITmfEventField[] { fField1, fField2 });
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfEventFieldTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testTerminalStructConstructor() {
assertSame("getName", fFieldName1, fStructTerminalField1.getName());
assertNull("getValue", fStructTerminalField1.getValue());
assertNull("getFieldName", fStructTerminalField1.getFieldName(0));
}
- /**
- *
- */
+ @Test
public void testNonTerminalStructConstructor() {
assertSame("getName", fStructRootFieldName, fStructRootField.getName());
assertNull("getValue", fStructRootField.getValue());
assertNull("getFieldName", fStructRootField.getFieldName(names.length));
}
- /**
- *
- */
+ @Test
public void testTerminalConstructor() {
assertSame("getName", fFieldName1, fField1.getName());
assertSame("getValue", fValue1, fField1.getValue());
assertNull("getFieldName", fField2.getFieldName(0));
}
- /**
- *
- */
+ @Test
public void testNonTerminalConstructor() {
assertSame("getName", fRootFieldName, fRootField.getName());
assertNull("getValue", fRootField.getValue());
assertNull("getFieldName", fRootField.getFieldName(names.length));
}
- /**
- *
- */
+ @Test
public void testConstructorBadArg() {
try {
new TmfEventField(null, fValue1, null);
}
}
- /**
- *
- */
+ @Test
public void testTerminalCopyConstructor() {
final TmfEventField copy = new TmfEventField(fField1);
assertSame("getName", fFieldName1, copy.getName());
assertNull("getFieldName", copy.getFieldName(0));
}
- /**
- *
- */
+ @Test
public void testNonTerminalCopyConstructor() {
assertSame("getName", fRootFieldName, fRootField.getName());
assertNull("getValue", fRootField.getValue());
assertNull("getFieldName", fRootField.getFieldName(names.length));
}
- /**
- *
- */
+ @Test
public void testCopyConstructorBadArg() {
try {
new TmfEventField(null);
// hashCode
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testHashCode() {
TmfEventField copy = new TmfEventField(fField1);
assertTrue("hashCode", fField1.hashCode() == copy.hashCode());
// equals
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testEqualsReflexivity() {
assertTrue("equals", fField1.equals(fField1));
assertTrue("equals", fField2.equals(fField2));
assertFalse("equals", fStructTerminalField2.equals(fStructTerminalField1));
}
- /**
- *
- */
+ @Test
public void testEqualsSymmetry() {
final TmfEventField copy0 = new TmfEventField(fField1);
assertTrue("equals", fField1.equals(copy0));
assertTrue("equals", copy3.equals(fField2));
}
- /**
- *
- */
+ @Test
public void testEqualsTransivity() {
TmfEventField copy1 = new TmfEventField(fField1);
TmfEventField copy2 = new TmfEventField(copy1);
assertTrue("equals", fField2.equals(copy2));
}
- /**
- *
- */
+ @Test
public void testEquals() {
assertTrue("equals", fStructTerminalField1.equals(fStructTerminalField3));
assertTrue("equals", fStructTerminalField3.equals(fStructTerminalField1));
assertFalse("equals", fField3.equals(fStructTerminalField1));
}
- /**
- *
- */
+ @Test
public void testEqualsNull() {
assertFalse("equals", fField1.equals(null));
assertFalse("equals", fField2.equals(null));
}
- /**
- *
- */
+ @Test
public void testNonEqualClasses() {
assertFalse("equals", fField1.equals(fStructTerminalField1));
assertFalse("equals", fField1.equals(fValue1));
}
- /**
- *
- */
+ @Test
public void testNonEqualValues() {
final TmfEventField copy1 = new TmfEventField(fFieldName1, fValue1);
TmfEventField copy2 = new TmfEventField(fFieldName1, fValue1);
assertFalse("equals", copy2.equals(copy1));
}
- /**
- *
- */
+ @Test
public void testNonEquals() {
assertFalse("equals", fField1.equals(fField2));
assertFalse("equals", fField2.equals(fField1));
// toString
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testToString() {
final String expected1 = fFieldName1 + "=" + fValue1.toString();
TmfEventField field = new TmfEventField(fFieldName1, fValue1, null);
// makeRoot
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testMakeRoot() {
ITmfEventField root = TmfEventField.makeRoot(fStructFieldNames);
String[] names = root.getFieldNames();
/*******************************************************************************
- * Copyright (c) 2009, 2012 Ericsson
+ * Copyright (c) 2009, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adjusted for new Event Model
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.event;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
-import junit.framework.TestCase;
-
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.Test;
/**
* Test suite for the TmfEvent class.
*/
-@SuppressWarnings("nls")
-public class TmfEventTest extends TestCase {
+@SuppressWarnings({"nls", "javadoc"})
+public class TmfEventTest {
// ------------------------------------------------------------------------
// Variables
private final String fTracePath = "testfiles" + File.separator + "A-Test-10K";
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfEventTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
// ------------------------------------------------------------------------
// Helper functions
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testDefaultConstructor() {
final ITmfEvent event = new TmfEvent();
assertNull("getTrace", event.getTrace());
assertNull("getReference", event.getReference());
}
- /**
- *
- */
+ @Test
public void testFullConstructor() {
assertNull("getTrace", fEvent1.getTrace());
assertEquals("getRank", 0, fEvent1.getRank());
assertEquals("getReference", fReference2, fEvent2.getReference());
}
- /**
- *
- */
+ @Test
public void testNoRankConstructor() {
final ITmfEvent event = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference1);
assertNull("getTrace", event.getTrace());
assertEquals("getReference", fReference1, event.getReference());
}
- /**
- *
- */
+ @Test
public void testConstructorWithTrace() {
final ITmfTrace trace = openTrace();
final ITmfEvent event = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
trace.dispose();
}
- /**
- *
- */
+ @Test
public void testTmfEventCopy() {
final ITmfEvent event = new TmfEvent(fEvent1);
assertNull("getTrace", event.getTrace());
assertEquals("getReference", fReference1, event.getReference());
}
- /**
- *
- */
+ @Test
public void testEventCopy2() {
try {
new TmfEvent(null);
// hashCode
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testHashCode() {
ITmfEvent event1 = new TmfEvent();
ITmfEvent event2 = new TmfEvent();
// equals
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testEqualsReflexivity() {
assertTrue("equals", fEvent1.equals(fEvent1));
assertTrue("equals", fEvent2.equals(fEvent2));
assertFalse("equals", fEvent2.equals(fEvent1));
}
- /**
- *
- */
+ @Test
public void testEqualsSymmetry() {
final ITmfEvent event1 = new TmfEvent(fEvent1);
final ITmfEvent event2 = new TmfEvent(fEvent2);
assertTrue("equals", fEvent2.equals(event2));
}
- /**
- *
- */
+ @Test
public void testEqualsTransivity() {
final ITmfEvent event1 = new TmfEvent(fEvent1);
final ITmfEvent event2 = new TmfEvent(fEvent1);
assertTrue("equals", event1.equals(event3));
}
- /**
- *
- */
+ @Test
public void testEqualsNull() {
assertFalse("equals", fEvent1.equals(null));
assertFalse("equals", fEvent2.equals(null));
}
- /**
- *
- */
+ @Test
public void testNonEqualClasses() {
assertFalse("equals", fEvent1.equals(fEvent1.getType()));
assertFalse("equals", fEvent1.equals(null));
}
- /**
- *
- */
+ @Test
public void testNonEqualTraces() {
final ITmfTrace trace1 = openTrace();
final ITmfTrace trace2 = openTrace();
trace2.dispose();
}
- /**
- *
- */
+ @Test
public void testNonEqualRanks() {
final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertFalse("equals", event2.equals(event1));
}
- /**
- *
- */
+ @Test
public void testNonEqualTimestamps() {
final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertFalse("equals", event2.equals(event1));
}
- /**
- *
- */
+ @Test
public void testNonEqualSources() {
final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertFalse("equals", event2.equals(event1));
}
- /**
- *
- */
+ @Test
public void testNonEqualTypes() {
final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertFalse("equals", event2.equals(event1));
}
- /**
- *
- */
+ @Test
public void testNonEqualContents() {
final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertFalse("equals", event2.equals(event1));
}
- /**
- *
- */
+ @Test
public void testNonEqualReferences() {
final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
// toString
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testToString() {
final String expected1 = "TmfEvent [fTimestamp=" + fTimestamp1 + ", fTrace=null, fRank=0, fSource=" + fSource
+ ", fType=" + fType + ", fContent=" + fContent1 + ", fReference=" + fReference1 + "]";
/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.event;
-import java.util.Arrays;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
-import junit.framework.TestCase;
+import java.util.Arrays;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfEventTypeManager;
+import org.junit.Test;
/**
* Test suite for the TmfEventTypeManager class.
*/
-@SuppressWarnings("nls")
-public class TmfEventTypeManagerTest extends TestCase {
+@SuppressWarnings({"nls", "javadoc"})
+public class TmfEventTypeManagerTest {
// ------------------------------------------------------------------------
// Variables
private final TmfEventType fType2 = new TmfEventType(fContext2, fTypeId3, TmfEventField.makeRoot(fLabels2));
private final TmfEventType fType3 = new TmfEventType(fContext2, fTypeId4, TmfEventField.makeRoot(fLabels1));
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfEventTypeManagerTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
// ------------------------------------------------------------------------
// Getters
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testGetContexts() {
fInstance.clear();
fInstance.add(fContext1, fType0);
assertEquals("getContexts", fContext2, contexts[1]);
}
- /**
- *
- */
+ @Test
public void testGetTypes() {
fInstance.clear();
fInstance.add(fContext1, fType0);
}
}
- /**
- *
- */
+ @Test
public void testGetType() {
fInstance.clear();
fInstance.add(fContext1, fType0);
// Operations
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testClear() {
fInstance.clear();
assertEquals("clear", 0, fInstance.getContexts().length);
assertEquals("clear", "TmfEventTypeManager [fEventTypes={}]", fInstance.toString());
}
- /**
- *
- */
+ @Test
public void testClearContext() {
fInstance.clear();
fInstance.add(fContext1, fType0);
}
}
- /**
- *
- */
+ @Test
public void testBasicAdd() {
fInstance.clear();
fInstance.add(fContext1, fType0);
assertNotSame("add", fType0, type);
}
- /**
- *
- */
+ @Test
public void testAdd() {
fInstance.clear();
fInstance.add(fContext1, fType0);
// Object
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testToString() {
fInstance.clear();
assertEquals("toString", "TmfEventTypeManager [fEventTypes={}]", fInstance.toString());
/*******************************************************************************
- * Copyright (c) 2009, 2012 Ericsson
+ * Copyright (c) 2009, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are made
* available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adjusted for new Event Model
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.event;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
+import org.junit.Test;
/**
* Test suite for the TmfEventType class.
*/
-@SuppressWarnings("nls")
-public class TmfEventTypeTest extends TestCase {
+@SuppressWarnings({"nls", "javadoc"})
+public class TmfEventTypeTest {
// ------------------------------------------------------------------------
// Variables
private final ITmfEventType fType2 = new TmfEventType(fContext2, fTypeId1, TmfEventField.makeRoot(fLabels2));
private final ITmfEventType fType3 = new TmfEventType(fContext2, fTypeId2, TmfEventField.makeRoot(fLabels1));
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfEventTypeTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testDefaultConstructor() {
final ITmfEventType type = new TmfEventType();
assertEquals("getContext", ITmfEventType.DEFAULT_CONTEXT_ID, type.getContext());
assertNull("getFieldName", type.getFieldName(0));
}
- /**
- *
- */
+ @Test
public void testFullConstructor() {
final ITmfEventType type0 = new TmfEventType(fContext1, fTypeId1, TmfEventField.makeRoot(fLabels0));
assertEquals("getContext", fContext1, type0.getContext());
assertNull("getFieldName", type2.getFieldName(labels2.length));
}
- /**
- *
- */
+ @Test
public void testConstructorCornerCases() {
try {
new TmfEventType(null, fTypeId1, null);
}
}
- /**
- *
- */
+ @Test
public void testCopyConstructor() {
final TmfEventType original = new TmfEventType(fContext1, fTypeId1, TmfEventField.makeRoot(fLabels1));
final TmfEventType copy = new TmfEventType(original);
assertNull("getFieldName", copy.getFieldName(labels1.length));
}
- /**
- *
- */
+ @Test
public void testCopyConstructorCornerCases() {
try {
new TmfEventType(null);
// clone
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testClone() {
final ITmfEventType clone = fType1.clone();
assertEquals("clone", fType1, clone);
}
- /**
- *
- */
+ @Test
public void testClone2() {
final ITmfEventType type = new TmfEventType();
final ITmfEventType clone = type.clone();
// hashCode
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testHashCode() {
final TmfEventType copy1 = new TmfEventType(fType0);
// equals
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testEqualsReflexivity() {
assertTrue("equals", fType0.equals(fType0));
assertTrue("equals", fType3.equals(fType3));
assertFalse("equals", fType3.equals(fType0));
}
- /**
- *
- */
+ @Test
public void testEqualsSymmetry() {
final TmfEventType copy0 = new TmfEventType(fType0);
assertTrue("equals", fType0.equals(copy0));
assertTrue("equals", copy2.equals(fType2));
}
- /**
- *
- */
+ @Test
public void testEqualsTransivity() {
TmfEventType copy1 = new TmfEventType(fType1);
TmfEventType copy2 = new TmfEventType(copy1);
assertTrue("equals", fType3.equals(copy2));
}
- /**
- *
- */
+ @Test
public void testEqualsNull() {
assertFalse("equals", fType0.equals(null));
assertFalse("equals", fType3.equals(null));
}
- /**
- *
- */
+ @Test
public void testNonEquals() {
assertFalse("equals", fType0.equals(fType1));
assertFalse("equals", fType1.equals(fType2));
assertFalse("equals", fType3.equals(fType0));
}
- /**
- *
- */
+ @Test
public void testNonEqualsClasses() {
assertFalse("equals", fType1.equals(fLabels1));
}
// toString
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testToString() {
final String expected1 = "TmfEventType [fContext=" + ITmfEventType.DEFAULT_CONTEXT_ID +
", fTypeId=" + ITmfEventType.DEFAULT_TYPE_ID + "]";
/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.event;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
-import junit.framework.TestCase;
-
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.event.TmfSimpleTimestamp;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
+import org.junit.Test;
/**
* Test suite for the TmfSimpleTimestampTest class.
*/
-@SuppressWarnings("nls")
-public class TmfSimpleTimestampTest extends TestCase {
+@SuppressWarnings({"nls", "javadoc"})
+public class TmfSimpleTimestampTest {
// ------------------------------------------------------------------------
// Variables
private final ITmfTimestamp ts1 = new TmfSimpleTimestamp(12345);
private final ITmfTimestamp ts2 = new TmfSimpleTimestamp(-1234);
- // ------------------------------------------------------------------------
- // Housekeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfSimpleTimestampTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testDefaultConstructor() {
assertEquals("getValue", 0, ts0.getValue());
assertEquals("getscale", 0, ts0.getScale());
assertEquals("getPrecision", 0, ts0.getPrecision());
}
- /**
- *
- */
+ @Test
public void testFullConstructor() {
assertEquals("getValue", 12345, ts1.getValue());
assertEquals("getscale", 0, ts1.getScale());
assertEquals("getPrecision", 0, ts1.getPrecision());
}
- /**
- *
- */
+ @Test
public void testCopyConstructor() {
final ITmfTimestamp copy = new TmfSimpleTimestamp(ts1);
assertEquals("getPrecision", 0, copy.getPrecision());
}
- /**
- *
- */
+ @Test
public void testCopyBadTimestamp() {
try {
new TmfSimpleTimestamp(null);
// equals
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testEqualsReflexivity() {
assertTrue("equals", ts0.equals(ts0));
assertTrue("equals", ts1.equals(ts1));
assertTrue("equals", !ts2.equals(ts1));
}
- /**
- *
- */
+ @Test
public void testEqualsSymmetry() {
final ITmfTimestamp ts0copy = new TmfSimpleTimestamp(ts0);
assertTrue("equals", ts0.equals(ts0copy));
assertTrue("equals", ts1copy.equals(ts1));
}
- /**
- *
- */
+ @Test
public void testEqualsTransivity() {
final ITmfTimestamp ts0copy1 = new TmfSimpleTimestamp(ts0);
final ITmfTimestamp ts0copy2 = new TmfSimpleTimestamp(ts0copy1);
assertTrue("equals", ts1.equals(ts1copy2));
}
- /**
- *
- */
+ @Test
public void testEqualsNull() {
assertTrue("equals", !ts0.equals(null));
assertTrue("equals", !ts1.equals(null));
assertTrue("equals", !ts2.equals(null));
}
- /**
- *
- */
+ @Test
public void testEqualsNonTimestamp() {
assertFalse("equals", ts0.equals(ts0.toString()));
}
// toString
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testToString() {
DateFormat df = new SimpleDateFormat("HH:mm:ss.SSS");
Date d0 = new Date(ts0.getValue()*1000);
// hashCode
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testHashCode() {
final ITmfTimestamp ts0copy = new TmfTimestamp(ts0);
final ITmfTimestamp ts1copy = new TmfTimestamp(ts1);
// normalize
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testNormalizeScale0() {
ITmfTimestamp ts = ts0.normalize(0, 0);
assertEquals("getValue", 0, ts.getValue());
assertEquals("getPrecision", 0, ts.getPrecision());
}
- /**
- *
- */
+ @Test
public void testNormalizeScaleNot0() {
ITmfTimestamp ts = ts0.normalize(0, 1);
assertEquals("getValue", 0, ts.getValue());
// compareTo
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testBasicCompareTo() {
final ITmfTimestamp tstamp1 = new TmfSimpleTimestamp(900);
final ITmfTimestamp tstamp2 = new TmfSimpleTimestamp(1000);
assertTrue("CompareTo", tstamp3.compareTo(tstamp2) > 0);
}
- /**
- *
- */
+ @Test
public void testCompareTo() {
final ITmfTimestamp ts0a = new TmfTimestamp(0, 2, 0);
final ITmfTimestamp ts1a = new TmfTimestamp(123450, -1);
// getDelta
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testDelta() {
// Delta for same scale and precision (delta > 0)
TmfTimestamp tstamp0 = new TmfSimpleTimestamp(10);
assertEquals("getDelta", 0, delta.compareTo(expectd, false));
}
- /**
- *
- */
+ @Test
public void testDelta2() {
// Delta for different scale and same precision (delta > 0)
final TmfTimestamp tstamp0 = new TmfSimpleTimestamp(10);
/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2010, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adjusted for new Event Model
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.event;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
+import org.junit.Test;
/**
* Test suite for the TmfTimeRange class.
*/
-@SuppressWarnings("nls")
-public class TmfTimeRangeTest extends TestCase {
-
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfTimeRangeTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
+@SuppressWarnings({"nls", "javadoc"})
+public class TmfTimeRangeTest {
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testConstructor() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
assertEquals("endTime", ts2, range.getEndTime());
}
- /**
- *
- */
+ @Test
public void testBadConstructor() {
try {
new TmfTimeRange(TmfTimestamp.BIG_BANG, null);
}
}
- /**
- *
- */
+ @Test
public void testOpenRange1() {
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, ts2);
assertEquals("endTime", ts2, range.getEndTime());
}
- /**
- *
- */
+ @Test
public void testOpenRange2() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final TmfTimeRange range = new TmfTimeRange(ts1, TmfTimestamp.BIG_CRUNCH);
assertEquals("endTime", TmfTimestamp.BIG_CRUNCH, range.getEndTime());
}
- /**
- *
- */
+ @Test
public void testOpenRange3() {
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
assertEquals("endTime", TmfTimestamp.BIG_CRUNCH, range.getEndTime());
}
- /**
- *
- */
+ @Test
public void testCopyConstructor() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
assertEquals("endTime", TmfTimestamp.BIG_CRUNCH, range3.getEndTime());
}
- /**
- *
- */
+ @Test
public void testCopyConstructor2() {
try {
new TmfTimeRange(null);
// hashCode
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testHashCode() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
// equals
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testEqualsReflexivity() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
assertTrue("equals", !range2.equals(range1));
}
- /**
- *
- */
+ @Test
public void testEqualsSymmetry() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
assertTrue("equals", range2b.equals(range2a));
}
- /**
- *
- */
+ @Test
public void testEqualsTransivity() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
assertTrue("equals", range1a.equals(range1c));
}
- /**
- *
- */
+ @Test
public void testEqualsNull() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
assertTrue("equals", !range1.equals(null));
}
- /**
- *
- */
+ @Test
public void testEqualsBadType() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
assertTrue("equals", !range1.equals(ts1));
}
- /**
- *
- */
+ @Test
public void testEqualStartTime() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
assertTrue("equals", !range1.equals(range3));
}
- /**
- *
- */
+ @Test
public void testEqualsEndTime() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
// toString
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testToString() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
// contains
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testContainsTimestamp() {
final ITmfTimestamp ts1 = new TmfTimestamp(12345);
final ITmfTimestamp ts2 = new TmfTimestamp(12350);
assertTrue("contains (zero)", range.contains(TmfTimestamp.ZERO));
}
- /**
- *
- */
+ @Test
public void testContainsRange() {
final ITmfTimestamp ts1 = new TmfTimestamp(10);
final ITmfTimestamp ts2 = new TmfTimestamp(20);
// getIntersection
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testGetIntersection() {
final ITmfTimestamp ts1a = new TmfTimestamp(1000);
/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Bernd Hufmann - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.event;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimestampDelta;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
+import org.eclipse.linuxtools.tmf.core.event.TmfTimestampDelta;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestampFormat;
+import org.junit.Test;
/**
* Test suite for the TmfTimestampDelta class.
*/
-@SuppressWarnings("nls")
-public class TmfTimestampDeltaTest extends TestCase {
+@SuppressWarnings({"nls", "javadoc"})
+public class TmfTimestampDeltaTest {
// ------------------------------------------------------------------------
// Variables
private final ITmfTimestamp ts3 = new TmfTimestampDelta(12345, 2, 5);
private final ITmfTimestamp ts4 = new TmfTimestampDelta(-12345, -5);
- // ------------------------------------------------------------------------
- // Housekeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfTimestampDeltaTest(final String name) {
- super(name);
- }
-
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testDefaultConstructor() {
assertEquals("getValue", 0, ts0.getValue());
assertEquals("getscale", 0, ts0.getScale());
assertEquals("getPrecision", 0, ts0.getPrecision());
}
- /**
- *
- */
+ @Test
public void testValueConstructor() {
assertEquals("getValue", 12345, ts1.getValue());
assertEquals("getscale", 0, ts1.getScale());
assertEquals("getPrecision", 0, ts1.getPrecision());
}
- /**
- *
- */
+ @Test
public void testValueScaleConstructor() {
assertEquals("getValue", 12345, ts2.getValue());
assertEquals("getscale", -1, ts2.getScale());
assertEquals("getPrecision", 0, ts2.getPrecision());
}
- /**
- *
- */
+ @Test
public void testFullConstructor() {
assertEquals("getValue", 12345, ts3.getValue());
assertEquals("getscale", 2, ts3.getScale());
assertEquals("getPrecision", 0, ts4.getPrecision());
}
- /**
- *
- */
+ @Test
public void testCopyConstructor() {
final ITmfTimestamp ts = new TmfTimestamp(12345, 2, 5);
final ITmfTimestamp copy = new TmfTimestamp(ts);
assertEquals("getPrecision", 5, copy.getPrecision());
}
- /**
- *
- */
+ @Test
public void testCopyNullConstructor() {
try {
new TmfTimestamp(null);
// ------------------------------------------------------------------------
// normalize
// ------------------------------------------------------------------------
- /**
- *
- */
- public void testNormalizeOffset() {
- ITmfTimestamp ts = ts0.normalize(12345, 0);
- assertTrue("instance", ts instanceof TmfTimestampDelta);
- assertEquals("getValue", 12345, ts.getValue());
- assertEquals("getscale", 0, ts.getScale());
- assertEquals("getPrecision", 0, ts.getPrecision());
- }
+
+ @Test
+ public void testNormalizeOffset() {
+ ITmfTimestamp ts = ts0.normalize(12345, 0);
+ assertTrue("instance", ts instanceof TmfTimestampDelta);
+ assertEquals("getValue", 12345, ts.getValue());
+ assertEquals("getscale", 0, ts.getScale());
+ assertEquals("getPrecision", 0, ts.getPrecision());
+ }
// ------------------------------------------------------------------------
// toString
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testToStringDefault() {
assertEquals("toString", "000.000 000 000", ts0.toString());
assertEquals("toString", "12345.000 000 000", ts1.toString());
assertEquals("toString", "-000.123 450 000", ts4.toString());
}
- /**
- *
- */
- public void testToStringFormat() {
- TmfTimestampFormat format = new TmfTimestampFormat("HH:mm:ss.SSS CCC NNN");
- assertEquals("toString", "00:00:00.000 000 000", ts0.toString(format));
- assertEquals("toString", "03:25:45.000 000 000", ts1.toString(format));
- assertEquals("toString", "00:20:34.500 000 000", ts2.toString(format));
- assertEquals("toString", "06:55:00.000 000 000", ts3.toString(format));
- assertEquals("toString", "-00:00:00.123 450 000", ts4.toString(format));
- }
+ @Test
+ public void testToStringFormat() {
+ TmfTimestampFormat format = new TmfTimestampFormat("HH:mm:ss.SSS CCC NNN");
+ assertEquals("toString", "00:00:00.000 000 000", ts0.toString(format));
+ assertEquals("toString", "03:25:45.000 000 000", ts1.toString(format));
+ assertEquals("toString", "00:20:34.500 000 000", ts2.toString(format));
+ assertEquals("toString", "06:55:00.000 000 000", ts3.toString(format));
+ assertEquals("toString", "-00:00:00.123 450 000", ts4.toString(format));
+ }
}
/*******************************************************************************
- * Copyright (c) 2009, 2012 Ericsson
+ * Copyright (c) 2009, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adjusted for new Event Model
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.event;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
-import junit.framework.TestCase;
-
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestampFormat;
+import org.junit.Test;
/**
* Test suite for the TmfTimestamp class.
*/
-@SuppressWarnings("nls")
-public class TmfTimestampTest extends TestCase {
+@SuppressWarnings({"nls", "javadoc"})
+public class TmfTimestampTest {
// ------------------------------------------------------------------------
// Variables
private final ITmfTimestamp ts2 = new TmfTimestamp(12345, -1);
private final ITmfTimestamp ts3 = new TmfTimestamp(12345, 2, 5);
- // ------------------------------------------------------------------------
- // Housekeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfTimestampTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testDefaultConstructor() {
assertEquals("getValue", 0, ts0.getValue());
assertEquals("getscale", 0, ts0.getScale());
assertEquals("getPrecision", 0, ts0.getPrecision());
}
- /**
- *
- */
+ @Test
public void testValueConstructor() {
assertEquals("getValue", 12345, ts1.getValue());
assertEquals("getscale", 0, ts1.getScale());
assertEquals("getPrecision", 0, ts1.getPrecision());
}
- /**
- *
- */
+ @Test
public void testValueScaleConstructor() {
assertEquals("getValue", 12345, ts2.getValue());
assertEquals("getscale", -1, ts2.getScale());
assertEquals("getPrecision", 0, ts2.getPrecision());
}
- /**
- *
- */
+ @Test
public void testFullConstructor() {
assertEquals("getValue", 12345, ts3.getValue());
assertEquals("getscale", 2, ts3.getScale());
assertEquals("getPrecision", 5, ts3.getPrecision());
}
- /**
- *
- */
+ @Test
public void testCopyConstructor() {
final ITmfTimestamp ts = new TmfTimestamp(12345, 2, 5);
final ITmfTimestamp copy = new TmfTimestamp(ts);
assertEquals("getPrecision", 5, copy.getPrecision());
}
- /**
- *
- */
+ @Test
public void testCopyNullConstructor() {
try {
new TmfTimestamp(null);
}
}
- /**
- *
- */
+ @Test
public void testCopyConstructorBigBang() {
final ITmfTimestamp ts = new TmfTimestamp(TmfTimestamp.BIG_BANG);
assertEquals("getValue", TmfTimestamp.BIG_BANG.getValue(), ts.getValue());
assertEquals("getPrecision", TmfTimestamp.BIG_BANG.getPrecision(), ts.getPrecision());
}
- /**
- *
- */
+ @Test
public void testCopyConstructorBigCrunch() {
final ITmfTimestamp ts = new TmfTimestamp(TmfTimestamp.BIG_CRUNCH);
assertEquals("getValue", TmfTimestamp.BIG_CRUNCH.getValue(), ts.getValue());
assertEquals("getPrecision", TmfTimestamp.BIG_CRUNCH.getPrecision(), ts.getPrecision());
}
- /**
- *
- */
+ @Test
public void testCopyConstructorZero() {
final ITmfTimestamp ts = new TmfTimestamp(TmfTimestamp.ZERO);
assertEquals("getValue", TmfTimestamp.ZERO.getValue(), ts.getValue());
// hashCode
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testHashCode() {
final ITmfTimestamp ts0copy = new TmfTimestamp(ts0);
final ITmfTimestamp ts1copy = new TmfTimestamp(ts1);
// equals
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testEqualsReflexivity() {
assertTrue("equals", ts0.equals(ts0));
assertTrue("equals", ts1.equals(ts1));
assertTrue("equals", !ts1.equals(ts0));
}
- /**
- *
- */
+ @Test
public void testEqualsSymmetry() {
final ITmfTimestamp ts0copy = new TmfTimestamp(ts0);
assertTrue("equals", ts0.equals(ts0copy));
assertTrue("equals", ts2copy.equals(ts2));
}
- /**
- *
- */
+ @Test
public void testEqualsTransivity() {
final ITmfTimestamp ts0copy1 = new TmfTimestamp(ts0);
final ITmfTimestamp ts0copy2 = new TmfTimestamp(ts0copy1);
assertTrue("equals", ts2.equals(ts2copy2));
}
- /**
- *
- */
+ @Test
public void testEqualsNull() {
assertTrue("equals", !ts0.equals(null));
assertTrue("equals", !ts1.equals(null));
}
- /**
- *
- */
+ @Test
public void testEqualsNonTimestamp() {
assertFalse("equals", ts0.equals(ts0.toString()));
}
// toString
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testToStringDefault() {
DateFormat df = new SimpleDateFormat("HH:mm:ss.SSS");
Date d0 = new Date(ts0.getValue() * (long) Math.pow(10, ts0.getScale() + 3));
assertEquals("toString", df.format(d3) + " 000 000", ts3.toString());
}
- /**
- *
- */
- public void testToStringInterval() {
- assertEquals("toString", "000.000 000 000", ts0.toString(TmfTimestampFormat.getDefaulIntervalFormat()));
- assertEquals("toString", "12345.000 000 000", ts1.toString(TmfTimestampFormat.getDefaulIntervalFormat()));
- assertEquals("toString", "1234.500 000 000", ts2.toString(TmfTimestampFormat.getDefaulIntervalFormat()));
- assertEquals("toString", "1234500.000 000 000", ts3.toString(TmfTimestampFormat.getDefaulIntervalFormat()));
- }
+ @Test
+ public void testToStringInterval() {
+ assertEquals("toString", "000.000 000 000", ts0.toString(TmfTimestampFormat.getDefaulIntervalFormat()));
+ assertEquals("toString", "12345.000 000 000", ts1.toString(TmfTimestampFormat.getDefaulIntervalFormat()));
+ assertEquals("toString", "1234.500 000 000", ts2.toString(TmfTimestampFormat.getDefaulIntervalFormat()));
+ assertEquals("toString", "1234500.000 000 000", ts3.toString(TmfTimestampFormat.getDefaulIntervalFormat()));
+ }
// ------------------------------------------------------------------------
// normalize
// ------------------------------------------------------------------------
- /**
- *
- */
+ @Test
public void testNormalizeOffset() {
ITmfTimestamp ts = ts0.normalize(0, 0);
assertEquals("getValue", 0, ts.getValue());
assertEquals("getPrecision", 0, ts.getPrecision());
}
- /**
- *
- */
+ @Test
public void testNormalizeOffsetLowerLimits() {
final ITmfTimestamp ref = new TmfTimestamp(Long.MIN_VALUE + 5, 0);
assertEquals("getPrecision", 0, ts.getPrecision());
}
- /**
- *
- */
+ @Test
public void testNormalizeOffsetUpperLimits() {
final ITmfTimestamp ref = new TmfTimestamp(Long.MAX_VALUE - 5, 0);
assertEquals("getPrecision", 0, ts.getPrecision());
}
- /**
- *
- */
+ @Test
public void testNormalizeScale() {
ITmfTimestamp ts = ts0.normalize(0, 10);
assertEquals("getValue", 0, ts.getValue());
assertEquals("getPrecision", 0, ts.getPrecision());
}
- /**
- *
- */
+ @Test
public void testNormalizedScaleLimits() {
final int MAX_SCALE_DIFF = 19;
}
}
- /**
- *
- */
+ @Test
public void testNormalizeOffsetAndScaleTrivial() {
final ITmfTimestamp ts = ts0.normalize(0, 0);
assertEquals("getValue", 0, ts.getValue());
assertEquals("getPrecision", 0, ts.getPrecision());
}
- /**
- *
- */
+ @Test
public void testNormalizeOffsetAndScale() {
final int SCALE = 12;
assertEquals("getPrecision", 0, ts.getPrecision());
}
- /**
- *
- */
+ @Test
public void testNormalizeOffsetAndScale2() {
int SCALE = 2;
ITmfTimestamp ts = ts1.normalize(0, SCALE);
// compareTo
// ------------------------------------------------------------------------
- /**
- *
- */
- @SuppressWarnings("hiding")
+ @Test
public void testBasicCompareTo() {
- final ITmfTimestamp ts1 = new TmfTimestamp(900, 0, 50);
- final ITmfTimestamp ts2 = new TmfTimestamp(1000, 0, 50);
- final ITmfTimestamp ts3 = new TmfTimestamp(1100, 0, 50);
- final ITmfTimestamp ts4 = new TmfTimestamp(1000, 0, 75);
+ final ITmfTimestamp t1 = new TmfTimestamp(900, 0, 50);
+ final ITmfTimestamp t2 = new TmfTimestamp(1000, 0, 50);
+ final ITmfTimestamp t3 = new TmfTimestamp(1100, 0, 50);
+ final ITmfTimestamp t4 = new TmfTimestamp(1000, 0, 75);
- assertTrue(ts1.compareTo(ts1) == 0);
+ assertTrue(t1.compareTo(t1) == 0);
- assertTrue("CompareTo", ts1.compareTo(ts2) < 0);
- assertTrue("CompareTo", ts1.compareTo(ts3) < 0);
- assertTrue("CompareTo", ts1.compareTo(ts4) < 0);
+ assertTrue("CompareTo", t1.compareTo(t2) < 0);
+ assertTrue("CompareTo", t1.compareTo(t3) < 0);
+ assertTrue("CompareTo", t1.compareTo(t4) < 0);
- assertTrue("CompareTo", ts2.compareTo(ts1) > 0);
- assertTrue("CompareTo", ts2.compareTo(ts3) < 0);
- assertTrue("CompareTo", ts2.compareTo(ts4) == 0);
+ assertTrue("CompareTo", t2.compareTo(t1) > 0);
+ assertTrue("CompareTo", t2.compareTo(t3) < 0);
+ assertTrue("CompareTo", t2.compareTo(t4) == 0);
- assertTrue("CompareTo", ts3.compareTo(ts1) > 0);
- assertTrue("CompareTo", ts3.compareTo(ts2) > 0);
- assertTrue("CompareTo", ts3.compareTo(ts4) > 0);
+ assertTrue("CompareTo", t3.compareTo(t1) > 0);
+ assertTrue("CompareTo", t3.compareTo(t2) > 0);
+ assertTrue("CompareTo", t3.compareTo(t4) > 0);
}
- /**
- *
- */
+ @Test
public void testCompareToCornerCases1() {
final ITmfTimestamp ts0a = new TmfTimestamp(ts0);
final ITmfTimestamp ts0b = new TmfTimestamp(ts0.getValue(), ts0.getScale() + 1);
assertTrue("compareTo", ts0.compareTo(ts0d, false) == -1);
}
- /**
- *
- */
+ @Test
public void testCompareToCornerCases2() {
final ITmfTimestamp ts0a = new TmfTimestamp(Long.MAX_VALUE, Integer.MAX_VALUE - 1);
final ITmfTimestamp ts0b = new TmfTimestamp(0, Integer.MAX_VALUE);
assertTrue("compareTo", ts0c.compareTo(ts0b, false) == 1);
}
- /**
- *
- */
+ @Test
public void testCompareToCornerCases3() {
final ITmfTimestamp ts0a = new TmfTimestamp(Long.MIN_VALUE, Integer.MAX_VALUE - 1);
final ITmfTimestamp ts0b = new TmfTimestamp(0, Integer.MAX_VALUE);
assertTrue("compareTo", ts0c.compareTo(ts0b, false) == -1);
}
- /**
- *
- */
+ @Test
public void testCompareToCornerCases4() {
assertTrue("compareTo", ts0.compareTo(null, false) == 1);
assertTrue("compareTo", ts0.compareTo(null, true) == 1);
}
- /**
- *
- */
- @SuppressWarnings("hiding")
+ @Test
public void testCompareToSameScale() {
- final ITmfTimestamp ts1 = new TmfTimestamp(900, 0, 50);
- final ITmfTimestamp ts2 = new TmfTimestamp(1000, 0, 50);
- final ITmfTimestamp ts3 = new TmfTimestamp(1100, 0, 50);
- final ITmfTimestamp ts4 = new TmfTimestamp(1000, 0, 75);
+ final ITmfTimestamp t1 = new TmfTimestamp(900, 0, 50);
+ final ITmfTimestamp t2 = new TmfTimestamp(1000, 0, 50);
+ final ITmfTimestamp t3 = new TmfTimestamp(1100, 0, 50);
+ final ITmfTimestamp t4 = new TmfTimestamp(1000, 0, 75);
- assertTrue(ts1.compareTo(ts1, false) == 0);
+ assertTrue(t1.compareTo(t1, false) == 0);
- assertTrue("CompareTo", ts1.compareTo(ts2, false) < 0);
- assertTrue("CompareTo", ts1.compareTo(ts3, false) < 0);
- assertTrue("CompareTo", ts1.compareTo(ts4, false) < 0);
+ assertTrue("CompareTo", t1.compareTo(t2, false) < 0);
+ assertTrue("CompareTo", t1.compareTo(t3, false) < 0);
+ assertTrue("CompareTo", t1.compareTo(t4, false) < 0);
- assertTrue("CompareTo", ts2.compareTo(ts1, false) > 0);
- assertTrue("CompareTo", ts2.compareTo(ts3, false) < 0);
- assertTrue("CompareTo", ts2.compareTo(ts4, false) == 0);
+ assertTrue("CompareTo", t2.compareTo(t1, false) > 0);
+ assertTrue("CompareTo", t2.compareTo(t3, false) < 0);
+ assertTrue("CompareTo", t2.compareTo(t4, false) == 0);
- assertTrue("CompareTo", ts3.compareTo(ts1, false) > 0);
- assertTrue("CompareTo", ts3.compareTo(ts2, false) > 0);
- assertTrue("CompareTo", ts3.compareTo(ts4, false) > 0);
+ assertTrue("CompareTo", t3.compareTo(t1, false) > 0);
+ assertTrue("CompareTo", t3.compareTo(t2, false) > 0);
+ assertTrue("CompareTo", t3.compareTo(t4, false) > 0);
}
- /**
- *
- */
- @SuppressWarnings("hiding")
+ @Test
public void testCompareToDifferentScale() {
- final ITmfTimestamp ts1 = new TmfTimestamp(9000, -1, 50);
- final ITmfTimestamp ts2 = new TmfTimestamp(1000, 0, 50);
- final ITmfTimestamp ts3 = new TmfTimestamp(110, 1, 50);
- final ITmfTimestamp ts4 = new TmfTimestamp(1, 3, 75);
+ final ITmfTimestamp t1 = new TmfTimestamp(9000, -1, 50);
+ final ITmfTimestamp t2 = new TmfTimestamp(1000, 0, 50);
+ final ITmfTimestamp t3 = new TmfTimestamp(110, 1, 50);
+ final ITmfTimestamp t4 = new TmfTimestamp(1, 3, 75);
- assertTrue("CompareTo", ts1.compareTo(ts1, false) == 0);
+ assertTrue("CompareTo", t1.compareTo(t1, false) == 0);
- assertTrue("CompareTo", ts1.compareTo(ts2, false) < 0);
- assertTrue("CompareTo", ts1.compareTo(ts3, false) < 0);
- assertTrue("CompareTo", ts1.compareTo(ts4, false) < 0);
+ assertTrue("CompareTo", t1.compareTo(t2, false) < 0);
+ assertTrue("CompareTo", t1.compareTo(t3, false) < 0);
+ assertTrue("CompareTo", t1.compareTo(t4, false) < 0);
- assertTrue("CompareTo", ts2.compareTo(ts1, false) > 0);
- assertTrue("CompareTo", ts2.compareTo(ts3, false) < 0);
- assertTrue("CompareTo", ts2.compareTo(ts4, false) == 0);
+ assertTrue("CompareTo", t2.compareTo(t1, false) > 0);
+ assertTrue("CompareTo", t2.compareTo(t3, false) < 0);
+ assertTrue("CompareTo", t2.compareTo(t4, false) == 0);
- assertTrue("CompareTo", ts3.compareTo(ts1, false) > 0);
- assertTrue("CompareTo", ts3.compareTo(ts2, false) > 0);
- assertTrue("CompareTo", ts3.compareTo(ts4, false) > 0);
+ assertTrue("CompareTo", t3.compareTo(t1, false) > 0);
+ assertTrue("CompareTo", t3.compareTo(t2, false) > 0);
+ assertTrue("CompareTo", t3.compareTo(t4, false) > 0);
}
- /**
- *
- */
- @SuppressWarnings("hiding")
+ @Test
public void testCompareToWithinPrecision() {
- final ITmfTimestamp ts1 = new TmfTimestamp(900, 0, 50);
- final ITmfTimestamp ts2 = new TmfTimestamp(1000, 0, 50);
- final ITmfTimestamp ts3 = new TmfTimestamp(1100, 0, 50);
- final ITmfTimestamp ts4 = new TmfTimestamp(1000, 0, 75);
+ final ITmfTimestamp t1 = new TmfTimestamp(900, 0, 50);
+ final ITmfTimestamp t2 = new TmfTimestamp(1000, 0, 50);
+ final ITmfTimestamp t3 = new TmfTimestamp(1100, 0, 50);
+ final ITmfTimestamp t4 = new TmfTimestamp(1000, 0, 75);
- assertTrue("CompareTo", ts1.compareTo(ts1, true) == 0);
+ assertTrue("CompareTo", t1.compareTo(t1, true) == 0);
- assertTrue("CompareTo", ts1.compareTo(ts2, true) == 0);
- assertTrue("CompareTo", ts1.compareTo(ts3, true) < 0);
- assertTrue("CompareTo", ts1.compareTo(ts4, true) == 0);
+ assertTrue("CompareTo", t1.compareTo(t2, true) == 0);
+ assertTrue("CompareTo", t1.compareTo(t3, true) < 0);
+ assertTrue("CompareTo", t1.compareTo(t4, true) == 0);
- assertTrue("CompareTo", ts2.compareTo(ts1, true) == 0);
- assertTrue("CompareTo", ts2.compareTo(ts3, true) == 0);
- assertTrue("CompareTo", ts2.compareTo(ts4, true) == 0);
+ assertTrue("CompareTo", t2.compareTo(t1, true) == 0);
+ assertTrue("CompareTo", t2.compareTo(t3, true) == 0);
+ assertTrue("CompareTo", t2.compareTo(t4, true) == 0);
- assertTrue("CompareTo", ts3.compareTo(ts1, true) > 0);
- assertTrue("CompareTo", ts3.compareTo(ts2, true) == 0);
- assertTrue("CompareTo", ts3.compareTo(ts4, true) == 0);
+ assertTrue("CompareTo", t3.compareTo(t1, true) > 0);
+ assertTrue("CompareTo", t3.compareTo(t2, true) == 0);
+ assertTrue("CompareTo", t3.compareTo(t4, true) == 0);
}
- /**
- *
- */
- @SuppressWarnings("hiding")
+ @Test
public void testCompareToLargeScale1() {
- final ITmfTimestamp ts1 = new TmfTimestamp(-1, 100);
- final ITmfTimestamp ts2 = new TmfTimestamp(-1000, -100);
- final ITmfTimestamp ts3 = new TmfTimestamp(1, 100);
- final ITmfTimestamp ts4 = new TmfTimestamp(1000, -100);
+ final ITmfTimestamp t1 = new TmfTimestamp(-1, 100);
+ final ITmfTimestamp t2 = new TmfTimestamp(-1000, -100);
+ final ITmfTimestamp t3 = new TmfTimestamp(1, 100);
+ final ITmfTimestamp t4 = new TmfTimestamp(1000, -100);
- assertTrue("CompareTo", ts1.compareTo(ts2, false) < 0);
- assertTrue("CompareTo", ts1.compareTo(ts3, false) < 0);
- assertTrue("CompareTo", ts1.compareTo(ts4, false) < 0);
+ assertTrue("CompareTo", t1.compareTo(t2, false) < 0);
+ assertTrue("CompareTo", t1.compareTo(t3, false) < 0);
+ assertTrue("CompareTo", t1.compareTo(t4, false) < 0);
- assertTrue("CompareTo", ts2.compareTo(ts1, false) > 0);
- assertTrue("CompareTo", ts2.compareTo(ts3, false) < 0);
- assertTrue("CompareTo", ts2.compareTo(ts4, false) < 0);
+ assertTrue("CompareTo", t2.compareTo(t1, false) > 0);
+ assertTrue("CompareTo", t2.compareTo(t3, false) < 0);
+ assertTrue("CompareTo", t2.compareTo(t4, false) < 0);
- assertTrue("CompareTo", ts3.compareTo(ts1, false) > 0);
- assertTrue("CompareTo", ts3.compareTo(ts2, false) > 0);
- assertTrue("CompareTo", ts3.compareTo(ts4, false) > 0);
+ assertTrue("CompareTo", t3.compareTo(t1, false) > 0);
+ assertTrue("CompareTo", t3.compareTo(t2, false) > 0);
+ assertTrue("CompareTo", t3.compareTo(t4, false) > 0);
- assertTrue("CompareTo", ts4.compareTo(ts1, false) > 0);
- assertTrue("CompareTo", ts4.compareTo(ts2, false) > 0);
- assertTrue("CompareTo", ts4.compareTo(ts3, false) < 0);
+ assertTrue("CompareTo", t4.compareTo(t1, false) > 0);
+ assertTrue("CompareTo", t4.compareTo(t2, false) > 0);
+ assertTrue("CompareTo", t4.compareTo(t3, false) < 0);
}
- /**
- *
- */
+ @Test
public void testCompareToLargeScale2() {
final ITmfTimestamp ts0a = new TmfTimestamp(0, Integer.MAX_VALUE);
final ITmfTimestamp ts0b = new TmfTimestamp(1, Integer.MAX_VALUE);
// getDelta
// ------------------------------------------------------------------------
- /**
- *
- */
- @SuppressWarnings("hiding")
+ @Test
public void testDelta() {
// Delta for same scale and precision (delta > 0)
- ITmfTimestamp ts0 = new TmfTimestamp(10, 9);
- ITmfTimestamp ts1 = new TmfTimestamp(5, 9);
+ ITmfTimestamp t0 = new TmfTimestamp(10, 9);
+ ITmfTimestamp t1 = new TmfTimestamp(5, 9);
ITmfTimestamp exp = new TmfTimestamp(5, 9);
- ITmfTimestamp delta = ts0.getDelta(ts1);
+ ITmfTimestamp delta = t0.getDelta(t1);
assertEquals("getDelta", 0, delta.compareTo(exp, false));
// Delta for same scale and precision (delta < 0)
- ts0 = new TmfTimestamp(5, 9);
- ts1 = new TmfTimestamp(10, 9);
+ t0 = new TmfTimestamp(5, 9);
+ t1 = new TmfTimestamp(10, 9);
exp = new TmfTimestamp(-5, 9);
- delta = ts0.getDelta(ts1);
+ delta = t0.getDelta(t1);
assertEquals("getDelta", 0, delta.compareTo(exp, false));
// Delta for different scale and same precision (delta > 0)
- ts0 = new TmfTimestamp(5, 9);
- ts1 = new TmfTimestamp(10, 8);
+ t0 = new TmfTimestamp(5, 9);
+ t1 = new TmfTimestamp(10, 8);
exp = new TmfTimestamp(4, 9);
- delta = ts0.getDelta(ts1);
+ delta = t0.getDelta(t1);
assertEquals("getDelta", 0, delta.compareTo(exp, false));
// Delta for different scale and same precision (delta > 0)
- ts0 = new TmfTimestamp(5, 9);
- ts1 = new TmfTimestamp(10, 7);
+ t0 = new TmfTimestamp(5, 9);
+ t1 = new TmfTimestamp(10, 7);
exp = new TmfTimestamp(5, 9);
- delta = ts0.getDelta(ts1);
+ delta = t0.getDelta(t1);
assertEquals("getDelta", 0, delta.compareTo(exp, false));
// Delta for different scale and same precision
- ts0 = new TmfTimestamp(10, 9);
- ts1 = new TmfTimestamp(5, 8);
+ t0 = new TmfTimestamp(10, 9);
+ t1 = new TmfTimestamp(5, 8);
exp = new TmfTimestamp(10, 9);
- delta = ts0.getDelta(ts1);
+ delta = t0.getDelta(t1);
assertEquals("getDelta", 0, delta.compareTo(exp, false));
// Delta for same scale and different precision
- ts0 = new TmfTimestamp(10, 9, 1);
- ts1 = new TmfTimestamp(5, 9, 2);
+ t0 = new TmfTimestamp(10, 9, 1);
+ t1 = new TmfTimestamp(5, 9, 2);
exp = new TmfTimestamp(5, 9, 3);
- delta = ts0.getDelta(ts1);
+ delta = t0.getDelta(t1);
assertEquals("getDelta", 0, delta.compareTo(exp, true));
assertEquals("precision", 3, delta.getPrecision());
// Delta for same scale and different precision
- ts0 = new TmfTimestamp(5, 9, 2);
- ts1 = new TmfTimestamp(10, 9, 1);
+ t0 = new TmfTimestamp(5, 9, 2);
+ t1 = new TmfTimestamp(10, 9, 1);
exp = new TmfTimestamp(-5, 9, 3);
- delta = ts0.getDelta(ts1);
+ delta = t0.getDelta(t1);
assertEquals("getDelta", 0, delta.compareTo(exp, true));
assertEquals("precision", 3, delta.getPrecision());
// Delta for different scale and different precision
- ts0 = new TmfTimestamp(5, 9, 2);
- ts1 = new TmfTimestamp(10, 8, 1);
+ t0 = new TmfTimestamp(5, 9, 2);
+ t1 = new TmfTimestamp(10, 8, 1);
exp = new TmfTimestamp(4, 9, 3);
- delta = ts0.getDelta(ts1);
+ delta = t0.getDelta(t1);
assertEquals("getDelta", 0, delta.compareTo(exp, true));
assertEquals("precision", 2, delta.getPrecision());
}
-package org.eclipse.linuxtools.tmf.core.tests.request;
+/*******************************************************************************
+ * Copyright (c) 2013 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
+ *******************************************************************************/
-import junit.framework.Test;
-import junit.framework.TestSuite;
+package org.eclipse.linuxtools.tmf.core.tests.request;
-import org.eclipse.linuxtools.internal.tmf.core.Activator;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
- * <b><u>AllTests</u></b>
- * <p>
- * Implement me. Please.
- * <p>
+ * Requests tests
*/
-@SuppressWarnings({ "nls" })
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TmfCoalescedDataRequestTest.class,
+ TmfCoalescedEventRequestTest.class,
+ TmfDataRequestTest.class,
+ TmfEventRequestTest.class,
+ TmfRequestExecutorTest.class
+})
public class AllTests {
- /**
- * @return the test suite
- */
- public static Test suite() {
- TestSuite suite = new TestSuite("Test suite for " + Activator.PLUGIN_ID + ".request"); //$NON-NLS-1$);
- //$JUnit-BEGIN$
- suite.addTestSuite(TmfDataRequestTest.class);
- suite.addTestSuite(TmfEventRequestTest.class);
- suite.addTestSuite(TmfCoalescedDataRequestTest.class);
- suite.addTestSuite(TmfCoalescedEventRequestTest.class);
- suite.addTestSuite(TmfRequestExecutorTest.class);
- //$JUnit-END$
- return suite;
- }
-
}
/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2010, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Added tests to check offsets
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.request;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedDataRequest;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub;
+import org.junit.Before;
+import org.junit.Test;
/**
* Test suite for the TmfCoalescedDataRequest class.
*/
-@SuppressWarnings({"nls","javadoc"})
-public class TmfCoalescedDataRequestTest extends TestCase {
-
- // ------------------------------------------------------------------------
- // Variables
- // ------------------------------------------------------------------------
-
- private TmfCoalescedDataRequest fRequest1;
- private TmfCoalescedDataRequest fRequest2;
- private TmfCoalescedDataRequest fRequest3;
- private TmfCoalescedDataRequest fRequest4;
-
- private TmfCoalescedDataRequest fRequest1b;
- private TmfCoalescedDataRequest fRequest1c;
-
- private int fRequestCount;
-
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfCoalescedDataRequestTest(final String name) {
- super(name);
- }
-
- @Override
- public void setUp() throws Exception {
- super.setUp();
- TmfDataRequest.reset();
- fRequest1 = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
- fRequest2 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 100, 200);
- fRequest3 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 200, 200);
- fRequest4 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 200, 300);
-
- fRequest1b = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
- fRequest1c = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
-
- fRequestCount = fRequest1c.getRequestId() + 1;
- }
-
- @Override
- public void tearDown() throws Exception {
- super.tearDown();
- }
-
- private static TmfCoalescedDataRequest setupTestRequest(final boolean[] flags) {
-
- TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200) {
- @Override
- public void handleCompleted() {
- super.handleCompleted();
- flags[0] = true;
- }
- @Override
- public void handleSuccess() {
- super.handleSuccess();
- flags[1] = true;
- }
- @Override
- public void handleFailure() {
- super.handleFailure();
- flags[2] = true;
- }
- @Override
- public void handleCancel() {
- super.handleCancel();
- flags[3] = true;
- }
- };
- return request;
- }
-
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
-
- public void testTmfCoalescedDataRequest() {
- TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class);
+@SuppressWarnings({ "nls", "javadoc" })
+public class TmfCoalescedDataRequestTest {
+
+ // ------------------------------------------------------------------------
+ // Variables
+ // ------------------------------------------------------------------------
+
+ private TmfCoalescedDataRequest fRequest1;
+ private TmfCoalescedDataRequest fRequest2;
+ private TmfCoalescedDataRequest fRequest3;
+ private TmfCoalescedDataRequest fRequest4;
+
+ private TmfCoalescedDataRequest fRequest1b;
+ private TmfCoalescedDataRequest fRequest1c;
+
+ private int fRequestCount;
+
+ // ------------------------------------------------------------------------
+ // Housekeeping
+ // ------------------------------------------------------------------------
+
+ @Before
+ public void setUp() {
+ TmfDataRequest.reset();
+ fRequest1 = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ fRequest2 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 100, 200);
+ fRequest3 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 200, 200);
+ fRequest4 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 200, 300);
+
+ fRequest1b = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ fRequest1c = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+
+ fRequestCount = fRequest1c.getRequestId() + 1;
+ }
+
+ private static TmfCoalescedDataRequest setupTestRequest(final boolean[] flags) {
+
+ TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200) {
+ @Override
+ public void handleCompleted() {
+ super.handleCompleted();
+ flags[0] = true;
+ }
+
+ @Override
+ public void handleSuccess() {
+ super.handleSuccess();
+ flags[1] = true;
+ }
+
+ @Override
+ public void handleFailure() {
+ super.handleFailure();
+ flags[2] = true;
+ }
+
+ @Override
+ public void handleCancel() {
+ super.handleCancel();
+ flags[3] = true;
+ }
+ };
+ return request;
+ }
+
+ // ------------------------------------------------------------------------
+ // Constructors
+ // ------------------------------------------------------------------------
+
+ @Test
+ public void testTmfCoalescedDataRequest() {
+ TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfCoalescedDataRequestIndex() {
- TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10);
+ @Test
+ public void testTmfCoalescedDataRequestIndex() {
+ TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfCoalescedDataRequestIndexNbRequested() {
- TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100);
+ @Test
+ public void testTmfCoalescedDataRequestIndexNbRequested() {
+ TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
- TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ @Test
+ public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
+ TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- // ------------------------------------------------------------------------
- // equals
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // equals
+ // ------------------------------------------------------------------------
- public void testEqualsReflexivity() {
+ @Test
+ public void testEqualsReflexivity() {
assertTrue("equals", fRequest1.equals(fRequest1));
assertTrue("equals", fRequest2.equals(fRequest2));
assertFalse("equals", fRequest1.equals(fRequest2));
assertFalse("equals", fRequest2.equals(fRequest1));
- }
+ }
- public void testEqualsSymmetry() {
+ @Test
+ public void testEqualsSymmetry() {
assertTrue("equals", fRequest1.equals(fRequest1b));
assertTrue("equals", fRequest1b.equals(fRequest1));
assertFalse("equals", fRequest2.equals(fRequest3));
assertFalse("equals", fRequest3.equals(fRequest1));
assertFalse("equals", fRequest3.equals(fRequest2));
- }
+ }
- public void testEqualsTransivity() {
+ @Test
+ public void testEqualsTransivity() {
assertTrue("equals", fRequest1.equals(fRequest1b));
assertTrue("equals", fRequest1b.equals(fRequest1c));
assertTrue("equals", fRequest1.equals(fRequest1c));
- }
+ }
- public void testEqualsNull() {
+ @Test
+ public void testEqualsNull() {
assertFalse("equals", fRequest1.equals(null));
assertFalse("equals", fRequest2.equals(null));
- }
+ }
- // ------------------------------------------------------------------------
- // hashCode
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
- public void testHashCode() {
+ @Test
+ public void testHashCode() {
assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
- assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
- }
+ assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
+ }
- // ------------------------------------------------------------------------
- // toString
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // toString
+ // ------------------------------------------------------------------------
- public void testToString() {
+ @Test
+ public void testToString() {
String expected1 = "[TmfCoalescedDataRequest(0,ITmfEvent,10,100,200)]";
String expected2 = "[TmfCoalescedDataRequest(1,ITmfEvent,20,100,200)]";
String expected3 = "[TmfCoalescedDataRequest(2,ITmfEvent,20,200,200)]";
// isCompatible
// ------------------------------------------------------------------------
+ @Test
public void testIsCompatible() {
TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
- TmfDataRequest request1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
- TmfDataRequest request2 = new TmfDataRequestStub(ITmfEvent.class, 5, 100, 200);
- TmfDataRequest request3 = new TmfDataRequestStub(ITmfEvent.class, 5, 4, 200);
- TmfDataRequest request4 = new TmfDataRequestStub(ITmfEvent.class, 5, 5, 200);
- TmfDataRequest request5 = new TmfDataRequestStub(ITmfEvent.class, 15, 100, 200);
+ TmfDataRequest request1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request2 = new TmfDataRequestStub(ITmfEvent.class, 5, 100, 200);
+ TmfDataRequest request3 = new TmfDataRequestStub(ITmfEvent.class, 5, 4, 200);
+ TmfDataRequest request4 = new TmfDataRequestStub(ITmfEvent.class, 5, 5, 200);
+ TmfDataRequest request5 = new TmfDataRequestStub(ITmfEvent.class, 15, 100, 200);
TmfDataRequest request6 = new TmfDataRequestStub(ITmfEvent.class, 100, 100, 200);
TmfDataRequest request7 = new TmfDataRequestStub(ITmfEvent.class, 110, 100, 200);
TmfDataRequest request8 = new TmfDataRequestStub(ITmfEvent.class, 111, 100, 200);
// addRequest
// ------------------------------------------------------------------------
+ @Test
public void testAddRequest1() {
TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
- assertEquals("addRequest", 10, coalescedRequest.getIndex());
+ assertEquals("addRequest", 10, coalescedRequest.getIndex());
assertEquals("addRequest", 100, coalescedRequest.getNbRequested());
assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
}
+ @Test
public void testAddRequest2() {
TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
- assertEquals("addRequest", 5, coalescedRequest.getIndex());
+ assertEquals("addRequest", 5, coalescedRequest.getIndex());
assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
}
+ @Test
public void testAddRequest3() {
TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 4, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
- assertEquals("addRequest", 5, coalescedRequest.getIndex());
+ assertEquals("addRequest", 5, coalescedRequest.getIndex());
assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
}
+ @Test
public void testAddRequest4() {
TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 5, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
- assertEquals("addRequest", 5, coalescedRequest.getIndex());
+ assertEquals("addRequest", 5, coalescedRequest.getIndex());
assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
}
+ @Test
public void testAddRequest5() {
TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 15, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
- assertEquals("addRequest", 10, coalescedRequest.getIndex());
+ assertEquals("addRequest", 10, coalescedRequest.getIndex());
assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
}
+ @Test
public void testAddRequest6() {
TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 100, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
- assertEquals("addRequest", 10, coalescedRequest.getIndex());
+ assertEquals("addRequest", 10, coalescedRequest.getIndex());
assertEquals("addRequest", 190, coalescedRequest.getNbRequested());
assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
}
+ @Test
public void testAddRequest7() {
TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 110, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
- assertEquals("addRequest", 10, coalescedRequest.getIndex());
+ assertEquals("addRequest", 10, coalescedRequest.getIndex());
assertEquals("addRequest", 200, coalescedRequest.getNbRequested());
assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
}
+ @Test
public void testAddRequest8() {
TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 111, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
- assertEquals("addRequest", 10, coalescedRequest.getIndex());
+ assertEquals("addRequest", 10, coalescedRequest.getIndex());
assertEquals("addRequest", 201, coalescedRequest.getNbRequested());
assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
}
- // ------------------------------------------------------------------------
- // done
+ // ------------------------------------------------------------------------
+ // done
// ------------------------------------------------------------------------
+ @Test
public void testDone() {
-
// Test request
final boolean[] crFlags = new boolean[4];
TmfCoalescedDataRequest request = setupTestRequest(crFlags);
request.addRequest(subRequest1);
request.addRequest(subRequest2);
- request.done();
-
- // Validate the coalescing request
- assertTrue ("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
- assertFalse("isCancelled", request.isCancelled());
-
- assertTrue ("handleCompleted", crFlags[0]);
- assertTrue ("handleSuccess", crFlags[1]);
- assertFalse("handleFailure", crFlags[2]);
- assertFalse("handleCancel", crFlags[3]);
-
- // Validate the first coalesced request
- assertTrue ("isCompleted", subRequest1.isCompleted());
- assertFalse("isFailed", subRequest1.isFailed());
- assertFalse("isCancelled", subRequest1.isCancelled());
-
- // Validate the second coalesced request
- assertTrue ("isCompleted", subRequest2.isCompleted());
- assertFalse("isFailed", subRequest2.isFailed());
- assertFalse("isCancelled", subRequest2.isCancelled());
- }
-
- // ------------------------------------------------------------------------
- // fail
- // ------------------------------------------------------------------------
-
- public void testFail() {
-
- final boolean[] crFlags = new boolean[4];
- TmfCoalescedDataRequest request = setupTestRequest(crFlags);
- TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
- TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
- request.addRequest(subRequest1);
- request.addRequest(subRequest2);
-
- request.fail();
-
- // Validate the coalescing request
- assertTrue ("isCompleted", request.isCompleted());
- assertTrue ("isFailed", request.isFailed());
- assertFalse("isCancelled", request.isCancelled());
-
- assertTrue ("handleCompleted", crFlags[0]);
- assertFalse("handleSuccess", crFlags[1]);
- assertTrue ("handleFailure", crFlags[2]);
- assertFalse("handleCancel", crFlags[3]);
-
- // Validate the first coalesced request
- assertTrue ("isCompleted", subRequest1.isCompleted());
- assertTrue ("isFailed", subRequest1.isFailed());
- assertFalse("isCancelled", subRequest1.isCancelled());
-
- // Validate the second coalesced request
- assertTrue ("isCompleted", subRequest2.isCompleted());
- assertTrue ("isFailed", subRequest2.isFailed());
- assertFalse("isCancelled", subRequest2.isCancelled());
- }
-
- // ------------------------------------------------------------------------
- // cancel
- // ------------------------------------------------------------------------
-
- public void testCancel() {
-
- final boolean[] crFlags = new boolean[4];
- TmfCoalescedDataRequest request = setupTestRequest(crFlags);
- TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
- TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
- request.addRequest(subRequest1);
- request.addRequest(subRequest2);
-
- request.cancel();
-
- // Validate the coalescing request
- assertTrue ("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
- assertTrue ("isCancelled", request.isCancelled());
-
- assertTrue ("handleCompleted", crFlags[0]);
- assertFalse("handleSuccess", crFlags[1]);
- assertFalse("handleFailure", crFlags[2]);
- assertTrue ("handleCancel", crFlags[3]);
-
- // Validate the first coalesced request
- assertTrue ("isCompleted", subRequest1.isCompleted());
- assertFalse("isFailed", subRequest1.isFailed());
- assertTrue ("isCancelled", subRequest1.isCancelled());
-
- // Validate the second coalesced request
- assertTrue ("isCompleted", subRequest2.isCompleted());
- assertFalse("isFailed", subRequest2.isFailed());
- assertTrue ("isCancelled", subRequest2.isCancelled());
- }
-
-
- // ------------------------------------------------------------------------
- // cancel sub-requests
- // ------------------------------------------------------------------------
+ request.done();
- public void testCancelSubRequests() {
+ // Validate the coalescing request
+ assertTrue("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
+
+ assertTrue("handleCompleted", crFlags[0]);
+ assertTrue("handleSuccess", crFlags[1]);
+ assertFalse("handleFailure", crFlags[2]);
+ assertFalse("handleCancel", crFlags[3]);
+
+ // Validate the first coalesced request
+ assertTrue("isCompleted", subRequest1.isCompleted());
+ assertFalse("isFailed", subRequest1.isFailed());
+ assertFalse("isCancelled", subRequest1.isCancelled());
+
+ // Validate the second coalesced request
+ assertTrue("isCompleted", subRequest2.isCompleted());
+ assertFalse("isFailed", subRequest2.isFailed());
+ assertFalse("isCancelled", subRequest2.isCancelled());
+ }
+
+ // ------------------------------------------------------------------------
+ // fail
+ // ------------------------------------------------------------------------
+ @Test
+ public void testFail() {
+ final boolean[] crFlags = new boolean[4];
+ TmfCoalescedDataRequest request = setupTestRequest(crFlags);
+ TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ request.addRequest(subRequest1);
+ request.addRequest(subRequest2);
+
+ request.fail();
+
+ // Validate the coalescing request
+ assertTrue("isCompleted", request.isCompleted());
+ assertTrue("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
+
+ assertTrue("handleCompleted", crFlags[0]);
+ assertFalse("handleSuccess", crFlags[1]);
+ assertTrue("handleFailure", crFlags[2]);
+ assertFalse("handleCancel", crFlags[3]);
+
+ // Validate the first coalesced request
+ assertTrue("isCompleted", subRequest1.isCompleted());
+ assertTrue("isFailed", subRequest1.isFailed());
+ assertFalse("isCancelled", subRequest1.isCancelled());
+
+ // Validate the second coalesced request
+ assertTrue("isCompleted", subRequest2.isCompleted());
+ assertTrue("isFailed", subRequest2.isFailed());
+ assertFalse("isCancelled", subRequest2.isCancelled());
+ }
+
+ // ------------------------------------------------------------------------
+ // cancel
+ // ------------------------------------------------------------------------
+
+ @Test
+ public void testCancel() {
+ final boolean[] crFlags = new boolean[4];
+ TmfCoalescedDataRequest request = setupTestRequest(crFlags);
+ TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ request.addRequest(subRequest1);
+ request.addRequest(subRequest2);
+
+ request.cancel();
+
+ // Validate the coalescing request
+ assertTrue("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertTrue("isCancelled", request.isCancelled());
+
+ assertTrue("handleCompleted", crFlags[0]);
+ assertFalse("handleSuccess", crFlags[1]);
+ assertFalse("handleFailure", crFlags[2]);
+ assertTrue("handleCancel", crFlags[3]);
+
+ // Validate the first coalesced request
+ assertTrue("isCompleted", subRequest1.isCompleted());
+ assertFalse("isFailed", subRequest1.isFailed());
+ assertTrue("isCancelled", subRequest1.isCancelled());
+
+ // Validate the second coalesced request
+ assertTrue("isCompleted", subRequest2.isCompleted());
+ assertFalse("isFailed", subRequest2.isFailed());
+ assertTrue("isCancelled", subRequest2.isCancelled());
+ }
+
+ // ------------------------------------------------------------------------
+ // cancel sub-requests
+ // ------------------------------------------------------------------------
+
+ @Test
+ public void testCancelSubRequests() {
final boolean[] crFlags = new boolean[4];
TmfCoalescedDataRequest request = setupTestRequest(crFlags);
TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
// Validate the coalescing request
assertFalse("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
+ assertFalse("isFailed", request.isFailed());
assertFalse("isCancelled", request.isCancelled());
// Cancel second sub-request
/*******************************************************************************
- * Copyright (c) 2009, 2010 Ericsson
+ * Copyright (c) 2009, 2010, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.request;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Vector;
-import junit.framework.TestCase;
-
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.internal.tmf.core.component.TmfProviderManager;
import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfEventRequestStub;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.Before;
+import org.junit.Test;
/**
- * <b><u>TmfCoalescedEventRequestTest</u></b>
- * <p>
* Test suite for the TmfCoalescedEventRequest class.
*/
-@SuppressWarnings({"nls","javadoc"})
-public class TmfCoalescedEventRequestTest extends TestCase {
-
- // ------------------------------------------------------------------------
- // Variables
- // ------------------------------------------------------------------------
-
- private final TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.ETERNITY);
- private final TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
-
- private TmfCoalescedEventRequest fRequest1;
- private TmfCoalescedEventRequest fRequest2;
- private TmfCoalescedEventRequest fRequest3;
- private TmfCoalescedEventRequest fRequest4;
-
- private TmfCoalescedEventRequest fRequest1b;
- private TmfCoalescedEventRequest fRequest1c;
-
- private int fRequestCount;
-
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfCoalescedEventRequestTest(String name) {
- super(name);
- }
-
- @Override
- public void setUp() throws Exception {
- super.setUp();
- TmfDataRequest.reset();
- fRequest1 = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
- fRequest2 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 100, 200);
- fRequest3 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 200, 200);
- fRequest4 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 200, 300);
-
- fRequest1b = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
- fRequest1c = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
-
- fRequestCount = fRequest1c.getRequestId() + 1;
- }
-
- @Override
- public void tearDown() throws Exception {
- super.tearDown();
- }
-
- private TmfCoalescedEventRequest setupTestRequest(final boolean[] flags) {
-
- TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200) {
- @Override
- public void handleCompleted() {
- super.handleCompleted();
- flags[0] = true;
- }
- @Override
- public void handleSuccess() {
- super.handleSuccess();
- flags[1] = true;
- }
- @Override
- public void handleFailure() {
- super.handleFailure();
- flags[2] = true;
- }
- @Override
- public void handleCancel() {
- super.handleCancel();
- flags[3] = true;
- }
- };
- return request;
- }
-
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
-
- public void testTmfCoalescedEventRequest() {
- TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class);
+@SuppressWarnings({ "nls", "javadoc" })
+public class TmfCoalescedEventRequestTest {
+
+ // ------------------------------------------------------------------------
+ // Variables
+ // ------------------------------------------------------------------------
+
+ private final TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.ETERNITY);
+ private final TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
+
+ private TmfCoalescedEventRequest fRequest1;
+ private TmfCoalescedEventRequest fRequest2;
+ private TmfCoalescedEventRequest fRequest3;
+ private TmfCoalescedEventRequest fRequest4;
+
+ private TmfCoalescedEventRequest fRequest1b;
+ private TmfCoalescedEventRequest fRequest1c;
+
+ private int fRequestCount;
+
+ // ------------------------------------------------------------------------
+ // Housekeeping
+ // ------------------------------------------------------------------------
+
+ @Before
+ public void setUp() {
+ TmfDataRequest.reset();
+ fRequest1 = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
+ fRequest2 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 100, 200);
+ fRequest3 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 200, 200);
+ fRequest4 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 200, 300);
+
+ fRequest1b = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
+ fRequest1c = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
+
+ fRequestCount = fRequest1c.getRequestId() + 1;
+ }
+
+ private TmfCoalescedEventRequest setupTestRequest(final boolean[] flags) {
+
+ TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200) {
+ @Override
+ public void handleCompleted() {
+ super.handleCompleted();
+ flags[0] = true;
+ }
+
+ @Override
+ public void handleSuccess() {
+ super.handleSuccess();
+ flags[1] = true;
+ }
+
+ @Override
+ public void handleFailure() {
+ super.handleFailure();
+ flags[2] = true;
+ }
+
+ @Override
+ public void handleCancel() {
+ super.handleCancel();
+ flags[3] = true;
+ }
+ };
+ return request;
+ }
+
+ // ------------------------------------------------------------------------
+ // Constructors
+ // ------------------------------------------------------------------------
+
+ @Test
+ public void testTmfCoalescedEventRequest() {
+ TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getRange", range1, request.getRange());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfCoalescedEventRequestIndex() {
- TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1);
+ @Test
+ public void testTmfCoalescedEventRequestIndex() {
+ TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getRange", range1, request.getRange());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfCoalescedEventRequestIndexNbRequested() {
- TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100);
+ public void testTmfCoalescedEventRequestIndexNbRequested() {
+ TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getRange", range1, request.getRange());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
- TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
+ @Test
+ public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
+ TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getRange", range1, request.getRange());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- // ------------------------------------------------------------------------
- // equals
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // equals
+ // ------------------------------------------------------------------------
- public void testEqualsReflexivity() {
+ @Test
+ public void testEqualsReflexivity() {
assertTrue("equals", fRequest1.equals(fRequest1));
assertTrue("equals", fRequest2.equals(fRequest2));
assertFalse("equals", fRequest1.equals(fRequest2));
assertFalse("equals", fRequest2.equals(fRequest1));
- }
+ }
- public void testEqualsSymmetry() {
+ @Test
+ public void testEqualsSymmetry() {
assertTrue("equals", fRequest1.equals(fRequest1b));
assertTrue("equals", fRequest1b.equals(fRequest1));
assertFalse("equals", fRequest2.equals(fRequest3));
assertFalse("equals", fRequest3.equals(fRequest1));
assertFalse("equals", fRequest3.equals(fRequest2));
- }
+ }
- public void testEqualsTransivity() {
+ @Test
+ public void testEqualsTransivity() {
assertTrue("equals", fRequest1.equals(fRequest1b));
assertTrue("equals", fRequest1b.equals(fRequest1c));
assertTrue("equals", fRequest1.equals(fRequest1c));
- }
+ }
- public void testEqualsNull() {
+ @Test
+ public void testEqualsNull() {
assertFalse("equals", fRequest1.equals(null));
assertFalse("equals", fRequest2.equals(null));
- }
+ }
- public void testEqualsSuper() {
- TmfCoalescedDataRequest dataRequest1 = new TmfCoalescedDataRequest(
- fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
- TmfCoalescedDataRequest dataRequest2 = new TmfCoalescedDataRequest(
- fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
- TmfCoalescedDataRequest dataRequest3 = new TmfCoalescedDataRequest(
- fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested());
+ @Test
+ public void testEqualsSuper() {
+ TmfCoalescedDataRequest dataRequest1 = new TmfCoalescedDataRequest(
+ fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
+ TmfCoalescedDataRequest dataRequest2 = new TmfCoalescedDataRequest(
+ fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
+ TmfCoalescedDataRequest dataRequest3 = new TmfCoalescedDataRequest(
+ fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested());
- assertTrue("equals", fRequest1.equals(dataRequest2));
+ assertTrue("equals", fRequest1.equals(dataRequest2));
assertTrue("equals", fRequest2.equals(dataRequest1));
assertFalse("equals", fRequest1.equals(dataRequest3));
assertFalse("equals", fRequest3.equals(dataRequest1));
- }
+ }
- // ------------------------------------------------------------------------
- // hashCode
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
- public void testHashCode() {
+ @Test
+ public void testHashCode() {
assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
- assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
- }
+ assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
+ }
- // ------------------------------------------------------------------------
- // toString
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // toString
+ // ------------------------------------------------------------------------
- public void testToString() {
+ @Test
+ public void testToString() {
String expected1 = "[TmfCoalescedEventRequest(0,ITmfEvent," + range1 + ",0,100,200)]";
String expected2 = "[TmfCoalescedEventRequest(1,ITmfEvent," + range2 + ",0,100,200)]";
String expected3 = "[TmfCoalescedEventRequest(2,ITmfEvent," + range2 + ",0,200,200)]";
assertEquals("toString", expected2, fRequest2.toString());
assertEquals("toString", expected3, fRequest3.toString());
assertEquals("toString", expected4, fRequest4.toString());
- }
+ }
- // ------------------------------------------------------------------------
- // isCompatible
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // isCompatible
+ // ------------------------------------------------------------------------
- @SuppressWarnings("hiding")
- public void testIsCompatible() {
- TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
- TmfEventRequest request1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
- TmfEventRequest request2 = new TmfEventRequestStub(ITmfEvent.class, range2, 100, 200);
- TmfEventRequest request3 = new TmfEventRequestStub(ITmfEvent.class, range1, 101, 200);
+ @Test
+ public void testIsCompatible() {
+ TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
+ TmfEventRequest req1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ TmfEventRequest req2 = new TmfEventRequestStub(ITmfEvent.class, range2, 100, 200);
+ TmfEventRequest req3 = new TmfEventRequestStub(ITmfEvent.class, range1, 101, 200);
- assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
- assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
- assertTrue("isCompatible", coalescedRequest.isCompatible(request3));
- }
+ assertTrue("isCompatible", coalescedRequest.isCompatible(req1));
+ assertTrue("isCompatible", coalescedRequest.isCompatible(req2));
+ assertTrue("isCompatible", coalescedRequest.isCompatible(req3));
+ }
// ------------------------------------------------------------------------
// addEvent
// ------------------------------------------------------------------------
- @SuppressWarnings("hiding")
+ @Test
public void testAddEvent1() {
TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 0, 2147483647, 200, ExecutionType.FOREGROUND);
- TmfEventRequest request1 = new TmfEventRequestStub(ITmfEvent.class, range1, 0, 2147483647, 200);
- TmfEventRequest request2 = new TmfEventRequestStub(ITmfEvent.class, range1, 1, 2147483647, 200);
+ TmfEventRequest req1 = new TmfEventRequestStub(ITmfEvent.class, range1, 0, 2147483647, 200);
+ TmfEventRequest req2 = new TmfEventRequestStub(ITmfEvent.class, range1, 1, 2147483647, 200);
- assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
- assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
+ assertTrue("isCompatible", coalescedRequest.isCompatible(req1));
+ assertTrue("isCompatible", coalescedRequest.isCompatible(req2));
- coalescedRequest.addRequest(request1);
- coalescedRequest.addRequest(request2);
+ coalescedRequest.addRequest(req1);
+ coalescedRequest.addRequest(req2);
- assertEquals("addRequest", 0, coalescedRequest.getIndex());
+ assertEquals("addRequest", 0, coalescedRequest.getIndex());
assertEquals("addRequest", 2147483647, coalescedRequest.getNbRequested());
- assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
+ assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
}
- @SuppressWarnings("hiding")
+ @Test
public void testAddEvent2() {
TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 1, 2147483647, 200, ExecutionType.FOREGROUND);
- TmfEventRequest request1 = new TmfEventRequestStub(ITmfEvent.class, range1, 1, 2147483647, 200);
- TmfEventRequest request2 = new TmfEventRequestStub(ITmfEvent.class, range1, 0, 2147483647, 200);
+ TmfEventRequest req1 = new TmfEventRequestStub(ITmfEvent.class, range1, 1, 2147483647, 200);
+ TmfEventRequest req2 = new TmfEventRequestStub(ITmfEvent.class, range1, 0, 2147483647, 200);
- assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
- assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
+ assertTrue("isCompatible", coalescedRequest.isCompatible(req1));
+ assertTrue("isCompatible", coalescedRequest.isCompatible(req2));
- coalescedRequest.addRequest(request1);
- coalescedRequest.addRequest(request2);
+ coalescedRequest.addRequest(req1);
+ coalescedRequest.addRequest(req2);
- assertEquals("addRequest", 0, coalescedRequest.getIndex());
+ assertEquals("addRequest", 0, coalescedRequest.getIndex());
assertEquals("addRequest", 2147483647, coalescedRequest.getNbRequested());
- assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
+ assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
+
+ }
+
+ // ------------------------------------------------------------------------
+ // done
+ // ------------------------------------------------------------------------
+
+ @Test
+ public void testDone() {
+ // Test request
+ final boolean[] crFlags = new boolean[4];
+ TmfCoalescedEventRequest request = setupTestRequest(crFlags);
+ TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ request.addRequest(subRequest1);
+ request.addRequest(subRequest2);
+
+ request.done();
+
+ // Validate the coalescing request
+ assertTrue("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
+
+ assertTrue("handleCompleted", crFlags[0]);
+ assertTrue("handleSuccess", crFlags[1]);
+ assertFalse("handleFailure", crFlags[2]);
+ assertFalse("handleCancel", crFlags[3]);
+
+ // Validate the first coalesced request
+ assertTrue("isCompleted", subRequest1.isCompleted());
+ assertFalse("isFailed", subRequest1.isFailed());
+ assertFalse("isCancelled", subRequest1.isCancelled());
+
+ // Validate the second coalesced request
+ assertTrue("isCompleted", subRequest2.isCompleted());
+ assertFalse("isFailed", subRequest2.isFailed());
+ assertFalse("isCancelled", subRequest2.isCancelled());
+ }
+
+ // ------------------------------------------------------------------------
+ // fail
+ // ------------------------------------------------------------------------
+
+ @Test
+ public void testFail() {
+ final boolean[] crFlags = new boolean[4];
+ TmfCoalescedEventRequest request = setupTestRequest(crFlags);
+ TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ request.addRequest(subRequest1);
+ request.addRequest(subRequest2);
+
+ request.fail();
+
+ // Validate the coalescing request
+ assertTrue("isCompleted", request.isCompleted());
+ assertTrue("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
+
+ assertTrue("handleCompleted", crFlags[0]);
+ assertFalse("handleSuccess", crFlags[1]);
+ assertTrue("handleFailure", crFlags[2]);
+ assertFalse("handleCancel", crFlags[3]);
+
+ // Validate the first coalesced request
+ assertTrue("isCompleted", subRequest1.isCompleted());
+ assertTrue("isFailed", subRequest1.isFailed());
+ assertFalse("isCancelled", subRequest1.isCancelled());
+ // Validate the second coalesced request
+ assertTrue("isCompleted", subRequest2.isCompleted());
+ assertTrue("isFailed", subRequest2.isFailed());
+ assertFalse("isCancelled", subRequest2.isCancelled());
}
- // ------------------------------------------------------------------------
- // done
- // ------------------------------------------------------------------------
-
- public void testDone() {
-
- // Test request
- final boolean[] crFlags = new boolean[4];
- TmfCoalescedEventRequest request = setupTestRequest(crFlags);
- TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
- TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
- request.addRequest(subRequest1);
- request.addRequest(subRequest2);
-
- request.done();
-
- // Validate the coalescing request
- assertTrue ("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
- assertFalse("isCancelled", request.isCancelled());
-
- assertTrue ("handleCompleted", crFlags[0]);
- assertTrue ("handleSuccess", crFlags[1]);
- assertFalse("handleFailure", crFlags[2]);
- assertFalse("handleCancel", crFlags[3]);
-
- // Validate the first coalesced request
- assertTrue ("isCompleted", subRequest1.isCompleted());
- assertFalse("isFailed", subRequest1.isFailed());
- assertFalse("isCancelled", subRequest1.isCancelled());
-
- // Validate the second coalesced request
- assertTrue ("isCompleted", subRequest2.isCompleted());
- assertFalse("isFailed", subRequest2.isFailed());
- assertFalse("isCancelled", subRequest2.isCancelled());
- }
-
- // ------------------------------------------------------------------------
- // fail
- // ------------------------------------------------------------------------
-
- public void testFail() {
-
- final boolean[] crFlags = new boolean[4];
- TmfCoalescedEventRequest request = setupTestRequest(crFlags);
- TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
- TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
- request.addRequest(subRequest1);
- request.addRequest(subRequest2);
-
- request.fail();
-
- // Validate the coalescing request
- assertTrue ("isCompleted", request.isCompleted());
- assertTrue ("isFailed", request.isFailed());
- assertFalse("isCancelled", request.isCancelled());
-
- assertTrue ("handleCompleted", crFlags[0]);
- assertFalse("handleSuccess", crFlags[1]);
- assertTrue ("handleFailure", crFlags[2]);
- assertFalse("handleCancel", crFlags[3]);
-
- // Validate the first coalesced request
- assertTrue ("isCompleted", subRequest1.isCompleted());
- assertTrue ("isFailed", subRequest1.isFailed());
- assertFalse("isCancelled", subRequest1.isCancelled());
-
- // Validate the second coalesced request
- assertTrue ("isCompleted", subRequest2.isCompleted());
- assertTrue ("isFailed", subRequest2.isFailed());
- assertFalse("isCancelled", subRequest2.isCancelled());
- }
-
- // ------------------------------------------------------------------------
- // cancel
- // ------------------------------------------------------------------------
-
- public void testCancel() {
-
- final boolean[] crFlags = new boolean[4];
- TmfCoalescedEventRequest request = setupTestRequest(crFlags);
- TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
- TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
- request.addRequest(subRequest1);
- request.addRequest(subRequest2);
-
- request.cancel();
-
- // Validate the coalescing request
- assertTrue ("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
- assertTrue ("isCancelled", request.isCancelled());
-
- assertTrue ("handleCompleted", crFlags[0]);
- assertFalse("handleSuccess", crFlags[1]);
- assertFalse("handleFailure", crFlags[2]);
- assertTrue ("handleCancel", crFlags[3]);
-
- // Validate the first coalesced request
- assertTrue ("isCompleted", subRequest1.isCompleted());
- assertFalse("isFailed", subRequest1.isFailed());
- assertTrue ("isCancelled", subRequest1.isCancelled());
-
- // Validate the second coalesced request
- assertTrue ("isCompleted", subRequest2.isCompleted());
- assertFalse("isFailed", subRequest2.isFailed());
- assertTrue ("isCancelled", subRequest2.isCancelled());
- }
-
- // ------------------------------------------------------------------------
- // Coalescing
- // ------------------------------------------------------------------------
-
- private static final String DIRECTORY = "testfiles";
+ // ------------------------------------------------------------------------
+ // cancel
+ // ------------------------------------------------------------------------
+
+ @Test
+ public void testCancel() {
+ final boolean[] crFlags = new boolean[4];
+ TmfCoalescedEventRequest request = setupTestRequest(crFlags);
+ TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ request.addRequest(subRequest1);
+ request.addRequest(subRequest2);
+
+ request.cancel();
+
+ // Validate the coalescing request
+ assertTrue("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertTrue("isCancelled", request.isCancelled());
+
+ assertTrue("handleCompleted", crFlags[0]);
+ assertFalse("handleSuccess", crFlags[1]);
+ assertFalse("handleFailure", crFlags[2]);
+ assertTrue("handleCancel", crFlags[3]);
+
+ // Validate the first coalesced request
+ assertTrue("isCompleted", subRequest1.isCompleted());
+ assertFalse("isFailed", subRequest1.isFailed());
+ assertTrue("isCancelled", subRequest1.isCancelled());
+
+ // Validate the second coalesced request
+ assertTrue("isCompleted", subRequest2.isCompleted());
+ assertFalse("isFailed", subRequest2.isFailed());
+ assertTrue("isCancelled", subRequest2.isCancelled());
+ }
+
+ // ------------------------------------------------------------------------
+ // Coalescing
+ // ------------------------------------------------------------------------
+
+ private static final String DIRECTORY = "testfiles";
private static final String TEST_STREAM = "A-Test-10K";
- private static final int NB_EVENTS = 5000;
- private static final int BLOCK_SIZE = 100;
+ private static final int NB_EVENTS = 5000;
+ private static final int BLOCK_SIZE = 100;
// Initialize the test trace
private TmfTraceStub fTrace = null;
+
private synchronized TmfTraceStub setupTrace(String path) {
- if (fTrace == null) {
- try {
- URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
- File test = new File(FileLocator.toFileURL(location).toURI());
- fTrace = new TmfTraceStub(test.getPath(), 500);
- } catch (TmfTraceException e) {
- e.printStackTrace();
+ if (fTrace == null) {
+ try {
+ URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
+ File test = new File(FileLocator.toFileURL(location).toURI());
+ fTrace = new TmfTraceStub(test.getPath(), 500);
+ } catch (TmfTraceException e) {
+ e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
- return fTrace;
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ return fTrace;
}
- Vector<ITmfEvent> requestedEvents1;
+ Vector<ITmfEvent> requestedEvents1;
Vector<ITmfEvent> requestedEvents2;
Vector<ITmfEvent> requestedEvents3;
ITmfDataProvider[] providers;
private static class TmfTestTriggerSignal extends TmfSignal {
- public final boolean forceCancel;
- public final long fIndex;
- public TmfTestTriggerSignal(Object source, long index, boolean cancel) {
- super(source);
- forceCancel = cancel;
- fIndex = index;
- }
+ public final boolean forceCancel;
+ public final long fIndex;
+
+ public TmfTestTriggerSignal(Object source, long index, boolean cancel) {
+ super(source);
+ forceCancel = cancel;
+ fIndex = index;
+ }
}
- @TmfSignalHandler
+ @TmfSignalHandler
public void trigger(final TmfTestTriggerSignal signal) {
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
int nbRead = 0;
@Override
public void handleData(ITmfEvent event) {
- super.handleData(event);
- if (!isCompleted()) {
- requestedEvents1.add(event);
- if (++nbRead >= BLOCK_SIZE && signal.forceCancel) {
+ super.handleData(event);
+ if (!isCompleted()) {
+ requestedEvents1.add(event);
+ if (++nbRead >= BLOCK_SIZE && signal.forceCancel) {
cancel();
}
- }
+ }
}
};
request2 = new TmfEventRequest(ITmfEvent.class, range, signal.fIndex + REQUEST_OFFSET, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(ITmfEvent event) {
- super.handleData(event);
- if (!isCompleted()) {
- requestedEvents2.add(event);
- }
+ super.handleData(event);
+ if (!isCompleted()) {
+ requestedEvents2.add(event);
+ }
}
};
request3 = new TmfEventRequest(ITmfEvent.class, range, signal.fIndex + 2 * REQUEST_OFFSET, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(ITmfEvent event) {
- super.handleData(event);
- if (!isCompleted()) {
- requestedEvents3.add(event);
- }
+ super.handleData(event);
+ if (!isCompleted()) {
+ requestedEvents3.add(event);
+ }
}
};
try {
assertEquals("Request1: nbEvents", NB_EVENTS, requestedEvents1.size());
- assertTrue ("Request1: isCompleted", request1.isCompleted());
- assertFalse ("Request1: isCancelled", request1.isCancelled());
+ assertTrue("Request1: isCompleted", request1.isCompleted());
+ assertFalse("Request1: isCancelled", request1.isCancelled());
assertEquals("Request2: nbEvents", NB_EVENTS, requestedEvents2.size());
- assertTrue ("Request2: isCompleted", request2.isCompleted());
- assertFalse ("Request2: isCancelled", request2.isCancelled());
+ assertTrue("Request2: isCompleted", request2.isCompleted());
+ assertFalse("Request2: isCancelled", request2.isCancelled());
assertEquals("Request3: nbEvents", NB_EVENTS, requestedEvents3.size());
- assertTrue ("Request3: isCompleted", request3.isCompleted());
- assertFalse ("Request3: isCancelled", request3.isCancelled());
+ assertTrue("Request3: isCompleted", request3.isCompleted());
+ assertFalse("Request3: isCancelled", request3.isCancelled());
// Ensure that we have distinct events.
// Don't go overboard: we are not validating the stub!
assertEquals("Distinct events", i + 1 + request2.getIndex(), requestedEvents2.get(i).getTimestamp().getValue());
assertEquals("Distinct events", i + 1 + request3.getIndex(), requestedEvents3.get(i).getTimestamp().getValue());
}
- }
- finally {
+ } finally {
TmfSignalManager.deregister(this);
fTrace.dispose();
fTrace = null;
}
}
+ @Test
public void testCoalescedRequest() throws InterruptedException {
runCoalescedRequest(0);
runCoalescedRequest(1);
runCoalescedRequest(5);
}
- public void testCancelCoalescedRequest() throws InterruptedException {
+ @Test
+ public void testCancelCoalescedRequest() throws InterruptedException {
- fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
+ fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
- TmfSignalManager.register(this);
- TmfTestTriggerSignal signal = new TmfTestTriggerSignal(this, 0, true);
- TmfSignalManager.dispatchSignal(signal);
+ TmfSignalManager.register(this);
+ TmfTestTriggerSignal signal = new TmfTestTriggerSignal(this, 0, true);
+ TmfSignalManager.dispatchSignal(signal);
request1.waitForCompletion();
request2.waitForCompletion();
request3.waitForCompletion();
assertEquals("Request1: nbEvents", BLOCK_SIZE, requestedEvents1.size());
- assertTrue ("Request1: isCompleted", request1.isCompleted());
- assertTrue ("Request1: isCancelled", request1.isCancelled());
+ assertTrue("Request1: isCompleted", request1.isCompleted());
+ assertTrue("Request1: isCancelled", request1.isCancelled());
assertEquals("Request2: nbEvents", NB_EVENTS, requestedEvents2.size());
- assertTrue ("Request2: isCompleted", request2.isCompleted());
- assertFalse ("Request2: isCancelled", request2.isCancelled());
+ assertTrue("Request2: isCompleted", request2.isCompleted());
+ assertFalse("Request2: isCancelled", request2.isCancelled());
assertEquals("Request3: nbEvents", NB_EVENTS, requestedEvents3.size());
- assertTrue ("Request3: isCompleted", request3.isCompleted());
- assertFalse ("Request3: isCancelled", request3.isCancelled());
+ assertTrue("Request3: isCompleted", request3.isCompleted());
+ assertFalse("Request3: isCancelled", request3.isCancelled());
// Ensure that we have distinct events.
// Don't go overboard: we are not validating the stub!
fTrace = null;
}
- // ------------------------------------------------------------------------
- //
- // ------------------------------------------------------------------------
-
}
/*******************************************************************************
- * Copyright (c) 2009, 2010 Ericsson
+ * Copyright (c) 2009, 2010, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.request;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub;
+import org.junit.Before;
+import org.junit.Test;
/**
- * <b><u>TmfDataRequestTest</u></b>
- * <p>
* Test suite for the TmfDataRequest class.
*/
-@SuppressWarnings({"nls","javadoc"})
-public class TmfDataRequestTest extends TestCase {
+@SuppressWarnings({ "nls", "javadoc" })
+public class TmfDataRequestTest {
- // ------------------------------------------------------------------------
- // Variables
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // Variables
+ // ------------------------------------------------------------------------
- private static TmfDataRequest fRequest1;
- private static TmfDataRequest fRequest1b;
- private static TmfDataRequest fRequest1c;
- private static TmfDataRequest fRequest2;
- private static TmfDataRequest fRequest3;
- private static TmfDataRequest fRequest4;
+ private static TmfDataRequest fRequest1;
+ private static TmfDataRequest fRequest1b;
+ private static TmfDataRequest fRequest1c;
+ private static TmfDataRequest fRequest2;
+ private static TmfDataRequest fRequest3;
+ private static TmfDataRequest fRequest4;
- private static int fRequestCount;
+ private static int fRequestCount;
// ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfDataRequestTest(String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- TmfDataRequest.reset();
- fRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
- fRequest2 = new TmfDataRequestStub(ITmfEvent.class, 20, 100, 200);
- fRequest3 = new TmfDataRequestStub(ITmfEvent.class, 20, 200, 200);
- fRequest4 = new TmfDataRequestStub(ITmfEvent.class, 20, 200, 300);
- fRequest1b = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
- fRequest1c = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
- fRequestCount = fRequest1c.getRequestId() + 1;
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
- private static TmfDataRequest setupTestRequest(final boolean[] flags) {
-
- TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200) {
- @Override
- public void handleCompleted() {
- super.handleCompleted();
- flags[0] = true;
- }
- @Override
- public void handleSuccess() {
- super.handleSuccess();
- flags[1] = true;
- }
- @Override
- public void handleFailure() {
- super.handleFailure();
- flags[2] = true;
- }
- @Override
- public void handleCancel() {
- super.handleCancel();
- flags[3] = true;
- }
- };
- return request;
- }
-
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
-
- public void testTmfDataRequest() {
+ // Housekeeping
+ // ------------------------------------------------------------------------
+
+ @Before
+ public void setUp() {
+ TmfDataRequest.reset();
+ fRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ fRequest2 = new TmfDataRequestStub(ITmfEvent.class, 20, 100, 200);
+ fRequest3 = new TmfDataRequestStub(ITmfEvent.class, 20, 200, 200);
+ fRequest4 = new TmfDataRequestStub(ITmfEvent.class, 20, 200, 300);
+ fRequest1b = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ fRequest1c = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ fRequestCount = fRequest1c.getRequestId() + 1;
+ }
+
+ private static TmfDataRequest setupTestRequest(final boolean[] flags) {
+
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200) {
+ @Override
+ public void handleCompleted() {
+ super.handleCompleted();
+ flags[0] = true;
+ }
+
+ @Override
+ public void handleSuccess() {
+ super.handleSuccess();
+ flags[1] = true;
+ }
+
+ @Override
+ public void handleFailure() {
+ super.handleFailure();
+ flags[2] = true;
+ }
+
+ @Override
+ public void handleCancel() {
+ super.handleCancel();
+ flags[3] = true;
+ }
+ };
+ return request;
+ }
+
+ // ------------------------------------------------------------------------
+ // Constructors
+ // ------------------------------------------------------------------------
+
+ @Test
+ public void testTmfDataRequest() {
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfDataRequestIndex() {
+ @Test
+ public void testTmfDataRequestIndex() {
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfDataRequestIndexNbRequested() {
+ @Test
+ public void testTmfDataRequestIndexNbRequested() {
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfDataRequestIndexNbEventsBlocksize() {
+ @Test
+ public void testTmfDataRequestIndexNbEventsBlocksize() {
TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- // ------------------------------------------------------------------------
- // equals
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // equals
+ // ------------------------------------------------------------------------
- public void testEqualsReflexivity() {
+ @Test
+ public void testEqualsReflexivity() {
assertTrue("equals", fRequest1.equals(fRequest1));
assertTrue("equals", fRequest2.equals(fRequest2));
assertFalse("equals", fRequest1.equals(fRequest2));
assertFalse("equals", fRequest2.equals(fRequest1));
- }
+ }
- public void testEqualsSymmetry() {
+ @Test
+ public void testEqualsSymmetry() {
assertTrue("equals", fRequest1.equals(fRequest1b));
assertTrue("equals", fRequest1b.equals(fRequest1));
assertFalse("equals", fRequest2.equals(fRequest3));
assertFalse("equals", fRequest3.equals(fRequest1));
assertFalse("equals", fRequest3.equals(fRequest2));
- }
+ }
- public void testEqualsTransivity() {
+ @Test
+ public void testEqualsTransivity() {
assertTrue("equals", fRequest1.equals(fRequest1b));
assertTrue("equals", fRequest1b.equals(fRequest1c));
assertTrue("equals", fRequest1.equals(fRequest1c));
- }
+ }
- public void testEqualsNull() {
+ @Test
+ public void testEqualsNull() {
assertFalse("equals", fRequest1.equals(null));
assertFalse("equals", fRequest2.equals(null));
- }
+ }
- // ------------------------------------------------------------------------
- // hashCode
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
- public void testHashCode() {
+ @Test
+ public void testHashCode() {
assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
- assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
- }
+ assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
+ }
- // ------------------------------------------------------------------------
- // toString
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // toString
+ // ------------------------------------------------------------------------
- public void testToString() {
+ @Test
+ public void testToString() {
String expected1 = "[TmfDataRequest(0,ITmfEvent,10,100,200)]";
String expected2 = "[TmfDataRequest(1,ITmfEvent,20,100,200)]";
String expected3 = "[TmfDataRequest(2,ITmfEvent,20,200,200)]";
assertEquals("toString", expected2, fRequest2.toString());
assertEquals("toString", expected3, fRequest3.toString());
assertEquals("toString", expected4, fRequest4.toString());
- }
+ }
- // ------------------------------------------------------------------------
- // done
- // ------------------------------------------------------------------------
-
- public void testDone() {
-
- final boolean[] flags = new boolean[4];
- TmfDataRequest request = setupTestRequest(flags);
- request.done();
-
- assertTrue ("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
- assertFalse("isCancelled", request.isCancelled());
-
- assertTrue ("handleCompleted", flags[0]);
- assertTrue ("handleSuccess", flags[1]);
- assertFalse("handleFailure", flags[2]);
- assertFalse("handleCancel", flags[3]);
- }
+ // ------------------------------------------------------------------------
+ // done
+ // ------------------------------------------------------------------------
- // ------------------------------------------------------------------------
- // fail
- // ------------------------------------------------------------------------
+ @Test
+ public void testDone() {
+ final boolean[] flags = new boolean[4];
+ TmfDataRequest request = setupTestRequest(flags);
+ request.done();
- public void testFail() {
+ assertTrue("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
- final boolean[] flags = new boolean[4];
- TmfDataRequest request = setupTestRequest(flags);
- request.fail();
+ assertTrue("handleCompleted", flags[0]);
+ assertTrue("handleSuccess", flags[1]);
+ assertFalse("handleFailure", flags[2]);
+ assertFalse("handleCancel", flags[3]);
+ }
- assertTrue ("isCompleted", request.isCompleted());
- assertTrue ("isFailed", request.isFailed());
- assertFalse("isCancelled", request.isCancelled());
+ // ------------------------------------------------------------------------
+ // fail
+ // ------------------------------------------------------------------------
- assertTrue ("handleCompleted", flags[0]);
- assertFalse("handleSuccess", flags[1]);
- assertTrue ("handleFailure", flags[2]);
- assertFalse("handleCancel", flags[3]);
- }
+ @Test
+ public void testFail() {
+ final boolean[] flags = new boolean[4];
+ TmfDataRequest request = setupTestRequest(flags);
+ request.fail();
- // ------------------------------------------------------------------------
- // cancel
- // ------------------------------------------------------------------------
+ assertTrue("isCompleted", request.isCompleted());
+ assertTrue("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
- public void testCancel() {
+ assertTrue("handleCompleted", flags[0]);
+ assertFalse("handleSuccess", flags[1]);
+ assertTrue("handleFailure", flags[2]);
+ assertFalse("handleCancel", flags[3]);
+ }
- final boolean[] flags = new boolean[4];
- TmfDataRequest request = setupTestRequest(flags);
- request.cancel();
+ // ------------------------------------------------------------------------
+ // cancel
+ // ------------------------------------------------------------------------
- assertTrue ("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
- assertTrue ("isCancelled", request.isCancelled());
+ @Test
+ public void testCancel() {
+ final boolean[] flags = new boolean[4];
+ TmfDataRequest request = setupTestRequest(flags);
+ request.cancel();
- assertTrue ("handleCompleted", flags[0]);
- assertFalse("handleSuccess", flags[1]);
- assertFalse("handleFailure", flags[2]);
- assertTrue ("handleCancel", flags[3]);
- }
+ assertTrue("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertTrue("isCancelled", request.isCancelled());
- // ------------------------------------------------------------------------
- // waitForCompletion
- // ------------------------------------------------------------------------
+ assertTrue("handleCompleted", flags[0]);
+ assertFalse("handleSuccess", flags[1]);
+ assertFalse("handleFailure", flags[2]);
+ assertTrue("handleCancel", flags[3]);
+ }
}
/*******************************************************************************
- * Copyright (c) 2009, 2010 Ericsson
+ * Copyright (c) 2009, 2010, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.request;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfEventRequestStub;
+import org.junit.Before;
+import org.junit.Test;
/**
- * <b><u>TmfEventRequestTest</u></b>
- * <p>
* Test suite for the TmfEventRequest class.
*/
-@SuppressWarnings({"nls","javadoc"})
-public class TmfEventRequestTest extends TestCase {
-
- // ------------------------------------------------------------------------
- // Variables
- // ------------------------------------------------------------------------
-
- private static TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.ETERNITY);
- private static TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
-
- private static TmfEventRequest fRequest1;
- private static TmfEventRequest fRequest1b;
- private static TmfEventRequest fRequest1c;
- private static TmfEventRequest fRequest2;
- private static TmfEventRequest fRequest3;
- private static TmfEventRequest fRequest4;
-
- private static int fRequestCount;
-
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfEventRequestTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- TmfDataRequest.reset();
- fRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
- fRequest2 = new TmfEventRequestStub(ITmfEvent.class, range2, 100, 200);
- fRequest3 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 200);
- fRequest4 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 300);
- fRequest1b = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
- fRequest1c = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
- fRequestCount = fRequest1c.getRequestId() + 1;
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
- private static TmfEventRequest setupTestRequest(final boolean[] flags) {
-
- TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, new TmfTimeRange(TmfTimeRange.ETERNITY), 100, 200) {
- @Override
- public void handleCompleted() {
- super.handleCompleted();
- flags[0] = true;
- }
- @Override
- public void handleSuccess() {
- super.handleSuccess();
- flags[1] = true;
- }
- @Override
- public void handleFailure() {
- super.handleFailure();
- flags[2] = true;
- }
- @Override
- public void handleCancel() {
- super.handleCancel();
- flags[3] = true;
- }
- };
- return request;
- }
-
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
-
- public void testTmfEventRequest() {
+@SuppressWarnings({ "nls", "javadoc" })
+public class TmfEventRequestTest {
+
+ // ------------------------------------------------------------------------
+ // Variables
+ // ------------------------------------------------------------------------
+
+ private static TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.ETERNITY);
+ private static TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
+
+ private static TmfEventRequest fRequest1;
+ private static TmfEventRequest fRequest1b;
+ private static TmfEventRequest fRequest1c;
+ private static TmfEventRequest fRequest2;
+ private static TmfEventRequest fRequest3;
+ private static TmfEventRequest fRequest4;
+
+ private static int fRequestCount;
+
+ // ------------------------------------------------------------------------
+ // Housekeeping
+ // ------------------------------------------------------------------------
+
+ @Before
+ public void setUp() {
+ TmfDataRequest.reset();
+ fRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ fRequest2 = new TmfEventRequestStub(ITmfEvent.class, range2, 100, 200);
+ fRequest3 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 200);
+ fRequest4 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 300);
+ fRequest1b = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ fRequest1c = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ fRequestCount = fRequest1c.getRequestId() + 1;
+ }
+
+ private static TmfEventRequest setupTestRequest(final boolean[] flags) {
+
+ TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, new TmfTimeRange(TmfTimeRange.ETERNITY), 100, 200) {
+ @Override
+ public void handleCompleted() {
+ super.handleCompleted();
+ flags[0] = true;
+ }
+
+ @Override
+ public void handleSuccess() {
+ super.handleSuccess();
+ flags[1] = true;
+ }
+
+ @Override
+ public void handleFailure() {
+ super.handleFailure();
+ flags[2] = true;
+ }
+
+ @Override
+ public void handleCancel() {
+ super.handleCancel();
+ flags[3] = true;
+ }
+ };
+ return request;
+ }
+
+ // ------------------------------------------------------------------------
+ // Constructors
+ // ------------------------------------------------------------------------
+
+ @Test
+ public void testTmfEventRequest() {
TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", ITmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
- assertEquals("StartTime", TmfTimestamp.BIG_BANG, request.getRange().getStartTime());
- assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
+ assertEquals("StartTime", TmfTimestamp.BIG_BANG, request.getRange().getStartTime());
+ assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfEventRequestTimeRange() {
+ @Test
+ public void testTmfEventRequestTimeRange() {
TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range);
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
- assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
+ assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfEventRequestTimeRangeNbRequested() {
+ @Test
+ public void testTmfEventRequestTimeRangeNbRequested() {
TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100);
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
- assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
+ assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- public void testTmfEventRequestTimeRangeNbRequestedBlocksize() {
+ @Test
+ public void testTmfEventRequestTimeRangeNbRequestedBlocksize() {
TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100, 200);
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
- assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
+ assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
assertFalse("isCancelled", request.isCancelled());
assertEquals("getNbRead", 0, request.getNbRead());
- }
+ }
- // ------------------------------------------------------------------------
- // equals
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // equals
+ // ------------------------------------------------------------------------
- public void testEqualsReflexivity() {
+ @Test
+ public void testEqualsReflexivity() {
assertTrue("equals", fRequest1.equals(fRequest1));
assertTrue("equals", fRequest2.equals(fRequest2));
assertFalse("equals", fRequest1.equals(fRequest2));
assertFalse("equals", fRequest2.equals(fRequest1));
- }
+ }
- public void testEqualsSymmetry() {
+ @Test
+ public void testEqualsSymmetry() {
assertTrue("equals", fRequest1.equals(fRequest1b));
assertTrue("equals", fRequest1b.equals(fRequest1));
assertFalse("equals", fRequest2.equals(fRequest3));
assertFalse("equals", fRequest3.equals(fRequest1));
assertFalse("equals", fRequest3.equals(fRequest2));
- }
+ }
- public void testEqualsTransivity() {
+ @Test
+ public void testEqualsTransivity() {
assertTrue("equals", fRequest1.equals(fRequest1b));
assertTrue("equals", fRequest1b.equals(fRequest1c));
assertTrue("equals", fRequest1.equals(fRequest1c));
- }
+ }
- public void testEqualsNull() {
+ @Test
+ public void testEqualsNull() {
assertFalse("equals", fRequest1.equals(null));
assertFalse("equals", fRequest2.equals(null));
- }
+ }
- // ------------------------------------------------------------------------
- // hashCode
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
- public void testHashCode() {
+ @Test
+ public void testHashCode() {
assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
- assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
- }
+ assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
+ }
- // ------------------------------------------------------------------------
- // toString
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // toString
+ // ------------------------------------------------------------------------
- public void testToString() {
+ @Test
+ public void testToString() {
String expected1 = "[TmfEventRequest(0,ITmfEvent," + range1 + ",0,100,200)]";
String expected2 = "[TmfEventRequest(1,ITmfEvent," + range2 + ",0,100,200)]";
String expected3 = "[TmfEventRequest(2,ITmfEvent," + range2 + ",0,200,200)]";
assertEquals("toString", expected2, fRequest2.toString());
assertEquals("toString", expected3, fRequest3.toString());
assertEquals("toString", expected4, fRequest4.toString());
- }
-
- // ------------------------------------------------------------------------
- // done
- // ------------------------------------------------------------------------
-
- public void testDone() {
-
- final boolean[] flags = new boolean[4];
- TmfEventRequest request = setupTestRequest(flags);
- request.done();
-
- assertTrue ("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
- assertFalse("isCancelled", request.isCancelled());
+ }
- assertTrue ("handleCompleted", flags[0]);
- assertTrue ("handleSuccess", flags[1]);
- assertFalse("handleFailure", flags[2]);
- assertFalse("handleCancel", flags[3]);
- }
+ // ------------------------------------------------------------------------
+ // done
+ // ------------------------------------------------------------------------
- // ------------------------------------------------------------------------
- // fail
- // ------------------------------------------------------------------------
+ @Test
+ public void testDone() {
+ final boolean[] flags = new boolean[4];
+ TmfEventRequest request = setupTestRequest(flags);
+ request.done();
- public void testFail() {
+ assertTrue("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
- final boolean[] flags = new boolean[4];
- TmfEventRequest request = setupTestRequest(flags);
- request.fail();
+ assertTrue("handleCompleted", flags[0]);
+ assertTrue("handleSuccess", flags[1]);
+ assertFalse("handleFailure", flags[2]);
+ assertFalse("handleCancel", flags[3]);
+ }
- assertTrue ("isCompleted", request.isCompleted());
- assertTrue ("isFailed", request.isFailed());
- assertFalse("isCancelled", request.isCancelled());
+ // ------------------------------------------------------------------------
+ // fail
+ // ------------------------------------------------------------------------
- assertTrue ("handleCompleted", flags[0]);
- assertFalse("handleSuccess", flags[1]);
- assertTrue ("handleFailure", flags[2]);
- assertFalse("handleCancel", flags[3]);
- }
+ @Test
+ public void testFail() {
+ final boolean[] flags = new boolean[4];
+ TmfEventRequest request = setupTestRequest(flags);
+ request.fail();
- // ------------------------------------------------------------------------
- // cancel
- // ------------------------------------------------------------------------
+ assertTrue("isCompleted", request.isCompleted());
+ assertTrue("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
- public void testCancel() {
+ assertTrue("handleCompleted", flags[0]);
+ assertFalse("handleSuccess", flags[1]);
+ assertTrue("handleFailure", flags[2]);
+ assertFalse("handleCancel", flags[3]);
+ }
- final boolean[] flags = new boolean[4];
- TmfEventRequest request = setupTestRequest(flags);
- request.cancel();
+ // ------------------------------------------------------------------------
+ // cancel
+ // ------------------------------------------------------------------------
- assertTrue ("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
- assertTrue ("isCancelled", request.isCancelled());
+ @Test
+ public void testCancel() {
+ final boolean[] flags = new boolean[4];
+ TmfEventRequest request = setupTestRequest(flags);
+ request.cancel();
- assertTrue ("handleCompleted", flags[0]);
- assertFalse("handleSuccess", flags[1]);
- assertFalse("handleFailure", flags[2]);
- assertTrue ("handleCancel", flags[3]);
- }
+ assertTrue("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertTrue("isCancelled", request.isCancelled());
- // ------------------------------------------------------------------------
- // waitForCompletion
- // ------------------------------------------------------------------------
+ assertTrue("handleCompleted", flags[0]);
+ assertFalse("handleSuccess", flags[1]);
+ assertFalse("handleFailure", flags[2]);
+ assertTrue("handleCancel", flags[3]);
+ }
}
/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2010, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.request;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import org.eclipse.linuxtools.internal.tmf.core.component.TmfEventThread;
import org.eclipse.linuxtools.internal.tmf.core.request.TmfRequestExecutor;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
/**
* Test suite for the TmfRequestExecutor class.
*/
@SuppressWarnings({ "nls" })
-public class TmfRequestExecutorTest extends TestCase {
+public class TmfRequestExecutorTest {
// ------------------------------------------------------------------------
// Variables
private TmfRequestExecutor fExecutor;
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfRequestExecutorTest(String name) {
- super(name);
- }
+ // ------------------------------------------------------------------------
+ // Housekeeping
+ // ------------------------------------------------------------------------
- @Override
- protected void setUp() throws Exception {
- super.setUp();
+ /**
+ * Setup
+ */
+ @Before
+ public void setUp() {
fExecutor = new TmfRequestExecutor();
-
}
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
+ /**
+ * Cleanup
+ */
+ @After
+ public void tearDown() {
fExecutor.stop();
}
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
-
- /**
- * Test method for {@link org.eclipse.linuxtools.internal.tmf.core.request.TmfRequestExecutor#TmfRequestExecutor()}.
- */
- public void testTmfRequestExecutor() {
- TmfRequestExecutor executor = new TmfRequestExecutor();
- assertFalse("isShutdown", executor.isShutdown());
- assertFalse("isTerminated", executor.isTerminated());
- }
-
- /**
- * Test method for {@link org.eclipse.linuxtools.internal.tmf.core.request.TmfRequestExecutor#stop()}.
- */
- public void testStop() {
- TmfRequestExecutor executor = new TmfRequestExecutor();
- executor.stop();
- assertTrue("isShutdown", executor.isShutdown());
- assertTrue("isTerminated", executor.isTerminated());
- }
-
- // ------------------------------------------------------------------------
- // execute
- // ------------------------------------------------------------------------
-
- // Dummy context
- private static class MyContext implements ITmfContext {
- private long fNbRequested;
+ // ------------------------------------------------------------------------
+ // Constructors
+ // ------------------------------------------------------------------------
+
+ /**
+ * Test method for
+ * {@link org.eclipse.linuxtools.internal.tmf.core.request.TmfRequestExecutor#TmfRequestExecutor()}
+ */
+ @Test
+ public void testTmfRequestExecutor() {
+ TmfRequestExecutor executor = new TmfRequestExecutor();
+ assertFalse("isShutdown", executor.isShutdown());
+ assertFalse("isTerminated", executor.isTerminated());
+ }
+
+ /**
+ * Test method for
+ * {@link org.eclipse.linuxtools.internal.tmf.core.request.TmfRequestExecutor#stop()}
+ */
+ @Test
+ public void testStop() {
+ TmfRequestExecutor executor = new TmfRequestExecutor();
+ executor.stop();
+ assertTrue("isShutdown", executor.isShutdown());
+ assertTrue("isTerminated", executor.isTerminated());
+ }
+
+ // ------------------------------------------------------------------------
+ // execute
+ // ------------------------------------------------------------------------
+
+ // Dummy context
+ private static class MyContext implements ITmfContext {
+ private long fNbRequested;
private long fRank;
public MyContext(long requested) {
fNbRequested = requested;
fRank = 0;
}
+
@Override
public long getRank() {
return (fRank <= fNbRequested) ? fRank : -1;
}
+
@Override
public ITmfLocation getLocation() {
return null;
}
+
@Override
public boolean hasValidRank() {
return true;
}
+
@Override
public void setLocation(ITmfLocation location) {
}
+
@Override
public void setRank(long rank) {
fRank = rank;
}
+
@Override
public void increaseRank() {
fRank++;
}
+
@Override
public void dispose() {
}
+
@Override
public MyContext clone() {
return this;
}
- }
+ }
- // Dummy provider
- private static class MyProvider extends TmfDataProvider {
- private ITmfEvent fEvent = new TmfEvent();
+ // Dummy provider
+ private static class MyProvider extends TmfDataProvider {
+ private ITmfEvent fEvent = new TmfEvent();
@Override
public String getName() {
return null;
}
+
@Override
public void dispose() {
}
+
@Override
public void broadcast(TmfSignal signal) {
}
+
@Override
public void sendRequest(ITmfDataRequest request) {
}
+
@Override
public void fireRequest() {
}
+
@Override
public void notifyPendingRequest(boolean isIncrement) {
}
+
@Override
public ITmfEvent getNext(ITmfContext context) {
context.increaseRank();
return context.getRank() >= 0 ? fEvent : null;
}
+
@Override
public ITmfContext armRequest(ITmfDataRequest request) {
return new MyContext(request.getNbRequested());
}
- }
+ }
- // Dummy request
+ // Dummy request
private static class MyRequest extends TmfDataRequest {
public MyRequest(ExecutionType priority, int requested) {
super(ITmfEvent.class, 0, requested, priority);
}
+
@Override
public void done() {
synchronized (monitor) {
private final static Object monitor = new Object();
/**
- * Test method for {@link org.eclipse.linuxtools.internal.tmf.core.request.TmfRequestExecutor#execute(java.lang.Runnable)}.
- */
- public void testExecute() {
+ * Test method for
+ * {@link org.eclipse.linuxtools.internal.tmf.core.request.TmfRequestExecutor#execute(java.lang.Runnable)}
+ */
+ @Test
+ public void testExecute() {
MyProvider provider = new MyProvider();
- MyRequest request1 = new MyRequest(ExecutionType.BACKGROUND, Integer.MAX_VALUE / 5);
- MyThread thread1 = new MyThread(provider, request1);
- MyRequest request2 = new MyRequest(ExecutionType.FOREGROUND, Integer.MAX_VALUE / 10);
- MyThread thread2 = new MyThread(provider, request2);
- MyRequest request3 = new MyRequest(ExecutionType.FOREGROUND, Integer.MAX_VALUE / 10);
- MyThread thread3 = new MyThread(provider, request3);
+ MyRequest request1 = new MyRequest(ExecutionType.BACKGROUND, Integer.MAX_VALUE / 5);
+ MyThread thread1 = new MyThread(provider, request1);
+ MyRequest request2 = new MyRequest(ExecutionType.FOREGROUND, Integer.MAX_VALUE / 10);
+ MyThread thread2 = new MyThread(provider, request2);
+ MyRequest request3 = new MyRequest(ExecutionType.FOREGROUND, Integer.MAX_VALUE / 10);
+ MyThread thread3 = new MyThread(provider, request3);
// Start thread1
fExecutor.execute(thread1);
Thread.sleep(1000);
} catch (InterruptedException e) {
}
- assertTrue("isRunning", thread1.isRunning());
+ assertTrue("isRunning", thread1.isRunning());
// Start higher priority thread2
fExecutor.execute(thread2);
assertTrue("isCompleted", thread1.isCompleted());
}
- // ------------------------------------------------------------------------
- // toString
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // toString
+ // ------------------------------------------------------------------------
- /**
- * Test method for {@link org.eclipse.linuxtools.internal.tmf.core.request.TmfRequestExecutor#toString()}.
- */
- public void testToString() {
+ /**
+ * Test method for
+ * {@link org.eclipse.linuxtools.internal.tmf.core.request.TmfRequestExecutor#toString()}
+ */
+ @Test
+ public void testToString() {
TmfRequestExecutor executor = new TmfRequestExecutor();
String expected = "[TmfRequestExecutor(ThreadPoolExecutor)]";
assertEquals("toString", expected, executor.toString());
- }
+ }
}
/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Alexandre Montplaisir - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.statesystem;
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-import org.eclipse.linuxtools.internal.tmf.core.Activator;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
* Test suite for org.eclipse.linuxtools.tmf.core.statesystem
*/
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ StateSystemPushPopTest.class
+})
public class AllTests {
- /**
- * @return The state system test suite
- */
- public static Test suite() {
- final TestSuite suite = new TestSuite("Test suite for " + Activator.PLUGIN_ID + ".statesystem"); //$NON-NLS-1$ //$NON-NLS-2$;
- //$JUnit-BEGIN$
- suite.addTestSuite(StateSystemPushPopTest.class);
- //$JUnit-END$
- return suite;
- }
}
\ No newline at end of file
/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Alexandre Montplaisir - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.statesystem;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.io.File;
import java.io.IOException;
import java.util.List;
-import junit.framework.TestCase;
-
import org.eclipse.linuxtools.internal.tmf.core.statesystem.StateSystem;
import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.IStateHistoryBackend;
import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.historytree.HistoryTreeBackend;
import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystemBuilder;
import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue;
import org.eclipse.linuxtools.tmf.core.statevalue.TmfStateValue;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
/**
* Unit tests for stack-attributes in the Generic State System (using
*
* @author Alexandre Montplaisir
*/
-public class StateSystemPushPopTest extends TestCase {
+public class StateSystemPushPopTest {
private ITmfStateSystemBuilder ss;
/**
* Test case constructor
*
- * @param name
- * The test name
* @throws IOException
* If we couldn't create the state history test file
*/
- public StateSystemPushPopTest(final String name) throws IOException {
- super(name);
+ public StateSystemPushPopTest() throws IOException {
testHtFile = File.createTempFile("test", ".ht"); //$NON-NLS-1$ //$NON-NLS-2$
testHtFile.deleteOnExit();
}
* @throws StateValueTypeException
* Fails the test
*/
- @Override
+ @Before
public void setUp() throws IOException, TimeRangeException,
AttributeNotFoundException, StateValueTypeException {
ITmfStateValue value;
/**
* Clean-up after running a test. Delete the .ht file we created.
*/
- @Override
+ @After
public void tearDown() {
testHtFile.delete();
}
* Test that the value of the stack-attribute at the start and end of the
* history are correct.
*/
+ @Test
public void testBeginEnd() {
try {
interval = ss.querySingleState(0, attribute);
/**
* Run single queries on the attribute stacks (with .querySingleState()).
*/
+ @Test
public void testSingleQueries() {
try {
final int subAttribute1 = ss.getQuarkRelative(attribute, "1"); //$NON-NLS-1$
/**
* Test the .querySingletStackTop() convenience method.
*/
+ @Test
public void testStackTop() {
try {
interval = ss.querySingleStackTop(10, attribute);
/**
* Test the places where the stack is empty.
*/
+ @Test
public void testEmptyStack() {
try {
/* At the start */
/**
* Test full-queries (.queryFullState()) on the attribute stacks.
*/
+ @Test
public void testFullQueries() {
List<ITmfStateInterval> state;
try {
/*******************************************************************************
- * Copyright (c) 2009, 2012 Ericsson
+ * Copyright (c) 2009, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adjusted for new Trace Model
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-import org.eclipse.linuxtools.internal.tmf.core.Activator;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
* Test suite for org.eclipse.linuxtools.tmf.core.trace
*/
-@SuppressWarnings({ "nls" })
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TmfCheckpointIndexTest.class,
+ TmfCheckpointIndexTest2.class,
+ TmfCheckpointTest.class,
+ TmfContextTest.class,
+ TmfExperimentCheckpointIndexTest.class,
+ TmfExperimentTest.class,
+ TmfLocationTest.class,
+ TmfMultiTraceExperimentTest.class,
+ TmfTraceTest.class
+})
public class AllTests {
- /**
- * @return the test suite
- */
- public static Test suite() {
- TestSuite suite = new TestSuite("Test suite for " + Activator.PLUGIN_ID + ".trace"); //$NON-NLS-1$);
- //$JUnit-BEGIN$
- suite.addTestSuite(TmfLocationTest.class);
- suite.addTestSuite(TmfContextTest.class);
- suite.addTestSuite(TmfCheckpointTest.class);
- suite.addTestSuite(TmfCheckpointIndexTest.class);
- suite.addTestSuite(TmfCheckpointIndexTest2.class);
- suite.addTestSuite(TmfTraceTest.class);
-
- suite.addTestSuite(TmfExperimentCheckpointIndexTest.class);
- suite.addTestSuite(TmfExperimentTest.class);
- suite.addTestSuite(TmfMultiTraceExperimentTest.class);
- //$JUnit-END$
- return suite;
- }
-
}
\ No newline at end of file
/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2010, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adapted for TMF Trace Model 1.0
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.List;
-import junit.framework.TestCase;
-
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfEmptyTraceStub;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
/**
* Test suite for the TmfCheckpointIndexTest class.
*/
@SuppressWarnings({"nls","javadoc"})
-public class TmfCheckpointIndexTest extends TestCase {
+public class TmfCheckpointIndexTest {
// ------------------------------------------------------------------------
// Variables
// Housekeeping
// ------------------------------------------------------------------------
- /**
- * @param name the test name
- */
- public TmfCheckpointIndexTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
+ @Before
+ public void setUp() {
setupTrace(DIRECTORY + File.separator + TEST_STREAM);
}
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
+ @After
+ public void tearDown() {
fTrace.dispose();
fTrace = null;
fEmptyTrace.dispose();
// Verify checkpoints
// ------------------------------------------------------------------------
+ @Test
@SuppressWarnings("null")
public void testTmfTraceIndexing() {
assertEquals("getCacheSize", BLOCK_SIZE, fTrace.getCacheSize());
}
}
+ @Test
@SuppressWarnings("null")
public void testEmptyTmfTraceIndexing() {
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, fEmptyTrace.getCacheSize());
/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Bernd Hufmann - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.List;
-import junit.framework.TestCase;
-
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpointIndexer;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfEmptyTraceStub;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
/**
* Test suite for the TmfCheckpointIndexer class (events with same
* timestamp around checkpoint).
*/
@SuppressWarnings({"nls","javadoc"})
-public class TmfCheckpointIndexTest2 extends TestCase {
+public class TmfCheckpointIndexTest2 {
// ------------------------------------------------------------------------
// Variables
// Housekeeping
// ------------------------------------------------------------------------
- /**
- * @param name the test name
- */
- public TmfCheckpointIndexTest2(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
+ @Before
+ public void setUp() {
setupTrace(DIRECTORY + File.separator + TEST_STREAM);
}
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
+ @After
+ public void tearDown() {
fTrace.dispose();
fTrace = null;
fEmptyTrace.dispose();
// Verify checkpoints
// ------------------------------------------------------------------------
+ @Test
@SuppressWarnings("null")
public void testTmfTraceMultiTimestamps() {
assertEquals("getCacheSize", BLOCK_SIZE, fTrace.getCacheSize());
/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2010, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adapted for TMF Trace Model 1.0
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpoint;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
import org.eclipse.linuxtools.tmf.core.trace.TmfLongLocation;
+import org.junit.Test;
/**
* Test suite for the TmfCheckpoint class.
*/
@SuppressWarnings({"nls","javadoc"})
-public class TmfCheckpointTest extends TestCase {
+public class TmfCheckpointTest {
// ------------------------------------------------------------------------
// Variables
// ------------------------------------------------------------------------
- ITmfTimestamp fTimestamp1 = new TmfTimestamp();
- ITmfTimestamp fTimestamp2 = TmfTimestamp.BIG_BANG;
- ITmfTimestamp fTimestamp3 = TmfTimestamp.BIG_CRUNCH;
+ private ITmfTimestamp fTimestamp1 = new TmfTimestamp();
+ private ITmfTimestamp fTimestamp2 = TmfTimestamp.BIG_BANG;
+ private ITmfTimestamp fTimestamp3 = TmfTimestamp.BIG_CRUNCH;
- Long aLong1 = 12345L;
- Long aLong2 = 23456L;
- Long aLong3 = 34567L;
- ITmfLocation fLocation1 = new TmfLongLocation(aLong1);
- ITmfLocation fLocation2 = new TmfLongLocation(aLong2);
- ITmfLocation fLocation3 = new TmfLongLocation(aLong3);
+ private Long aLong1 = 12345L;
+ private Long aLong2 = 23456L;
+ private Long aLong3 = 34567L;
+ private ITmfLocation fLocation1 = new TmfLongLocation(aLong1);
+ private ITmfLocation fLocation2 = new TmfLongLocation(aLong2);
+ private ITmfLocation fLocation3 = new TmfLongLocation(aLong3);
- TmfCheckpoint fCheckpoint1 = new TmfCheckpoint(fTimestamp1, new TmfContext(fLocation1));
- TmfCheckpoint fCheckpoint2 = new TmfCheckpoint(fTimestamp2, new TmfContext(fLocation2));
- TmfCheckpoint fCheckpoint3 = new TmfCheckpoint(fTimestamp3, new TmfContext(fLocation3));
-
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfCheckpointTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
+ private TmfCheckpoint fCheckpoint1 = new TmfCheckpoint(fTimestamp1, new TmfContext(fLocation1));
+ private TmfCheckpoint fCheckpoint2 = new TmfCheckpoint(fTimestamp2, new TmfContext(fLocation2));
+ private TmfCheckpoint fCheckpoint3 = new TmfCheckpoint(fTimestamp3, new TmfContext(fLocation3));
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
+ @Test
public void testTmfCheckpoint() {
assertEquals("TmfCheckpoint", fTimestamp1, fCheckpoint1.getTimestamp());
assertEquals("TmfCheckpoint", fLocation1, fCheckpoint1.getLocation());
assertEquals("TmfCheckpoint", fLocation1, checkpoint.getLocation());
}
+ @Test
public void testTmfLocationCopy2() {
try {
new TmfCheckpoint(null);
// clone
// ------------------------------------------------------------------------
+ @Test
public void testClone() {
try {
TmfCheckpoint checkpoint1 = fCheckpoint1.clone();
// compareTo
// ------------------------------------------------------------------------
+ @Test
public void testCompareTo() {
assertEquals("compareTo", 0, fCheckpoint1.compareTo(fCheckpoint1));
assertEquals("compareTo", 1, fCheckpoint1.compareTo(fCheckpoint2));
assertEquals("compareTo", 0, fCheckpoint3.compareTo(fCheckpoint3));
}
+ @Test
public void testCompareToNull() {
final TmfCheckpoint checkpoint1 = new TmfCheckpoint(null, new TmfContext(fLocation1));
final TmfCheckpoint checkpoint2 = new TmfCheckpoint(null, new TmfContext(fLocation2));
// hashCode
// ------------------------------------------------------------------------
+ @Test
public void testHashCode() {
final TmfCheckpoint checkpoint1 = new TmfCheckpoint(fCheckpoint1);
final TmfCheckpoint checkpoint2 = new TmfCheckpoint(fCheckpoint2);
assertTrue("hashCode", fCheckpoint2.hashCode() != checkpoint1.hashCode());
}
+ @Test
public void testHashCodeNull() {
final TmfCheckpoint checkpoint1 = new TmfCheckpoint(null, new TmfContext(fLocation1));
final TmfCheckpoint checkpoint2 = new TmfCheckpoint(fTimestamp1, null);
// equals
// ------------------------------------------------------------------------
+ @Test
public void testEqualsReflexivity() {
assertTrue("equals", fCheckpoint1.equals(fCheckpoint1));
assertTrue("equals", fCheckpoint2.equals(fCheckpoint2));
assertTrue("equals", !fCheckpoint2.equals(fCheckpoint1));
}
+ @Test
public void testEqualsSymmetry() {
final TmfCheckpoint checkpoint1 = new TmfCheckpoint(fCheckpoint1);
final TmfCheckpoint checkpoint2 = new TmfCheckpoint(fCheckpoint2);
assertTrue("equals", fCheckpoint2.equals(checkpoint2));
}
+ @Test
public void testEqualsTransivity() {
final TmfCheckpoint checkpoint1 = new TmfCheckpoint(fCheckpoint1);
final TmfCheckpoint checkpoint2 = new TmfCheckpoint(checkpoint1);
assertTrue("equals", checkpoint1.equals(checkpoint3));
}
+ @Test
public void testNotEqual() {
// Various checkpoints
final TmfCheckpoint checkpoint1 = new TmfCheckpoint(fTimestamp1, new TmfContext(fLocation1));
// toString
// ------------------------------------------------------------------------
+ @Test
public void testToString() {
final String expected1 = "TmfCheckpoint [fContext=" + fCheckpoint1.getContext() +
", fTimestamp=" + fCheckpoint1.getTimestamp() + "]";
/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2010, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adapted for TMF Trace Model 1.0
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
import org.eclipse.linuxtools.tmf.core.trace.TmfLongLocation;
import org.eclipse.linuxtools.tmf.core.trace.TmfTimestampLocation;
+import org.junit.Test;
/**
* Test suite for the TmfContext class.
*/
@SuppressWarnings({"nls","javadoc"})
-public class TmfContextTest extends TestCase {
+public class TmfContextTest {
// ------------------------------------------------------------------------
// Variables
// ------------------------------------------------------------------------
- final String aString = "some location";
- final Long aLong = 12345L;
- final TmfTimestamp aTimestamp = new TmfTimestamp();
+ private final String aString = "some location";
+ private final Long aLong = 12345L;
+ private final TmfTimestamp aTimestamp = new TmfTimestamp();
- final TmfStringLocation fLocation1 = new TmfStringLocation(aString);
- final TmfLongLocation fLocation2 = new TmfLongLocation(aLong);
- final TmfTimestampLocation fLocation3 = new TmfTimestampLocation(aTimestamp);
+ private final TmfStringLocation fLocation1 = new TmfStringLocation(aString);
+ private final TmfLongLocation fLocation2 = new TmfLongLocation(aLong);
+ private final TmfTimestampLocation fLocation3 = new TmfTimestampLocation(aTimestamp);
- final long fRank1 = 1;
- final long fRank2 = 2;
- final long fRank3 = 3;
+ private final long fRank1 = 1;
+ private final long fRank2 = 2;
+ private final long fRank3 = 3;
- final TmfContext fContext1 = new TmfContext(fLocation1, fRank1);
- final TmfContext fContext2 = new TmfContext(fLocation2, fRank2);
- final TmfContext fContext3 = new TmfContext(fLocation3, fRank3);
-
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- /**
- * @param name the test name
- */
- public TmfContextTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
+ private final TmfContext fContext1 = new TmfContext(fLocation1, fRank1);
+ private final TmfContext fContext2 = new TmfContext(fLocation2, fRank2);
+ private final TmfContext fContext3 = new TmfContext(fLocation3, fRank3);
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
+ @Test
public void testTmfContextDefault() {
final TmfContext context = new TmfContext();
assertEquals("getLocation", null, context.getLocation());
assertEquals("getRank", ITmfContext.UNKNOWN_RANK, context.getRank());
}
+ @Test
public void testTmfContextNoRank() {
final TmfContext context1 = new TmfContext(fLocation1);
final TmfContext context2 = new TmfContext(fLocation2);
assertEquals("getRank", ITmfContext.UNKNOWN_RANK, context3.getRank());
}
+ @Test
public void testTmfContext() {
assertEquals("getLocation", fLocation1, fContext1.getLocation());
assertEquals("getLocation", fLocation2, fContext2.getLocation());
assertEquals("getRank", fRank3, fContext3.getRank());
}
+ @Test
public void testTmfContextCopy() {
final TmfContext context1 = new TmfContext(fContext1);
final TmfContext context2 = new TmfContext(fContext2);
assertEquals("getRank", fRank3, context3.getRank());
}
+ @Test
public void testTmfContextCopy2() {
try {
new TmfContext((TmfContext) null);
// equals
// ------------------------------------------------------------------------
+ @Test
public void testEqualsReflexivity() {
assertTrue("equals", fContext1.equals(fContext1));
assertTrue("equals", fContext2.equals(fContext2));
assertFalse("equals", fContext2.equals(fContext1));
}
+ @Test
public void testEqualsSymmetry() {
final TmfContext context1 = new TmfContext(fContext1);
final TmfContext context2 = new TmfContext(fContext2);
assertTrue("equals", fContext2.equals(context2));
}
+ @Test
public void testEqualsTransivity() {
final TmfContext context1 = new TmfContext(fContext1);
final TmfContext context2 = new TmfContext(context1);
assertTrue("equals", context1.equals(context3));
}
+ @Test
public void testEqualsNull() {
assertFalse("equals", fContext1.equals(null));
assertFalse("equals", fContext2.equals(null));
private static class MyContext extends TmfContext {
}
+ @Test
public void testNonEquals() {
// Different classes
// hashCode
// ------------------------------------------------------------------------
+ @Test
public void testHashCode() {
final TmfContext context1 = new TmfContext(fContext1);
final TmfContext context2 = new TmfContext(fContext2);
// toString
// ------------------------------------------------------------------------
+ @Test
public void testToString() {
final String expected1 = "TmfContext [fLocation=" + fLocation1 + ", fRank=" + 1 + "]";
final String expected2 = "TmfContext [fLocation=" + fLocation2 + ", fRank=" + 2 + "]";
// clone
// ------------------------------------------------------------------------
+ @Test
public void testClone() {
try {
final TmfContext context1 = fContext1.clone();
// setLocation, setRank, updateRank
// ------------------------------------------------------------------------
+ @Test
public void testSetLocation() {
final TmfContext context1 = new TmfContext(fContext1);
context1.setLocation(fContext2.getLocation());
assertEquals("getRank", 1, context1.getRank());
}
+ @Test
public void testSetRank() {
final TmfContext context1 = new TmfContext(fContext1);
context1.setRank(fContext2.getRank());
assertEquals("getRank", fRank2, context1.getRank());
}
+ @Test
public void testIncreaseRank() {
final TmfContext context1 = new TmfContext(fContext1);
/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.List;
-import junit.framework.TestCase;
-
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentContext;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfExperimentStub;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
/**
* Test suite for the TmfCheckpointIndexTest class.
*/
@SuppressWarnings({"nls","javadoc"})
-public class TmfExperimentCheckpointIndexTest extends TestCase {
+public class TmfExperimentCheckpointIndexTest {
// ------------------------------------------------------------------------
// Attributes
// Housekeeping
// ------------------------------------------------------------------------
- /**
- * @param name the test name
- */
- public TmfExperimentCheckpointIndexTest(final String name) {
- super(name);
- }
-
- @Override
- protected synchronized void setUp() throws Exception {
- super.setUp();
- if (fExperiment == null) {
- setupTrace(DIRECTORY + File.separator + TEST_STREAM1, DIRECTORY + File.separator + TEST_STREAM2);
- fExperiment = new TmfExperimentStub(EXPERIMENT, fTestTraces, BLOCK_SIZE);
- fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
- }
+ @Before
+ public void setUp() {
+ setupTraces();
+ fExperiment = new TmfExperimentStub(EXPERIMENT, fTestTraces, BLOCK_SIZE);
+ fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
}
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
+ @After
+ public void tearDown() {
fExperiment.dispose();
fExperiment = null;
+ for (ITmfTrace trace : fTestTraces) {
+ trace.dispose();
+ }
fTestTraces = null;
}
- private synchronized static ITmfTrace[] setupTrace(final String path1, final String path2) {
- if (fTestTraces == null) {
- fTestTraces = new ITmfTrace[2];
- try {
- URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path1), null);
- File test = new File(FileLocator.toFileURL(location).toURI());
- final TmfTraceStub trace1 = new TmfTraceStub(test.getPath(), 0, true);
- fTestTraces[0] = trace1;
- location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path2), null);
- test = new File(FileLocator.toFileURL(location).toURI());
- final TmfTraceStub trace2 = new TmfTraceStub(test.getPath(), 0, true);
- fTestTraces[1] = trace2;
- } catch (final TmfTraceException e) {
- e.printStackTrace();
- } catch (final URISyntaxException e) {
- e.printStackTrace();
- } catch (final IOException e) {
- e.printStackTrace();
- }
+ private static void setupTraces() {
+ final String path1 = DIRECTORY + File.separator + TEST_STREAM1;
+ final String path2 = DIRECTORY + File.separator + TEST_STREAM2;
+
+ fTestTraces = new ITmfTrace[2];
+ try {
+ URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path1), null);
+ File test = new File(FileLocator.toFileURL(location).toURI());
+ final TmfTraceStub trace1 = new TmfTraceStub(test.getPath(), 0, true);
+ fTestTraces[0] = trace1;
+ location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path2), null);
+ test = new File(FileLocator.toFileURL(location).toURI());
+ final TmfTraceStub trace2 = new TmfTraceStub(test.getPath(), 0, true);
+ fTestTraces[1] = trace2;
+ } catch (final TmfTraceException e) {
+ e.printStackTrace();
+ } catch (final URISyntaxException e) {
+ e.printStackTrace();
+ } catch (final IOException e) {
+ e.printStackTrace();
}
- return fTestTraces;
}
// ------------------------------------------------------------------------
// Verify checkpoints
// ------------------------------------------------------------------------
+ @Test
@SuppressWarnings("null")
public void testTmfTraceIndexing() {
assertEquals("getCacheSize", BLOCK_SIZE, fExperiment.getCacheSize());
// Streaming
// ------------------------------------------------------------------------
+ @Test
@SuppressWarnings("null")
public void testGrowingIndex() {
-
ITmfTrace[] testTraces = new TmfTraceStub[2];
try {
URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM1), null);
assertTrue((checkpoint.getTimestamp().compareTo(event.getTimestamp(), false) == 0));
assertEquals("Checkpoint value", i * pageSize + 1, checkpoint.getTimestamp().getValue());
}
+
+ /* Clean up (since we didn't use the class-specific fixtures) */
+ experiment.dispose();
+ for (ITmfTrace trace : testTraces) {
+ trace.dispose();
+ }
}
}
\ No newline at end of file
/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2010, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adjusted for new Trace Model
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Collection;
import java.util.Vector;
-import junit.framework.TestCase;
-
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.core.trace.TmfLongLocation;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfExperimentStub;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.Before;
+import org.junit.Test;
/**
* Test suite for the TmfExperiment class (single trace).
*/
@SuppressWarnings({"nls","javadoc"})
-public class TmfExperimentTest extends TestCase {
+public class TmfExperimentTest {
// ------------------------------------------------------------------------
// Attributes
private static int NB_EVENTS = 10000;
private static int BLOCK_SIZE = 1000;
+ private static final double DELTA = 1e-15;
+
private ITmfTrace[] fTestTraces;
private TmfExperimentStub fExperiment;
}
}
- /**
- * @param name the test name
- */
- public TmfExperimentTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
+ @Before
+ public void setUp() {
setupTrace(DIRECTORY + File.separator + TEST_STREAM);
setupExperiment();
}
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
+ @Test
public void testSimpleTmfExperimentConstructor() {
-
TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, EXPERIMENT, fTestTraces);
assertEquals("GetId", EXPERIMENT, experiment.getName());
assertEquals("GetCacheSize", TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, experiment.getCacheSize());
experiment.dispose();
}
+ @Test
public void testNormalTmfExperimentConstructor() {
-
assertEquals("GetId", EXPERIMENT, fExperiment.getName());
assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents());
// getTimestamp
// ------------------------------------------------------------------------
+ @Test
public void testGetTimestamp() {
assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment.getTimestamp( 0));
assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment.getTimestamp( 1));
// Bookmarks file handling
// ------------------------------------------------------------------------
+ @Test
public void testBookmarks() {
assertNull("GetBookmarksFile", fExperiment.getBookmarksFile());
IFile bookmarks = (IFile) fTestTraces[0].getResource();
// State system and statistics methods
// ------------------------------------------------------------------------
+ @Test
public void testGetStatistics() {
/* There should not be any experiment-specific statistics */
ITmfStatistics stats = fExperiment.getStatistics();
assertNull(stats);
}
+ @Test
public void testGetStateSystem() {
/* There should not be any experiment-specific state system */
ITmfStateSystem ss = fExperiment.getStateSystem("something");
assertNull(ss);
}
+ @Test
public void testListStateSystem() {
Collection<String> sss = fExperiment.listStateSystems();
assertNotNull(sss);
// seekEvent by location
// ------------------------------------------------------------------------
+ @Test
public void testSeekBadLocation() {
ITmfContext context = fExperiment.seekEvent(new TmfLongLocation(0L));
assertNull("seekEvent", context);
}
+ @Test
public void testSeekNoTrace() {
TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, EXPERIMENT, null);
ITmfContext context = experiment.seekEvent((TmfExperimentLocation) null);
// seekEvent on ratio
// ------------------------------------------------------------------------
+ @Test
public void testSeekEventOnRatio() {
-
// First event
ITmfContext context = fExperiment.seekEvent(0.0);
assertEquals("Context rank", 0, context.getRank());
assertEquals("Context rank", 0, context.getRank());
}
+ @Test
public void testGetLocationRatio() {
-
// First event
ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
double ratio = fExperiment.getLocationRatio(context.getLocation());
context = fExperiment.seekEvent(ratio);
double ratio2 = fExperiment.getLocationRatio(context.getLocation());
- assertEquals("getLocationRatio", ratio, ratio2);
+ assertEquals("getLocationRatio", ratio, ratio2, DELTA);
// Middle event
context = fExperiment.seekEvent(NB_EVENTS / 2);
ratio = fExperiment.getLocationRatio(context.getLocation());
context = fExperiment.seekEvent(ratio);
ratio2 = fExperiment.getLocationRatio(context.getLocation());
- assertEquals("getLocationRatio", ratio, ratio2);
+ assertEquals("getLocationRatio", ratio, ratio2, DELTA);
// Last event
context = fExperiment.seekEvent(NB_EVENTS - 1);
ratio = fExperiment.getLocationRatio(context.getLocation());
context = fExperiment.seekEvent(ratio);
ratio2 = fExperiment.getLocationRatio(context.getLocation());
- assertEquals("getLocationRatio", ratio, ratio2);
+ assertEquals("getLocationRatio", ratio, ratio2, DELTA);
}
// @SuppressWarnings("rawtypes")
// seekEvent on rank
// ------------------------------------------------------------------------
+ @Test
public void testSeekRankOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// On lower bound, returns the first event (TS = 1)
assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
}
+ @Test
public void testSeekRankNotOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event rank 9
assertEquals("Context rank", 4501, context.getRank());
}
+ @Test
public void testSeekRankOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fExperiment.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
// seekEvent on timestamp
// ------------------------------------------------------------------------
+ @Test
public void testSeekTimestampOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event rank 0
assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
}
+ @Test
public void testSeekTimestampNotOnCacheBoundary() {
-
// Position trace at event rank 1 (TS = 2)
ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
assertEquals("Context rank", 1, context.getRank());
assertEquals("Context rank", 4501, context.getRank());
}
+ @Test
public void testSeekTimestampOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
// seekEvent by location (context rank is undefined)
// ------------------------------------------------------------------------
+ @Test
public void testSeekLocationOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event rank 0
assertEquals("Event timestamp", 4 * cacheSize + 2, event.getTimestamp().getValue());
}
+ @Test
public void testSeekLocationNotOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event 'cacheSize' - 1
assertEquals("Event timestamp", 4502, event.getTimestamp().getValue());
}
+ @Test
public void testSeekLocationOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
assertEquals("Experiment context rank", expRank, ctx.getRank());
}
+ @Test
public void testGetNextAfteSeekingOnTS_1() {
final long INITIAL_TS = 1;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfteSeekingOnTS_2() {
-
final long INITIAL_TS = 2;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfteSeekingOnTS_3() {
final long INITIAL_TS = 500;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnRank_1() {
-
final long INITIAL_RANK = 0L;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnRank_2() {
-
final long INITIAL_RANK = 1L;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnRank_3() {
-
final long INITIAL_RANK = 500L;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnLocation_1() {
-
final ITmfLocation INITIAL_LOC = null;
final long INITIAL_TS = 1;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnLocation_2() {
-
final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(1L).getLocation();
final long INITIAL_TS = 2;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnLocation_3() {
-
final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(500L).getLocation();
final long INITIAL_TS = 501;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextLocation() {
ITmfContext context1 = fExperiment.seekEvent(0);
fExperiment.getNext(context1);
assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
}
+ @Test
public void testGetNextEndLocation() {
ITmfContext context1 = fExperiment.seekEvent(fExperiment.getNbEvents() - 1);
fExperiment.getNext(context1);
// processRequest
// ------------------------------------------------------------------------
+ @Test
public void testProcessRequestForNbEvents() throws InterruptedException {
-
final int blockSize = 100;
final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
}
}
+ @Test
public void testProcessRequestForNbEvents2() throws InterruptedException {
-
final int blockSize = 2 * NB_EVENTS;
final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
}
}
+ @Test
public void testProcessRequestForAllEvents() throws InterruptedException {
-
final int nbEvents = TmfDataRequest.ALL_DATA;
final int blockSize = 1;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
// cancel
// ------------------------------------------------------------------------
+ @Test
public void testCancel() throws InterruptedException {
-
final int nbEvents = NB_EVENTS;
final int blockSize = BLOCK_SIZE;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2010, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Francois Chouinard - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
import org.eclipse.linuxtools.tmf.core.trace.TmfLongLocation;
import org.eclipse.linuxtools.tmf.core.trace.TmfTimestampLocation;
+import org.junit.Before;
+import org.junit.Test;
/**
* Test suite for the TmfLocation class.
*/
@SuppressWarnings({"nls","javadoc"})
-public class TmfLocationTest extends TestCase {
+public class TmfLocationTest {
// ------------------------------------------------------------------------
// Variables
// ------------------------------------------------------------------------
- String aString = "some location";
- Long aLong = 12345L;
- TmfTimestamp aTimestamp = new TmfTimestamp();
+ private String aString = "some location";
+ private Long aLong = 12345L;
+ private TmfTimestamp aTimestamp = new TmfTimestamp();
- TmfStringLocation fLocation1;
- TmfStringLocation fLocation2;
- TmfLongLocation fLocation3;
- TmfTimestampLocation fLocation4;
+ private TmfStringLocation fLocation1;
+ private TmfStringLocation fLocation2;
+ private TmfLongLocation fLocation3;
+ private TmfTimestampLocation fLocation4;
// ------------------------------------------------------------------------
// Housekeeping
// ------------------------------------------------------------------------
- /**
- * @param name
- * the test name
- */
- public TmfLocationTest(String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
+ @Before
+ public void setUp() {
fLocation1 = new TmfStringLocation((String) null);
fLocation2 = new TmfStringLocation(aString);
fLocation3 = new TmfLongLocation(aLong);
fLocation4 = new TmfTimestampLocation(aTimestamp);
}
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
+ @Test
public void testTmfLocation() {
assertNull("TmfLocation", fLocation1.getLocationInfo());
assertEquals("TmfLocation", aString, fLocation2.getLocationInfo());
assertEquals("TmfLocation", aTimestamp, fLocation4.getLocationInfo());
}
+ @Test
public void testTmfLocationCopy() {
TmfStringLocation location1 = new TmfStringLocation(fLocation1);
TmfStringLocation location2 = new TmfStringLocation(fLocation2);
// hashCode
// ------------------------------------------------------------------------
+ @Test
public void testHashCode() {
TmfStringLocation location1 = new TmfStringLocation((String) null);
TmfStringLocation location2 = new TmfStringLocation(aString);
}
}
+ @Test
public void testEqualsWrongTypes() {
ITmfLocation location1 = new TmfStringLocation(aString);
TmfLocation2 location2 = new TmfLocation2(aString);
assertFalse("equals", location2.equals(location1));
}
+ @Test
public void testEqualsWithNulls() {
TmfStringLocation location1 = new TmfStringLocation(aString);
TmfStringLocation location2 = new TmfStringLocation((String) null);
assertFalse("equals", location2.equals(location1));
}
+ @Test
public void testEqualsReflexivity() {
assertTrue("equals", fLocation2.equals(fLocation2));
assertTrue("equals", fLocation3.equals(fLocation3));
assertTrue("equals", !fLocation3.equals(fLocation2));
}
+ @Test
public void testEqualsSymmetry() {
TmfStringLocation location2 = new TmfStringLocation(aString);
TmfLongLocation location3 = new TmfLongLocation(aLong);
assertTrue("equals", fLocation3.equals(location3));
}
+ @Test
public void testEqualsTransivity() {
TmfStringLocation location1 = new TmfStringLocation(aString);
TmfStringLocation location2 = new TmfStringLocation(aString);
assertTrue("equals", location3.equals(location1));
}
+ @Test
public void testEqualsNull() {
assertTrue("equals", !fLocation2.equals(null));
assertTrue("equals", !fLocation2.equals(null));
// toString
// ------------------------------------------------------------------------
- @SuppressWarnings("hiding")
+ @Test
public void testToString() {
- String aString = "some location";
- Long aLong = 12345L;
- TmfTimestamp aTimestamp = new TmfTimestamp();
+ String str = "some location";
+ Long lng = 12345L;
+ TmfTimestamp ts = new TmfTimestamp();
- TmfStringLocation location1 = new TmfStringLocation(aString);
- TmfLongLocation location2 = new TmfLongLocation(aLong);
- TmfTimestampLocation location3 = new TmfTimestampLocation(aTimestamp);
+ TmfStringLocation location1 = new TmfStringLocation(str);
+ TmfLongLocation location2 = new TmfLongLocation(lng);
+ TmfTimestampLocation location3 = new TmfTimestampLocation(ts);
- String expected1 = "TmfLocation [fLocation=" + aString + "]";
- String expected2 = "TmfLocation [fLocation=" + aLong + "]";
- String expected3 = "TmfLocation [fLocation=" + aTimestamp + "]";
+ String expected1 = "TmfLocation [fLocation=" + str + "]";
+ String expected2 = "TmfLocation [fLocation=" + lng + "]";
+ String expected3 = "TmfLocation [fLocation=" + ts + "]";
assertEquals("toString", expected1, location1.toString());
assertEquals("toString", expected2, location2.toString());
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adjusted for new Trace Model
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Vector;
-import junit.framework.TestCase;
-
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentContext;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfExperimentStub;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.Before;
+import org.junit.Test;
/**
* Test suite for the TmfExperiment class (multiple traces).
*/
@SuppressWarnings({"nls","javadoc"})
-public class TmfMultiTraceExperimentTest extends TestCase {
+public class TmfMultiTraceExperimentTest {
// ------------------------------------------------------------------------
// Attributes
// ------------------------------------------------------------------------
+
private static final long DEFAULT_INITIAL_OFFSET_VALUE = (1L * 100 * 1000 * 1000); // .1sec
private static final String DIRECTORY = "testfiles";
private static final String TEST_STREAM1 = "O-Test-10K";
// Housekeeping
// ------------------------------------------------------------------------
+ @Before
+ public void setUp() {
+ setupTrace(DIRECTORY + File.separator + TEST_STREAM1, DIRECTORY + File.separator + TEST_STREAM2);
+ if (fExperiment == null) {
+ fExperiment = new TmfExperimentStub(EXPERIMENT, fTraces, BLOCK_SIZE);
+ fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
+ }
+ }
+
private synchronized static ITmfTrace[] setupTrace(final String path1, final String path2) {
if (fTraces == null) {
fTraces = new ITmfTrace[2];
return fTraces;
}
- /**
- * @param name the test name
- */
- public TmfMultiTraceExperimentTest(final String name) {
- super(name);
- }
-
- @Override
- protected synchronized void setUp() throws Exception {
- super.setUp();
- setupTrace(DIRECTORY + File.separator + TEST_STREAM1, DIRECTORY + File.separator + TEST_STREAM2);
- if (fExperiment == null) {
- fExperiment = new TmfExperimentStub(EXPERIMENT, fTraces, BLOCK_SIZE);
- fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
- }
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
+ @Test
public void testBasicTmfExperimentConstructor() {
-
assertEquals("GetId", EXPERIMENT, fExperiment.getName());
assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents());
// seekEvent on rank
// ------------------------------------------------------------------------
+ @Test
public void testSeekRankOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// On lower bound, returns the first event (TS = 1)
assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
}
+ @Test
public void testSeekRankNotOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event rank 9
assertEquals("Context rank", 4501, context.getRank());
}
+ @Test
public void testSeekRankOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fExperiment.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
// seekEvent on timestamp
// ------------------------------------------------------------------------
+ @Test
public void testSeekTimestampOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event rank 0
assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
}
+ @Test
public void testSeekTimestampNotOnCacheBoundary() {
-
// Position trace at event rank 1 (TS = 2)
ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
assertEquals("Context rank", 1, context.getRank());
assertEquals("Context rank", 4501, context.getRank());
}
+ @Test
public void testSeekTimestampOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
// seekEvent by location (context rank is undefined)
// ------------------------------------------------------------------------
+ @Test
public void testSeekLocationOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event rank 0
assertEquals("Event timestamp", 4 * cacheSize + 2, event.getTimestamp().getValue());
}
+ @Test
public void testSeekLocationNotOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event 'cacheSize' - 1
assertEquals("Event timestamp", 4502, event.getTimestamp().getValue());
}
+ @Test
public void testSeekLocationOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
assertEquals("Experiment context rank", expRank, ctx.getRank());
}
+ @Test
public void testGetNextAfteSeekingOnTS_1() {
-
final long INITIAL_TS = 1;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfteSeekingOnTS_2() {
-
final long INITIAL_TS = 2;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfteSeekingOnTS_3() {
-
final long INITIAL_TS = 500;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnRank_1() {
-
final long INITIAL_RANK = 0L;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnRank_2() {
-
final long INITIAL_RANK = 1L;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnRank_3() {
-
final long INITIAL_RANK = 500L;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnLocation_1() {
-
final ITmfLocation INITIAL_LOC = null;
final long INITIAL_TS = 1;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnLocation_2() {
-
final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(1L).getLocation();
final long INITIAL_TS = 2;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnLocation_3() {
-
final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(500L).getLocation();
final long INITIAL_TS = 501;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextLocation() {
ITmfContext context1 = fExperiment.seekEvent(0);
fExperiment.getNext(context1);
assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
}
+ @Test
public void testGetNextEndLocation() {
ITmfContext context1 = fExperiment.seekEvent(fExperiment.getNbEvents() - 1);
fExperiment.getNext(context1);
// processRequest
// ------------------------------------------------------------------------
+ @Test
public void testProcessRequestForNbEvents() throws InterruptedException {
-
final int blockSize = 100;
final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
}
}
+ @Test
public void testProcessRequestForNbEvents2() throws InterruptedException {
-
final int blockSize = 2 * NB_EVENTS;
final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
}
}
+ @Test
public void testProcessRequestForAllEvents() throws InterruptedException {
-
final int nbEvents = TmfDataRequest.ALL_DATA;
final int blockSize = 1;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
// cancel
// ------------------------------------------------------------------------
+ @Test
public void testCancel() throws InterruptedException {
-
final int nbEvents = NB_EVENTS;
final int blockSize = BLOCK_SIZE;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
// getTimestamp
// ------------------------------------------------------------------------
+ @Test
public void testGetTimestamp() {
assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment.getTimestamp( 0));
assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment.getTimestamp( 1));
// getInitialRangeOffset, getCurrentRange, getCurrentTime
// ------------------------------------------------------------------------
+ @Test
public void testDefaultCurrentTimeValues() {
// reset to default initial range offset
((TmfTraceStub)fTraces[0]).setInitialRangeOffset(null);
assertEquals("getInitialRangeOffset", initRange, exp.getInitialRangeOffset());
assertEquals("getCurrentTime", TmfTimestamp.ZERO, exp.getCurrentTime());
assertEquals("getCurrentRange", TmfTimeRange.NULL_RANGE, exp.getCurrentRange());
-
}
+
}
/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2010, 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adapted for TMF Trace Model 1.0
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Collection;
import java.util.Vector;
-import junit.framework.TestCase;
-
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.internal.tmf.core.component.TmfProviderManager;
import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpointIndexer;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
/**
* Test suite for the TmfTrace class.
*/
@SuppressWarnings({"nls","javadoc"})
-public class TmfTraceTest extends TestCase {
+public class TmfTraceTest {
// ------------------------------------------------------------------------
// Variables
// ------------------------------------------------------------------------
+
private static final long DEFAULT_INITIAL_OFFSET_VALUE = (1L * 100 * 1000 * 1000); // .1sec
private static final String DIRECTORY = "testfiles";
private static final String TEST_STREAM = "A-Test-10K";
// Housekeeping
// ------------------------------------------------------------------------
- /**
- * @param name the test name
- */
- public TmfTraceTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
+ @Before
+ public void setUp() {
fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
}
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
+ @After
+ public void tearDown() {
fTrace.dispose();
fTrace = null;
}
// Constructors
// ------------------------------------------------------------------------
+ @Test
@SuppressWarnings("null")
public void testStandardConstructor() throws TmfTraceException {
TmfTraceStub trace = null;
assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
}
+ @Test
@SuppressWarnings("null")
public void testStandardConstructorCacheSize() throws TmfTraceException {
TmfTraceStub trace = null;
assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
}
+ @Test
@SuppressWarnings("null")
public void testFullConstructor() throws TmfTraceException {
TmfTraceStub trace = null;
assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
}
+ @Test
@SuppressWarnings("null")
public void testLiveTraceConstructor() throws TmfTraceException {
TmfTraceStub trace = null;
assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
}
+ @Test
@SuppressWarnings("null")
public void testCopyConstructor() throws TmfTraceException {
TmfTraceStub original = null;
// Trace initialization
// ------------------------------------------------------------------------
+ @Test
public void testInitializeNullPath() {
-
// Instantiate an "empty" trace
final TmfTraceStub trace = new TmfTraceStub();
}
}
+ @Test
public void testInitializeSimplePath() {
-
// Instantiate an "empty" trace
final TmfTraceStub trace = new TmfTraceStub();
assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
}
+ @Test
public void testInitializeNormalPath() {
-
// Instantiate an "empty" trace
final TmfTraceStub trace = new TmfTraceStub();
assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
}
+ @Test
public void testInitTrace() throws URISyntaxException, IOException, TmfTraceException, InterruptedException {
-
// Instantiate an "empty" trace
final TmfTraceStub trace = new TmfTraceStub();
// Set/Get streaming interval
// ------------------------------------------------------------------------
+ @Test
public void testSetStreamingInterval() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
// Set/Get time range
// ------------------------------------------------------------------------
+ @Test
public void testSetTimeRange() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
trace.indexTrace();
trace.dispose();
}
+ @Test
public void testSetStartTime() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
trace.indexTrace();
trace.dispose();
}
+ @Test
public void testSetEndTime() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
trace.indexTrace();
trace.dispose();
}
+ @Test
public void testSetNbEvents() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
trace.indexTrace();
// State system and statistics methods
// ------------------------------------------------------------------------
+ @Test
public void testGetStatistics() {
/* Should be null in unit tests */
ITmfStatistics stats = fTrace.getStatistics();
assertNull(stats);
}
+ @Test
public void testGetStateSystem() {
/* There should be no state system registered so far */
ITmfStateSystem ss = fTrace.getStateSystem("something");
assertNull(ss);
}
+ @Test
public void testListStateSystem() {
Collection<String> sss = fTrace.listStateSystems();
assertNotNull(sss);
// seekEvent on location (note: does not reliably set the rank)
// ------------------------------------------------------------------------
+ @Test
public void testSeekEventOnCacheBoundary() {
-
// Position trace at event rank 0
ITmfContext context = fTrace.seekEvent(0);
ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
}
+ @Test
public void testSeekEventNotOnCacheBoundary() {
-
// Position trace at event rank 9
ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
TmfContext context = fTrace.seekEvent(tmpContext.getLocation());
assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
}
+ @Test
public void testSeekEventOutOfScope() {
-
// Position trace at beginning
ITmfContext tmpContext = fTrace.seekEvent(0);
ITmfContext context = fTrace.seekEvent(tmpContext.getLocation());
// seekEvent on timestamp (note: does not reliably set the rank)
// ------------------------------------------------------------------------
+ @Test
public void testSeekEventOnNullTimestamp() {
-
// Position trace at event rank 0
ITmfContext context = fTrace.seekEvent((ITmfTimestamp) null);
assertEquals("Event rank", 0, context.getRank());
assertEquals("Event rank", 0, context.getRank());
}
+ @Test
public void testSeekEventOnTimestampOnCacheBoundary() {
-
// Position trace at event rank 0
ITmfContext context = fTrace.seekEvent(new TmfTimestamp(1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
assertEquals("Event rank", 4001, context.getRank());
}
+ @Test
public void testSeekEventOnTimestampNotOnCacheBoundary() {
-
// Position trace at event rank 1
ITmfContext context = fTrace.seekEvent(new TmfTimestamp(2, SCALE, 0));
assertEquals("Event rank", 1, context.getRank());
assertEquals("Event rank", 4501, context.getRank());
}
+ @Test
public void testSeekEventOnTimestampOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
// seekEvent on rank
// ------------------------------------------------------------------------
+ @Test
public void testSeekEventOnNegativeRank() {
-
// Position trace at event rank 0
ITmfContext context = fTrace.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
assertEquals("Event rank", 0, context.getRank());
}
+ @Test
public void testSeekOnRankOnCacheBoundary() {
-
// On lower bound, returns the first event (ts = 1)
ITmfContext context = fTrace.seekEvent(0);
assertEquals("Event rank", 0, context.getRank());
assertEquals("Event rank", 4001, context.getRank());
}
+ @Test
public void testSeekOnRankNotOnCacheBoundary() {
-
// Position trace at event rank 9
ITmfContext context = fTrace.seekEvent(9);
assertEquals("Event rank", 9, context.getRank());
assertEquals("Event rank", 4501, context.getRank());
}
+ @Test
public void testSeekEventOnRankOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fTrace.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
// parseEvent - make sure parseEvent doesn't update the context
// ------------------------------------------------------------------------
+ @Test
public void testParseEvent() {
-
final int NB_READS = 20;
// On lower bound, returns the first event (ts = 0)
// getNext - updates the context
// ------------------------------------------------------------------------
+ @Test
public void testGetNextAfteSeekingOnTS_1() {
-
final long INITIAL_TS = 1;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
}
+ @Test
public void testGetNextAfteSeekingOnTS_2() {
-
final long INITIAL_TS = 2;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
}
+ @Test
public void testGetNextAfteSeekingOnTS_3() {
-
final long INITIAL_TS = 500;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
}
+ @Test
public void testGetNextAfterSeekingOnRank_1() {
-
final long INITIAL_RANK = 0L;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
}
+ @Test
public void testGetNextAfterSeekingOnRank_2() {
-
final long INITIAL_RANK = 1L;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
}
+ @Test
public void testGetNextAfterSeekingOnRank_3() {
-
final long INITIAL_RANK = 500L;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
}
+ @Test
public void testGetNextAfterSeekingOnLocation_1() {
-
final ITmfLocation INITIAL_LOC = null;
final long INITIAL_TS = 1;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
}
+ @Test
public void testGetNextAfterSeekingOnLocation_2() {
-
final ITmfLocation INITIAL_LOC = fTrace.seekEvent(1L).getLocation();
final long INITIAL_TS = 2;
final int NB_READS = 20;
assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
}
+ @Test
public void testGetNextAfterSeekingOnLocation_3() {
-
final ITmfLocation INITIAL_LOC = fTrace.seekEvent(500L).getLocation();
final long INITIAL_TS = 501;
final int NB_READS = 20;
assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
}
+ @Test
public void testGetNextLocation() {
ITmfContext context1 = fTrace.seekEvent(0);
fTrace.getNext(context1);
assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
}
+ @Test
public void testGetNextEndLocation() {
ITmfContext context1 = fTrace.seekEvent(fTrace.getNbEvents() - 1);
fTrace.getNext(context1);
// processRequest
// ------------------------------------------------------------------------
- @SuppressWarnings("hiding")
+ @Test
public void testProcessEventRequestForAllEvents() throws InterruptedException {
- final int BLOCK_SIZE = 1;
+ final int blockSize = 1;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
}
}
- @SuppressWarnings("hiding")
+ @Test
public void testProcessEventRequestForNbEvents() throws InterruptedException {
- final int BLOCK_SIZE = 100;
- final int NB_EVENTS = 1000;
+ final int blockSize = 100;
+ final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
providers[0].sendRequest(request);
request.waitForCompletion();
- assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
+ assertEquals("nbEvents", nbEvents, requestedEvents.size());
assertTrue("isCompleted", request.isCompleted());
assertFalse("isCancelled", request.isCancelled());
// Ensure that we have distinct events.
// Don't go overboard: we are not validating the stub!
- for (int i = 0; i < NB_EVENTS; i++) {
+ for (int i = 0; i < nbEvents; i++) {
assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
}
}
- @SuppressWarnings("hiding")
+ @Test
public void testProcessEventRequestForSomeEvents() throws InterruptedException {
- final int BLOCK_SIZE = 1;
+ final int blockSize = 1;
final long startTime = 100;
- final int NB_EVENTS = 1000;
+ final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
providers[0].sendRequest(request);
request.waitForCompletion();
- assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
+ assertEquals("nbEvents", nbEvents, requestedEvents.size());
assertTrue("isCompleted", request.isCompleted());
assertFalse("isCancelled", request.isCancelled());
// Ensure that we have distinct events.
// Don't go overboard: we are not validating the stub!
- for (int i = 0; i < NB_EVENTS; i++) {
+ for (int i = 0; i < nbEvents; i++) {
assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
}
}
- @SuppressWarnings("hiding")
+ @Test
public void testProcessEventRequestForOtherEvents() throws InterruptedException {
- final int BLOCK_SIZE = 1;
+ final int blockSize = 1;
final int startIndex = 99;
final long startTime = 100;
- final int NB_EVENTS = 1000;
+ final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, startIndex, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, startIndex, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
providers[0].sendRequest(request);
request.waitForCompletion();
- assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
+ assertEquals("nbEvents", nbEvents, requestedEvents.size());
assertTrue("isCompleted", request.isCompleted());
assertFalse("isCancelled", request.isCancelled());
// Ensure that we have distinct events.
// Don't go overboard: we are not validating the stub!
- for (int i = 0; i < NB_EVENTS; i++) {
+ for (int i = 0; i < nbEvents; i++) {
assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
}
}
- @SuppressWarnings("hiding")
+ @Test
public void testProcessDataRequestForSomeEvents() throws InterruptedException {
final int startIndex = 100;
- final int NB_EVENTS = 1000;
+ final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
- final TmfDataRequest request = new TmfDataRequest(ITmfEvent.class, startIndex, NB_EVENTS) {
+ final TmfDataRequest request = new TmfDataRequest(ITmfEvent.class, startIndex, nbEvents) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
providers[0].sendRequest(request);
request.waitForCompletion();
- assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
+ assertEquals("nbEvents", nbEvents, requestedEvents.size());
assertTrue("isCompleted", request.isCompleted());
assertFalse("isCancelled", request.isCancelled());
// Ensure that we have distinct events.
// Don't go overboard: we are not validating the stub!
- for (int i = 0; i < NB_EVENTS; i++) {
+ for (int i = 0; i < nbEvents; i++) {
assertEquals("Distinct events", startIndex + 1 + i, requestedEvents.get(i).getTimestamp().getValue());
}
}
// cancel
// ------------------------------------------------------------------------
+ @Test
public void testCancel() throws InterruptedException {
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
// toString
// ------------------------------------------------------------------------
+ @Test
public void testDefaultTmfTraceStub() {
assertFalse ("Open trace", fTrace == null);
assertEquals("getType", ITmfEvent.class, fTrace.getType());
// ------------------------------------------------------------------------
// getInitialRangeOffset, getCurrentRange, getCurrentTime
// ------------------------------------------------------------------------
+
+ @Test
@SuppressWarnings("null")
public void testCurrentTimeValues() throws TmfTraceException {
-package org.eclipse.linuxtools.tmf.core.tests.uml2sd;
+/*******************************************************************************
+ * Copyright (c) 2013 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Alexandre Montplaisir - Port to JUnit4
+ *******************************************************************************/
-import junit.framework.Test;
-import junit.framework.TestSuite;
+package org.eclipse.linuxtools.tmf.core.tests.uml2sd;
-import org.eclipse.linuxtools.internal.tmf.core.Activator;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
- * <b><u>AllTests</u></b>
- * <p>
- * Implement me. Please.
- * <p>
+ * Unit tests for tmf.core.uml2sd
*/
-@SuppressWarnings({ "nls" })
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TmfAsyncSequenceDiagramEventTest.class,
+ TmfSyncSequenceDiagramEventTest.class
+})
public class AllTests {
- /**
- * @return the test suite
- */
- public static Test suite() {
- TestSuite suite = new TestSuite("Test suite for " + Activator.PLUGIN_ID + ".uml2sd"); //$NON-NLS-1$);
- //$JUnit-BEGIN$
- suite.addTestSuite(TmfSyncSequenceDiagramEventTest.class);
- suite.addTestSuite(TmfAsyncSequenceDiagramEventTest.class);
- //$JUnit-END$
- return suite;
- }
-
}
\ No newline at end of file
/*******************************************************************************
- * Copyright (c) 2011 Ericsson
+ * Copyright (c) 2011, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Bernd Hufmann - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
+
package org.eclipse.linuxtools.tmf.core.tests.uml2sd;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.uml2sd.TmfAsyncSequenceDiagramEvent;
+import org.junit.Test;
+
/**
- * <b><u>TmfAsyncSequenceDiagramEventTest</u></b>
- * <p>
- * Implement me. Please.
- * <p>
+ * TmfAsyncSequenceDiagramEventTest
*/
-@SuppressWarnings({"nls","javadoc"})
-public class TmfAsyncSequenceDiagramEventTest extends TestCase {
+@SuppressWarnings("nls")
+public class TmfAsyncSequenceDiagramEventTest {
private final String fContext = ITmfEventType.DEFAULT_CONTEXT_ID;
private final String fTypeId = "Some type";
private final TmfEventField fContent1;
private final TmfEventField fContent2;
-
+ /**
+ * Constructor for the test case
+ */
public TmfAsyncSequenceDiagramEventTest() {
fContent1 = new TmfEventField(ITmfEventField.ROOT_FIELD_ID, "Some content");
fEvent1 = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference);
fEvent2 = new TmfEvent(null, fTimestamp2, fSource, fType, fContent2, fReference);
}
- @Override
- public void setUp() throws Exception {
- }
-
- @Override
- public void tearDown() throws Exception {
- }
-
+ /**
+ * Main test
+ */
+ @Test
public void testTmfAsyncSequenceDiagramEvent() {
TmfAsyncSequenceDiagramEvent event = null;
/*******************************************************************************
- * Copyright (c) 2011 Ericsson
+ * Copyright (c) 2011, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Bernd Hufmann - Initial API and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
+
package org.eclipse.linuxtools.tmf.core.tests.uml2sd;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.uml2sd.TmfSyncSequenceDiagramEvent;
+import org.junit.Test;
+
/**
- * <b><u>TmfSyncSequenceDiagramEventTest</u></b>
- * <p>
- * Implement me. Please.
- * <p>
+ * TmfSyncSequenceDiagramEventTest
*/
-@SuppressWarnings({"nls","javadoc"})
-public class TmfSyncSequenceDiagramEventTest extends TestCase {
+@SuppressWarnings("nls")
+public class TmfSyncSequenceDiagramEventTest {
private final String fContext = ITmfEventType.DEFAULT_CONTEXT_ID;
private final String fTypeId = "Some type";
private final ITmfEvent fEvent1;
private final TmfEventField fContent1;
- public TmfSyncSequenceDiagramEventTest () {
+ /**
+ * Constructor for the test case
+ */
+ public TmfSyncSequenceDiagramEventTest() {
fContent1 = new TmfEventField(ITmfEventField.ROOT_FIELD_ID, "Some content");
fEvent1 = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference);
}
- @Override
- public void setUp() throws Exception {
- }
-
- @Override
- public void tearDown() throws Exception {
- }
-
+ /**
+ * Main test
+ */
+ @Test
public void testTmfSyncSequenceDiagramEvent() {
TmfSyncSequenceDiagramEvent event = null;
try {
-package org.eclipse.linuxtools.tmf.core.tests.util;
+/*******************************************************************************
+ * Copyright (c) 2013 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Alexandre Montplaisir - Port to JUnit4
+ *******************************************************************************/
-import junit.framework.Test;
-import junit.framework.TestSuite;
+package org.eclipse.linuxtools.tmf.core.tests.util;
-import org.eclipse.linuxtools.internal.tmf.core.Activator;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
- * <b><u>AllTests</u></b>
- * <p>
- * <p>
+ * Unit tests for tmf.core.util
*/
-@SuppressWarnings({ "nls" })
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ PairTest.class
+})
public class AllTests {
- /**
- * @return the test suite
- */
- public static Test suite() {
- TestSuite suite = new TestSuite("Test suite for " + Activator.PLUGIN_ID + ".util"); //$NON-NLS-1$);
- //$JUnit-BEGIN$
- suite.addTestSuite(PairTest.class);
- //$JUnit-END$
- return suite;
- }
}
\ No newline at end of file
/*******************************************************************************
- * Copyright (c) 2011 Ericsson
+ * Copyright (c) 2011, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Bernd Hufmann - Initial design and implementation
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.util;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import org.eclipse.linuxtools.tmf.core.util.Pair;
+import org.junit.Test;
/**
* Test case for Pair class.
* @author Bernd Hufmann
*/
@SuppressWarnings({ "nls", "javadoc" })
-public class PairTest extends TestCase {
+public class PairTest {
// ------------------------------------------------------------------------
// Field(s)
// ------------------------------------------------------------------------
+
Pair<String, Long> fPair1 = new Pair<String, Long>("String 1", 1L);
Pair<String, Long> fPair2 = new Pair<String, Long>("String 2", 2L);
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- }
-
// ------------------------------------------------------------------------
// to String
// ------------------------------------------------------------------------
+ @Test
public void testToString() {
String result = fPair1.toString();
assertEquals("(String 1, 1)", result);
// Setters/Getters
// ------------------------------------------------------------------------
+ @Test
public void testAccessors() {
Pair<String, Long> myPair = new Pair<String, Long>("String 1", 1L);
assertEquals("String 1", myPair.getFirst());
// equals
// ------------------------------------------------------------------------
+ @Test
public void testEqualsReflexivity() {
assertTrue("equals", fPair1.equals(fPair1));
assertTrue("equals", fPair2.equals(fPair2));
assertTrue("equals", !fPair2.equals(fPair1));
}
+ @Test
public void testEqualsSymmetry() {
Pair<String, Long> info1 = new Pair<String, Long>(fPair1.getFirst(), fPair1.getSecond().longValue());
Pair<String, Long> info2 = new Pair<String, Long>(fPair2.getFirst(), fPair2.getSecond().longValue());
assertTrue("equals", fPair2.equals(info2));
}
+ @Test
public void testEqualsTransivity() {
Pair<String, Long> info1 = new Pair<String, Long>(fPair1.getFirst(), fPair1.getSecond().longValue());
Pair<String, Long> info2 = new Pair<String, Long>(fPair1.getFirst(), fPair1.getSecond().longValue());
assertTrue("equals", info1.equals(info3));
}
+ @Test
public void testEqualsNull() {
assertTrue("equals", !fPair1.equals(null));
assertTrue("equals", !fPair2.equals(null));
}
+ @Test
public void testEqualsDifferentObj() {
Pair<Long, String> info = new Pair<Long, String>(1L, "String1");
assertTrue("equals", !fPair1.equals(info));
// hashCode
// ------------------------------------------------------------------------
+ @Test
public void testHashCode() {
Pair<String, Long> info1 = new Pair<String, Long>(fPair1.getFirst(), fPair1.getSecond().longValue());
Pair<String, Long> info2 = new Pair<String, Long>(fPair2.getFirst(), fPair2.getSecond().longValue());
projects / deliverable / tracecompass.git / commitdiff
