fEventContent1.setFieldValue(Index.TIMESTAMP, "Jan 1 01:01:01");
fEventContent1.setFieldValue(Index.HOST, "HostA");
fEventContent1.setFieldValue(Index.LOGGER, "LoggerA");
+ fEventContent1.setFieldValue(Index.FILE, "SourceFileA");
+ fEventContent1.setFieldValue(Index.LINE, "0");
fEventContent1.setFieldValue(Index.MESSAGE, "MessageA");
fEventContent1Clone = new TextTraceEventContent(SyslogEventType.LABELS);
fEventContent1Clone.setFieldValue(Index.TIMESTAMP, "Jan 1 01:01:01");
fEventContent1Clone.setFieldValue(Index.HOST, "HostA");
fEventContent1Clone.setFieldValue(Index.LOGGER, "LoggerA");
+ fEventContent1Clone.setFieldValue(Index.FILE, "SourceFileA");
+ fEventContent1Clone.setFieldValue(Index.LINE, "0");
fEventContent1Clone.setFieldValue(Index.MESSAGE, "MessageA");
fEventContent2 = new TextTraceEventContent(SyslogEventType.LABELS);
fEventContent2.setFieldValue(SyslogEventType.LABELS[0], "Jan 1 02:02:02");
fEventContent2.setFieldValue(SyslogEventType.LABELS[1], "HostB");
fEventContent2.setFieldValue(SyslogEventType.LABELS[2], "LoggerB");
+ fEventContent2.setFieldValue(SyslogEventType.LABELS[3], "SourceFileB");
+ fEventContent2.setFieldValue(SyslogEventType.LABELS[4], "2");
StringBuffer buffer = new StringBuffer();
buffer.append("Message B");
- fEventContent2.setFieldValue(SyslogEventType.LABELS[3], buffer);
+ fEventContent2.setFieldValue(SyslogEventType.LABELS[5], buffer);
fEventContent2Clone = new TextTraceEventContent(SyslogEventType.LABELS);
fEventContent2Clone.setFieldValue(SyslogEventType.LABELS[0], "Jan 1 02:02:02");
fEventContent2Clone.setFieldValue(SyslogEventType.LABELS[1], "HostB");
fEventContent2Clone.setFieldValue(SyslogEventType.LABELS[2], "LoggerB");
+ fEventContent2Clone.setFieldValue(SyslogEventType.LABELS[3], "SourceFileB");
+ fEventContent2Clone.setFieldValue(SyslogEventType.LABELS[4], "2");
buffer = new StringBuffer();
buffer.append("Message B");
- fEventContent2Clone.setFieldValue(SyslogEventType.LABELS[3], buffer);
+ fEventContent2Clone.setFieldValue(SyslogEventType.LABELS[5], buffer);
}
public void testConstructorConstructor() {
assertEquals("getField:TIMESTAMP", "Jan 1 01:01:01", fEventContent1.getFieldValue(Index.TIMESTAMP));
assertEquals("getField:HOST", "HostA", fEventContent1.getFieldValue(Index.HOST));
assertEquals("getField:LOGGER", "LoggerA", fEventContent1.getFieldValue(Index.LOGGER));
+ assertEquals("getField:FILE", "SourceFileA", fEventContent1.getFieldValue(Index.FILE));
+ assertEquals("getField:LINE", "0", fEventContent1.getFieldValue(Index.LINE));
assertEquals("getField:MESSAGE", "MessageA", fEventContent1.getFieldValue(Index.MESSAGE).toString());
}
assertTrue (eventType.getFieldNames().contains("Timestamp"));
assertTrue (eventType.getFieldNames().contains("Host"));
assertTrue (eventType.getFieldNames().contains("Logger"));
+ assertTrue (eventType.getFieldNames().contains("File"));
+ assertTrue (eventType.getFieldNames().contains("Line"));
assertTrue (eventType.getFieldNames().contains("Message"));
}
assertEquals("getFieldValue:TIMESTAMP", "Jan 1 01:01:01", fEventContent1.getFieldValue(Index.TIMESTAMP));
assertEquals("getFieldValue:HOST", "HostA", fEventContent1.getFieldValue(Index.HOST));
assertEquals("getFieldValue:LOGGER", "LoggerA", fEventContent1.getFieldValue(Index.LOGGER));
+ assertEquals("getFieldValue:FILE", "SourceFileA", fEventContent1.getFieldValue(Index.FILE));
+ assertEquals("getFieldValue:LINE", "0", fEventContent1.getFieldValue(Index.LINE));
assertEquals("getFieldValue:MESSAGE", "MessageA", fEventContent1.getFieldValue(Index.MESSAGE));
- assertNull(fEventContent1.getFieldValue(4));
+ assertNull(fEventContent1.getFieldValue(6));
}
@Test
assertEquals("getFieldValue:TIMESTAMP", "Jan 1 01:01:01", fEventContent1.getFieldValue("Timestamp"));
assertEquals("getFieldValue:HOST", "HostA", fEventContent1.getFieldValue("Host"));
assertEquals("getFieldValue:LOGGER", "LoggerA", fEventContent1.getFieldValue("Logger"));
+ assertEquals("getFieldValue:FILE", "SourceFileA", fEventContent1.getFieldValue("File"));
+ assertEquals("getFieldValue:LINE", "0", fEventContent1.getFieldValue("Line"));
assertEquals("getFieldValue:MESSAGE", "MessageA", fEventContent1.getFieldValue("Message"));
assertNull(fEventContent1.getFieldValue("BlaBla"));
}
assertEquals("getFieldName:TIMESTAMP", SyslogEventType.LABELS[0], fEventContent1.getFieldName(Index.TIMESTAMP));
assertEquals("getFieldName:HOST", SyslogEventType.LABELS[1], fEventContent1.getFieldName(Index.HOST));
assertEquals("getFieldName:LOGGER", SyslogEventType.LABELS[2], fEventContent1.getFieldName(Index.LOGGER));
- assertEquals("getFieldName:MESSAGE", SyslogEventType.LABELS[3], fEventContent1.getFieldName(Index.MESSAGE));
- assertNull(fEventContent1.getFieldValue(4));
+ assertEquals("getFieldName:FILE", SyslogEventType.LABELS[3], fEventContent1.getFieldName(Index.FILE));
+ assertEquals("getFieldName:LINE", SyslogEventType.LABELS[4], fEventContent1.getFieldName(Index.LINE));
+ assertEquals("getFieldName:MESSAGE", SyslogEventType.LABELS[5], fEventContent1.getFieldName(Index.MESSAGE));
+ assertNull(fEventContent1.getFieldValue(6));
}
@Test
public void testGetFields() {
List<TextTraceEventContent> fields = fEventContent1.getFields();
- assertEquals(4, fields.size());
+ assertEquals(6, fields.size());
assertEquals("getFields:TIMESTAMP", SyslogEventType.LABELS[0], fields.get(Index.TIMESTAMP).getName());
assertEquals("getFields:TIMESTAMP", "Jan 1 01:01:01", fields.get(Index.TIMESTAMP).getValue());
assertEquals("getFields:HOST", SyslogEventType.LABELS[1], fields.get(Index.HOST).getName());
assertEquals("getFields:HOST", "HostA", fields.get(Index.HOST).getValue());
assertEquals("getFields:LOGGER", SyslogEventType.LABELS[2], fields.get(Index.LOGGER).getName());
assertEquals("getFields:LOGGER", "LoggerA", fields.get(Index.LOGGER).getValue());
- assertEquals("getFields:MESSAGE", SyslogEventType.LABELS[3], fields.get(Index.MESSAGE).getName());
+ assertEquals("getFields:FILE", SyslogEventType.LABELS[3], fields.get(Index.FILE).getName());
+ assertEquals("getFields:FILE", "SourceFileA", fields.get(Index.FILE).getValue());
+ assertEquals("getFields:LINE", SyslogEventType.LABELS[4], fields.get(Index.LINE).getName());
+ assertEquals("getFields:LINE", "0", fields.get(Index.LINE).getValue());
+ assertEquals("getFields:MESSAGE", SyslogEventType.LABELS[5], fields.get(Index.MESSAGE).getName());
assertEquals("getFields:MESSAGE", "MessageA", fields.get(Index.MESSAGE).getValue());
}
assertEquals("getFieldName:LOGGER", "LoggerA", field.getValue());
field = fEventContent1.getField(SyslogEventType.LABELS[3]);
- assertEquals("getFieldName:Message", SyslogEventType.LABELS[3], field.getName());
+ assertEquals("getFieldName:FILE", SyslogEventType.LABELS[3], field.getName());
+ assertEquals("getFieldName:FILE", "SourceFileA", field.getValue());
+
+ field = fEventContent1.getField(SyslogEventType.LABELS[4]);
+ assertEquals("getFieldName:LINE", SyslogEventType.LABELS[4], field.getName());
+ assertEquals("getFieldName:LINE", "0", field.getValue());
+
+ field = fEventContent1.getField(SyslogEventType.LABELS[5]);
+ assertEquals("getFieldName:Message", SyslogEventType.LABELS[5], field.getName());
assertEquals("getgetFieldName:Message", "MessageA", field.getValue());
field = fEventContent1.getField("BlaBla");
@Test
public void testToString() {
- assertEquals("Timestamp=Jan 1 01:01:01, Host=HostA, Logger=LoggerA, Message=MessageA", fEventContent1.toString());
+ assertEquals("Timestamp=Jan 1 01:01:01, Host=HostA, Logger=LoggerA, File=SourceFileA, Line=0, Message=MessageA", fEventContent1.toString());
}
@Test
@Test
public void testGetFieldNames() {
- String[] labels = {"Timestamp", "Host", "Logger", "Message"};
+ String[] labels = {"Timestamp", "Host", "Logger", "File", "Line", "Message"};
List<String> names = fEventContent1.getFieldNames();
assertArrayEquals(labels, names.toArray(new String[names.size()]));
}
IStatus status = trace.validate(null, validTracePath);
assertTrue(status.isOK());
assertTrue(status instanceof TraceValidationStatus);
- assertEquals(180, ((TraceValidationStatus) status).getConfidence());
+ assertEquals(185, ((TraceValidationStatus) status).getConfidence());
URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(OTHER_PATH), null);
URI uri = FileLocator.toFileURL(location).toURI();
assertEquals("getField:TIMESTAMP", "Jan 1 01:01:01", content.getFieldValue(Index.TIMESTAMP));
assertEquals("getField:HOST", "HostA", content.getFieldValue(Index.HOST));
assertEquals("getField:LOGGER", "LoggerA", content.getFieldValue(Index.LOGGER));
+ assertEquals("getField:FILE", "SourceFileA", content.getFieldValue(Index.FILE));
+ assertEquals("getField:LINE", "4", content.getFieldValue(Index.LINE));
assertEquals("getField:MESSAGE", "Message A", content.getFieldValue(Index.MESSAGE).toString());
event = fTrace.getNext(context);
content = event.getContent();
assertEquals("getField:TIMESTAMP", "Jan 1 02:02:02", content.getFieldValue(Index.TIMESTAMP));
assertEquals("getField:HOST", "HostB", content.getFieldValue(Index.HOST));
assertEquals("getField:LOGGER", "LoggerB", content.getFieldValue(Index.LOGGER));
+ assertEquals("getField:FILE", "SourceFileB", content.getFieldValue(Index.FILE));
+ assertEquals("getField:LINE", "5", content.getFieldValue(Index.LINE));
assertEquals("getField:MESSAGE", "Message B", content.getFieldValue(Index.MESSAGE).toString());
event = fTrace.getNext(context);
content = event.getContent();
assertEquals("getField:TIMESTAMP", "Jan 1 03:03:03", content.getFieldValue(Index.TIMESTAMP));
assertEquals("getField:HOST", "HostC", content.getFieldValue(Index.HOST));
assertEquals("getField:LOGGER", "LoggerC", content.getFieldValue(Index.LOGGER));
+ assertEquals("getField:FILE", "SourceFileC", content.getFieldValue(Index.FILE));
+ assertEquals("getField:LINE", "6", content.getFieldValue(Index.LINE));
assertEquals("getField:MESSAGE", "Message C", content.getFieldValue(Index.MESSAGE).toString());
event = fTrace.getNext(context);
content = event.getContent();
assertEquals("getField:TIMESTAMP", "Jan 1 04:04:04", content.getFieldValue(Index.TIMESTAMP));
assertEquals("getField:HOST", "HostD", content.getFieldValue(Index.HOST));
assertEquals("getField:LOGGER", "LoggerD", content.getFieldValue(Index.LOGGER));
+ assertEquals("getField:FILE", "SourceFileD", content.getFieldValue(Index.FILE));
+ assertEquals("getField:LINE", "7", content.getFieldValue(Index.LINE));
assertEquals("getField:MESSAGE", "Message D", content.getFieldValue(Index.MESSAGE).toString());
event = fTrace.getNext(context);
content = event.getContent();
assertEquals("getField:TIMESTAMP", "Jan 1 05:05:05", content.getFieldValue(Index.TIMESTAMP));
assertEquals("getField:HOST", "HostE", content.getFieldValue(Index.HOST));
assertEquals("getField:LOGGER", "LoggerE", content.getFieldValue(Index.LOGGER));
+ assertEquals("getField:FILE", "SourceFileE", content.getFieldValue(Index.FILE));
+ assertEquals("getField:LINE", "8", content.getFieldValue(Index.LINE));
assertEquals("getField:MESSAGE", "", content.getFieldValue(Index.MESSAGE).toString());
event = fTrace.getNext(context);
content = event.getContent();
assertEquals("getField:TIMESTAMP", "Jan 1 06:06:06", content.getFieldValue(Index.TIMESTAMP));
assertEquals("getField:HOST", "HostF", content.getFieldValue(Index.HOST));
assertEquals("getField:LOGGER", "LoggerF", content.getFieldValue(Index.LOGGER));
+ assertEquals("getField:FILE", "SourceFileF", content.getFieldValue(Index.FILE));
+ assertEquals("getField:LINE", "9", content.getFieldValue(Index.LINE));
assertEquals("getField:MESSAGE", "Message F", content.getFieldValue(Index.MESSAGE).toString());
event = fTrace.getNext(context);
assertEquals("event", null, event);
assertEquals("event", null, event);
context.dispose();
}
-}
+}
\ No newline at end of file
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventType;
import org.eclipse.tracecompass.tmf.core.event.collapse.ITmfCollapsibleEvent;
+import org.eclipse.tracecompass.tmf.core.event.lookup.ITmfCallsite;
+import org.eclipse.tracecompass.tmf.core.event.lookup.ITmfSourceLookup;
+import org.eclipse.tracecompass.tmf.core.event.lookup.TmfCallsite;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.text.TextTraceEvent;
import org.eclipse.tracecompass.tmf.core.trace.text.TextTraceEventContent;
+import org.eclipse.tracecompass.tmf.tests.stubs.trace.text.SyslogEventType.Index;
/**
* System log trace implementation of TmfEvent.
*/
-public class SyslogEvent extends TextTraceEvent implements ITmfCollapsibleEvent {
+public class SyslogEvent extends TextTraceEvent implements ITmfCollapsibleEvent, ITmfSourceLookup {
/**
* Default constructor
return true;
}
+ @Override
+ public ITmfCallsite getCallsite() {
+ if (getContent() != null) {
+ long lineNo = 0;
+ try {
+ lineNo = Long.valueOf((String) getContent().getField(Index.LINE).getValue());
+ } catch (NumberFormatException e) {
+ // ignore
+ }
+ return new TmfCallsite((String) getContent().getField(Index.FILE).getValue(), null, lineNo);
+ }
+ return null;
+ }
+
}
public static final String TYPE_ID = "Syslog"; //$NON-NLS-1$
/** The labels (field names) used for SA system log events. */
@SuppressWarnings("nls")
- public static final String[] LABELS = {"Timestamp", "Host", "Logger", "Message"};
+ public static final String[] LABELS = {"Timestamp", "Host", "Logger", "File", "Line", "Message"};
/** A default instance of this class */
public static final SyslogEventType INSTANCE = new SyslogEventType();
int HOST = 1;
/** Index for the logger name */
int LOGGER = 2;
+ /** Index for the logger name */
+ int FILE = 3;
+ /** Index for the logger name */
+ int LINE = 4;
/** Index for the event message */
- int MESSAGE = 3;
+ int MESSAGE = 5;
}
/**
TIMESTAMP_FORMAT, TmfTimePreferences.getLocale());
/** The regular expression pattern of the first line of an event. */
public static final Pattern LINE1_PATTERN = Pattern.compile(
- "\\s*(\\S\\S\\S \\d\\d? \\d\\d:\\d\\d:\\d\\d)\\s*(\\S*)\\s*(\\S*):+\\s*(.*\\S)?"); //$NON-NLS-1$
+ "\\s*(\\S\\S\\S \\d\\d? \\d\\d:\\d\\d:\\d\\d)\\s*(\\S*)\\s*(\\S*):+\\s*(\\S*):([0-9]*)\\s*(.*\\S)?"); //$NON-NLS-1$
/* The current calendar to use */
private static final Calendar CURRENT = Calendar.getInstance();
content.setFieldValue(Index.TIMESTAMP, matcher.group(1));
content.setFieldValue(Index.HOST, matcher.group(2));
content.setFieldValue(Index.LOGGER, matcher.group(3));
- content.setFieldValue(Index.MESSAGE, new StringBuffer(matcher.group(4) != null ? matcher.group(4) : "")); //$NON-NLS-1$
+ content.setFieldValue(Index.FILE, matcher.group(4));
+ content.setFieldValue(Index.LINE, matcher.group(5));
+ content.setFieldValue(Index.MESSAGE, new StringBuffer(matcher.group(6) != null ? matcher.group(6) : "")); //$NON-NLS-1$
SyslogEvent event = new SyslogEvent(
this,
--- /dev/null
+This is source line 1
+This is source line 2
+This is source line 3
+This is source line 4
+This is source line 5
+This is source line 6
+This is source line 7
+This is source line 8
+This is source line 9
+This is source line 10
\ No newline at end of file
-Jan 1 01:01:01 HostA LoggerA: Message A
-Jan 1 02:02:02 HostB LoggerB: Message B
-Jan 1 03:03:03 HostC LoggerC: Message C
-Jan 1 04:04:04 HostD LoggerD: Message D
-Jan 1 05:05:05 HostE LoggerE:
-Jan 1 06:06:06 HostF LoggerF: Message F
+Jan 1 01:01:01 HostA LoggerA: SourceFileA:4 Message A
+Jan 1 02:02:02 HostB LoggerB: SourceFileB:5 Message B
+Jan 1 03:03:03 HostC LoggerC: SourceFileC:6 Message C
+Jan 1 04:04:04 HostD LoggerD: SourceFileD:7 Message D
+Jan 1 05:05:05 HostE LoggerE: SourceFileE:8
+Jan 1 06:06:06 HostF LoggerF: SourceFileF:9 Message F
-Jan 1 01:01:01 HostA LoggerA: Message A
-Jan 1 02:02:02 HostB LoggerB: Message B
-Jan 1 03:03:03 HostC LoggerC: Message C
-Jan 1 04:04:04 HostD LoggerD: Message D
-Jan 1 05:05:05 HostE LoggerE:
-Jan 1 06:06:06 HostF LoggerF: Message F
-Jan 1 06:06:07 HostF LoggerF: Message F
-Jan 1 06:06:08 HostF LoggerF: Message F
-Jan 1 06:06:09 HostF LoggerF: Message F
-Jan 1 06:06:10 HostF LoggerF: Message F
-Jan 1 06:06:11 HostF LoggerF: Message F
-Jan 1 06:06:12 HostF LoggerF: Message F
-Jan 1 06:06:13 HostF LoggerF: Message F
-Jan 1 06:06:14 HostF LoggerF: Message F
-Jan 1 06:06:15 HostF LoggerF: Message F
-Jan 1 06:06:16 HostF LoggerF: Message F
-Jan 1 06:06:17 HostF LoggerF: Message F
-Jan 1 06:06:18 HostF LoggerF: Message F
-Jan 1 06:06:19 HostF LoggerF: Message F
-Jan 1 06:06:20 HostF LoggerF: Message F
-Jan 1 06:06:21 HostF LoggerF: Message D
-Jan 1 06:06:22 HostF LoggerF: Message D
+Jan 1 01:01:01 HostA LoggerA: SourceFile:4 Message A
+Jan 1 02:02:02 HostB LoggerB: SourceFile:5 Message B
+Jan 1 03:03:03 HostC LoggerC: SourceFile:6 Message C
+Jan 1 04:04:04 HostD LoggerD: SourceFile:7 Message D
+Jan 1 05:05:05 HostE LoggerE: SourceFile:8
+Jan 1 06:06:06 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:07 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:08 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:09 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:10 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:11 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:12 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:13 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:14 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:15 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:16 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:17 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:18 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:19 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:20 HostF LoggerF: SourceFile:9 Message F
+Jan 1 06:06:21 HostF LoggerF: SourceFile:10 Message D
+Jan 1 06:06:22 HostF LoggerF: SourceFile:10 Message D
*/
@RunWith(Suite.class)
@Suite.SuiteClasses({
- CollapseEventsInTableTest.class,
+ CallsiteEventsInTableTest.class,
+ CollapseEventsInTableTest.class
})
public class AllTests {
}
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 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:
+ * Bernd Hufmann - Initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.ui.swtbot.tests.table;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+
+import org.apache.log4j.ConsoleAppender;
+import org.apache.log4j.Logger;
+import org.apache.log4j.SimpleLayout;
+import org.eclipse.core.runtime.FileLocator;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.core.runtime.preferences.IEclipsePreferences;
+import org.eclipse.core.runtime.preferences.InstanceScope;
+import org.eclipse.jface.bindings.keys.IKeyLookup;
+import org.eclipse.jface.bindings.keys.KeyStroke;
+import org.eclipse.jface.bindings.keys.ParseException;
+import org.eclipse.tracecompass.internal.tmf.core.Activator;
+import org.eclipse.tracecompass.tmf.core.tests.TmfCoreTestPlugin;
+import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimePreferencesConstants;
+import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
+import org.eclipse.tracecompass.tmf.ui.swtbot.tests.SWTBotUtil;
+import org.eclipse.swtbot.eclipse.finder.SWTWorkbenchBot;
+import org.eclipse.swtbot.eclipse.finder.matchers.WidgetMatcherFactory;
+import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor;
+import org.eclipse.swtbot.swt.finder.junit.SWTBotJunit4ClassRunner;
+import org.eclipse.swtbot.swt.finder.utils.SWTBotPreferences;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotMenu;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotTable;
+import org.eclipse.ui.IEditorReference;
+import org.hamcrest.Matcher;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * SWTBot test for testing callsite feature.
+ *
+ * @author Bernd Hufmann
+ */
+@RunWith(SWTBotJunit4ClassRunner.class)
+public class CallsiteEventsInTableTest {
+
+ private static final String TRACE_PROJECT_NAME = "test";
+ private static final String CALLSITE_TRACE_NAME = "syslog_collapse";
+ private static final String CALLSITE_TRACE_PATH = "testfiles/" + CALLSITE_TRACE_NAME;
+ private static final String CALLSITE_TRACE_TYPE = "org.eclipse.linuxtools.tmf.tests.stubs.trace.text.testsyslog";
+ private static final String SOURCE_FILE_NAME = "SourceFile";
+ private static final String SOURCE_FILE_PATH = "testfiles/" + SOURCE_FILE_NAME;
+
+ private static File fTestFile = null;
+ private static File fSourceFile = null;
+
+ private static SWTWorkbenchBot fBot;
+
+ /** The Log4j logger instance. */
+ private static final Logger fLogger = Logger.getRootLogger();
+
+ /**
+ * Test Class setup
+ */
+ @BeforeClass
+ public static void init() {
+ SWTBotUtil.failIfUIThread();
+
+ /* set up test trace*/
+ URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(CALLSITE_TRACE_PATH), null);
+ URI uri;
+ try {
+ uri = FileLocator.toFileURL(location).toURI();
+ fTestFile = new File(uri);
+ } catch (URISyntaxException | IOException e) {
+ e.printStackTrace();
+ fail();
+ }
+
+ assumeTrue(fTestFile.exists());
+
+ IEclipsePreferences defaultPreferences = InstanceScope.INSTANCE.getNode(Activator.PLUGIN_ID);
+ defaultPreferences.put(ITmfTimePreferencesConstants.DATIME, "MMM d HH:mm:ss");
+ defaultPreferences.put(ITmfTimePreferencesConstants.SUBSEC, ITmfTimePreferencesConstants.SUBSEC_NO_FMT);
+ TmfTimestampFormat.updateDefaultFormats();
+
+ /* Create source file link */
+ location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(SOURCE_FILE_PATH), null);
+ try {
+ uri = FileLocator.toFileURL(location).toURI();
+ fSourceFile = new File(uri);
+ } catch (URISyntaxException | IOException e) {
+ e.printStackTrace();
+ fail();
+ }
+
+ assumeTrue(fSourceFile.exists());
+
+
+
+ /* Set up for swtbot */
+ SWTBotPreferences.TIMEOUT = 20000; /* 20 second timeout */
+ fLogger.addAppender(new ConsoleAppender(new SimpleLayout(), ConsoleAppender.SYSTEM_OUT));
+ fBot = new SWTWorkbenchBot();
+
+ /* Close welcome view */
+ SWTBotUtil.closeView("Welcome", fBot);
+
+ /* Switch perspectives */
+ SWTBotUtil.switchToTracingPerspective();
+
+ /* Finish waiting for eclipse to load */
+ SWTBotUtil.waitForJobs();
+ }
+
+ /**
+ * Test class tear down method.
+ */
+ @AfterClass
+ public static void tearDown() {
+ /* Set timestamp defaults */
+ IEclipsePreferences defaultPreferences = InstanceScope.INSTANCE.getNode(Activator.PLUGIN_ID);
+ defaultPreferences.put(ITmfTimePreferencesConstants.DATIME, ITmfTimePreferencesConstants.TIME_HOUR_FMT);
+ defaultPreferences.put(ITmfTimePreferencesConstants.SUBSEC, ITmfTimePreferencesConstants.SUBSEC_NANO_FMT);
+ TmfTimestampFormat.updateDefaultFormats();
+ }
+
+ /**
+ * Main test case
+ */
+ @Test
+ public void test() {
+ SWTBotUtil.createProject(TRACE_PROJECT_NAME);
+
+ // Open source file as a unknown trace
+ SWTBotUtil.openTrace(TRACE_PROJECT_NAME, fSourceFile.getAbsolutePath(), null);
+
+ // Open the actual trace
+ SWTBotUtil.openTrace(TRACE_PROJECT_NAME, fTestFile.getAbsolutePath(), CALLSITE_TRACE_TYPE);
+ SWTBotEditor editorBot = SWTBotUtil.openEditor(fBot, fTestFile.getName());
+
+ SWTBotTable tableBot = editorBot.bot().table();
+
+ // Maximize editor area
+ maximizeTable(tableBot);
+ tableBot.click(1, 0);
+
+ // Open source code location
+ SWTBotMenu menuBot = tableBot.contextMenu("Open Source Code");
+ menuBot.click();
+
+ // Verify that source code was actually opened
+ Matcher<IEditorReference> matcher = WidgetMatcherFactory.withPartName(fSourceFile.getName());
+ final SWTBotEditor sourceEditorBot = fBot.editor(matcher);
+ assertTrue(sourceEditorBot.isActive());
+
+ maximizeTable(tableBot);
+
+ fBot.closeAllEditors();
+ SWTBotUtil.deleteProject(TRACE_PROJECT_NAME, fBot);
+ }
+
+ private static void maximizeTable(SWTBotTable tableBot) {
+ try {
+ tableBot.pressShortcut(KeyStroke.getInstance(IKeyLookup.CTRL_NAME + "+"), KeyStroke.getInstance("M"));
+ } catch (ParseException e) {
+ fail();
+ }
+ }
+
+}
assertEquals("type", "Syslog", filterString);
filterString = tableBot.cell(7, 3);
- assertEquals("content", "Timestamp=Jan 1 06:06:06, Host=HostF, Logger=LoggerF, Message=Message F", filterString);
+ assertEquals("content", "Timestamp=Jan 1 06:06:06, Host=HostF, Logger=LoggerF, File=SourceFile, Line=9, Message=Message F", filterString);
filterString = tableBot.cell(8, 0);
assertEquals("repeatCount", "+1", filterString);
assertEquals("first timestamp (2nd collapse)", "Jan 1 06:06:21", filterString);
filterString = tableBot.cell(8, 3);
- assertEquals("content", "Timestamp=Jan 1 06:06:21, Host=HostF, Logger=LoggerF, Message=Message D", filterString);
+ assertEquals("content", "Timestamp=Jan 1 06:06:21, Host=HostF, Logger=LoggerF, File=SourceFile, Line=10, Message=Message D", filterString);
/* Clear Filter */
menuBot = tableBot.contextMenu("Clear Filters");
*/
protected void setItemData(final TableItem item, final ITmfEvent event, final long rank) {
String[] itemStrings = getItemStrings(fColumns, event);
+
+ // Get the actual ITmfEvent from the CachedEvent
+ ITmfEvent tmfEvent = event;
+ if (event instanceof CachedEvent) {
+ tmfEvent = ((CachedEvent) event).event;
+ }
item.setText(itemStrings);
- item.setData(event);
- item.setData(Key.TIMESTAMP, new TmfTimestamp(event.getTimestamp()));
+ item.setData(tmfEvent);
+ item.setData(Key.TIMESTAMP, new TmfTimestamp(tmfEvent.getTimestamp()));
item.setData(Key.RANK, rank);
final Collection<Long> markerIds = fBookmarksMap.get(rank);
boolean searchNoMatch = false;
final ITmfFilter searchFilter = (ITmfFilter) fTable.getData(Key.SEARCH_OBJ);
if (searchFilter != null) {
- if (searchFilter.matches(event)) {
+ if (searchFilter.matches(tmfEvent)) {
searchMatch = true;
} else {
searchNoMatch = true;
}
}
- final ColorSetting colorSetting = ColorSettingsManager.getColorSetting(event);
+ final ColorSetting colorSetting = ColorSettingsManager.getColorSetting(tmfEvent);
if (searchNoMatch) {
item.setForeground(colorSetting.getDimmedForegroundColor());
item.setBackground(colorSetting.getDimmedBackgroundColor());
projects / deliverable / tracecompass.git / commitdiff
