public class BtfAnalysisModule extends TmfStateSystemAnalysisModule {
@Override
- public void setTrace(ITmfTrace trace) throws TmfAnalysisException {
+ public boolean setTrace(ITmfTrace trace) throws TmfAnalysisException {
if (!(trace instanceof BtfTrace)) {
- throw new IllegalArgumentException("BtfAnalysisModule: trace should be of type BtfTrace"); //$NON-NLS-1$
+ return false;
}
- super.setTrace(trace);
+ return super.setTrace(trace);
}
@Override
ITmfTrace trace = fTrace;
assertNotNull(trace);
try {
- fKernelAnalysisModule.setTrace(trace);
+ assertTrue(fKernelAnalysisModule.setTrace(trace));
} catch (TmfAnalysisException e) {
fail(e.getMessage());
}
}
};
- module.setTrace(trace);
+ if (!module.setTrace(trace)) {
+ throw new IllegalStateException();
+ }
module.setId("test-values");
module.schedule();
module.waitForCompletion();
module = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
try {
- module.setTrace(testTrace.getTrace());
+ assertTrue(module.setTrace(testTrace.getTrace()));
} catch (TmfAnalysisException e) {
fail();
}
}
@Override
- public void setTrace(@Nullable ITmfTrace trace) throws TmfAnalysisException {
+ public boolean setTrace(@Nullable ITmfTrace trace) throws TmfAnalysisException {
if (!(trace instanceof CtfTmfTrace)) {
- throw new IllegalStateException("TestLttngKernelAnalysisModule: trace should be of type CtfTmfTrace"); //$NON-NLS-1$
+ return false;
}
- super.setTrace(trace);
+ return super.setTrace(trace);
}
@Override
module = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
try {
- module.setTrace(testTrace.getTrace());
+ assertTrue(module.setTrace(testTrace.getTrace()));
} catch (TmfAnalysisException e) {
fail();
}
public void testBuild() {
TestLttngKernelAnalysisModule module2 = new TestLttngKernelAnalysisModule(BENCHMARK_FILE_NAME);
try {
- module2.setTrace(testTrace.getTrace());
+ assertTrue(module2.setTrace(testTrace.getTrace()));
} catch (TmfAnalysisException e) {
module2.dispose();
fail();
/* 'newStateFile' should have already been created */
TestLttngKernelAnalysisModule module2 = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
try {
- module2.setTrace(testTrace.getTrace());
+ assertTrue(module2.setTrace(testTrace.getTrace()));
} catch (TmfAnalysisException e) {
module2.dispose();
fail();
}
@Override
- public void setTrace(@Nullable ITmfTrace trace) throws TmfAnalysisException {
+ public boolean setTrace(@Nullable ITmfTrace trace) throws TmfAnalysisException {
if (!(trace instanceof CtfTmfTrace)) {
- throw new IllegalStateException("TestLttngKernelAnalysisModule: trace should be of type CtfTmfTrace"); //$NON-NLS-1$
+ return false;
}
- super.setTrace(trace);
+ return super.setTrace(trace);
}
@Override
module = new TestLttngKernelAnalysisModule();
try {
- module.setTrace(testTrace.getTrace());
+ assertTrue(module.setTrace(testTrace.getTrace()));
} catch (TmfAnalysisException e) {
fail();
}
}
@Override
- public void setTrace(ITmfTrace trace) throws TmfAnalysisException {
+ public boolean setTrace(ITmfTrace trace) throws TmfAnalysisException {
if (!(trace instanceof CtfTmfTrace)) {
- throw new IllegalStateException("TestLttngKernelAnalysisModule: trace should be of type CtfTmfTrace"); //$NON-NLS-1$
+ return false;
}
- super.setTrace(trace);
+ return super.setTrace(trace);
}
@Override
fTrace = trace;
fModule = new TestLttngCallStackModule();
try {
- fModule.setTrace(trace);
+ assertTrue(fModule.setTrace(trace));
} catch (TmfAnalysisException e) {
fail();
}
try {
module = new TestLttngCallStackModule();
try {
- module.setTrace(ustTrace);
+ assertTrue(module.setTrace(ustTrace));
} catch (TmfAnalysisException e) {
fail();
}
return new MemoryUsageStateProvider(checkNotNull(getTrace()));
}
+ /**
+ * @since 1.0
+ */
@Override
- public void setTrace(ITmfTrace trace) throws TmfAnalysisException {
+ public boolean setTrace(ITmfTrace trace) throws TmfAnalysisException {
if (!(trace instanceof LttngUstTrace)) {
- throw new IllegalStateException("UstMemoryAnalysisModule: trace should be of type LttngUstTrace"); //$NON-NLS-1$
+ return false;
}
- super.setTrace(trace);
+ return super.setTrace(trace);
}
@Override
*/
public class LttngUstCallStackAnalysis extends AbstractCallStackAnalysis {
+ /**
+ * @since 1.0
+ */
@Override
- public void setTrace(ITmfTrace trace) throws TmfAnalysisException {
+ public boolean setTrace(ITmfTrace trace) throws TmfAnalysisException {
if (!(trace instanceof LttngUstTrace)) {
- throw new IllegalArgumentException("Trace should be of type LttngUstTrace"); //$NON-NLS-1$
+ return false;
}
- super.setTrace(trace);
+ return super.setTrace(trace);
}
@Override
}
if (module != null) {
- module.setTrace(trace);
- TmfAnalysisManager.analysisModuleCreated(module);
+ if (module.setTrace(trace)) {
+ TmfAnalysisManager.analysisModuleCreated(module);
+ } else {
+ /* The analysis does not apply to the trace, dispose of the module */
+ module.dispose();
+ module = null;
+ }
}
return module;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.osgi.util.NLS;
import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModuleHelper;
-import org.eclipse.tracecompass.tmf.core.analysis.Messages;
import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisManager;
import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisModuleHelperConfigElement;
import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement;
@Test
public void testNewModule() {
/* Test analysis module with traceStub */
- Exception exception = null;
IAnalysisModule module = null;
try {
module = fModule.newModule(TmfTestTrace.A_TEST_10K.getTrace());
assertNotNull(module);
assertTrue(module instanceof TestAnalysis);
} catch (TmfAnalysisException e) {
- exception = e;
+ fail();
} finally {
if (module != null) {
module.dispose();
}
}
- assertNull(exception);
/* TestAnalysis2 module with trace, should return an exception */
try {
module = fModuleOther.newModule(TmfTestTrace.A_TEST_10K.getTrace());
+ assertNull(module);
} catch (TmfAnalysisException e) {
- exception = e;
+ fail();
} finally {
if (module != null) {
module.dispose();
}
}
- assertNotNull(exception);
- assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModuleOther.getName()), exception.getMessage());
/* TestAnalysis2 module with a TraceStub2 */
- exception = null;
ITmfTrace trace = fTrace;
assertNotNull(trace);
try {
assertNotNull(module);
assertTrue(module instanceof TestAnalysis2);
} catch (TmfAnalysisException e) {
- exception = e;
+ fail();
} finally {
if (module != null) {
module.dispose();
}
}
- assertNull(exception);
}
try {
- /* fModule should throw exception for both experiments */
- Exception exception = null;
+ /* fModule should return null for both experiments */
IAnalysisModule module = null;
try {
module = fModule.newModule(exp1);
+ assertNull(module);
} catch (TmfAnalysisException e) {
- exception = e;
+ fail();
} finally {
if (module != null) {
module.dispose();
}
}
- assertNotNull(exception);
- assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModule.getName()), exception.getMessage());
- exception = null;
try {
module = fModule.newModule(exp2);
+ assertNull(module);
} catch (TmfAnalysisException e) {
- exception = e;
+ fail();
} finally {
if (module != null) {
module.dispose();
}
}
- assertNotNull(exception);
- assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModule.getName()), exception.getMessage());
/* fModuleOther should throw exception for exp1, but not exp2 */
- exception = null;
try {
module = fModuleOther.newModule(exp1);
+ assertNull(module);
} catch (TmfAnalysisException e) {
- exception = e;
+ fail();
} finally {
if (module != null) {
module.dispose();
}
}
- assertNotNull(exception);
- assertEquals(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, fModuleOther.getName()), exception.getMessage());
- exception = null;
try {
module = fModuleOther.newModule(exp2);
assertNotNull(module);
} catch (TmfAnalysisException e) {
- exception = e;
+ fail();
} finally {
if (module != null) {
module.dispose();
}
}
- assertNull(exception);
} finally {
exp2.dispose();
IAnalysisModule module = null;
try {
module = helper.newModule(trace);
+ assertNotNull(module);
assertNull(module.getParameter(TestAnalysis.PARAM_TEST));
module.setParameter(TestAnalysis.PARAM_TEST, 1);
assertEquals(1, module.getParameter(TestAnalysis.PARAM_TEST));
assertNotNull(helper);
try {
module = helper.newModule(trace);
+ assertNotNull(module);
assertEquals(3, module.getParameter(TestAnalysis.PARAM_TEST));
module.setParameter(TestAnalysis.PARAM_TEST, 1);
assertEquals(1, module.getParameter(TestAnalysis.PARAM_TEST));
assertNotNull(trace);
try {
module = helper.newModule(trace);
+ assertNotNull(module);
assertNull(module.getParameter(TestAnalysis.PARAM_TEST));
try {
/* Set a stub trace for analysis */
try {
- module.setTrace(TmfTestTrace.A_TEST_10K.getTrace());
+ assertTrue(module.setTrace(TmfTestTrace.A_TEST_10K.getTrace()));
} catch (TmfAnalysisException e) {
fail(e.getMessage());
}
/* Set a stub trace for analysis */
ITmfTrace trace = TmfTestTrace.A_TEST_10K.getTrace();
try {
- module.setTrace(trace);
+ assertTrue(module.setTrace(trace));
} catch (TmfAnalysisException e) {
fail(e.getMessage());
}
assertEquals(MODULE_GENERIC_ID, module.getId());
assertEquals(MODULE_GENERIC_NAME, module.getName());
- Exception exception = null;
+ try {
+ assertFalse(module.setTrace(TmfTestTrace.A_TEST_10K.getTrace()));
+ } catch (TmfAnalysisException e) {
+ fail();
+ }
+
+ module.dispose();
+ }
+
+ /**
+ * Test the {@link TmfAbstractAnalysisModule#setTrace(ITmfTrace)} method
+ * with wrong trace
+ */
+ @Test
+ public void testSetTraceTwice() {
+ IAnalysisModule module = new TestAnalysis();
+
+ module.setName(MODULE_GENERIC_NAME);
+ module.setId(MODULE_GENERIC_ID);
+
+ try {
+ assertTrue(module.setTrace(TmfTestTrace.A_TEST_10K.getTrace()));
+ } catch (TmfAnalysisException e) {
+ fail();
+ }
+ TmfAnalysisException 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());
module.dispose();
}
module.setParameter(TestAnalysis.PARAM_TEST, 999);
try {
- module.setTrace(TmfTestTrace.A_TEST_10K.getTrace());
+ assertTrue(module.setTrace(TmfTestTrace.A_TEST_10K.getTrace()));
} catch (TmfAnalysisException e) {
fail(e.getMessage());
}
TestAnalysis module = setUpAnalysis();
try {
- module.setTrace(TmfTestTrace.A_TEST_10K.getTrace());
+ assertTrue(module.setTrace(TmfTestTrace.A_TEST_10K.getTrace()));
} catch (TmfAnalysisException e) {
fail(e.getMessage());
}
TestAnalysis module = setUpAnalysis();
try {
- module.setTrace(TmfTestTrace.A_TEST_10K.getTrace());
+ assertTrue(module.setTrace(TmfTestTrace.A_TEST_10K.getTrace()));
} catch (TmfAnalysisException e) {
fail(e.getMessage());
}
module.setParameter(TestAnalysis.PARAM_TEST, paramAndResult);
try {
- depModule.setTrace(trace);
- module.setTrace(trace);
+ assertTrue(depModule.setTrace(trace));
+ assertTrue(module.setTrace(trace));
} catch (TmfAnalysisException e) {
fail(e.getMessage());
}
IAnalysisModule module = null;
try {
module = helper.newModule(trace);
+ assertNotNull(module);
assertEquals(10, module.getParameter(TestAnalysis.PARAM_TEST));
module.setName(getName());
module.setId(getId());
module.setAutomatic(isAutomatic());
- module.setTrace(trace);
+ if (!module.setTrace(trace)) {
+ module.dispose();
+ module = null;
+ }
break;
case TEST2:
module = new TestAnalysis2();
module.setName(getName());
module.setId(getId());
module.setAutomatic(isAutomatic());
- module.setTrace(trace);
+ if (!module.setTrace(trace)) {
+ module.dispose();
+ module = null;
+ }
break;
default:
break;
}
@Override
- public void setTrace(ITmfTrace trace) throws TmfAnalysisException {
+ public boolean setTrace(ITmfTrace trace) throws TmfAnalysisException {
+ return super.setTrace(trace);
}
@Override
boolean isAutomatic();
/**
- * Sets the trace on which to run the analysis
+ * Sets the trace on which to run the analysis and return whether the trace
+ * could be successfully set
*
* Note: The trace cannot be final since most modules are instantiated in a
* way that does not know about the trace, but it shouldn't be set more than
*
* @param trace
* The trace to run the analysis on
+ * @return {@code true} if the trace was successfully set on the module,
+ * {@code false} if the analysis cannot be applied to the trace,
+ * for instance if the trace does not have the right requirements
* @throws TmfAnalysisException
+ * This exception should be thrown if the trace is set more than
+ * once
+ * @since 1.0
*/
- void setTrace(@NonNull ITmfTrace trace) throws TmfAnalysisException;
+ boolean setTrace(@NonNull ITmfTrace trace) throws TmfAnalysisException;
/**
* Add a parameter to this module
package org.eclipse.tracecompass.tmf.core.analysis;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.osgi.framework.Bundle;
* @param trace
* The trace to be linked to the module
* @return A new {@link IAnalysisModule} instance initialized with the
- * trace.
+ * trace or {@code null} if the module couldn't be instantiated
* @throws TmfAnalysisException
* Exceptions that occurred when setting trace
*/
- IAnalysisModule newModule(@NonNull ITmfTrace trace) throws TmfAnalysisException;
+ @Nullable IAnalysisModule newModule(@NonNull ITmfTrace trace) throws TmfAnalysisException;
}
fAutomatic = auto;
}
+ /**
+ * @since 1.0
+ */
@Override
- public void setTrace(ITmfTrace trace) throws TmfAnalysisException {
+ public boolean setTrace(ITmfTrace trace) throws TmfAnalysisException {
if (fTrace != null) {
throw new TmfAnalysisException(NLS.bind(Messages.TmfAbstractAnalysisModule_TraceSetMoreThanOnce, getName()));
}
/* Check that analysis can be executed */
if (!canExecute(trace)) {
- throw new TmfAnalysisException(NLS.bind(Messages.TmfAbstractAnalysisModule_AnalysisCannotExecute, getName()));
+ return false;
}
fTrace = trace;
}
resetAnalysis();
fStarted = false;
+ return true;
}
/**
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.InvalidRegistryObjectException;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.osgi.util.NLS;
import org.eclipse.tracecompass.internal.tmf.core.Activator;
import org.eclipse.tracecompass.internal.tmf.core.analysis.TmfAnalysisModuleSourceConfigElement;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
}
}
- /* Check that analysis can be executed */
if (!applies) {
- throw new TmfAnalysisException(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, getName()));
+ return null;
}
IAnalysisModule module = createModule();
module.setParameter(paramName, defaultValue);
}
}
- module.setTrace(trace);
- TmfAnalysisManager.analysisModuleCreated(module);
+ if (module.setTrace(trace)) {
+ TmfAnalysisManager.analysisModuleCreated(module);
+ } else {
+ module.dispose();
+ module = null;
+ }
return module;
}
@Override
- public void setTrace(ITmfTrace trace) throws TmfAnalysisException {
- super.setTrace(trace);
+ public boolean setTrace(ITmfTrace trace) throws TmfAnalysisException {
+ if (!super.setTrace(trace)) {
+ return false;
+ }
/*
* Since these sub-analyzes are not built from an extension point, we
* have to assign the trace ourselves. Very important to do so before
* calling schedule()!
*/
- totalsModule.setTrace(trace);
- eventTypesModule.setTrace(trace);
+ if (!totalsModule.setTrace(trace)) {
+ return false;
+ }
+ if (!eventTypesModule.setTrace(trace)) {
+ return false;
+ }
+ return true;
}
@Override
for (IAnalysisModuleHelper helper : modules.values()) {
try {
IAnalysisModule module = helper.newModule(this);
+ if (module == null) {
+ continue;
+ }
fAnalysisModules.put(module.getId(), module);
if (module.isAutomatic()) {
status.add(module.schedule());
projects / deliverable / tracecompass.git / commitdiff
