/* Prepare the files */
File logFile = File.createTempFile("TestValues", ".java");
try (final CtfTmfTrace trace = testTrace.getTrace();
- PrintWriter writer = new PrintWriter(new FileWriter(logFile), true);) {
- /* Build and query the state system */
- TmfStateSystemAnalysisModule module = new TmfStateSystemAnalysisModule() {
- @Override
- protected ITmfStateProvider createStateProvider() {
- return new LttngKernelStateProvider(trace);
- }
- @Override
- protected String getSsFileName() {
- return "test-values";
- }
- };
+ PrintWriter writer = new PrintWriter(new FileWriter(logFile), true);
+ /* Build and query the state system */
+ TmfStateSystemAnalysisModule module = new TmfStateSystemAnalysisModule() {
+ @Override
+ protected ITmfStateProvider createStateProvider() {
+ return new LttngKernelStateProvider(trace);
+ }
+
+ @Override
+ protected String getSsFileName() {
+ return "test-values";
+ }
+ };) {
module.setTrace(trace);
module.setId("test-values");
module.schedule();
*/
public class PartialStateSystemTest extends StateSystemTest {
- private static File stateFile;
private static final String TEST_FILE_NAME = "test-partial";
+ private static File stateFile;
+ private static TestLttngKernelAnalysisModule module;
+
/**
* Initialization
stateFile.delete();
}
- TestLttngKernelAnalysisModule module = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
+ module = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
try {
module.setTrace(testTrace.getTrace());
} catch (TmfAnalysisException e) {
*/
@AfterClass
public static void tearDownClass() {
+ module.close();
stateFile.delete();
}
*/
public class StateSystemFullHistoryTest extends StateSystemTest {
+ private static final String TEST_FILE_NAME = "test.ht";
+ private static final String BENCHMARK_FILE_NAME = "test.benchmark.ht";
+
private static File stateFile;
private static File stateFileBenchmark;
+ private static TestLttngKernelAnalysisModule module;
- private static final String TEST_FILE_NAME = "test.ht";
- private static final String BENCHMARK_FILE_NAME = "test.benchmark.ht";
/**
* Initialize the test cases (build the history file once for all tests).
stateFile = createStateFile(TEST_FILE_NAME);
stateFileBenchmark = createStateFile(BENCHMARK_FILE_NAME);
- TestLttngKernelAnalysisModule module = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
+ module = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
try {
module.setTrace(testTrace.getTrace());
} catch (TmfAnalysisException e) {
*/
@AfterClass
public static void tearDownClass() {
+ module.close();
stateFile.delete();
stateFileBenchmark.delete();
}
*/
@Test
public void testBuild() {
- TestLttngKernelAnalysisModule module2 = new TestLttngKernelAnalysisModule(BENCHMARK_FILE_NAME);
- try {
- module2.setTrace(testTrace.getTrace());
- } catch (TmfAnalysisException e) {
- fail();
- }
- module2.schedule();
- assertTrue(module2.waitForCompletion());
- ITmfStateSystem ssb2 = module2.getStateSystem();
+ try (TestLttngKernelAnalysisModule module2 =
+ new TestLttngKernelAnalysisModule(BENCHMARK_FILE_NAME);) {
+ try {
+ module2.setTrace(testTrace.getTrace());
+ } catch (TmfAnalysisException e) {
+ fail();
+ }
+ module2.schedule();
+ assertTrue(module2.waitForCompletion());
+ ITmfStateSystem ssb2 = module2.getStateSystem();
- assertNotNull(ssb2);
- assertEquals(startTime, ssb2.getStartTime());
- assertEquals(endTime, ssb2.getCurrentEndTime());
+ assertNotNull(ssb2);
+ assertEquals(startTime, ssb2.getStartTime());
+ assertEquals(endTime, ssb2.getCurrentEndTime());
+ }
}
/**
@Test
public void testOpenExistingStateFile() {
/* 'newStateFile' should have already been created */
- TestLttngKernelAnalysisModule module2 = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
- try {
- module2.setTrace(testTrace.getTrace());
- } catch (TmfAnalysisException e) {
- fail();
- }
- module2.schedule();
- assertTrue(module2.waitForCompletion());
- ITmfStateSystem ssb2 = module2.getStateSystem();
+ try (TestLttngKernelAnalysisModule module2 = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);) {
+ try {
+ module2.setTrace(testTrace.getTrace());
+ } catch (TmfAnalysisException e) {
+ fail();
+ }
+ module2.schedule();
+ assertTrue(module2.waitForCompletion());
+ ITmfStateSystem ssb2 = module2.getStateSystem();
- assertNotNull(ssb2);
- assertEquals(startTime, ssb2.getStartTime());
- assertEquals(endTime, ssb2.getCurrentEndTime());
+ assertNotNull(ssb2);
+ assertEquals(startTime, ssb2.getStartTime());
+ assertEquals(endTime, ssb2.getCurrentEndTime());
+ }
}
private static class TestLttngKernelAnalysisModule extends TmfStateSystemAnalysisModule {
import org.eclipse.linuxtools.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.ctf.core.CtfTmfTrace;
+import org.junit.AfterClass;
import org.junit.BeforeClass;
/**
*/
public class StateSystemInMemoryTest extends StateSystemTest {
+ private static TestLttngKernelAnalysisModule module;
+
/**
* Initialization
*/
public static void initialize() {
assumeTrue(testTrace.exists());
- TestLttngKernelAnalysisModule module = new TestLttngKernelAnalysisModule();
+ module = new TestLttngKernelAnalysisModule();
try {
module.setTrace(testTrace.getTrace());
} catch (TmfAnalysisException e) {
assertNotNull(ssq);
}
+ /**
+ * Class cleanup
+ */
+ @AfterClass
+ public static void cleanupClass() {
+ module.close();
+ }
+
private static class TestLttngKernelAnalysisModule extends TmfStateSystemAnalysisModule {
/**
private CtfTmfTrace fTrace = null;
private ITmfStateSystem fSS = null;
+ private TestLttngCallStackModule fModule;
+
// ------------------------------------------------------------------------
// Abstract methods
assumeTrue(testTrace.exists());
fTrace = testTrace.getTrace();
- TestLttngCallStackModule module = new TestLttngCallStackModule();
+ fModule = new TestLttngCallStackModule();
try {
- module.setTrace(fTrace);
+ fModule.setTrace(fTrace);
} catch (TmfAnalysisException e) {
fail();
}
- module.schedule();
- assertTrue(module.waitForCompletion());
+ fModule.schedule();
+ assertTrue(fModule.waitForCompletion());
- fSS = module.getStateSystem();
+ fSS = fModule.getStateSystem();
assertNotNull(fSS);
}
*/
@After
public void tearDown() {
+ fModule.close();
if (fTrace != null) {
fTrace.dispose();
File suppDir = new File(TmfTraceManager.getSupplementaryFileDir(fTrace));
public void testOtherUstTrace() {
/* Initialize the trace and analysis module */
final ITmfTrace ustTrace = otherUstTrace.getTrace();
- TestLttngCallStackModule module = new TestLttngCallStackModule();
- try {
- module.setTrace(ustTrace);
- } catch (TmfAnalysisException e) {
- fail();
+ try (TestLttngCallStackModule module = new TestLttngCallStackModule();) {
+ try {
+ module.setTrace(ustTrace);
+ } catch (TmfAnalysisException e) {
+ fail();
+ }
+ module.schedule();
+ assertTrue(module.waitForCompletion());
+
+ /* Make sure the generated state system exists, but is empty */
+ ITmfStateSystem ss = module.getStateSystem();
+ assertNotNull(ss);
+ assertTrue(ss.getStartTime() >= ustTrace.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue());
+ assertEquals(0, ss.getNbAttributes());
}
- module.schedule();
- assertTrue(module.waitForCompletion());
-
- /* Make sure the generated state system exists, but is empty */
- ITmfStateSystem ss = module.getStateSystem();
- assertNotNull(ss);
- assertTrue(ss.getStartTime() >= ustTrace.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue());
- assertEquals(0, ss.getNbAttributes());
-
/* Dispose the trace */
ustTrace.dispose();
File suppDir = new File(TmfTraceManager.getSupplementaryFileDir(ustTrace));
*/
@Test
public void testGettersSetters() {
- IAnalysisModule module = new TestAnalysis();
-
- module.setName(MODULE_GENERIC_NAME);
- module.setId(MODULE_GENERIC_ID);
- assertEquals(MODULE_GENERIC_ID, module.getId());
- assertEquals(MODULE_GENERIC_NAME, module.getName());
-
- module.setAutomatic(false);
- assertFalse(module.isAutomatic());
- module.setAutomatic(true);
- assertTrue(module.isAutomatic());
- module.addParameter(TestAnalysis.PARAM_TEST);
- assertNull(module.getParameter(TestAnalysis.PARAM_TEST));
- module.setParameter(TestAnalysis.PARAM_TEST, 1);
- assertEquals(1, module.getParameter(TestAnalysis.PARAM_TEST));
-
- /* Try to set and get wrong parameter */
- String wrongParam = "abc";
- Exception exception = null;
- try {
- module.setParameter(wrongParam, 1);
- } catch (RuntimeException e) {
- exception = e;
- assertEquals(NLS.bind(Messages.TmfAbstractAnalysisModule_InvalidParameter, wrongParam, module.getName()), e.getMessage());
+ try (IAnalysisModule module = new TestAnalysis();) {
+
+ module.setName(MODULE_GENERIC_NAME);
+ module.setId(MODULE_GENERIC_ID);
+ assertEquals(MODULE_GENERIC_ID, module.getId());
+ assertEquals(MODULE_GENERIC_NAME, module.getName());
+
+ module.setAutomatic(false);
+ assertFalse(module.isAutomatic());
+ module.setAutomatic(true);
+ assertTrue(module.isAutomatic());
+ module.addParameter(TestAnalysis.PARAM_TEST);
+ assertNull(module.getParameter(TestAnalysis.PARAM_TEST));
+ module.setParameter(TestAnalysis.PARAM_TEST, 1);
+ assertEquals(1, module.getParameter(TestAnalysis.PARAM_TEST));
+
+ /* Try to set and get wrong parameter */
+ String wrongParam = "abc";
+ Exception exception = null;
+ try {
+ module.setParameter(wrongParam, 1);
+ } catch (RuntimeException e) {
+ exception = e;
+ assertEquals(NLS.bind(Messages.TmfAbstractAnalysisModule_InvalidParameter, wrongParam, module.getName()), e.getMessage());
+ }
+ assertNotNull(exception);
+ assertNull(module.getParameter(wrongParam));
}
- assertNotNull(exception);
- assertNull(module.getParameter(wrongParam));
}
private static TestAnalysis setUpAnalysis() {
module.addParameter(TestAnalysis.PARAM_TEST);
return module;
-
}
/**
*/
@Test
public void testSetWrongTrace() {
- IAnalysisModule module = new TestAnalysis2();
-
- module.setName(MODULE_GENERIC_NAME);
- module.setId(MODULE_GENERIC_ID);
- assertEquals(MODULE_GENERIC_ID, module.getId());
- assertEquals(MODULE_GENERIC_NAME, module.getName());
-
- Exception exception = null;
- try {
- module.setTrace(TmfTestTrace.A_TEST_10K.getTrace());
- } catch (TmfAnalysisException e) {
- exception = e;
+ try (IAnalysisModule module = new TestAnalysis2();) {
+
+ module.setName(MODULE_GENERIC_NAME);
+ module.setId(MODULE_GENERIC_ID);
+ assertEquals(MODULE_GENERIC_ID, module.getId());
+ assertEquals(MODULE_GENERIC_NAME, module.getName());
+
+ Exception exception = null;
+ try {
+ module.setTrace(TmfTestTrace.A_TEST_10K.getTrace());
+ } catch (TmfAnalysisException e) {
+ exception = e;
+ }
+ assertNotNull(exception);
+ assertEquals(NLS.bind(Messages.TmfAbstractAnalysisModule_AnalysisCannotExecute, module.getName()), exception.getMessage());
}
- assertNotNull(exception);
- assertEquals(NLS.bind(Messages.TmfAbstractAnalysisModule_AnalysisCannotExecute, module.getName()), exception.getMessage());
-
}
/**
* @author Geneviève Bastien
* @since 3.0
*/
-public interface IAnalysisModule extends ITmfComponent, IAnalysisRequirementProvider {
+public interface IAnalysisModule extends ITmfComponent, IAnalysisRequirementProvider, AutoCloseable {
// --------------------------------------------------------
// Getters and setters
* The of the parameter that changed
*/
void notifyParameterChanged(String name);
+
+ // -----------------------------------------------------
+ // AutoCloseable (remove the thrown exception)
+ // -----------------------------------------------------
+
+ @Override
+ void close();
}
}
}
+ @Override
+ public void close() {
+ dispose();
+ }
+
@Override
public void dispose() {
super.dispose();
/** The statistics back-end object for the trace with lost events */
private ITmfStatistics fStats;
+ /* The two analysis modules needed for fStats */
+ private TmfStatisticsTotalsModule fTotalsMod;
+ private TmfStatisticsEventTypesModule fEventTypesMod;
+
// ------------------------------------------------------------------------
// Maintenance
// ------------------------------------------------------------------------
fTrace = lostEventsTrace.getTrace();
/* Prepare the two analysis-backed state systems */
- TmfStatisticsTotalsModule totalsMod = new TmfStatisticsTotalsModule();
- TmfStatisticsEventTypesModule eventTypesMod = new TmfStatisticsEventTypesModule();
+ fTotalsMod = new TmfStatisticsTotalsModule();
+ fEventTypesMod = new TmfStatisticsEventTypesModule();
try {
- totalsMod.setTrace(fTrace);
- eventTypesMod.setTrace(fTrace);
+ fTotalsMod.setTrace(fTrace);
+ fEventTypesMod.setTrace(fTrace);
} catch (TmfAnalysisException e) {
fail();
}
- totalsMod.schedule();
- eventTypesMod.schedule();
- assertTrue(totalsMod.waitForCompletion());
- assertTrue(eventTypesMod.waitForCompletion());
+ fTotalsMod.schedule();
+ fEventTypesMod.schedule();
+ assertTrue(fTotalsMod.waitForCompletion());
+ assertTrue(fEventTypesMod.waitForCompletion());
- ITmfStateSystem totalsSS = totalsMod.getStateSystem();
- ITmfStateSystem eventTypesSS = eventTypesMod.getStateSystem();
+ ITmfStateSystem totalsSS = fTotalsMod.getStateSystem();
+ ITmfStateSystem eventTypesSS = fEventTypesMod.getStateSystem();
assertNotNull(totalsSS);
assertNotNull(eventTypesSS);
*/
@After
public void tearDown() {
+ fStats.dispose();
+ fTotalsMod.close();
+ fEventTypesMod.close();
fTrace.dispose();
}
private ITmfTrace fTrace;
+ private TmfStatisticsTotalsModule fTotalsMod;
+ private TmfStatisticsEventTypesModule fEventTypesMod;
+
/**
* Class setup
*/
fTrace = testTrace.getTrace();
/* Prepare the two analysis-backed state systems */
- TmfStatisticsTotalsModule totalsMod = new TmfStatisticsTotalsModule();
- TmfStatisticsEventTypesModule eventTypesMod = new TmfStatisticsEventTypesModule();
+ fTotalsMod = new TmfStatisticsTotalsModule();
+ fEventTypesMod = new TmfStatisticsEventTypesModule();
try {
- totalsMod.setTrace(fTrace);
- eventTypesMod.setTrace(fTrace);
+ fTotalsMod.setTrace(fTrace);
+ fEventTypesMod.setTrace(fTrace);
} catch (TmfAnalysisException e) {
fail();
}
- totalsMod.schedule();
- eventTypesMod.schedule();
- assertTrue(totalsMod.waitForCompletion());
- assertTrue(eventTypesMod.waitForCompletion());
+ fTotalsMod.schedule();
+ fEventTypesMod.schedule();
+ assertTrue(fTotalsMod.waitForCompletion());
+ assertTrue(fEventTypesMod.waitForCompletion());
- ITmfStateSystem totalsSS = totalsMod.getStateSystem();
- ITmfStateSystem eventTypesSS = eventTypesMod.getStateSystem();
+ ITmfStateSystem totalsSS = fTotalsMod.getStateSystem();
+ ITmfStateSystem eventTypesSS = fEventTypesMod.getStateSystem();
assertNotNull(totalsSS);
assertNotNull(eventTypesSS);
*/
@After
public void tearDown() {
+ fTotalsMod.close();
+ fEventTypesMod.close();
fTrace.dispose();
}
}
projects / deliverable / tracecompass.git / commitdiff
