org.eclipse.tracecompass.tmf.ctf.core,
org.eclipse.tracecompass.tmf.ctf.core.tests,
org.eclipse.core.resources
-Import-Package: com.google.common.collect
+Import-Package: com.google.common.collect,
+ org.eclipse.tracecompass.testtraces.ctf;version="1.0.0"
Export-Package: org.eclipse.tracecompass.analysis.os.linux.core.tests,
org.eclipse.tracecompass.analysis.os.linux.core.tests.cpuusage
Bundle-Activator: org.eclipse.tracecompass.analysis.os.linux.core.tests.Activator
package org.eclipse.tracecompass.analysis.os.linux.core.tests.kernelanalysis;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assume.assumeTrue;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEventLayout;
import org.eclipse.tracecompass.internal.analysis.os.linux.core.kernelanalysis.KernelStateProvider;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
+import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
+import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
*/
public class KernelStateProviderTest {
- private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.TRACE2;
+ private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.TRACE2;
+ private static CtfTmfTrace trace;
private static ITmfStateProvider input;
/**
*/
@BeforeClass
public static void initialize() {
- assumeTrue(testTrace.exists());
- input = new KernelStateProvider(testTrace.getTrace(), IKernelAnalysisEventLayout.DEFAULT_LAYOUT);
+ CtfTmfTrace thetrace = CtfTmfTestTraceUtils.getTrace(testTrace);
+ trace = thetrace;
+ input = new KernelStateProvider(thetrace, IKernelAnalysisEventLayout.DEFAULT_LAYOUT);
+ }
+
+ /**
+ * Class teardown
+ */
+ @AfterClass
+ public static void classTeardown() {
+ if (trace != null) {
+ trace.dispose();
+ }
}
/**
org.eclipse.tracecompass.ctf.core.tests.perf.trace;x-internal:=true,
org.eclipse.tracecompass.ctf.core.tests.scope,
org.eclipse.tracecompass.ctf.core.tests.shared,
- org.eclipse.tracecompass.ctf.core.tests.synthetictraces;x-friends:="org.eclipse.tracecompass.tmf.remote.ui.swtbot.tests",
org.eclipse.tracecompass.ctf.core.tests.trace;x-internal:=true,
org.eclipse.tracecompass.ctf.core.tests.types;x-internal:=true
Import-Package: com.google.common.collect,
org.antlr.runtime;version="3.2.0",
- org.eclipse.test.performance
+ org.eclipse.test.performance,
+ org.eclipse.tracecompass.testtraces.ctf;version="1.0.0"
bin.includes = META-INF/,\
.,\
plugin.properties,\
- traces/get-traces.xml,\
about.html
src.includes = about.html
additional.bundles = org.eclipse.jdt.annotation
package org.eclipse.tracecompass.ctf.core.tests.perf.trace;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import org.eclipse.test.performance.Dimension;
import org.eclipse.test.performance.Performance;
import org.eclipse.test.performance.PerformanceMeter;
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.event.EventDefinition;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Test;
/**
}
private static void readTrace(CtfTestTrace testTrace, String testName, boolean inGlobalSummary) {
- assumeTrue(testTrace.exists());
-
Performance perf = Performance.getDefault();
PerformanceMeter pm = perf.createPerformanceMeter(TEST_ID + '#' + testName);
perf.tagAsSummary(pm, TEST_SUITE_NAME + ':' + testName, Dimension.CPU_TIME);
for (int loop = 0; loop < LOOP_COUNT; loop++) {
pm.start();
try {
- CTFTrace trace = testTrace.getTrace();
+ CTFTrace trace = CtfTestTraceUtils.getTrace(testTrace);
try (CTFTraceReader traceReader = new CTFTraceReader(trace);) {
while (traceReader.hasMoreEvents()) {
package org.eclipse.tracecompass.ctf.core.tests.perf.trace;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.util.LinkedList;
import java.util.List;
import org.eclipse.test.performance.PerformanceMeter;
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.event.EventDefinition;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Test;
/**
}
private static void readAndSeekTrace(CtfTestTrace testTrace, String testName, boolean inGlobalSummary) throws CTFException {
- assumeTrue(testTrace.exists());
-
Performance perf = Performance.getDefault();
PerformanceMeter pm = perf.createPerformanceMeter(TEST_ID + '#' + testName);
perf.tagAsSummary(pm, TEST_SUITE_NAME + ':' + testName, Dimension.CPU_TIME);
}
for (int loop = 0; loop < LOOP_COUNT; loop++) {
- CTFTrace trace = testTrace.getTrace();
+ CTFTrace trace = CtfTestTraceUtils.getTrace(testTrace);
try (CTFTraceReader traceReader = new CTFTraceReader(trace);) {
/* Read the whole trace to find out the start and end times */
<version>1.0.0-SNAPSHOT</version>
<packaging>eclipse-test-plugin</packaging>
- <properties>
- <ctfTestSuiteCommit>0f8beba86ae551f42adeb81d1bfddd5645f31013</ctfTestSuiteCommit>
- </properties>
-
<!-- Do not download the test traces if "maven.test.skip" is set -->
<profiles>
<profile>
<phase>pre-integration-test</phase>
<configuration>
<target>
- <property name="ctf-test-suite-commit" value="${ctfTestSuiteCommit}"/>
<ant antfile="get-traces.xml" dir="traces" />
</target>
</configuration>
<phase>clean</phase>
<configuration>
<filesets>
- <fileset><directory>traces/ctf-testsuite</directory></fileset>
- <fileset><directory>traces/cyg-profile</directory></fileset>
- <fileset><directory>traces/django-benchmark</directory></fileset>
- <fileset><directory>traces/funky_trace</directory></fileset>
- <fileset><directory>traces/hello-lost</directory></fileset>
- <fileset><directory>traces/kernel</directory></fileset>
- <fileset><directory>traces/kernel_vm</directory></fileset>
<fileset><directory>traces/synctraces</directory></fileset>
- <fileset><directory>traces/synthetic-trace</directory></fileset>
- <fileset><directory>traces/trace2</directory></fileset>
- <fileset><directory>traces/exp</directory></fileset>
- <fileset><directory>traces/flipping-endianness</directory></fileset>
- <fileset><directory>traces/bug470846</directory></fileset>
</filesets>
</configuration>
<goals>
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2013, 2014 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.tracecompass.ctf.core.tests.shared;
-
-import java.io.File;
-
-import org.eclipse.tracecompass.ctf.core.CTFException;
-import org.eclipse.tracecompass.ctf.core.tests.synthetictraces.LttngKernelTraceGenerator;
-import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
-
-/**
- * Here is the list of the available test traces for the CTF parser.
- *
- * Make sure you run the traces/get-traces.xml Ant script to download them
- * first!
- *
- * @author Alexandre Montplaisir
- */
-public enum CtfTestTrace {
- /**
- * Example kernel trace
- *
- * <pre>
- * Trace Size: 13 MB
- * Tracer: lttng-modules 2.0.0
- * Event count: 695 319
- * Kernel version: 3.0.0-16-generic-pae
- * Trace length: 10s
- * </pre>
- */
- KERNEL("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/kernel", 695319, 10),
-
- /**
- * Another kernel trace
- *
- * <pre>
- * Trace Size: 14 MB
- * Tracer: lttng-modules 2.0.0
- * Event count: 595 641
- * Kernel version: 3.2.0-18-generic
- * Trace length: 11s
- * </pre>
- */
- TRACE2("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/trace2", 595641, 11),
-
- /**
- * Kernel trace with event contexts: pid, ppid, tid, procname,
- * perf_page_fault, perf_major_faults, perf_minor_faults
- *
- * <pre>
- * Trace Size: 56 MB
- * Tracer: lttng-modules 2.1.0
- * Event count: 714 484
- * Kernel version: 3.8.1
- * Trace length: 29s
- * </pre>
- */
- KERNEL_VM("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/kernel_vm", 714484, 29),
-
- /**
- * Kernel trace with all events enabled. Contains 'inet_sock_local_*' events
- * provided by Francis's Giraldeau lttng-modules addons branch to trace TCP
- * events. Can be used along with {@link CtfTestTrace#SYNC_DEST} for trace
- * synchronization.
- *
- * <pre>
- * Trace Size: 2.4 MB
- * Tracer: lttng-modules 2.1.0
- * Event count: 110 771
- * Kernel version: 3.6.11-1-ARCH
- * Trace length: 23s
- * </pre>
- */
- SYNC_SRC("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/synctraces/scp_src", 110771, 23),
-
- /**
- * Kernel trace with all events enabled. Contains 'inet_sock_local_*' events
- * provided by Francis's Giraldeau lttng-modules addons branch to trace TCP
- * events. Can be used along with {@link CtfTestTrace#SYNC_SRC} for trace
- * synchronization.
- *
- * <pre>
- * Trace Size: 1.9 MB
- * Tracer: lttng-modules 2.1.0
- * Event count: 85 729
- * Kernel version: 3.6.11-1-ARCH
- * Trace length: 17s
- * </pre>
- */
- SYNC_DEST("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/synctraces/scp_dest", 85729, 17),
-
- /**
- * LTTng Kernel trace. Contains 'inet_sock_local_*' events provided by
- * Francis's Giraldeau lttng-modules addons branch to trace TCP events. Can
- * be used along with {@link CtfTestTrace#DJANGO_DB} and
- * {@link CtfTestTrace#DJANGO_HTTPD} for trace synchronization.
- *
- * <pre>
- * Trace Size: 33 MB
- * Tracer: lttng-modules 2.4.0
- * Event count: 754 787
- * Kernel version: 3.13.0-24-generic
- * Trace length: 15s
- * </pre>
- */
- DJANGO_CLIENT("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/django-benchmark/django-client", 754787, 15),
-
- /**
- * LTTng Kernel trace. Contains 'inet_sock_local_*' events provided by
- * Francis's Giraldeau lttng-modules addons branch to trace TCP events. Can
- * be used along with {@link CtfTestTrace#DJANGO_CLIENT} and
- * {@link CtfTestTrace#DJANGO_HTTPD} for trace synchronization.
- *
- * <pre>
- * Trace Size: 28 MB
- * Tracer: lttng-modules 2.4.0
- * Event count: 692 098
- * Kernel version: 3.13.0-24-generic
- * Trace length: 14s
- * </pre>
- */
- DJANGO_DB("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/django-benchmark/django-db", 692098, 14),
-
- /**
- * LTTng Kernel trace. Contains 'inet_sock_local_*' events provided by
- * Francis's Giraldeau lttng-modules addons branch to trace TCP events. Can
- * be used along with {@link CtfTestTrace#DJANGO_DB} and
- * {@link CtfTestTrace#DJANGO_CLIENT} for trace synchronization.
- *
- * <pre>
- * Trace Size: 31 MB
- * Tracer: lttng-modules 2.4.0
- * Event count: 779 096
- * Kernel version:3.13.0-24-generic
- * Trace length: 13s
- * </pre>
- */
- DJANGO_HTTPD("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/django-benchmark/django-httpd", 779096, 13),
-
- /**
- * UST trace with lots of lost events
- *
- * <pre>
- * Trace Size: 3.4 MB
- * Tracer: lttng-ust 2.3
- * Event count: 1 000 000, with 967 700 lost events
- * Trace length: 279ms
- * </pre>
- */
- HELLO_LOST("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/hello-lost", 1000000, 0),
-
- /**
- * UST trace with lttng-ust-cyg-profile events (aka -finstrument-functions)
- *
- * <pre>
- * Trace Size: 236 KB
- * Tracer: lttng-ust 2.3
- * Event count: 4 977
- * Trace length: 10s
- * </pre>
- */
- CYG_PROFILE("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/cyg-profile/glxgears-cyg-profile", 4977, 10),
-
- /**
- * UST trace with lttng-ust-cyg-profile-fast events (no address in
- * func_exit)
- *
- * <pre>
- * Trace Size: 184 KB
- * Tracer: lttng-ust 2.3
- * Event count: 5 161
- * Trace length: 11s
- * </pre>
- */
- CYG_PROFILE_FAST("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/cyg-profile/glxgears-cyg-profile-fast", 5161, 11),
-
- /** Autogenerated Syntetic trace */
- SYNTHETIC_TRACE(LttngKernelTraceGenerator.getPath(), -1, -1),
-
- /** Trace with non-standard field sizes */
- FUNKY_TRACE("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/funky_trace", 100002, 0),
-
- /**
- * Kernel Trace with 64 bit aligned headers
- *
- * <pre>
- * Trace Size: 1.1 MB
- * Tracer: lttng-kernel 2.5
- * Event count: 31 556
- * Trace length: 6 s
- * </pre>
- */
- ARM_64_BIT_HEADER("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/bug446190", 31556, 6),
-
- /**
- * Kernel Trace with flipping endianness
- *
- * <pre>
- * Trace Size: 327 KB
- * Tracer: lttng-kernel 2.5
- * Event count: 14 310
- * Trace length: 41 s
- * </pre>
- */
- FLIPPING_ENDIANNESS("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/flipping-endianness", 14310, 41),
-
- /**
- * Example dynamic scope, timestamp in field, empty stream trace
- *
- * <pre>
- * Trace Size: 3.5 MB
- * Tracer: generated
- * Event count: 101 003
- * Kernel version: 4.0.6-1
- * Trace length: 1 ms
- * </pre>
- */
- DYNSCOPE("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/ctfwriter_JF8nq3", 101003, 1),
-
- /** Set of many traces, do not call getTrace */
- TRACE_EXPERIMENT("../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/exp", -1, -1);
-
- private final String fPath;
- private CTFTrace fTrace = null;
- private CTFTrace fTraceFromFile = null;
- private final int fNbEvent;
- private int fDuration;
-
- private CtfTestTrace(String path, int nbEvent, int time) {
- fPath = path;
- fNbEvent = nbEvent;
- fDuration = time;
- }
-
- /**
- * @return The path to the test trace
- */
- public String getPath() {
- return fPath;
- }
-
- /**
- * Get the number of events for a trace
- *
- * @return the number of events, -1 if irrelevant
- */
- public int getNbEvents() {
- return fNbEvent;
- }
-
- /**
- * Get the duration in seconds of a trace
- *
- * @return the duration in seconds of a trace, -1 if irrelevant
- */
- public int getDuration() {
- return fDuration;
- }
-
- /**
- * Get a CTFTrace instance of a test trace. Make sure {@link #exists()}
- * before calling this!
- *
- * @return The CTFTrace object
- * @throws CTFException
- * If the trace cannot be found.
- */
- public CTFTrace getTrace() throws CTFException {
- if (fTrace == null) {
- fTrace = new CTFTrace(fPath);
- }
- return fTrace;
- }
-
- /**
- * Get a CTFTrace instance created from a File. Make sure {@link #exists()}
- * before calling this!
- *
- * @return The CTFTrace object
- * @throws CTFException
- * If the trace cannot be found.
- */
- public CTFTrace getTraceFromFile() throws CTFException {
- if (fTraceFromFile == null) {
- fTraceFromFile = new CTFTrace(new File(fPath));
- }
- return fTraceFromFile;
- }
-
- /**
- * Check if this test trace actually exists on disk.
- *
- * @return If the trace exists
- */
- public boolean exists() {
- try {
- getTrace();
- } catch (CTFException e) {
- return false;
- }
- return true;
- }
-}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2013, 2015 Ericsson, EfficiOS Inc. and others
+ *
+ * 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
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.ctf.core.tests.shared;
+
+import java.io.IOException;
+
+import org.eclipse.core.runtime.FileLocator;
+import org.eclipse.tracecompass.ctf.core.CTFException;
+import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
+
+/**
+ * Wrapper for the CTF test traces, instantiating {@link CTFTrace} objects from
+ * them.
+ *
+ * @author Alexandre Montplaisir
+ */
+public final class CtfTestTraceUtils {
+
+ private CtfTestTraceUtils() {}
+
+ /**
+ * Get a CTFTrace instance of a test trace.
+ *
+ * @param trace
+ * The test trace to use
+ * @return The CTFTrace object
+ * @throws CTFException
+ * If there is an error initializing the trace
+ */
+ public static synchronized CTFTrace getTrace(CtfTestTrace trace) throws CTFException {
+ String tracePath;
+ try {
+ tracePath = FileLocator.toFileURL(trace.getTraceURL()).getPath();
+ } catch (IOException e) {
+ throw new IllegalStateException();
+ }
+
+ return new CTFTrace(tracePath);
+ }
+}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2013, 2015 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 API and implementation
+ * Marc-Andre Laperle - Move generation to traces folder
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.ctf.core.tests.shared;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.FileChannel;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+
+import org.eclipse.tracecompass.ctf.core.tests.CtfCoreTestPlugin;
+
+/**
+ * Generate a kernel trace
+ *
+ * @author Matthew Khouzam
+ */
+public class LttngKernelTraceGenerator {
+
+ private static final String metadata = "/* CTF 1.8 */ \n" +
+ "typealias integer { size = 8; align = 8; signed = false; } := uint8_t;\n" +
+ "typealias integer { size = 16; align = 8; signed = false; } := uint16_t;\n" +
+ "typealias integer { size = 32; align = 8; signed = false; } := uint32_t;\n" +
+ "typealias integer { size = 64; align = 8; signed = false; } := uint64_t;\n" +
+ "typealias integer { size = 32; align = 8; signed = false; } := unsigned long;\n" +
+ "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n" +
+ "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n" +
+ "\n" +
+ "trace {\n" +
+ " major = 1;\n" +
+ " minor = 8;\n" +
+ " uuid = \"11111111-1111-1111-1111-111111111111\";\n" +
+ " byte_order = le;\n" +
+ " packet.header := struct {\n" +
+ " uint32_t magic;\n" +
+ " uint8_t uuid[16];\n" +
+ " uint32_t stream_id;\n" +
+ " };\n" +
+ "};\n" +
+ "\n" +
+ "env {\n" +
+ " hostname = \"synthetic-host\";\n" +
+ " domain = \"kernel\";\n" +
+ " sysname = \"FakeLinux\";\n" +
+ " kernel_release = \"1.0\";\n" +
+ " kernel_version = \"Fake Os Synthetic Trace\";\n" +
+ " tracer_name = \"lttng-modules\";\n" +
+ " tracer_major = 2;\n" +
+ " tracer_minor = 1;\n" +
+ " tracer_patchlevel = 0;\n" +
+ "};\n" +
+ "\n" +
+ "clock {\n" +
+ " name = monotonic;\n" +
+ " uuid = \"bbff68f0-c633-4ea1-92cd-bd11024ec4de\";\n" +
+ " description = \"Monotonic Clock\";\n" +
+ " freq = 1000000000; /* Frequency, in Hz */\n" +
+ " /* clock value offset from Epoch is: offset * (1/freq) */\n" +
+ " offset = 1368000272650993664;\n" +
+ "};\n" +
+ "\n" +
+ "typealias integer {\n" +
+ " size = 27; align = 1; signed = false;\n" +
+ " map = clock.monotonic.value;\n" +
+ "} := uint27_clock_monotonic_t;\n" +
+ "\n" +
+ "typealias integer {\n" +
+ " size = 32; align = 8; signed = false;\n" +
+ " map = clock.monotonic.value;\n" +
+ "} := uint32_clock_monotonic_t;\n" +
+ "\n" +
+ "typealias integer {\n" +
+ " size = 64; align = 8; signed = false;\n" +
+ " map = clock.monotonic.value;\n" +
+ "} := uint64_clock_monotonic_t;\n" +
+ "\n" +
+ "struct packet_context {\n" +
+ " uint64_clock_monotonic_t timestamp_begin;\n" +
+ " uint64_clock_monotonic_t timestamp_end;\n" +
+ " uint64_t content_size;\n" +
+ " uint64_t packet_size;\n" +
+ " unsigned long events_discarded;\n" +
+ " uint32_t cpu_id;\n" +
+ "};\n" +
+ "\n" +
+ "struct event_header_compact {\n" +
+ " enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n" +
+ " variant <id> {\n" +
+ " struct {\n" +
+ " uint27_clock_monotonic_t timestamp;\n" +
+ " } compact;\n" +
+ " struct {\n" +
+ " uint32_t id;\n" +
+ " uint64_clock_monotonic_t timestamp;\n" +
+ " } extended;\n" +
+ " } v;\n" +
+ "} align(8);\n" +
+ "\n" +
+ "struct event_header_large {\n" +
+ " enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n" +
+ " variant <id> {\n" +
+ " struct {\n" +
+ " uint32_clock_monotonic_t timestamp;\n" +
+ " } compact;\n" +
+ " struct {\n" +
+ " uint32_t id;\n" +
+ " uint64_clock_monotonic_t timestamp;\n" +
+ " } extended;\n" +
+ " } v;\n" +
+ "} align(8);\n" +
+ "\n" +
+ "stream {\n" +
+ " id = 0;\n" +
+ " event.header := struct event_header_compact;\n" +
+ " packet.context := struct packet_context;\n" +
+ "};\n" +
+ "\n" +
+ "event {\n" +
+ " name = sched_switch;\n" +
+ " id = 0;\n" +
+ " stream_id = 0;\n" +
+ " fields := struct {\n" +
+ " integer { size = 8; align = 8; signed = 1; encoding = UTF8; base = 10; } _prev_comm[16];\n" +
+ " integer { size = 32; align = 8; signed = 1; encoding = none; base = 10; } _prev_tid;\n" +
+ " integer { size = 32; align = 8; signed = 1; encoding = none; base = 10; } _prev_prio;\n" +
+ " integer { size = 32; align = 8; signed = 1; encoding = none; base = 10; } _prev_state;\n" +
+ " integer { size = 8; align = 8; signed = 1; encoding = UTF8; base = 10; } _next_comm[16];\n" +
+ " integer { size = 32; align = 8; signed = 1; encoding = none; base = 10; } _next_tid;\n" +
+ " integer { size = 32; align = 8; signed = 1; encoding = none; base = 10; } _next_prio;\n" +
+ " };\n" +
+ "};\n" +
+ "\n";
+
+ private final List<String> fProcesses;
+ private final long fDuration;
+ private final long fNbEvents;
+ private final int fNbChans;
+
+ private static final String[] sfProcesses = {
+ "IDLE",
+ "gnuplot",
+ "starcraft 2:pt3",
+ "bash",
+ "smash",
+ "thrash",
+ "fireball",
+ "Half-life 3",
+ "ST: The game"
+ };
+
+
+ private static final String TRACES_DIRECTORY = "traces";
+ private static final String TRACE_NAME = "synthetic-trace";
+
+ /**
+ * Main, not always needed
+ *
+ * @param args
+ * args
+ */
+ public static void main(String[] args) {
+ // not using createTempFile as this is a directory
+ String path = CtfCoreTestPlugin.getTemporaryDirPath() + File.separator + TRACE_NAME;
+ generateLttngKernelTrace(new File(path));
+ }
+
+ /**
+ * Gets the name of the trace (top directory name)
+ *
+ * @return the name of the trace
+ */
+ public static String getName() {
+ return TRACE_NAME;
+ }
+
+ /**
+ * Get the path
+ *
+ * @return the path
+ */
+ public static String getPath() {
+ CtfCoreTestPlugin plugin = CtfCoreTestPlugin.getDefault();
+ if (plugin == null) {
+ return null;
+ }
+ Path tracePath = Paths.get("..", "..", "ctf", "org.eclipse.tracecompass.ctf.core.tests", TRACES_DIRECTORY, TRACE_NAME);
+ tracePath = tracePath.toAbsolutePath();
+ File file = tracePath.toFile();
+
+ if (!file.exists()) {
+ generateLttngKernelTrace(file);
+ }
+ return file.getAbsolutePath();
+ }
+
+ /**
+ * Generate a trace
+ *
+ * @param file
+ * the file to write the trace to
+ */
+ public static void generateLttngKernelTrace(File file) {
+ final int cpus = 25;
+ LttngKernelTraceGenerator gt = new LttngKernelTraceGenerator(2l * Integer.MAX_VALUE - 100, 500000, cpus);
+ gt.writeTrace(file);
+ }
+
+ /**
+ * Make a kernel trace
+ *
+ * @param duration
+ * the duration of the trace
+ * @param events
+ * the number of events in a trace
+ * @param nbChannels
+ * the number of channels in the trace
+ */
+ public LttngKernelTraceGenerator(long duration, long events, int nbChannels) {
+ fProcesses = Arrays.asList(sfProcesses);
+ fDuration = duration;
+ fNbEvents = events;
+ fNbChans = nbChannels;
+ }
+
+ /**
+ * Write the trace to a file
+ *
+ * @param file
+ * the file to write the trace to
+ */
+ public void writeTrace(File file) {
+
+ if (!file.exists()) {
+ file.mkdir();
+ } else {
+ if (file.isFile()) {
+ file.delete();
+ file.mkdir();
+ } else {
+ // the ctf parser doesn't recurse, so we don't need to.
+ final File[] listFiles = file.listFiles();
+ for (File child : listFiles) {
+ child.delete();
+ }
+ }
+ }
+
+ File metadataFile = new File(file.getPath() + File.separator + "metadata");
+ File[] streams = new File[fNbChans];
+ FileChannel[] channels = new FileChannel[fNbChans];
+
+ try {
+ for (int i = 0; i < fNbChans; i++) {
+ streams[i] = new File(file.getPath() + File.separator + "channel" + i);
+ channels[i] = new FileOutputStream(streams[i]).getChannel();
+ }
+ } catch (FileNotFoundException e) {
+ }
+ // determine the number of events per channel
+ long evPerChan = fNbEvents / fNbChans;
+ long delta = (int) (fDuration / evPerChan);
+ long offsetTime = 0;
+ for (int chan = 0; chan < fNbChans; chan++) {
+ int currentSpace = 0;
+ ByteBuffer bb = ByteBuffer.allocate(65536);
+ bb.order(ByteOrder.LITTLE_ENDIAN);
+ Random rnd = new Random(1337);
+ int rnd0 = rnd.nextInt(fProcesses.size());
+ String prevComm = fProcesses.get(rnd0);
+ int prevPID = rnd0 + chan * fProcesses.size();
+ if (rnd0 == 0) {
+ prevPID = 0;
+ }
+ int prevPrio = 0;
+ int prevPos = -1;
+ for (int eventNb = 0; eventNb < evPerChan; eventNb++) {
+ long ts = eventNb * delta + delta / (fNbChans + 1) * chan;
+
+ int pos = rnd.nextInt((int) (fProcesses.size() * 1.5));
+ if (pos >= fProcesses.size()) {
+ pos = 0;
+ }
+ while (pos == prevPos) {
+ pos = rnd.nextInt((int) (fProcesses.size() * 1.5));
+ if (pos >= fProcesses.size()) {
+ pos = 0;
+ }
+ }
+ String nextComm = fProcesses.get(pos);
+ int nextPID = pos + fProcesses.size() * chan;
+ if (pos == 0) {
+ nextPID = 0;
+ }
+ int nextPrio = 0;
+ if (EventWriter.SIZE > currentSpace) {
+ // pad to end
+ for (int i = 0; i < currentSpace; i++) {
+ bb.put((byte) 0x00);
+ }
+ // write new packet
+ PacketWriter pw = new PacketWriter(bb);
+ long tsBegin = ts;
+ offsetTime = ts;
+ long tsEnd = (eventNb + (PacketWriter.SIZE / EventWriter.SIZE)) * delta + 1;
+ pw.writeNewHeader(tsBegin, tsEnd, chan);
+ currentSpace = PacketWriter.CONTENT_SIZE;
+ }
+ EventWriter ew = new EventWriter(bb);
+ int prev_state = rnd.nextInt(100);
+ if (prev_state != 0) {
+ prev_state = 1;
+ }
+ final long shrunkenTimestamp = ts - offsetTime;
+ final int tsMask = (1 << 27) - 1;
+ if (shrunkenTimestamp > ((1 << 27) + tsMask)) {
+ /* allow only one compact timestamp overflow per packet */
+ throw new IllegalStateException("Invalid timestamp overflow:" + shrunkenTimestamp);
+ }
+ final int clampedTs = (int) (ts & tsMask);
+ int evSize = ew.writeEvent(clampedTs, prevComm, prevPID, prevPrio, prev_state, nextComm, nextPID, nextPrio);
+ currentSpace -= evSize;
+ prevComm = nextComm;
+ prevPID = nextPID;
+ prevPrio = nextPrio;
+ if (bb.position() > 63000) {
+ writeToDisk(channels, chan, bb);
+ }
+ }
+ for (int i = 0; i < currentSpace; i++) {
+ bb.put((byte) 0x00);
+ }
+ writeToDisk(channels, chan, bb);
+ try {
+ channels[chan].close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ try (FileOutputStream fos = new FileOutputStream(metadataFile);) {
+ fos.write(metadata.getBytes());
+ } catch (IOException e) {
+ }
+ }
+
+ private static void writeToDisk(FileChannel[] channels, int chan, ByteBuffer bb) {
+ try {
+ bb.flip();
+ channels[chan].write(bb);
+ bb.clear();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ private class EventWriter {
+ public static final int SIZE =
+ 4 + // timestamp
+ 16 + // prev_comm
+ 4 + // prev_tid
+ 4 + // prev_prio
+ 4 + // prev_state
+ 16 + // current_comm
+ 4 + // next_tid
+ 4; // next_prio
+ private final ByteBuffer data;
+
+ public EventWriter(ByteBuffer bb) {
+ data = bb;
+ }
+
+ public int writeEvent(int ts, String prev_comm, int prev_tid, int prev_prio, int prev_state, String next_comm, int next_tid, int next_prio) {
+ byte[] bOut = new byte[16];
+ byte[] bIn = new byte[16];
+ byte[] temp = prev_comm.getBytes();
+ for (int i = 0; i < Math.min(temp.length, 16); i++) {
+ bOut[i] = temp[i];
+ }
+ temp = next_comm.getBytes();
+ for (int i = 0; i < Math.min(temp.length, 16); i++) {
+ bIn[i] = temp[i];
+ }
+
+ int timestamp = ts << 5;
+
+ data.putInt(timestamp);
+ data.put(bOut);
+ data.putInt(prev_tid);
+ data.putInt(prev_prio);
+ data.putInt(prev_state);
+ data.put(bIn);
+ data.putInt(next_tid);
+ data.putInt(next_prio);
+ return SIZE;
+ }
+
+ }
+
+ private class PacketWriter {
+ private static final int SIZE = 4096;
+ private static final int HEADER_SIZE = 64;
+ private static final int CONTENT_SIZE = SIZE - HEADER_SIZE;
+
+ private final ByteBuffer data;
+
+ public PacketWriter(ByteBuffer bb) {
+ data = bb;
+ }
+
+ public void writeNewHeader(long tsBegin, long tsEnd, int cpu) {
+ final int magicLE = 0xC1FC1FC1;
+ byte uuid[] = {
+ 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11 };
+ // packet header
+
+ // magic number 4
+ data.putInt(magicLE);
+ // uuid 16
+ data.put(uuid);
+ // stream ID 4
+ data.putInt(0);
+
+ // packet context
+ // timestamp_begin 8
+ data.putLong(tsBegin);
+
+ // timestamp_end 8
+ data.putLong(tsEnd);
+
+ // content_size 8
+ data.putLong((CONTENT_SIZE / EventWriter.SIZE * EventWriter.SIZE + HEADER_SIZE) * 8);
+
+ // packet_size 8
+ data.putLong((SIZE) * 8);
+
+ // events_discarded 4
+ data.putInt(0);
+
+ // cpu_id 4
+ data.putInt(cpu);
+
+ }
+
+ }
+
+
+
+}
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2013, 2015 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 API and implementation
- * Marc-Andre Laperle - Move generation to traces folder
- *******************************************************************************/
-
-package org.eclipse.tracecompass.ctf.core.tests.synthetictraces;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.net.URL;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.channels.FileChannel;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Random;
-
-import org.eclipse.core.runtime.FileLocator;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.tracecompass.ctf.core.tests.CtfCoreTestPlugin;
-
-/**
- * Generate a kernel trace
- *
- * @author Matthew Khouzam
- */
-public class LttngKernelTraceGenerator {
-
- private static final String metadata = "/* CTF 1.8 */ \n" +
- "typealias integer { size = 8; align = 8; signed = false; } := uint8_t;\n" +
- "typealias integer { size = 16; align = 8; signed = false; } := uint16_t;\n" +
- "typealias integer { size = 32; align = 8; signed = false; } := uint32_t;\n" +
- "typealias integer { size = 64; align = 8; signed = false; } := uint64_t;\n" +
- "typealias integer { size = 32; align = 8; signed = false; } := unsigned long;\n" +
- "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n" +
- "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n" +
- "\n" +
- "trace {\n" +
- " major = 1;\n" +
- " minor = 8;\n" +
- " uuid = \"11111111-1111-1111-1111-111111111111\";\n" +
- " byte_order = le;\n" +
- " packet.header := struct {\n" +
- " uint32_t magic;\n" +
- " uint8_t uuid[16];\n" +
- " uint32_t stream_id;\n" +
- " };\n" +
- "};\n" +
- "\n" +
- "env {\n" +
- " hostname = \"synthetic-host\";\n" +
- " domain = \"kernel\";\n" +
- " sysname = \"FakeLinux\";\n" +
- " kernel_release = \"1.0\";\n" +
- " kernel_version = \"Fake Os Synthetic Trace\";\n" +
- " tracer_name = \"lttng-modules\";\n" +
- " tracer_major = 2;\n" +
- " tracer_minor = 1;\n" +
- " tracer_patchlevel = 0;\n" +
- "};\n" +
- "\n" +
- "clock {\n" +
- " name = monotonic;\n" +
- " uuid = \"bbff68f0-c633-4ea1-92cd-bd11024ec4de\";\n" +
- " description = \"Monotonic Clock\";\n" +
- " freq = 1000000000; /* Frequency, in Hz */\n" +
- " /* clock value offset from Epoch is: offset * (1/freq) */\n" +
- " offset = 1368000272650993664;\n" +
- "};\n" +
- "\n" +
- "typealias integer {\n" +
- " size = 27; align = 1; signed = false;\n" +
- " map = clock.monotonic.value;\n" +
- "} := uint27_clock_monotonic_t;\n" +
- "\n" +
- "typealias integer {\n" +
- " size = 32; align = 8; signed = false;\n" +
- " map = clock.monotonic.value;\n" +
- "} := uint32_clock_monotonic_t;\n" +
- "\n" +
- "typealias integer {\n" +
- " size = 64; align = 8; signed = false;\n" +
- " map = clock.monotonic.value;\n" +
- "} := uint64_clock_monotonic_t;\n" +
- "\n" +
- "struct packet_context {\n" +
- " uint64_clock_monotonic_t timestamp_begin;\n" +
- " uint64_clock_monotonic_t timestamp_end;\n" +
- " uint64_t content_size;\n" +
- " uint64_t packet_size;\n" +
- " unsigned long events_discarded;\n" +
- " uint32_t cpu_id;\n" +
- "};\n" +
- "\n" +
- "struct event_header_compact {\n" +
- " enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n" +
- " variant <id> {\n" +
- " struct {\n" +
- " uint27_clock_monotonic_t timestamp;\n" +
- " } compact;\n" +
- " struct {\n" +
- " uint32_t id;\n" +
- " uint64_clock_monotonic_t timestamp;\n" +
- " } extended;\n" +
- " } v;\n" +
- "} align(8);\n" +
- "\n" +
- "struct event_header_large {\n" +
- " enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n" +
- " variant <id> {\n" +
- " struct {\n" +
- " uint32_clock_monotonic_t timestamp;\n" +
- " } compact;\n" +
- " struct {\n" +
- " uint32_t id;\n" +
- " uint64_clock_monotonic_t timestamp;\n" +
- " } extended;\n" +
- " } v;\n" +
- "} align(8);\n" +
- "\n" +
- "stream {\n" +
- " id = 0;\n" +
- " event.header := struct event_header_compact;\n" +
- " packet.context := struct packet_context;\n" +
- "};\n" +
- "\n" +
- "event {\n" +
- " name = sched_switch;\n" +
- " id = 0;\n" +
- " stream_id = 0;\n" +
- " fields := struct {\n" +
- " integer { size = 8; align = 8; signed = 1; encoding = UTF8; base = 10; } _prev_comm[16];\n" +
- " integer { size = 32; align = 8; signed = 1; encoding = none; base = 10; } _prev_tid;\n" +
- " integer { size = 32; align = 8; signed = 1; encoding = none; base = 10; } _prev_prio;\n" +
- " integer { size = 32; align = 8; signed = 1; encoding = none; base = 10; } _prev_state;\n" +
- " integer { size = 8; align = 8; signed = 1; encoding = UTF8; base = 10; } _next_comm[16];\n" +
- " integer { size = 32; align = 8; signed = 1; encoding = none; base = 10; } _next_tid;\n" +
- " integer { size = 32; align = 8; signed = 1; encoding = none; base = 10; } _next_prio;\n" +
- " };\n" +
- "};\n" +
- "\n";
-
- private final List<String> fProcesses;
- private final long fDuration;
- private final long fNbEvents;
- private final int fNbChans;
-
- private static final String[] sfProcesses = {
- "IDLE",
- "gnuplot",
- "starcraft 2:pt3",
- "bash",
- "smash",
- "thrash",
- "fireball",
- "Half-life 3",
- "ST: The game"
- };
-
-
- private static final String TRACES_DIRECTORY = "traces";
- private static final String TRACE_NAME = "synthetic-trace";
-
- /**
- * Main, not always needed
- *
- * @param args
- * args
- */
- public static void main(String[] args) {
- // not using createTempFile as this is a directory
- String path = CtfCoreTestPlugin.getTemporaryDirPath() + File.separator + TRACE_NAME;
- generateLttngKernelTrace(new File(path));
- }
-
- /**
- * Gets the name of the trace (top directory name)
- *
- * @return the name of the trace
- */
- public static String getName() {
- return TRACE_NAME;
- }
-
- /**
- * Get the path
- *
- * @return the path
- */
- public static String getPath() {
- CtfCoreTestPlugin plugin = CtfCoreTestPlugin.getDefault();
- if (plugin == null) {
- return null;
- }
- URL location = FileLocator.find(plugin.getBundle(), new Path(TRACES_DIRECTORY), null);
- File file = null;
- try {
- IPath path = new Path(FileLocator.toFileURL(location).getPath()).append(TRACE_NAME);
- file = path.toFile();
- } catch (IOException e) {
- // Shouldn't happen but at least throw something to get the test to fail early
- throw new IllegalStateException();
- }
-
- if (!file.exists()) {
- generateLttngKernelTrace(file);
- }
- return file.getAbsolutePath();
- }
-
- /**
- * Generate a trace
- *
- * @param file
- * the file to write the trace to
- */
- public static void generateLttngKernelTrace(File file) {
- final int cpus = 25;
- LttngKernelTraceGenerator gt = new LttngKernelTraceGenerator(2l * Integer.MAX_VALUE - 100, 500000, cpus);
- gt.writeTrace(file);
- }
-
- /**
- * Make a kernel trace
- *
- * @param duration
- * the duration of the trace
- * @param events
- * the number of events in a trace
- * @param nbChannels
- * the number of channels in the trace
- */
- public LttngKernelTraceGenerator(long duration, long events, int nbChannels) {
- fProcesses = Arrays.asList(sfProcesses);
- fDuration = duration;
- fNbEvents = events;
- fNbChans = nbChannels;
- }
-
- /**
- * Write the trace to a file
- *
- * @param file
- * the file to write the trace to
- */
- public void writeTrace(File file) {
-
- if (!file.exists()) {
- file.mkdir();
- } else {
- if (file.isFile()) {
- file.delete();
- file.mkdir();
- } else {
- // the ctf parser doesn't recurse, so we don't need to.
- final File[] listFiles = file.listFiles();
- for (File child : listFiles) {
- child.delete();
- }
- }
- }
-
- File metadataFile = new File(file.getPath() + File.separator + "metadata");
- File[] streams = new File[fNbChans];
- FileChannel[] channels = new FileChannel[fNbChans];
-
- try {
- for (int i = 0; i < fNbChans; i++) {
- streams[i] = new File(file.getPath() + File.separator + "channel" + i);
- channels[i] = new FileOutputStream(streams[i]).getChannel();
- }
- } catch (FileNotFoundException e) {
- }
- // determine the number of events per channel
- long evPerChan = fNbEvents / fNbChans;
- long delta = (int) (fDuration / evPerChan);
- long offsetTime = 0;
- for (int chan = 0; chan < fNbChans; chan++) {
- int currentSpace = 0;
- ByteBuffer bb = ByteBuffer.allocate(65536);
- bb.order(ByteOrder.LITTLE_ENDIAN);
- Random rnd = new Random(1337);
- int rnd0 = rnd.nextInt(fProcesses.size());
- String prevComm = fProcesses.get(rnd0);
- int prevPID = rnd0 + chan * fProcesses.size();
- if (rnd0 == 0) {
- prevPID = 0;
- }
- int prevPrio = 0;
- int prevPos = -1;
- for (int eventNb = 0; eventNb < evPerChan; eventNb++) {
- long ts = eventNb * delta + delta / (fNbChans + 1) * chan;
-
- int pos = rnd.nextInt((int) (fProcesses.size() * 1.5));
- if (pos >= fProcesses.size()) {
- pos = 0;
- }
- while (pos == prevPos) {
- pos = rnd.nextInt((int) (fProcesses.size() * 1.5));
- if (pos >= fProcesses.size()) {
- pos = 0;
- }
- }
- String nextComm = fProcesses.get(pos);
- int nextPID = pos + fProcesses.size() * chan;
- if (pos == 0) {
- nextPID = 0;
- }
- int nextPrio = 0;
- if (EventWriter.SIZE > currentSpace) {
- // pad to end
- for (int i = 0; i < currentSpace; i++) {
- bb.put((byte) 0x00);
- }
- // write new packet
- PacketWriter pw = new PacketWriter(bb);
- long tsBegin = ts;
- offsetTime = ts;
- long tsEnd = (eventNb + (PacketWriter.SIZE / EventWriter.SIZE)) * delta + 1;
- pw.writeNewHeader(tsBegin, tsEnd, chan);
- currentSpace = PacketWriter.CONTENT_SIZE;
- }
- EventWriter ew = new EventWriter(bb);
- int prev_state = rnd.nextInt(100);
- if (prev_state != 0) {
- prev_state = 1;
- }
- final long shrunkenTimestamp = ts - offsetTime;
- final int tsMask = (1 << 27) - 1;
- if (shrunkenTimestamp > ((1 << 27) + tsMask)) {
- /* allow only one compact timestamp overflow per packet */
- throw new IllegalStateException("Invalid timestamp overflow:" + shrunkenTimestamp);
- }
- final int clampedTs = (int) (ts & tsMask);
- int evSize = ew.writeEvent(clampedTs, prevComm, prevPID, prevPrio, prev_state, nextComm, nextPID, nextPrio);
- currentSpace -= evSize;
- prevComm = nextComm;
- prevPID = nextPID;
- prevPrio = nextPrio;
- if (bb.position() > 63000) {
- writeToDisk(channels, chan, bb);
- }
- }
- for (int i = 0; i < currentSpace; i++) {
- bb.put((byte) 0x00);
- }
- writeToDisk(channels, chan, bb);
- try {
- channels[chan].close();
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
- try (FileOutputStream fos = new FileOutputStream(metadataFile);) {
- fos.write(metadata.getBytes());
- } catch (IOException e) {
- }
- }
-
- private static void writeToDisk(FileChannel[] channels, int chan, ByteBuffer bb) {
- try {
- bb.flip();
- channels[chan].write(bb);
- bb.clear();
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
-
- private class EventWriter {
- public static final int SIZE =
- 4 + // timestamp
- 16 + // prev_comm
- 4 + // prev_tid
- 4 + // prev_prio
- 4 + // prev_state
- 16 + // current_comm
- 4 + // next_tid
- 4; // next_prio
- private final ByteBuffer data;
-
- public EventWriter(ByteBuffer bb) {
- data = bb;
- }
-
- public int writeEvent(int ts, String prev_comm, int prev_tid, int prev_prio, int prev_state, String next_comm, int next_tid, int next_prio) {
- byte[] bOut = new byte[16];
- byte[] bIn = new byte[16];
- byte[] temp = prev_comm.getBytes();
- for (int i = 0; i < Math.min(temp.length, 16); i++) {
- bOut[i] = temp[i];
- }
- temp = next_comm.getBytes();
- for (int i = 0; i < Math.min(temp.length, 16); i++) {
- bIn[i] = temp[i];
- }
-
- int timestamp = ts << 5;
-
- data.putInt(timestamp);
- data.put(bOut);
- data.putInt(prev_tid);
- data.putInt(prev_prio);
- data.putInt(prev_state);
- data.put(bIn);
- data.putInt(next_tid);
- data.putInt(next_prio);
- return SIZE;
- }
-
- }
-
- private class PacketWriter {
- private static final int SIZE = 4096;
- private static final int HEADER_SIZE = 64;
- private static final int CONTENT_SIZE = SIZE - HEADER_SIZE;
-
- private final ByteBuffer data;
-
- public PacketWriter(ByteBuffer bb) {
- data = bb;
- }
-
- public void writeNewHeader(long tsBegin, long tsEnd, int cpu) {
- final int magicLE = 0xC1FC1FC1;
- byte uuid[] = {
- 0x11, 0x11, 0x11, 0x11,
- 0x11, 0x11, 0x11, 0x11,
- 0x11, 0x11, 0x11, 0x11,
- 0x11, 0x11, 0x11, 0x11 };
- // packet header
-
- // magic number 4
- data.putInt(magicLE);
- // uuid 16
- data.put(uuid);
- // stream ID 4
- data.putInt(0);
-
- // packet context
- // timestamp_begin 8
- data.putLong(tsBegin);
-
- // timestamp_end 8
- data.putLong(tsEnd);
-
- // content_size 8
- data.putLong((CONTENT_SIZE / EventWriter.SIZE * EventWriter.SIZE + HEADER_SIZE) * 8);
-
- // packet_size 8
- data.putLong((SIZE) * 8);
-
- // events_discarded 4
- data.putInt(0);
-
- // cpu_id 4
- data.putInt(cpu);
-
- }
-
- }
-
-
-
-}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assume.assumeTrue;
import java.io.File;
import java.io.IOException;
import org.eclipse.tracecompass.ctf.core.event.types.StringDefinition;
import org.eclipse.tracecompass.ctf.core.event.types.StructDeclaration;
import org.eclipse.tracecompass.ctf.core.event.types.StructDefinition;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFResponse;
import org.eclipse.tracecompass.ctf.core.trace.CTFStream;
import org.eclipse.tracecompass.ctf.core.trace.CTFStreamInput;
import org.eclipse.tracecompass.ctf.core.trace.CTFStreamInputReader;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.internal.ctf.core.event.EventDeclaration;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Before;
import org.junit.Test;
}
private static CTFStreamInputReader getStreamInputReader() throws CTFException {
- assumeTrue(testTrace.exists());
- CTFTrace trace = testTrace.getTrace();
+ CTFTrace trace = CtfTestTraceUtils.getTrace(testTrace);
CTFStream s = trace.getStream((long) 0);
Set<CTFStreamInput> streamInput = s.getStreamInputs();
CTFStreamInputReader retVal = null;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
import java.io.File;
import java.io.FilenameFilter;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.event.types.IDefinition;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFStream;
import org.eclipse.tracecompass.ctf.core.trace.CTFStreamInput;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Before;
import org.junit.Test;
*/
@Before
public void setUp() throws CTFException {
- assumeTrue(testTrace.exists());
- fixture = new CTFStreamInput(new CTFStream(testTrace.getTrace()), createFile());
+ fixture = new CTFStreamInput(new CTFStream(CtfTestTraceUtils.getTrace(testTrace)), createFile());
fixture.setTimestampEnd(1L);
}
- @NonNull
- private static File createFile() {
- File path = new File(testTrace.getPath());
+ private static @NonNull File createFile() throws CTFException {
+ File path = new File(CtfTestTraceUtils.getTrace(testTrace).getPath());
final File[] listFiles = path.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
@Test
public void testEquals1() throws CTFException {
- s1 = new CTFStreamInput(new CTFStream(testTrace.getTrace()),
+ s1 = new CTFStreamInput(new CTFStream(CtfTestTraceUtils.getTrace(testTrace)),
createFile());
assertFalse(s1.equals(null));
}
@Test
public void testEquals2() throws CTFException {
- s1 = new CTFStreamInput(new CTFStream(testTrace.getTrace()),
+ s1 = new CTFStreamInput(new CTFStream(CtfTestTraceUtils.getTrace(testTrace)),
createFile());
assertFalse(s1.equals(new Long(23L)));
@Test
public void testEquals3() throws CTFException {
- s1 = new CTFStreamInput(new CTFStream(testTrace.getTrace()),
+ s1 = new CTFStreamInput(new CTFStream(CtfTestTraceUtils.getTrace(testTrace)),
createFile());
assertEquals(s1, s1);
@Test
public void testEquals4() throws CTFException {
- s1 = new CTFStreamInput(new CTFStream(testTrace.getTrace()),
+ s1 = new CTFStreamInput(new CTFStream(CtfTestTraceUtils.getTrace(testTrace)),
createFile());
- s2 = new CTFStreamInput(new CTFStream(testTrace.getTrace()),
+ s2 = new CTFStreamInput(new CTFStream(CtfTestTraceUtils.getTrace(testTrace)),
createFile());
assertEquals(s1, s2);
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
import java.io.File;
import java.io.FilenameFilter;
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.event.types.IDeclaration;
import org.eclipse.tracecompass.ctf.core.event.types.StructDeclaration;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFStream;
import org.eclipse.tracecompass.ctf.core.trace.CTFStreamInput;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.internal.ctf.core.event.EventDeclaration;
import org.eclipse.tracecompass.internal.ctf.core.event.metadata.exceptions.ParseException;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Before;
-import org.junit.BeforeClass;
import org.junit.Test;
/**
private CTFStreamInput fInput;
- @BeforeClass
- public static void initialize() {
- assumeTrue(testTrace.exists());
- }
-
/**
* Perform pre-test initialization.
*
*/
@Before
public void setUp() throws CTFException {
- fixture = new CTFStream(testTrace.getTrace());
+ fixture = new CTFStream(CtfTestTraceUtils.getTrace(testTrace));
fixture.setEventContext(new StructDeclaration(1L));
fixture.setPacketContext(new StructDeclaration(1L));
fixture.setEventHeader(new StructDeclaration(1L));
fixture.setId(1L);
- fInput = new CTFStreamInput(new CTFStream(testTrace.getTrace()), createFile());
+ fInput = new CTFStreamInput(new CTFStream(CtfTestTraceUtils.getTrace(testTrace)), createFile());
fixture.addInput(fInput);
}
- @NonNull
- private static File createFile() {
- File path = new File(testTrace.getPath());
+ private static @NonNull File createFile() throws CTFException {
+ File path = new File(CtfTestTraceUtils.getTrace(testTrace).getPath());
final File[] listFiles = path.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
*/
@Test
public void testStream() throws CTFException {
- CTFTrace trace = testTrace.getTrace();
+ CTFTrace trace = CtfTestTraceUtils.getTrace(testTrace);
CTFStream result = new CTFStream(trace);
assertNotNull(result);
}
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.event.EventDefinition;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.LttngKernelTraceGenerator;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
import org.eclipse.tracecompass.ctf.core.trace.Metadata;
*
*/
public class CTFTraceGrowingTest {
- final private String fPathName = CtfTestTrace.SYNTHETIC_TRACE.getPath();
- final private CTFTrace fixture = new CTFTrace();
+ private final String fPathName = LttngKernelTraceGenerator.getPath();
+ private final CTFTrace fixture = new CTFTrace();
/**
* Init
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.event.EventDefinition;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Before;
import org.junit.Test;
*/
@Before
public void setUp() throws CTFException {
- assumeTrue(testTrace.exists());
- fixture = new CTFTraceReader(testTrace.getTrace());
+ fixture = new CTFTraceReader(CtfTestTraceUtils.getTrace(testTrace));
}
/**
*/
@Test
public void testOpen_existing() throws CTFException {
- CTFTrace trace = testTrace.getTrace();
+ CTFTrace trace = CtfTestTraceUtils.getTrace(testTrace);
try (CTFTraceReader result = new CTFTraceReader(trace);) {
assertNotNull(result);
}
}
}
- /**
- * Test the hashCode method.
- */
- @Test
- public void testHash() {
- int result = fixture.hashCode();
- assertTrue(0 != result);
- }
-
- /**
- * Test the equals method. Uses the class-wide 'fixture' and another
- * method-local 'fixture2', which both point to the same trace.
- *
- * Both trace reader are different objects, so they shouldn't "equals" each
- * other.
- *
- * @throws CTFException
- */
- @Test
- public void testEquals() throws CTFException {
- try (CTFTraceReader fixture2 = new CTFTraceReader(testTrace.getTrace());) {
- assertEquals(fixture, fixture2);
- }
- }
-
/**
* Run the getCurrentEventDef() method test. Get the first event's
* definition.
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.io.File;
import java.nio.ByteOrder;
import org.eclipse.tracecompass.ctf.core.event.CTFClock;
import org.eclipse.tracecompass.ctf.core.event.types.IDefinition;
import org.eclipse.tracecompass.ctf.core.event.types.StructDeclaration;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFStream;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.internal.ctf.core.event.metadata.exceptions.ParseException;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Before;
import org.junit.Test;
*/
@Before
public void setUp() {
- assumeTrue(testTrace.exists());
try {
- fixture = testTrace.getTraceFromFile();
+ fixture = CtfTestTraceUtils.getTrace(testTrace);
} catch (CTFException e) {
/* If the assumeTrue() call passed, this should not happen. */
fail();
@Test
public void testOpen_existing() {
try {
- CTFTrace result = testTrace.getTraceFromFile();
+ CTFTrace result = CtfTestTraceUtils.getTrace(testTrace);
assertNotNull(result.getUUID());
} catch (CTFException e) {
fail();
// Add a stream
try {
- CTFStream stream = new CTFStream(testTrace.getTrace());
+ CTFStream stream = new CTFStream(CtfTestTraceUtils.getTrace(testTrace));
stream.setId(1234);
fixture.addStream(stream);
} catch (CTFException e) {
@Test
public void testPacketHeaderIsSet_invalid() {
try {
- CTFTrace fixture2 = testTrace.getTraceFromFile();
+ CTFTrace fixture2 = CtfTestTraceUtils.getTrace(testTrace);
fixture2.setMinor(1L);
fixture2.setUUID(UUID.randomUUID());
/*
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.io.File;
import java.net.URISyntaxException;
import org.eclipse.core.runtime.URIUtil;
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.event.EventDefinition;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
import org.eclipse.tracecompass.ctf.core.trace.CTFTraceWriter;
import org.eclipse.tracecompass.internal.ctf.core.trace.Utils;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
*/
@Test
public void testKernelTrace() {
- assumeTrue(CtfTestTrace.KERNEL.exists());
try {
- CTFTrace trace = CtfTestTrace.KERNEL.getTrace();
+ CTFTrace trace = CtfTestTraceUtils.getTrace(CtfTestTrace.KERNEL);
CTFTraceWriter ctfWriter = new CTFTraceWriter(checkNotNull(trace));
String traceName = createTraceName(fName);
ctfWriter.copyPackets(fStartTime, fEndTime, traceName);
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.nio.ByteOrder;
import java.util.ArrayList;
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.event.IEventDeclaration;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFStream;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.ctf.core.trace.Metadata;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Before;
import org.junit.Test;
*/
@Before
public void setUp() throws CTFException {
- assumeTrue(testTrace.exists());
- fixture = new Metadata(testTrace.getTrace());
+ fixture = new Metadata(CtfTestTraceUtils.getTrace(testTrace));
}
/**
@Test
public void testParse() throws CTFException {
setUp();
- assertEquals(new UUID(0xd18e637435a1cd42L, 0x8e70a9cffa712793L), testTrace.getTrace().getUUID());
- assertEquals(1332166405241713920.0, testTrace.getTrace().getClock().getClockOffset(), 200.0);
- assertEquals(8, testTrace.getTrace().getEnvironment().size());
+ assertEquals(new UUID(0xd18e637435a1cd42L, 0x8e70a9cffa712793L), CtfTestTraceUtils.getTrace(testTrace).getUUID());
+ assertEquals(1332166405241713920.0, CtfTestTraceUtils.getTrace(testTrace).getClock().getClockOffset(), 200.0);
+ assertEquals(8, CtfTestTraceUtils.getTrace(testTrace).getEnvironment().size());
}
}
import org.eclipse.tracecompass.ctf.core.CTFStrings;
import org.eclipse.tracecompass.ctf.core.event.EventDefinition;
import org.eclipse.tracecompass.ctf.core.event.types.IntegerDefinition;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
-import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestRule;
@Test
public void readTraces() {
if (fTraceEnum.getNbEvents() != -1) {
- try (CTFTraceReader reader = new CTFTraceReader(new CTFTrace(fTraceEnum.getPath()))) {
+ try (CTFTraceReader reader = new CTFTraceReader(CtfTestTraceUtils.getTrace(fTraceEnum))) {
EventDefinition currentEventDef = reader.getCurrentEventDef();
double start = currentEventDef.getTimestamp();
long count = 0;
assertEquals("Event count", fTraceEnum.getNbEvents(), count);
assertEquals("Trace duration", fTraceEnum.getDuration(), (end - start) / 1000000000.0, 1.0);
} catch (CTFException e) {
- fail(fTraceEnum.getPath() + " " + e.getMessage());
+ fail(fTraceEnum.name() + " " + e.getMessage());
}
} else {
assumeTrue("Trace did not specify events count", false);
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
import org.eclipse.tracecompass.ctf.core.CTFException;
import org.eclipse.tracecompass.ctf.core.event.EventDefinition;
import org.eclipse.tracecompass.ctf.core.event.IEventDeclaration;
import org.eclipse.tracecompass.ctf.core.event.LostEventDeclaration;
import org.eclipse.tracecompass.ctf.core.event.types.StructDeclaration;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
import org.eclipse.tracecompass.ctf.core.trace.CTFStream;
import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
import org.eclipse.tracecompass.ctf.core.trace.CTFTraceReader;
import org.eclipse.tracecompass.internal.ctf.core.event.EventDeclaration;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Before;
import org.junit.Test;
*/
@Before
public void setUp() throws CTFException {
- assumeTrue(testTrace.exists());
fixture = new EventDeclaration();
fixture.setContext(new StructDeclaration(1L));
fixture.setId(1L);
fixture.setFields(new StructDeclaration(1L));
- fixture.setStream(new CTFStream(testTrace.getTrace()));
+ fixture.setStream(new CTFStream(CtfTestTraceUtils.getTrace(testTrace)));
fixture.setName("");
}
obj.setContext(new StructDeclaration(1L));
obj.setId(1L);
obj.setFields(new StructDeclaration(1L));
- obj.setStream(new CTFStream(testTrace.getTrace()));
+ obj.setStream(new CTFStream(CtfTestTraceUtils.getTrace(testTrace)));
obj.setName("");
assertTrue(fixture.equals(fixture));
*/
@Test
public void testEventDefinition() throws CTFException {
- CTFTrace trace = testTrace.getTrace();
+ CTFTrace trace = CtfTestTraceUtils.getTrace(testTrace);
EventDefinition ed = null;
try (CTFTraceReader tr = new CTFTraceReader(trace);) {
tr.advance();
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assume.assumeTrue;
import java.nio.ByteBuffer;
import org.eclipse.tracecompass.ctf.core.event.types.StructDefinition;
import org.eclipse.tracecompass.ctf.core.event.types.VariantDeclaration;
import org.eclipse.tracecompass.ctf.core.event.types.VariantDefinition;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTraceUtils;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Before;
import org.junit.Test;
}
private static IDefinitionScope createDefinitionScope() throws CTFException {
- assumeTrue(testTrace.exists());
StructDeclaration declaration = new StructDeclaration(8);
VariantDeclaration variantDeclaration = new VariantDeclaration();
variantDeclaration.addField("a", IntegerDeclaration.INT_32B_DECL);
);
VariantDefinition variantDefinition = new VariantDefinition(
variantDeclaration,
- testTrace.getTrace(),
+ CtfTestTraceUtils.getTrace(testTrace),
"tag",
"tag",
new StringDefinition(
-*.bz2
*.gz
*.tar
-*.ht
-*.zip
-/ctf-testsuite
-/cyg-profile
-/funky_trace
-/hello-lost
-/kernel
-/kernel_vm
-/synctraces
-/synthetic-trace
-/trace2
-/exp
-/django-benchmark
-/bug446190
-/flipping-endianness
-/ctfwriter_JF8nq3/
+synctraces/
+synthetic-trace/
+++ /dev/null
-4c67592e010111285c6e5a89dda0e008
+++ /dev/null
-0ce513c01476d336f357c0ec39755671
+++ /dev/null
-00000000006062cc b angle
-0000000000606248 d animate
-00000000006062e0 b asp
-0000000000606290 d blue.19445
-00000000006062b0 B __bss_start
-00000000006062b8 b completed.6718
- U cos@@GLIBC_2.2.5
-0000000000401aac t current_time
- U __cyg_profile_func_enter@@GLIBC_2.2.5
- U __cyg_profile_func_exit@@GLIBC_2.2.5
-0000000000606230 D __data_start
-0000000000606230 W data_start
-00000000004019f0 t deregister_tm_clones
-0000000000401a60 t __do_global_dtors_aux
-0000000000605de8 t __do_global_dtors_aux_fini_array_entry
-00000000004033a7 t draw
-0000000000403760 t draw_frame
-000000000040357a t draw_gears
-0000000000606238 D __dso_handle
-0000000000605df8 d _DYNAMIC
-00000000006062b0 D _edata
-00000000006062e8 B _end
-00000000004045c8 t event_loop
- U exit@@GLIBC_2.2.5
-000000000060624c d eyesep
- U fflush@@GLIBC_2.2.5
-0000000000404c54 T _fini
-0000000000606250 d fix_point
-0000000000401a80 t frame_dummy
-0000000000605de0 t __frame_dummy_init_array_entry
-0000000000405470 r __FRAME_END__
-00000000006062e4 b frames.19426
-00000000006062d0 b fullscreen
-0000000000401b23 t gear
-00000000006062c0 b gear1
-00000000006062c4 b gear2
-00000000006062c8 b gear3
- U getenv@@GLIBC_2.2.5
- U gettimeofday@@GLIBC_2.2.5
- U glBegin
- U glCallList
- U glClear
- U glDeleteLists
- U glDrawBuffer
- U glEnable
- U glEnd
- U glEndList
- U glFrustum
- U glGenLists
- U glGetString
- U glLightfv
- U glLoadIdentity
- U glMaterialfv
- U glMatrixMode
- U glNewList
- U glNormal3f
-0000000000606000 d _GLOBAL_OFFSET_TABLE_
- U glPopMatrix
- U glPushMatrix
- U glRotatef
- U glShadeModel
- U glTranslated
- U glTranslatef
- U glVertex3f
- U glViewport
- U glXChooseVisual
- U glXCreateContext
- U glXDestroyContext
- U glXGetProcAddressARB
- U glXMakeCurrent
- U glXQueryDrawable
- U glXQueryExtensionsString
- U glXSwapBuffers
- w __gmon_start__
-0000000000606280 d green.19444
-0000000000404412 t handle_event
-0000000000403b14 t init
-0000000000401560 T _init
-0000000000605de8 t __init_array_end
-0000000000605de0 t __init_array_start
-0000000000404c60 R _IO_stdin_used
-0000000000404244 t is_glx_extension_supported
- w _ITM_deregisterTMCloneTable
- w _ITM_registerTMCloneTable
-0000000000605df0 d __JCR_END__
-0000000000605df0 d __JCR_LIST__
- w _Jv_RegisterClasses
-00000000006062d8 b left
-0000000000404c50 T __libc_csu_fini
-0000000000404bc0 T __libc_csu_init
- U __libc_start_main@@GLIBC_2.2.5
-000000000040472b T main
-0000000000403d60 t make_window
-0000000000405034 r MWM_HINTS_DECORATIONS.19450
-0000000000403cb1 t no_border
-0000000000606260 d pos.19442
- U printf@@GLIBC_2.2.5
-0000000000405038 r PROP_MOTIF_WM_HINTS_ELEMENTS.19451
- U puts@@GLIBC_2.2.5
-0000000000404311 t query_vsync
-0000000000606270 d red.19443
-0000000000401a20 t register_tm_clones
-000000000040392b t reshape
-00000000006062dc b right
-00000000006062d4 b samples
- U sin@@GLIBC_2.2.5
- U sqrt@@GLIBC_2.2.5
- U __stack_chk_fail@@GLIBC_2.4
-00000000004019c0 T _start
-00000000006062b0 B stdout@@GLIBC_2.2.5
-00000000006062d1 b stereo
- U strcmp@@GLIBC_2.2.5
- U strlen@@GLIBC_2.2.5
- U strstr@@GLIBC_2.2.5
- U strtod@@GLIBC_2.2.5
-00000000006062b0 D __TMC_END__
-00000000006062a8 d tRate0.19428
-00000000006062a0 d tRot0.19427
-00000000004046bd t usage
-0000000000606240 d view_rotx
-0000000000606244 d view_roty
-00000000006062bc b view_rotz
- U XChangeProperty
- U XCloseDisplay
- U XCreateColormap
- U XCreateWindow
- U XDestroyWindow
- U XFree
- U XInternAtom
- U XLookupKeysym
- U XLookupString
- U XMapWindow
- U XNextEvent
- U XOpenDisplay
- U XParseGeometry
- U XPending
- U XSetNormalHints
- U XSetStandardProperties
+++ /dev/null
-088795f3d7b483d197ffad51137ab39e
+++ /dev/null
-afd538a1dc0c42e825292f0ce4123583
+++ /dev/null
-c6309471689cf999ce2d3123f1594713
-
+++ /dev/null
-9c68dba0f722d4c4a34791651c5b0e83
<target name="deleteFailedCheckSumTraces"/>
</antcall>
<antcall target="downloadTraceFiles"/>
- <exec executable = "git" failifexecutionfails="false" timeout="20000">
- <arg value = "clone"/>
- <arg value = "https://github.com/efficios/ctf-testsuite.git"/>
- </exec>
- <condition property="testSuiteExists">
- <and>
- <available file="ctf-testsuite" type="dir"/>
- </and>
- </condition>
- <antcall target="pullTestSuite"/>
<condition property="tracesExist">
<and>
- <available file="sample-ctf-trace-20120412.tar.bz2"/>
- <available file="trace2.tar.bz2"/>
- <available file="kernel_vm.tar.bz2" />
<available file="synctraces.tar.gz" />
- <available file="django-benchmark.tar.gz" />
- <available file="hello-lost.tar.bz2" />
- <available file="cyg-profile.tar.bz2" />
- <available file="funky_trace.tar.bz2" />
- <available file="bug446190.tar.bz2" />
- <available file="flipping-endianness.tar.bz2" />
- <available file="bug470846.tar.bz2" />
</and>
</condition>
<antcall target="extractTraces"/>
<target name="checkAnyTraceExists">
<pathconvert property="anyTraceExists" setonempty="false" pathsep=" ">
<path>
- <fileset dir="." includes="*.tar.bz2" />
<fileset dir="." includes="*.tar.gz" />
- <fileset dir="." includes="*.zip" />
</path>
</pathconvert>
</target>
<not>
<and>
<checksum>
- <fileset dir="." includes="*.tar.bz2" />
<fileset dir="." includes="*.tar.gz" />
- <fileset dir="." includes="*.zip" />
</checksum>
</and>
</not>
<target name="deleteFailedCheckSumTraces" if="failedCheckSum">
<echo message="Some traces have failed the checksum tests. Deleting traces."/>
<delete verbose="true">
- <fileset dir="." includes="*.tar.bz2" />
<fileset dir="." includes="*.tar.gz" />
- <fileset dir="." includes="*.zip" />
</delete>
</target>
<target name="downloadTraceFiles">
<echo message="Attempting to download test traces"/>
- <get ignoreerrors="true" maxtime="60" skipexisting="true" dest="sample-ctf-trace-20120412.tar.bz2" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/sample-ctf-trace-20120412.tar.bz2"/>
- <get ignoreerrors="true" maxtime="60" skipexisting="true" dest="trace2.tar.bz2" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/trace2.tar.bz2"/>
- <get ignoreerrors="true" maxtime="60" skipexisting="true" dest="kernel_vm.tar.bz2" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/kernel_vm.tar.bz2" />
<get ignoreerrors="true" maxtime="60" skipexisting="true" dest="synctraces.tar.gz" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/synctraces.tar.gz" />
- <get ignoreerrors="true" maxtime="200" skipexisting="true" dest="django-benchmark.tar.gz" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/django-benchmark.tar.gz" />
- <get ignoreerrors="true" maxtime="60" skipexisting="true" dest="hello-lost.tar.bz2" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/hello-lost.tar.bz2" />
- <get ignoreerrors="true" maxtime="60" skipexisting="true" dest="cyg-profile.tar.bz2" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/cyg-profile.tar.bz2" />
- <get ignoreerrors="true" maxtime="60" skipexisting="true" dest="funky_trace.tar.bz2" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/funky_trace.tar.bz2" />
- <get ignoreerrors="true" maxtime="200" skipexisting="true" dest="testtraceExp.zip" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/testtraceExp.zip" />
- <get ignoreerrors="true" maxtime="200" skipexisting="true" dest="bug446190.tar.bz2" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/bug446190.tar.bz2" />
- <get ignoreerrors="true" maxtime="200" skipexisting="true" dest="flipping-endianness.tar.bz2" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/flipping-endianness.tar.bz2" />
- <get ignoreerrors="true" maxtime="200" skipexisting="true" dest="bug470846.tar.bz2" src="http://archive.eclipse.org/tracecompass/test-traces/ctf/bug470846.tar.bz2" />
-</target>
-
-<target name="pullTestSuite" if="testSuiteExists">
- <!-- Update the local 'master' branch -->
- <exec executable = "git" failifexecutionfails="false" dir="ctf-testsuite" timeout="20000">
- <arg value = "checkout"/>
- <arg value = "master"/>
- </exec>
- <exec executable = "git" failifexecutionfails="false" dir="ctf-testsuite" timeout="20000">
- <arg value = "pull"/>
- </exec>
-
- <!-- Checkout the commit requested by the current build -->
- <exec executable = "git" failifexecutionfails="false" dir="ctf-testsuite" timeout="20000">
- <arg value = "checkout"/>
- <arg value = "${ctf-test-suite-commit}"/>
- </exec>
</target>
<target name="extractTraces" if="tracesExist">
<target name="verifyChecksum"/>
<target name="warnFailedCheckSum"/>
</antcall>
- <bunzip2 src="sample-ctf-trace-20120412.tar.bz2"/>
- <bunzip2 src="trace2.tar.bz2"/>
- <bunzip2 src="kernel_vm.tar.bz2" />
<gunzip src="synctraces.tar.gz" />
- <gunzip src="django-benchmark.tar.gz" />
- <bunzip2 src="hello-lost.tar.bz2" />
- <bunzip2 src="cyg-profile.tar.bz2" />
- <bunzip2 src="funky_trace.tar.bz2" />
- <bunzip2 src="bug446190.tar.bz2"/>
- <bunzip2 src="flipping-endianness.tar.bz2"/>
- <bunzip2 src="bug470846.tar.bz2"/>
- <unzip src="testtraceExp.zip" dest="./exp" />
-
- <untar src="sample-ctf-trace-20120412.tar" dest="." />
- <untar src="trace2.tar" dest="." />
- <untar src="kernel_vm.tar" dest="." />
<untar src="synctraces.tar" dest="." />
- <untar src="django-benchmark.tar" dest="." />
- <untar src="hello-lost.tar" dest="." />
- <untar src="cyg-profile.tar" dest="." />
- <untar src="funky_trace.tar" dest="." />
- <untar src="bug446190.tar" dest="." />
- <untar src="flipping-endianness.tar" dest="." />
- <untar src="bug470846.tar" dest="." />
<echo message="Traces extracted successfully"/>
</target>
+++ /dev/null
-4ca17df0c3e3a0dc14940a988630d2d1
+++ /dev/null
-0aa7f55c4305e642e62c482474b937b3
+++ /dev/null
-6b54b6b4ff7313eb7cd1edb44b39b1d3
+++ /dev/null
-6c0bffcfaee984bc70eab5bcddce4708
+++ /dev/null
-6971bb6f2385abdb17d017f4faaefc16
org.eclipse.tracecompass.tmf.ctf.core.tests.temp.statistics;x-internal:=true,
org.eclipse.tracecompass.tmf.ctf.core.tests.temp.tracemanager;x-internal:=true
Import-Package: com.google.common.collect,
- org.eclipse.test.performance
+ org.eclipse.test.performance,
+ org.eclipse.tracecompass.testtraces.ctf;version="1.0.0"
import org.eclipse.test.performance.Dimension;
import org.eclipse.test.performance.Performance;
import org.eclipse.test.performance.PerformanceMeter;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest.ExecutionType;
import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfExperimentStub;
import org.junit.Test;
private static final String TEST_ID = "org.eclipse.linuxtools#Experiment benchmark#";
private static final int MAX_TRACES = 160;
private static final int BLOCK_SIZE = 100;
- private static final String TRACES_ROOT_PATH = CtfTestTrace.TRACE_EXPERIMENT.getPath();
+ private static final String TRACES_ROOT_PATH = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.TRACE_EXPERIMENT).getPath();
private static final int SAMPLE_SIZE_SLOW = 20;
private static final int SAMPLE_SIZE = 100;
+++ /dev/null
-/*******************************************************************************
- * Copyright (c) 2013, 2014 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.tracecompass.tmf.ctf.core.tests.shared;
-
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
-import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
-import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.stubs.CtfTmfTraceStub;
-import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
-
-/**
- * Available CTF TMF test traces. Kind-of-extends {@link CtfTestTrace}.
- *
- * To run tests using these, you first need to run the "get-traces.[xml|sh]"
- * script located under lttng/org.eclipse.tracecompass.ctf.core.tests/traces/ .
- *
- * @author Alexandre Montplaisir
- */
-@NonNullByDefault
-public enum CtfTmfTestTrace {
- /** Example kernel trace */
- KERNEL,
- /** Another kernel trace */
- TRACE2,
- /** Kernel trace with event contexts */
- KERNEL_VM,
- /** Trace synchronization: source trace */
- SYNC_SRC,
- /** Trace synchronization: destination trace */
- SYNC_DEST,
- /** Trace synchronization (case 2): django client trace */
- DJANGO_CLIENT,
- /** Trace synchronization (case 2): django db trace */
- DJANGO_DB,
- /** Trace synchronization (case 2): django web server trace */
- DJANGO_HTTPD,
- /** UST trace with lots of lost events */
- HELLO_LOST,
- /** UST trace with lttng-ust-cyg-profile events (aka -finstrument-functions) */
- CYG_PROFILE,
- /** UST trace with lttng-ust-cyg-profile-fast events (no address in func_exit) */
- CYG_PROFILE_FAST,
- /** Autogenerated Syntetic trace */
- SYNTHETIC_TRACE,
- /** Trace with non-standard field sizes */
- FUNKY_TRACE,
- /** Example dynamic scope, timestamp in field, empty stream trace */
- DYNSCOPE;
-
-
- private final String fPath;
- private @Nullable CtfTmfTraceStub fTrace = null;
-
- private CtfTmfTestTrace() {
- @SuppressWarnings("null")
- @NonNull String path = CtfTestTrace.valueOf(this.name()).getPath();
- fPath = path;
- }
-
- /**
- * @return The path of this trace
- */
- public String getPath() {
- return fPath;
- }
-
- /**
- * Return a CtfTmfTraceStub object of this test trace. It will be already
- * initTrace()'ed.
- *
- * Make sure you call {@link #exists()} before calling this!
- *
- * After being used by unit tests, traces must be properly disposed of by
- * calling the {@link CtfTmfTestTrace#dispose()} method.
- *
- * @return A CtfTmfTrace reference to this trace
- */
- public synchronized CtfTmfTrace getTrace() {
- CtfTmfTraceStub trace = fTrace;
- if (trace != null) {
- trace.dispose();
- }
- trace = new CtfTmfTraceStub();
- try {
- trace.initTrace(null, fPath, CtfTmfEvent.class);
- } catch (TmfTraceException e) {
- /* Should not happen if tracesExist() passed */
- throw new RuntimeException(e);
- }
- fTrace = trace;
- return trace;
- }
-
- /**
- * Check if the trace actually exists on disk or not.
- *
- * @return If the trace is present
- */
- public boolean exists() {
- return CtfTestTrace.valueOf(this.name()).exists();
- }
-
- /**
- * Dispose of the trace
- */
- public void dispose() {
- if (fTrace != null) {
- fTrace.dispose();
- fTrace = null;
- }
- }
-}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2013, 2015 Ericsson, EfficiOS Inc. and others
+ *
+ * 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
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.ctf.core.tests.shared;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.core.runtime.FileLocator;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.tracecompass.ctf.core.tests.shared.LttngKernelTraceGenerator;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
+import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
+import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.stubs.CtfTmfTraceStub;
+import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
+
+/**
+ * Wrapper for the CTF test traces, instantiating {@link CtfTmfTrace} objects
+ * from them.
+ *
+ * @author Alexandre Montplaisir
+ */
+@NonNullByDefault
+public final class CtfTmfTestTraceUtils {
+
+ private static final Map<CtfTestTrace, CtfTmfTrace> CTF_TMF_TRACES = new HashMap<>();
+
+ private CtfTmfTestTraceUtils() {}
+
+ /**
+ * Return a CtfTmfTraceStub object of this test trace. It will be already
+ * initTrace()'ed.
+ *
+ * After being used by unit tests, traces should be properly disposed by
+ * calling the {@link #dispose(CtfTestTrace)} method.
+ *
+ * @param ctfTrace
+ * The test trace to initialize
+ * @return A CtfTmfTrace reference to this trace
+ */
+ public static synchronized CtfTmfTrace getTrace(CtfTestTrace ctfTrace) {
+ String tracePath;
+ try {
+ tracePath = FileLocator.toFileURL(ctfTrace.getTraceURL()).getPath();
+ } catch (IOException e) {
+ throw new IllegalStateException();
+ }
+
+ dispose(ctfTrace);
+ CtfTmfTrace trace = new CtfTmfTraceStub();
+ try {
+ trace.initTrace(null, tracePath, CtfTmfEvent.class);
+ } catch (TmfTraceException e) {
+ /* Should not happen if tracesExist() passed */
+ throw new RuntimeException(e);
+ }
+ CTF_TMF_TRACES.put(ctfTrace, trace);
+ return trace;
+ }
+
+ /**
+ * Dispose of the trace
+ *
+ * @param ctfTrace
+ * Trace to dispose
+ */
+ public static synchronized void dispose(CtfTestTrace ctfTrace) {
+ CtfTmfTrace trace = CTF_TMF_TRACES.remove(ctfTrace);
+ if (trace != null) {
+ trace.dispose();
+ }
+ }
+
+ /**
+ * Get an initialized version of the synthetic trace.
+ *
+ * @return A reference to the synthetic trace
+ */
+ public static CtfTmfTrace getSyntheticTrace() {
+ CtfTmfTrace trace = new CtfTmfTrace();
+ try {
+ trace.initTrace(null, LttngKernelTraceGenerator.getPath(), CtfTmfEvent.class);
+ } catch (TmfTraceException e) {
+ throw new IllegalStateException();
+ }
+ return trace;
+ }
+}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
import java.util.ArrayList;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.ctf.core.context.CtfTmfContext;
-import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.After;
import org.junit.Before;
*/
public class CtfTmfContextTest {
- private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.KERNEL;
+ private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.KERNEL;
private static final long begin = 1332170682440133097L; /*
* Trace start time
*/
/**
* Pre-test initialization
- *
- * @throws TmfTraceException
- * If the trace couldn't be init'ed, which shouldn't happen.
*/
@Before
- public void setUp() throws TmfTraceException {
- assumeTrue(testTrace.exists());
- trace = new CtfTmfTrace();
- String path = testTrace.getPath();
- trace.initTrace((IResource) null, path, CtfTmfEvent.class);
+ public void setUp() {
+ trace = CtfTmfTestTraceUtils.getTrace(testTrace);
}
/**
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
-import static org.junit.Assume.assumeTrue;
import java.util.Collection;
import java.util.Set;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.internal.tmf.ctf.core.trace.iterator.CtfIterator;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventType;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEventFactory;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.Before;
import org.junit.Test;
*/
public class CtfTmfEventTest {
- private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.KERNEL;
+ private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.KERNEL;
private static CtfTmfEvent nullEvent;
private CtfTmfEvent fixture;
*/
@Before
public void setUp() {
- assumeTrue(testTrace.exists());
- CtfTmfTrace trace = testTrace.getTrace();
+ CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(testTrace);
try (CtfIterator tr = (CtfIterator) trace.createIterator();) {
tr.advance();
fixture = tr.getCurrentEvent();
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.util.Map;
import java.util.concurrent.TimeUnit;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.ctf.core.CTFStrings;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.statistics.ITmfStatistics;
import org.eclipse.tracecompass.tmf.core.statistics.TmfStateStatistics;
import org.eclipse.tracecompass.tmf.core.statistics.TmfStatisticsEventTypesModule;
import org.eclipse.tracecompass.tmf.core.statistics.TmfStatisticsTotalsModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.junit.After;
import org.junit.Before;
-import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestRule;
public TestRule globalTimeout= new Timeout(30, TimeUnit.SECONDS);
/**Test trace with lost events */
- private static final CtfTmfTestTrace lostEventsTrace = CtfTmfTestTrace.HELLO_LOST;
+ private static final @NonNull CtfTestTrace lostEventsTrace = CtfTestTrace.HELLO_LOST;
private ITmfTrace fTrace;
// Maintenance
// ------------------------------------------------------------------------
- /**
- * Class setup
- */
- @BeforeClass
- public static void setUpClass() {
- assumeTrue(lostEventsTrace.exists());
- }
-
/**
* Test setup
*/
@Before
public void setUp() {
- ITmfTrace trace = lostEventsTrace.getTrace();
+ ITmfTrace trace = CtfTmfTestTraceUtils.getTrace(lostEventsTrace);
fTrace = trace;
/* Prepare the two analysis-backed state systems */
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.event.ITmfLostEvent;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.After;
import org.junit.Before;
*/
public class CtfTmfLostEventsTest {
- private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.HELLO_LOST;
+ private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.HELLO_LOST;
private CtfTmfTrace fixture = null;
*/
@Before
public void setUp() {
- assumeTrue(testTrace.exists());
- fixture = testTrace.getTrace();
+ fixture = CtfTmfTestTraceUtils.getTrace(testTrace);
fixture.indexTrace(true);
}
*/
@Test
public void testNbEventsBug475007() {
- final CtfTmfTestTrace tmfTestTrace = CtfTmfTestTrace.DYNSCOPE;
- assumeTrue(tmfTestTrace.exists());
- CtfTmfTrace trace = tmfTestTrace.getTrace();
+ final CtfTestTrace tmfTestTrace = CtfTestTrace.DYNSCOPE;
+ CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(tmfTestTrace);
trace.indexTrace(true);
final long expectedReal = 100003;
package org.eclipse.tracecompass.tmf.ctf.core.tests.event;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assume.assumeTrue;
-import org.eclipse.core.resources.IResource;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
-import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.After;
import org.junit.Before;
// ------------------------------------------------------------------------
/* We use test trace #2, kernel_vm, which has event contexts */
- private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.KERNEL_VM;
+ private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.KERNEL_VM;
private CtfTmfTrace fixture;
private long startTime;
/**
* Perform pre-class initialization.
- *
- * @throws TmfTraceException
- * If the test trace is not found
*/
@Before
- public void setUp() throws TmfTraceException {
- assumeTrue(testTrace.exists());
- fixture = new CtfTmfTrace();
- fixture.initTrace((IResource) null, testTrace.getPath(), CtfTmfEvent.class);
+ public void setUp() {
+ fixture = CtfTmfTestTraceUtils.getTrace(testTrace);
fixture.indexTrace(true);
startTime = fixture.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.internal.tmf.ctf.core.trace.iterator.CtfIterator;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.ctf.core.context.CtfLocation;
import org.eclipse.tracecompass.tmf.ctf.core.context.CtfLocationInfo;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.After;
import org.junit.Before;
*/
public class CtfIteratorTest {
- private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.KERNEL;
+ private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.KERNEL;
private CtfTmfTrace trace;
private CtfIterator iterator;
*/
@Before
public void setUp() {
- assumeTrue(testTrace.exists());
- trace = testTrace.getTrace();
+ trace = CtfTmfTestTraceUtils.getTrace(testTrace);
iterator = (CtfIterator) trace.createIterator();
CtfLocation ctfLocation = new CtfLocation(new CtfLocationInfo(1, 0));
iterator.setLocation(ctfLocation);
import java.io.PrintWriter;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
/**
// Attributes
// ------------------------------------------------------------------------
- private static CtfTmfTrace trace = CtfTmfTestTrace.KERNEL.getTrace();
+ private static CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.KERNEL);
private static ForegroundRequest lastForegroundRequest = null;
private static BackgroundRequest lastBackgroundRequest = null;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
-import org.eclipse.core.resources.IResource;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
-import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
-import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.After;
import org.junit.Before;
// Constants
// ------------------------------------------------------------------------
- private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.KERNEL;
+ private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.KERNEL;
private static final int NB_EVENTS_TRACE = 695319;
private static final int NB_EVENTS_TIME_RANGE = 155133;
/**
* Perform pre-test initialization.
- *
- * @throws TmfTraceException
- * If the test trace is not found
*/
@Before
- public void setUp() throws TmfTraceException {
- assumeTrue(testTrace.exists());
- fixture = new CtfTmfTrace();
- fixture.initTrace((IResource) null, testTrace.getPath(), CtfTmfEvent.class);
+ public void setUp() {
+ fixture = CtfTmfTestTraceUtils.getTrace(testTrace);
fixture.indexTrace(true);
fStartTime = fixture.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
fEndTime = fixture.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
package org.eclipse.tracecompass.tmf.ctf.core.tests.temp.statistics;
-import static org.junit.Assume.assumeTrue;
-
import org.eclipse.tracecompass.tmf.core.statistics.TmfEventsStatistics;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.junit.BeforeClass;
/**
*/
@BeforeClass
public static void setUpClass() {
- assumeTrue(testTrace.exists());
- backend = new TmfEventsStatistics(testTrace.getTrace());
+ backend = new TmfEventsStatistics(CtfTmfTestTraceUtils.getTrace(testTrace));
}
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.statistics.TmfStatisticsEventTypesModule;
import org.eclipse.tracecompass.tmf.core.statistics.TmfStatisticsTotalsModule;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.junit.After;
import org.junit.Before;
-import org.junit.BeforeClass;
/**
* Unit tests for the {@link TmfStateStatistics}
private TmfStatisticsTotalsModule fTotalsMod;
private TmfStatisticsEventTypesModule fEventTypesMod;
- /**
- * Class setup
- */
- @BeforeClass
- public static void setUpClass() {
- assumeTrue(testTrace.exists());
- }
-
/**
* Test setup
*/
@Before
public void setUp() {
- ITmfTrace trace = testTrace.getTrace();
+ ITmfTrace trace = CtfTmfTestTraceUtils.getTrace(testTrace);
fTrace = trace;
/* Prepare the two analysis-backed state systems */
import java.util.Map;
import java.util.concurrent.TimeUnit;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.statistics.ITmfStatistics;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestRule;
@Rule public TestRule globalTimeout= new Timeout(30, TimeUnit.SECONDS);
/** Test trace used for these tests */
- protected static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.KERNEL;
+ protected static final @NonNull CtfTestTrace testTrace = CtfTestTrace.KERNEL;
/** The statistics back-end object */
protected static ITmfStatistics backend;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
-import static org.junit.Assume.assumeTrue;
import java.io.File;
import java.util.Collection;
import java.util.concurrent.TimeUnit;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
-import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
-import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
+import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceContext;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
*/
@BeforeClass
public static void setUpClass() {
- assumeTrue(CtfTmfTestTrace.TRACE2.exists());
- assumeTrue(CtfTmfTestTrace.KERNEL.exists());
- trace1 = CtfTmfTestTrace.TRACE2.getTrace();
- trace2 = CtfTmfTestTrace.KERNEL.getTrace();
+ trace1 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.TRACE2);
+ trace2 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.KERNEL);
trace1.indexTrace(true);
trace2.indexTrace(true);
*/
@AfterClass
public static void tearDownClass() {
- CtfTmfTestTrace.TRACE2.dispose();
- CtfTmfTestTrace.KERNEL.dispose();
+ CtfTmfTestTraceUtils.dispose(CtfTestTrace.TRACE2);
+ CtfTmfTestTraceUtils.dispose(CtfTestTrace.KERNEL);
}
// ------------------------------------------------------------------------
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
import java.util.Arrays;
import java.util.HashSet;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IStatus;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventType;
-import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.signal.TmfEndSynchSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.ctf.core.context.CtfLocation;
import org.eclipse.tracecompass.tmf.ctf.core.context.CtfLocationInfo;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.After;
import org.junit.Before;
*/
public class CtfTmfTraceTest {
- private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.KERNEL;
+ private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.KERNEL;
private CtfTmfTrace fixture;
/**
* Perform pre-test initialization.
- *
- * @throws TmfTraceException
- * If the test trace is not found
*/
@Before
- public void setUp() throws TmfTraceException {
- assumeTrue(testTrace.exists());
- fixture = new CtfTmfTrace();
- fixture.initTrace((IResource) null, testTrace.getPath(), CtfTmfEvent.class);
+ public void setUp() {
+ fixture = CtfTmfTestTraceUtils.getTrace(testTrace);
}
/**
@Test
public void testValidate() {
IProject project = null;
- IStatus result = fixture.validate(project, testTrace.getPath());
+ IStatus result = fixture.validate(project, fixture.getPath());
assertTrue(result.isOK());
}
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assume.assumeTrue;
import java.util.concurrent.TimeUnit;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.ctf.core.CtfEnumPair;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.After;
import org.junit.Before;
// Attributes
// ------------------------------------------------------------------------
- private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.FUNKY_TRACE;
+ private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.FUNKY_TRACE;
private static final double DELTA = 0.0000001;
private CtfTmfTrace fTrace;
*/
@Before
public void setup() {
- assumeTrue(testTrace.exists());
- fTrace = testTrace.getTrace();
+ fTrace = CtfTmfTestTraceUtils.getTrace(testTrace);
fTrace.indexTrace(true);
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
import java.io.File;
-import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.indexer.TmfBTreeTraceIndexer;
import org.eclipse.tracecompass.tmf.core.trace.indexer.checkpoint.ITmfCheckpoint;
import org.eclipse.tracecompass.tmf.core.trace.indexer.checkpoint.ITmfCheckpointIndex;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.junit.After;
import org.junit.Before;
-import org.junit.BeforeClass;
import org.junit.Test;
/**
public class CtfExperimentCheckpointIndexTest {
private static final String EXPERIMENT = "MyExperiment";
- private static final CtfTmfTestTrace TEST_TRACE1 = CtfTmfTestTrace.TRACE2;
- private static final CtfTmfTestTrace TEST_TRACE2 = CtfTmfTestTrace.KERNEL_VM;
+ private static final @NonNull CtfTestTrace TEST_TRACE1 = CtfTestTrace.TRACE2;
+ private static final @NonNull CtfTestTrace TEST_TRACE2 = CtfTestTrace.KERNEL_VM;
private static final int NB_EVENTS = CtfTestTrace.TRACE2.getNbEvents() + CtfTestTrace.KERNEL_VM.getNbEvents();
private static final long START_TIME = 1331668247314038062L;
private static TmfExperiment fExperiment;
private static TestIndexer fIndexer;
- /**
- * Setup the test class
- */
- @BeforeClass
- public static void setUpClass() {
- assumeTrue(TEST_TRACE1.exists());
- assumeTrue(TEST_TRACE2.exists());
- }
-
/**
* Setup the test
*/
private static void setUpTraces() {
fTestTraces = new ITmfTrace[2];
- fTestTraces[0] = TEST_TRACE1.getTrace();
- fTestTraces[1] = TEST_TRACE2.getTrace();
+ fTestTraces[0] = CtfTmfTestTraceUtils.getTrace(TEST_TRACE1);
+ fTestTraces[1] = CtfTmfTestTraceUtils.getTrace(TEST_TRACE2);
fExperiment = new TmfExperiment(ITmfEvent.class, EXPERIMENT, fTestTraces, BLOCK_SIZE, null) {
@Override
protected ITmfTraceIndexer createIndexer(int interval) {
org.eclipse.swtbot.swt.finder.results,
org.eclipse.swtbot.swt.finder.utils,
org.eclipse.swtbot.swt.finder.waits,
- org.eclipse.swtbot.swt.finder.widgets
+ org.eclipse.swtbot.swt.finder.widgets,
+ org.eclipse.tracecompass.testtraces.ctf;version="1.0.0"
package org.eclipse.tracecompass.tmf.ctf.ui.swtbot.tests;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assume.assumeTrue;
import java.util.List;
import org.apache.log4j.Logger;
import org.apache.log4j.varia.NullAppender;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
import org.eclipse.tracecompass.internal.tmf.ui.views.statistics.TmfStatisticsViewImpl;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.eclipse.tracecompass.tmf.ui.editors.TmfEventsEditor;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
/** Trace type name for generic CTF traces */
protected static final String TRACE_TYPE_NAME = "Generic CTF Trace";
/** A Generic CTF Trace */
- protected static final CtfTmfTestTrace fTrace = CtfTmfTestTrace.SYNC_DEST;
+ protected static final @NonNull CtfTestTrace fTrace = CtfTestTrace.SYNC_DEST;
/** SWT BOT workbench reference */
protected static SWTWorkbenchBot fBot;
/** Wizard to use */
/** Test Class setup */
@BeforeClass
public static void init() {
- assumeTrue(fTrace.exists());
SWTBotUtils.failIfUIThread();
/* set up for swtbot */
* @return the event at given rank
*/
protected CtfTmfEvent getEvent(int rank) {
- CtfTmfTrace trace = fTrace.getTrace();
+ CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(fTrace);
ITmfContext ctx = trace.seekEvent(rank);
CtfTmfEvent ret = trace.getNext(ctx);
ctx.dispose();
@RunWith(SWTBotJunit4ClassRunner.class)
public class StandardImportAndReadSmokeTest extends AbstractImportAndReadSmokeTest {
- private static final String TRACE_FOLDER_PARENT_PATH = fTrace.getPath() + File.separator + ".." + File.separator + ".." + File.separator;
+ private static final String TRACE_FOLDER_PARENT_PATH = "../../ctf/org.eclipse.tracecompass.ctf.core.tests/traces/";
private static final String ARCHIVE_FILE_NAME = "synctraces.tar.gz";
private static final String EMPTY_ARCHIVE_FOLDER = "emptyArchiveFolder";
private static final String EMPTY_FILE_NAME = "emptyFile";
org.eclipse.tracecompass.lttng2.kernel.core.tests.perf.analysis;x-internal:=true,
org.eclipse.tracecompass.lttng2.lttng.kernel.core.tests.shared.vm
Import-Package: com.google.common.collect,
- org.eclipse.test.performance
+ org.eclipse.test.performance,
+ org.eclipse.tracecompass.testtraces.ctf;version="1.0.0"
package org.eclipse.tracecompass.lttng2.kernel.core.tests.perf.analysis;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.io.File;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.test.performance.Dimension;
import org.eclipse.test.performance.Performance;
import org.eclipse.test.performance.PerformanceMeter;
import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.KernelAnalysisModule;
import org.eclipse.tracecompass.lttng2.kernel.core.trace.LttngKernelTrace;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestHelper;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.junit.Test;
/**
*/
@Test
public void testTrace2() {
- runTest(CtfTmfTestTrace.TRACE2, "Trace2");
+ runTest(CtfTestTrace.TRACE2, "Trace2");
}
- private static void runTest(CtfTmfTestTrace testTrace, String testName) {
- assumeTrue(testTrace.exists());
-
+ private static void runTest(@NonNull CtfTestTrace testTrace, String testName) {
Performance perf = Performance.getDefault();
PerformanceMeter pm = perf.createPerformanceMeter(TEST_ID + '#' + testName);
perf.tagAsSummary(pm, "LTTng Kernel Analysis: " + testName, Dimension.CPU_TIME);
- if (testTrace == CtfTmfTestTrace.TRACE2) {
+ if (testTrace == CtfTestTrace.TRACE2) {
/* Do not show all traces in the global summary */
perf.tagAsGlobalSummary(pm, "LTTng Kernel Analysis: " + testName, Dimension.CPU_TIME);
}
for (int i = 0; i < LOOP_COUNT; i++) {
LttngKernelTrace trace = null;
IAnalysisModule module = null;
+ // TODO Allow the utility method to instantiate trace sub-types
+ // directly.
+ String path = CtfTmfTestTraceUtils.getTrace(testTrace).getPath();
+
try {
trace = new LttngKernelTrace();
module = new KernelAnalysisModule();
module.setId("test");
- trace.initTrace(null, testTrace.getPath(), CtfTmfEvent.class);
+ trace.initTrace(null, path, CtfTmfEvent.class);
module.setTrace(trace);
pm.start();
}
}
pm.commit();
- testTrace.dispose();
+ CtfTmfTestTraceUtils.dispose(testTrace);
}
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
+import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.test.performance.Dimension;
import org.eclipse.test.performance.Performance;
import org.eclipse.test.performance.PerformanceMeter;
import org.eclipse.tracecompass.lttng2.kernel.core.trace.LttngKernelTrace;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.statistics.ITmfStatistics;
import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestHelper;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
+import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.BeforeClass;
import org.junit.Test;
*
* @author Alexis Cabana-Loriaux
*/
+@NonNullByDefault
public class StatisticsAnalysisBenchmark {
private static final String TEST_ID = "org.eclipse.linuxtools#Statistics analysis";
*/
@Test
public void testDjangoClient() {
- runTest(CtfTmfTestTrace.DJANGO_CLIENT, "Django-client trace", fDjangoClientEntriesToTest);
+ runTest(CtfTestTrace.DJANGO_CLIENT, "Django-client trace", fDjangoClientEntriesToTest);
}
/**
*/
@Test
public void testDjangoHttpd() {
- runTest(CtfTmfTestTrace.DJANGO_HTTPD, "Django-Httpd trace", fDjangoHttpdEntriesToTest);
+ runTest(CtfTestTrace.DJANGO_HTTPD, "Django-Httpd trace", fDjangoHttpdEntriesToTest);
}
- private static void runTest(CtfTmfTestTrace testTrace, String testName, Map<String, Long> testCases) {
- assumeTrue(testTrace.exists());
-
+ private static void runTest(CtfTestTrace testTrace, String testName, Map<String, Long> testCases) {
Performance perf = Performance.getDefault();
PerformanceMeter pm = perf.createPerformanceMeter(TEST_ID + '#' + testName);
perf.tagAsSummary(pm, "Statistics Analysis: " + testName, Dimension.CPU_TIME);
- if (testTrace == CtfTmfTestTrace.DJANGO_CLIENT || testTrace == CtfTmfTestTrace.DJANGO_HTTPD) {
+ if (testTrace == CtfTestTrace.DJANGO_CLIENT || testTrace == CtfTestTrace.DJANGO_HTTPD) {
/* Do not show all traces in the global summary */
perf.tagAsGlobalSummary(pm, "Statistics Analysis: " + testName, Dimension.CPU_TIME);
}
trace = new LttngKernelTrace();
module = new TmfStatisticsModule();
module.setId("test");
- trace.initTrace(null, testTrace.getPath(), CtfTmfEvent.class);
+
+ // TODO Allow the utility method to return a LttngKernelTrace directly
+ CtfTmfTrace ctfTmfTrace = CtfTmfTestTraceUtils.getTrace(testTrace);
+ trace.initTrace(null, ctfTmfTrace.getPath(), CtfTmfEvent.class);
module.setTrace(trace);
pm.start();
}
}
pm.commit();
- testTrace.dispose();
+ CtfTmfTestTraceUtils.dispose(testTrace);
}
}
package org.eclipse.tracecompass.lttng2.kernel.core.tests.perf.event.matching;
-import static org.junit.Assume.assumeTrue;
-
import java.util.Set;
import org.eclipse.test.performance.Dimension;
import org.eclipse.test.performance.PerformanceMeter;
import org.eclipse.tracecompass.internal.lttng2.kernel.core.event.matching.TcpEventMatching;
import org.eclipse.tracecompass.internal.lttng2.kernel.core.event.matching.TcpLttngEventMatching;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.matching.TmfEventMatching;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.BeforeClass;
import org.junit.Test;
*/
@Test
public void testSmallTraces() {
- assumeTrue(CtfTmfTestTrace.SYNC_SRC.exists());
- assumeTrue(CtfTmfTestTrace.SYNC_DEST.exists());
-
- CtfTmfTrace trace1 = CtfTmfTestTrace.SYNC_SRC.getTrace();
- CtfTmfTrace trace2 = CtfTmfTestTrace.SYNC_DEST.getTrace();
+ CtfTmfTrace trace1 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.SYNC_SRC);
+ CtfTmfTrace trace2 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.SYNC_DEST);
Set<ITmfTrace> traces = ImmutableSet.of((ITmfTrace) trace1, trace2);
runCpuTest(traces, "Match TCP events", 100);
*/
@Test
public void testDjangoTraces() {
- assumeTrue(CtfTmfTestTrace.DJANGO_CLIENT.exists());
- assumeTrue(CtfTmfTestTrace.DJANGO_DB.exists());
- assumeTrue(CtfTmfTestTrace.DJANGO_HTTPD.exists());
-
- CtfTmfTrace trace1 = CtfTmfTestTrace.DJANGO_CLIENT.getTrace();
- CtfTmfTrace trace2 = CtfTmfTestTrace.DJANGO_DB.getTrace();
- CtfTmfTrace trace3 = CtfTmfTestTrace.DJANGO_HTTPD.getTrace();
+ CtfTmfTrace trace1 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.DJANGO_CLIENT);
+ CtfTmfTrace trace2 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.DJANGO_DB);
+ CtfTmfTrace trace3 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.DJANGO_HTTPD);
Set<ITmfTrace> traces = ImmutableSet.of((ITmfTrace) trace1, trace2, trace3);
runCpuTest(traces, "Django traces", 10);
package org.eclipse.tracecompass.lttng2.kernel.core.tests.perf.event.matching;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assume.assumeTrue;
import java.util.Collections;
import org.eclipse.test.performance.PerformanceMeter;
import org.eclipse.tracecompass.internal.lttng2.kernel.core.event.matching.TcpEventMatching;
import org.eclipse.tracecompass.internal.lttng2.kernel.core.event.matching.TcpLttngEventMatching;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.matching.TmfEventMatching;
import org.eclipse.tracecompass.tmf.core.synchronization.SynchronizationAlgorithm;
import org.eclipse.tracecompass.tmf.core.synchronization.SynchronizationManager;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.BeforeClass;
import org.junit.Test;
*/
@Test
public void testSmallTraces() {
- assumeTrue(CtfTmfTestTrace.SYNC_SRC.exists());
- assumeTrue(CtfTmfTestTrace.SYNC_DEST.exists());
- CtfTmfTrace trace1 = CtfTmfTestTrace.SYNC_SRC.getTrace();
- CtfTmfTrace trace2 = CtfTmfTestTrace.SYNC_DEST.getTrace();
+ CtfTmfTrace trace1 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.SYNC_SRC);
+ CtfTmfTrace trace2 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.SYNC_DEST);
ITmfTrace[] traces = { trace1, trace2 };
TmfExperiment experiment = new TmfExperiment(CtfTmfEvent.class, "Test experiment", traces, TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, null);
*/
@Test
public void testDjangoTraces() {
- assumeTrue(CtfTmfTestTrace.DJANGO_CLIENT.exists());
- assumeTrue(CtfTmfTestTrace.DJANGO_DB.exists());
- assumeTrue(CtfTmfTestTrace.DJANGO_HTTPD.exists());
-
- CtfTmfTrace trace1 = CtfTmfTestTrace.DJANGO_CLIENT.getTrace();
- CtfTmfTrace trace2 = CtfTmfTestTrace.DJANGO_DB.getTrace();
- CtfTmfTrace trace3 = CtfTmfTestTrace.DJANGO_HTTPD.getTrace();
+ CtfTmfTrace trace1 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.DJANGO_CLIENT);
+ CtfTmfTrace trace2 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.DJANGO_DB);
+ CtfTmfTrace trace3 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.DJANGO_HTTPD);
ITmfTrace[] traces = { trace1, trace2, trace3 };
TmfExperiment experiment = new TmfExperiment(CtfTmfEvent.class, "Test experiment", traces, TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, null);
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.util.List;
import java.util.Set;
import org.eclipse.tracecompass.lttng2.control.core.session.SessionConfigStrings;
import org.eclipse.tracecompass.lttng2.kernel.core.trace.LttngKernelTrace;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestHelper;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.After;
import org.junit.Before;
-import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
private LttngKernelTrace fTrace;
private KernelAnalysisModule fKernelAnalysisModule;
- /**
- * Class setup
- */
- @BeforeClass
- public static void setUpClass() {
- assumeTrue(CtfTmfTestTrace.KERNEL.exists());
- }
-
/**
* Set-up the test
*/
@Before
public void setUp() {
fKernelAnalysisModule = new KernelAnalysisModule();
+ // Rework the utils to allow creating a sub-type directly.
+ String path = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.KERNEL).getPath();
+
fTrace = new LttngKernelTrace();
try {
- fTrace.initTrace(null, CtfTmfTestTrace.KERNEL.getPath(), CtfTmfEvent.class);
+ fTrace.initTrace(null, path, CtfTmfEvent.class);
} catch (TmfTraceException e) {
/* Should not happen if tracesExist() passed */
throw new RuntimeException(e);
assertTrue(fKernelAnalysisModule.canExecute(fTrace));
/* Test with a CTF trace that does not have required events */
- assumeTrue(CtfTmfTestTrace.CYG_PROFILE.exists());
- CtfTmfTrace trace = CtfTmfTestTrace.CYG_PROFILE.getTrace();
+ CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.CYG_PROFILE);
/*
* TODO: This should be false, but for now there is no mandatory events
* in the kernel analysis so it will return true.
import java.io.PrintWriter;
import java.util.List;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.KernelAnalysisModule;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
/**
*/
public class GenerateTestValues {
- private static CtfTmfTestTrace testTrace = CtfTmfTestTrace.TRACE2;
+ private static @NonNull CtfTestTrace testTrace = CtfTestTrace.TRACE2;
private static final long targetTimestamp = 18670067372290L + 1331649577946812237L;
private static final String INDENT = " ";
* I'm messing with Exception. Come at me bro!
*/
public static void main(String[] args) throws Exception {
- if (!testTrace.exists()) {
- System.err.println("Trace files not present.");
- return;
- }
-
/* Prepare the files */
File logFile = File.createTempFile("TestValues", ".java");
try (PrintWriter writer = new PrintWriter(new FileWriter(logFile), true);) {
/* Build and query the state system */
- final CtfTmfTrace trace = testTrace.getTrace();
+ final CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(testTrace);
TmfStateSystemAnalysisModule module = new KernelAnalysisModule() {
@Override
protected String getSsFileName() {
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.AfterClass;
import org.junit.BeforeClass;
private static final @NonNull String TEST_FILE_NAME = "test-partial";
+ private static CtfTmfTrace trace;
private static File stateFile;
private static TestLttngKernelAnalysisModule module;
*/
@BeforeClass
public static void initialize() {
- if (!testTrace.exists()) {
- traceIsPresent = false;
- return;
- }
- traceIsPresent = true;
+ trace = CtfTmfTestTraceUtils.getTrace(testTrace);
- stateFile = new File(TmfTraceManager.getSupplementaryFileDir(testTrace.getTrace()) + TEST_FILE_NAME);
+ stateFile = new File(TmfTraceManager.getSupplementaryFileDir(trace) + TEST_FILE_NAME);
if (stateFile.exists()) {
stateFile.delete();
}
module = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
try {
- assertTrue(module.setTrace(testTrace.getTrace()));
+ assertTrue(module.setTrace(trace));
} catch (TmfAnalysisException e) {
fail();
}
if (fixture != null) {
fixture.dispose();
}
+ if (trace != null) {
+ trace.dispose();
+ }
module = null;
fixture = null;
+ trace = null;
}
/**
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.AfterClass;
import org.junit.BeforeClass;
private static final @NonNull String TEST_FILE_NAME = "test.ht";
private static final @NonNull String BENCHMARK_FILE_NAME = "test.benchmark.ht";
+ private static CtfTmfTrace trace;
private static File stateFile;
private static File stateFileBenchmark;
private static TestLttngKernelAnalysisModule module;
*/
@BeforeClass
public static void initialize() {
- if (!testTrace.exists()) {
- traceIsPresent = false;
- return;
- }
- traceIsPresent = true;
+ trace = CtfTmfTestTraceUtils.getTrace(testTrace);
stateFile = createStateFile(TEST_FILE_NAME);
stateFileBenchmark = createStateFile(BENCHMARK_FILE_NAME);
module = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
try {
- assertTrue(module.setTrace(testTrace.getTrace()));
+ assertTrue(module.setTrace(trace));
} catch (TmfAnalysisException e) {
fail();
}
if (fixture != null) {
fixture.dispose();
}
+ if (trace != null) {
+ trace.dispose();
+ }
module = null;
fixture = null;
+ trace = null;
}
// ------------------------------------------------------------------------
public void testBuild() {
TestLttngKernelAnalysisModule module2 = new TestLttngKernelAnalysisModule(BENCHMARK_FILE_NAME);
try {
- assertTrue(module2.setTrace(testTrace.getTrace()));
+ assertTrue(module2.setTrace(trace));
} catch (TmfAnalysisException e) {
module2.dispose();
fail();
/* 'newStateFile' should have already been created */
TestLttngKernelAnalysisModule module2 = new TestLttngKernelAnalysisModule(TEST_FILE_NAME);
try {
- assertTrue(module2.setTrace(testTrace.getTrace()));
+ assertTrue(module2.setTrace(trace));
} catch (TmfAnalysisException e) {
module2.dispose();
fail();
}
private static File createStateFile(String name) {
- File file = new File(TmfTraceManager.getSupplementaryFileDir(testTrace.getTrace()) + name);
+ File file = new File(TmfTraceManager.getSupplementaryFileDir(trace) + name);
if (file.exists()) {
file.delete();
}
import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.KernelAnalysisModule;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.AfterClass;
import org.junit.BeforeClass;
*/
public class StateSystemInMemoryTest extends StateSystemTest {
+ private static CtfTmfTrace trace;
private static TestLttngKernelAnalysisModule module;
/**
*/
@BeforeClass
public static void initialize() {
- if (!testTrace.exists()) {
- traceIsPresent = false;
- return;
- }
- traceIsPresent = true;
+ CtfTmfTrace thetrace = CtfTmfTestTraceUtils.getTrace(testTrace);
+ trace = thetrace;
module = new TestLttngKernelAnalysisModule();
try {
- assertTrue(module.setTrace(testTrace.getTrace()));
+ assertTrue(module.setTrace(thetrace));
} catch (TmfAnalysisException e) {
fail();
}
if (fixture != null) {
fixture.dispose();
}
+ if (trace != null) {
+ trace.dispose();
+ }
module = null;
fixture = null;
+ trace = null;
}
private static class TestLttngKernelAnalysisModule extends KernelAnalysisModule {
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.util.List;
import java.util.concurrent.TimeUnit;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.Attributes;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
import org.eclipse.tracecompass.statesystem.core.StateSystemUtils;
import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
public TestRule timeoutRule = new Timeout(2, TimeUnit.MINUTES);
/** Test trace used for these tests */
- protected static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.TRACE2;
+ protected static final @NonNull CtfTestTrace testTrace = CtfTestTrace.TRACE2;
/** Expected start time of the test trace/state history */
protected static final long startTime = 1331668247314038062L;
private static final long NANOSECS_PER_SEC = 1000000000L;
protected static ITmfStateSystem fixture;
- protected static boolean traceIsPresent = false;
/**
* Test set-up
*/
@Before
public void setUp() {
- assumeTrue(traceIsPresent);
/* Subclasses should set-up 'fixture' */
assertNotNull(fixture);
}
package org.eclipse.tracecompass.lttng2.kernel.core.tests.event.matchandsync;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assume.assumeTrue;
import java.util.concurrent.TimeUnit;
import org.eclipse.tracecompass.internal.lttng2.kernel.core.event.matching.TcpEventMatching;
import org.eclipse.tracecompass.internal.lttng2.kernel.core.event.matching.TcpLttngEventMatching;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.matching.TmfEventMatching;
import org.eclipse.tracecompass.tmf.core.synchronization.ITmfTimestampTransform;
import org.eclipse.tracecompass.tmf.core.synchronization.SynchronizationAlgorithm;
import org.eclipse.tracecompass.tmf.core.synchronization.TimestampTransformFactory;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.BeforeClass;
import org.junit.Rule;
*/
@Test
public void testExperimentSync() {
- assumeTrue(CtfTmfTestTrace.SYNC_SRC.exists());
- assumeTrue(CtfTmfTestTrace.SYNC_DEST.exists());
- CtfTmfTrace trace1 = CtfTmfTestTrace.SYNC_SRC.getTrace();
- CtfTmfTrace trace2 = CtfTmfTestTrace.SYNC_DEST.getTrace();
+ CtfTmfTrace trace1 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.SYNC_SRC);
+ CtfTmfTrace trace2 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.SYNC_DEST);
ITmfTrace[] traces = { trace1, trace2 };
TmfExperiment experiment = new TmfExperiment(traces[0].getEventType(), EXPERIMENT, traces, BLOCK_SIZE, null);
*/
@Test
public void testDjangoExperimentSync() {
- assumeTrue(CtfTmfTestTrace.DJANGO_CLIENT.exists());
- assumeTrue(CtfTmfTestTrace.DJANGO_DB.exists());
- assumeTrue(CtfTmfTestTrace.DJANGO_HTTPD.exists());
-
- CtfTmfTrace trace1 = CtfTmfTestTrace.DJANGO_CLIENT.getTrace();
- CtfTmfTrace trace2 = CtfTmfTestTrace.DJANGO_DB.getTrace();
- CtfTmfTrace trace3 = CtfTmfTestTrace.DJANGO_HTTPD.getTrace();
+ CtfTmfTrace trace1 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.DJANGO_CLIENT);
+ CtfTmfTrace trace2 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.DJANGO_DB);
+ CtfTmfTrace trace3 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.DJANGO_HTTPD);
ITmfTrace[] traces = { trace1, trace2, trace3 };
TmfExperiment experiment = new TmfExperiment(traces[0].getEventType(), EXPERIMENT, traces, BLOCK_SIZE, null);
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.eclipse.tracecompass.internal.lttng2.kernel.core.event.matching.TcpEventMatching;
import org.eclipse.tracecompass.internal.lttng2.kernel.core.event.matching.TcpLttngEventMatching;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.event.matching.IMatchProcessingUnit;
import org.eclipse.tracecompass.tmf.core.event.matching.TmfEventMatching;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.Test;
*/
@Test
public void testMatching() {
- assumeTrue(CtfTmfTestTrace.SYNC_SRC.exists());
- assumeTrue(CtfTmfTestTrace.SYNC_DEST.exists());
- CtfTmfTrace trace1 = CtfTmfTestTrace.SYNC_SRC.getTrace();
- CtfTmfTrace trace2 = CtfTmfTestTrace.SYNC_DEST.getTrace();
+ CtfTmfTrace trace1 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.SYNC_SRC);
+ CtfTmfTrace trace2 = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.SYNC_DEST);
List<ITmfTrace> tracearr = new LinkedList<>();
tracearr.add(trace1);
org.eclipse.tracecompass.tmf.core.tests,
org.eclipse.tracecompass.tmf.ctf.core,
org.eclipse.tracecompass.tmf.ctf.core.tests,
+ org.eclipse.tracecompass.ctf.core.tests,
org.eclipse.tracecompass.tmf.ui,
org.eclipse.tracecompass.tmf.ui.swtbot.tests,
org.eclipse.swtbot.eclipse.finder,
org.eclipse.ui.ide,
org.eclipse.ui.views,
org.junit
+Import-Package: org.eclipse.tracecompass.testtraces.ctf
import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.eclipse.tracecompass.tmf.ui.editors.TmfEventsEditor;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
@RunWith(SWTBotJunit4ClassRunner.class)
public class ImportAndReadKernelSmokeTest extends KernelTest {
- private static final CtfTmfTestTrace CTT = CtfTmfTestTrace.SYNTHETIC_TRACE;
-
private ITmfEvent fDesired1;
private ITmfEvent fDesired2;
*/
@Test
public void test() {
- Matcher<IEditorReference> matcher = WidgetMatcherFactory.withPartName(CTT.getTrace().getName());
+ CtfTmfTrace trace = CtfTmfTestTraceUtils.getSyntheticTrace();
+ Matcher<IEditorReference> matcher = WidgetMatcherFactory.withPartName(trace.getName());
IEditorPart iep = fBot.editor(matcher).getReference().getEditor(true);
final TmfEventsEditor tmfEd = (TmfEventsEditor) iep;
- CtfTmfTrace trace = CtfTmfTestTrace.SYNTHETIC_TRACE.getTrace();
+
fDesired1 = getEvent(trace, 100);
fDesired2 = getEvent(trace, 10000);
import org.eclipse.swtbot.swt.finder.junit.SWTBotJunit4ClassRunner;
import org.eclipse.swtbot.swt.finder.results.BoolResult;
import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.ctf.core.tests.shared.LttngKernelTraceGenerator;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
import org.eclipse.ui.PlatformUI;
private static final String TRACE_TYPE = "org.eclipse.linuxtools.lttng2.kernel.tracetype";
private static final String KERNEL_PERSPECTIVE_ID = "org.eclipse.linuxtools.lttng2.kernel.ui.perspective";
private static final String TRACE_PROJECT_NAME = "test";
- private static final CtfTmfTestTrace CTT = CtfTmfTestTrace.SYNTHETIC_TRACE;
/** The workbench bot */
protected static SWTWorkbenchBot fBot;
switchKernelPerspective();
/* Finish waiting for eclipse to load */
SWTBotUtils.waitForJobs();
- SWTBotUtils.createProject(TRACE_PROJECT_NAME);
}
/**
*/
@AfterClass
public static void afterClass() {
- SWTBotUtils.deleteProject(TRACE_PROJECT_NAME, fBot);
fLogger.removeAllAppenders();
}
*/
@Before
public void before() {
- SWTBotUtils.openTrace(TRACE_PROJECT_NAME, CTT.getPath(), TRACE_TYPE);
- SWTBotUtils.activateEditor(fBot, CTT.getTrace().getName());
+ SWTBotUtils.createProject(TRACE_PROJECT_NAME);
+ SWTBotUtils.openTrace(TRACE_PROJECT_NAME, LttngKernelTraceGenerator.getPath(), TRACE_TYPE);
+ SWTBotUtils.activateEditor(fBot, LttngKernelTraceGenerator.getName());
}
/**
@After
public void after() {
fBot.closeAllEditors();
+ SWTBotUtils.deleteProject(TRACE_PROJECT_NAME, fBot);
}
}
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
import org.eclipse.swtbot.swt.finder.junit.SWTBotJunit4ClassRunner;
import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.analysis.Messages;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
import org.junit.BeforeClass;
import org.junit.Test;
private static final String TRACE_TYPE = "org.eclipse.linuxtools.lttng2.kernel.tracetype";
private static final String KERNEL_PERSPECTIVE_ID = "org.eclipse.linuxtools.lttng2.kernel.ui.perspective";
- private static final CtfTmfTestTrace CTF_TRACE = CtfTmfTestTrace.SYNC_DEST;
+ private static final @NonNull CtfTestTrace CTF_TRACE = CtfTestTrace.SYNC_DEST;
private static final String TRACE_PROJECT_NAME = "test";
private static SWTWorkbenchBot workbenchbot;
public void testOpenAndCloseConcurrency() {
SWTBotUtils.createProject(TRACE_PROJECT_NAME);
- File fTestFile = new File(CTF_TRACE.getPath());
+ File fTestFile = new File(CtfTmfTestTraceUtils.getTrace(CTF_TRACE).getPath());
String path = fTestFile.getAbsolutePath();
org.eclipse.tracecompass.lttng2.control.core
Export-Package: org.eclipse.tracecompass.lttng2.ust.core.tests,
org.eclipse.tracecompass.lttng2.ust.core.tests.callstack
-Import-Package: com.google.common.collect
+Import-Package: com.google.common.collect,
+ org.eclipse.tracecompass.testtraces.ctf;version="1.0.0"
import java.util.List;
import java.util.concurrent.TimeUnit;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.internal.lttng2.ust.core.callstack.LttngUstCallStackProvider;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
import org.eclipse.tracecompass.statesystem.core.StateSystemUtils;
import org.eclipse.tracecompass.statesystem.core.exceptions.StateSystemDisposedException;
import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfStateProvider;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.After;
import org.junit.Before;
// Attributes
// ------------------------------------------------------------------------
- private static final CtfTmfTestTrace otherUstTrace = CtfTmfTestTrace.HELLO_LOST;
+ private static final @NonNull CtfTestTrace otherUstTrace = CtfTestTrace.HELLO_LOST;
private CtfTmfTrace fTrace = null;
private ITmfStateSystem fSS = null;
/**
* @return The test trace to use for this test
*/
- protected abstract CtfTmfTestTrace getTestTrace();
+ protected abstract @NonNull CtfTestTrace getTestTrace();
/**
* @return The name of the executable process in that particular trace
*/
@Before
public void setUp() {
- CtfTmfTestTrace testTrace = getTestTrace();
+ CtfTestTrace testTrace = getTestTrace();
- CtfTmfTrace trace = testTrace.getTrace();
+ CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(testTrace);
fTrace = trace;
fModule = new TestLttngCallStackModule();
try {
public void testOtherUstTrace() {
/* Initialize the trace and analysis module */
File suppDir;
- CtfTmfTrace ustTrace = otherUstTrace.getTrace();
+ CtfTmfTrace ustTrace = CtfTmfTestTraceUtils.getTrace(otherUstTrace);
TestLttngCallStackModule module = null;
try {
module = new TestLttngCallStackModule();
package org.eclipse.tracecompass.lttng2.ust.core.tests.callstack;
-import static org.junit.Assume.assumeTrue;
-
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
-import org.junit.BeforeClass;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
/**
* Test suite for the UST callstack state provider, using the trace of a program
1379361250498400000L,
1379361250499759000L };
- /**
- * Class setup
- */
- @BeforeClass
- public static void setUpClass() {
- assumeTrue(CtfTmfTestTrace.CYG_PROFILE_FAST.exists());
- }
-
@Override
- protected CtfTmfTestTrace getTestTrace() {
- return CtfTmfTestTrace.CYG_PROFILE_FAST;
+ protected CtfTestTrace getTestTrace() {
+ return CtfTestTrace.CYG_PROFILE_FAST;
}
@Override
package org.eclipse.tracecompass.lttng2.ust.core.tests.callstack;
-import static org.junit.Assume.assumeTrue;
-
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
-import org.junit.BeforeClass;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
/**
* Test suite for the UST callstack state provider, using the trace of a program
1378850463770000000L,
1378850463868753000L };
- /**
- * Class setup
- */
- @BeforeClass
- public static void setUpClass() {
- assumeTrue(CtfTmfTestTrace.CYG_PROFILE.exists());
- }
-
@Override
- protected CtfTmfTestTrace getTestTrace() {
- return CtfTmfTestTrace.CYG_PROFILE;
+ protected CtfTestTrace getTestTrace() {
+ return CtfTestTrace.CYG_PROFILE;
}
@Override
org.eclipse.tracecompass.lttng2.ust.core,
org.eclipse.tracecompass.lttng2.ust.ui
Export-Package: org.eclipse.tracecompass.lttng2.ust.ui.swtbot.tests
-Import-Package: com.google.common.collect
+Import-Package: com.google.common.collect,
+ org.eclipse.tracecompass.testtraces.ctf;version="1.0.0"
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assume.assumeTrue;
import java.io.File;
import java.util.ArrayList;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
import org.eclipse.tracecompass.tmf.ui.views.callstack.CallStackView;
SWTBotUtils.createProject(PROJECT_NAME);
SWTBotTreeItem treeItem = SWTBotUtils.selectTracesFolder(fBot, PROJECT_NAME);
assertNotNull(treeItem);
- final CtfTmfTestTrace cygProfile = CtfTmfTestTrace.CYG_PROFILE;
- assumeTrue(cygProfile.exists());
- final File file = new File(cygProfile.getTrace().getPath());
+ final CtfTestTrace cygProfile = CtfTestTrace.CYG_PROFILE;
+ final File file = new File(CtfTmfTestTraceUtils.getTrace(cygProfile).getPath());
SWTBotUtils.openTrace(PROJECT_NAME, file.getAbsolutePath(), UST_ID);
SWTBotUtils.openView(CallStackView.ID);
SWTBotUtils.waitForJobs();
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<?pde version="3.8"?><target name="tracecompass-e4.5" sequenceNumber="55">
+<?pde version="3.8"?><target name="tracecompass-e4.5" sequenceNumber="56">
<locations>
<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
<unit id="org.eclipse.cdt.gnu.dsf.feature.group" version="0.0.0"/>
<unit id="org.eclipse.ui.views.log" version="0.0.0"/>
<repository location="http://download.eclipse.org/eclipse/updates/4.5/"/>
</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.tracecompass.testtraces.tracecompass-test-traces-ctf" version="1.0.0"/>
+<repository location="http://archive.eclipse.org/tracecompass/tracecompass-test-traces/repository/"/>
+</location>
</locations>
<targetJRE path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<launcherArgs>
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<?pde version="3.8"?><target name="tracecompass-eStaging" sequenceNumber="48">
+<?pde version="3.8"?><target name="tracecompass-eStaging" sequenceNumber="49">
<locations>
<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
<unit id="org.eclipse.cdt.gnu.dsf.feature.group" version="0.0.0"/>
<unit id="org.eclipse.jdt.annotation" version="1.1.100.v20140704-0625"/>
<repository location="http://download.eclipse.org/eclipse/updates/4.5/"/>
</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.tracecompass.testtraces.tracecompass-test-traces-ctf" version="1.0.0"/>
+<repository location="http://archive.eclipse.org/tracecompass/tracecompass-test-traces/repository/"/>
+</location>
</locations>
<targetJRE path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<launcherArgs>
org.eclipse.tracecompass.statesystem.core
Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Bundle-ActivationPolicy: lazy
-Import-Package: org.junit.runners
+Import-Package: org.eclipse.tracecompass.testtraces.ctf;version="1.0.0",
+ org.junit.runners
Export-Package: org.eclipse.tracecompass.tmf.analysis.xml.core.tests,
org.eclipse.tracecompass.tmf.analysis.xml.core.tests.common;x-friends:="org.eclipse.tracecompass.tmf.analysis.xml.ui.tests"
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.analysis.xml.core.stateprovider.TmfXmlStrings;
import org.eclipse.tracecompass.tmf.analysis.xml.core.stateprovider.XmlStateSystemModule;
import org.eclipse.tracecompass.tmf.analysis.xml.core.tests.common.TmfXmlTestFiles;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
import org.junit.Test;
import org.w3c.dom.Document;
*/
@Test
public void testModuleExecution() {
- assumeTrue(CtfTmfTestTrace.KERNEL.exists());
-
Document doc = TmfXmlTestFiles.VALID_FILE.getXmlDocument();
assertNotNull(doc);
fModule.setXmlFile(TmfXmlTestFiles.VALID_FILE.getPath());
- CtfTmfTrace trace = CtfTmfTestTrace.KERNEL.getTrace();
+ CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.KERNEL);
try {
fModule.setTrace(trace);
fModule.schedule();
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
import java.util.List;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.analysis.xml.core.stateprovider.TmfXmlStrings;
import org.eclipse.tracecompass.tmf.analysis.xml.core.stateprovider.XmlStateSystemModule;
import org.eclipse.tracecompass.tmf.analysis.xml.core.tests.common.TmfXmlTestFiles;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@Before
public void setupTest() {
/* Initialize the trace */
- assumeTrue(CtfTmfTestTrace.KERNEL.exists());
- ITmfTrace trace = CtfTmfTestTrace.KERNEL.getTrace();
+ ITmfTrace trace = CtfTmfTestTraceUtils.getTrace(CtfTestTrace.KERNEL);
fTrace = trace;
/* Initialize the state provider module */
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
-import org.eclipse.tracecompass.ctf.core.tests.synthetictraces.LttngKernelTraceGenerator;
+import org.eclipse.tracecompass.ctf.core.tests.shared.LttngKernelTraceGenerator;
import org.eclipse.tracecompass.tmf.remote.ui.swtbot.tests.TmfRemoteUISWTBotTestPlugin;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectRegistry;
projects / deliverable / tracecompass.git / commitdiff
