javaCompiler...args
build.xml
target
+testfiles/
ITmfTimestamp ts0b = new TmfTimestamp(0, 0, 1);
try {
- @SuppressWarnings("unused")
- ITmfTimestamp timestamp = new TmfSimpleTimestamp(null);
+ new TmfSimpleTimestamp(null);
fail("TmfSimpleTimestamp: null argument");
} catch (IllegalArgumentException e) {
}
try {
- @SuppressWarnings("unused")
- ITmfTimestamp ts = new TmfSimpleTimestamp(ts0a);
+ new TmfSimpleTimestamp(ts0a);
fail("TmfSimpleTimestamp: bad scale");
} catch (IllegalArgumentException e) {
}
try {
- @SuppressWarnings("unused")
- ITmfTimestamp ts = new TmfSimpleTimestamp(ts0b);
+ new TmfSimpleTimestamp(ts0b);
fail("TmfSimpleTimestamp: bad precision");
} catch (IllegalArgumentException e) {
}
public void testCopyNullConstructor() throws Exception {
try {
- @SuppressWarnings("unused")
- ITmfTimestamp timestamp = new TmfTimestamp(null);
+ new TmfTimestamp(null);
fail("TmfTimestamp: null argument");
} catch (IllegalArgumentException e) {
}
// Variables
// ------------------------------------------------------------------------
- private static TmfCoalescedDataRequest<TmfEvent> fRequest1;
- private static TmfCoalescedDataRequest<TmfEvent> fRequest2;
- private static TmfCoalescedDataRequest<TmfEvent> fRequest3;
- private static TmfCoalescedDataRequest<TmfEvent> fRequest4;
+ private TmfCoalescedDataRequest<TmfEvent> fRequest1;
+ private TmfCoalescedDataRequest<TmfEvent> fRequest2;
+ private TmfCoalescedDataRequest<TmfEvent> fRequest3;
+ private TmfCoalescedDataRequest<TmfEvent> fRequest4;
- private static TmfCoalescedDataRequest<TmfEvent> fRequest1b;
- private static TmfCoalescedDataRequest<TmfEvent> fRequest1c;
+ private TmfCoalescedDataRequest<TmfEvent> fRequest1b;
+ private TmfCoalescedDataRequest<TmfEvent> fRequest1c;
- private static int fRequestCount;
+ private int fRequestCount;
// ------------------------------------------------------------------------
// Housekeeping
// Variables
// ------------------------------------------------------------------------
- private static TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.Eternity);
- private static TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
+ private TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.Eternity);
+ private TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
- private static TmfCoalescedEventRequest<TmfEvent> fRequest1;
- private static TmfCoalescedEventRequest<TmfEvent> fRequest2;
- private static TmfCoalescedEventRequest<TmfEvent> fRequest3;
- private static TmfCoalescedEventRequest<TmfEvent> fRequest4;
+ private TmfCoalescedEventRequest<TmfEvent> fRequest1;
+ private TmfCoalescedEventRequest<TmfEvent> fRequest2;
+ private TmfCoalescedEventRequest<TmfEvent> fRequest3;
+ private TmfCoalescedEventRequest<TmfEvent> fRequest4;
- private static TmfCoalescedEventRequest<TmfEvent> fRequest1b;
- private static TmfCoalescedEventRequest<TmfEvent> fRequest1c;
+ private TmfCoalescedEventRequest<TmfEvent> fRequest1b;
+ private TmfCoalescedEventRequest<TmfEvent> fRequest1c;
- private static int fRequestCount;
+ private int fRequestCount;
// ------------------------------------------------------------------------
// Housekeeping
private static final int BLOCK_SIZE = 100;
// Initialize the test trace
- private static TmfTraceStub fTrace = null;
+ private TmfTraceStub fTrace = null;
private synchronized TmfTraceStub setupTrace(String path) {
if (fTrace == null) {
try {
ITmfDataProvider<TmfEvent>[] providers;
- private class TmfTestTriggerSignal extends TmfSignal {
+ private static class TmfTestTriggerSignal extends TmfSignal {
public final boolean forceCancel;
public TmfTestTriggerSignal(Object source, boolean cancel) {
super(source);
// Housekeeping
// ------------------------------------------------------------------------
- private ITmfTrace<?>[] setupTrace(String path) {
+ private synchronized ITmfTrace<?>[] setupTrace(String path) {
if (fTraces == null) {
fTraces = new ITmfTrace[1];
try {
}
@SuppressWarnings("unchecked")
- private void setupExperiment() {
+ private synchronized void setupExperiment() {
if (fExperiment == null) {
fExperiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, (ITmfTrace<TmfEvent>[]) fTraces);
// fExperiment.indexExperiment();
}
}
- public class MyCloneableClass implements Cloneable, Comparable<MyCloneableClass> {
+ public static class MyCloneableClass implements Cloneable, Comparable<MyCloneableClass> {
private String fName;
public MyCloneableClass(String name) {
fName = name;
}
}
- public class MyUnCloneableClass implements Comparable<MyUnCloneableClass> {
+ public static class MyUnCloneableClass implements Comparable<MyUnCloneableClass> {
private String fName;
public MyUnCloneableClass(String name) {
fName = name;
createTestFile("testfiles" + File.separator + "O-" + FILE_NAMES[i], FILE_SIZES[i], true, true);
createTestFile("testfiles" + File.separator + "E-" + FILE_NAMES[i], FILE_SIZES[i], true, false);
createTestFile("testfiles" + File.separator + "R-" + FILE_NAMES[i], FILE_SIZES[i], false, false);
- } catch (Exception e) {
+ } catch (FileNotFoundException e) {
+ } catch (IOException e) {
}
}
// Attributes
// ------------------------------------------------------------------------
- private final int NB_TYPES = 10;
+ private static final int NB_TYPES = 10;
private final TmfEventType[] fTypes;
// ------------------------------------------------------------------------
// Highly inefficient...
RandomAccessFile stream = ((TmfTraceStub) eventStream).getStream();
- String name = eventStream.getName();
- name = name.substring(name.lastIndexOf('/') + 1);
+// String name = eventStream.getName();
+// name = name.substring(name.lastIndexOf('/') + 1);
// no need to use synchronized since it's already cover by the calling method
long ts = stream.readLong();
String source = stream.readUTF();
String type = stream.readUTF();
- @SuppressWarnings("unused")
- int reference = stream.readInt();
+ Integer reference = stream.readInt();
int typeIndex = Integer.parseInt(type.substring(typePrefix.length()));
String[] fields = new String[typeIndex];
for (int i = 0; i < typeIndex; i++) {
fields[i] = stream.readUTF();
}
- String content = "[";
+ StringBuffer content = new StringBuffer("[");
if (typeIndex > 0) {
- content += fields[0];
+ content.append(fields[0]);
}
for (int i = 1; i < typeIndex; i++) {
- content += ", " + fields[i];
+ content.append(", ").append(fields[i]);
}
- content += "]";
+ content.append("]");
- TmfEventField root = new TmfEventField(ITmfEventField.ROOT_ID, content);
+ TmfEventField root = new TmfEventField(ITmfEventField.ROOT_ID, content.toString());
TmfEvent event = new TmfEvent(eventStream,
- new TmfTimestamp(ts, (byte) -3, 0), // millisecs
- source, fTypes[typeIndex], root, name);
- event.setContent(root);
+ new TmfTimestamp(ts, -3, 0), // millisecs
+ source, fTypes[typeIndex], root, reference.toString());
return event;
} catch (EOFException e) {
}
fLock.lock();
try {
if (fTrace != null) {
- ITmfLocation<?> location = new TmfLocation<Long>(new Long((long) (ratio * fTrace.length())));
+ ITmfLocation<?> location = new TmfLocation<Long>(Long.valueOf((long) (ratio * fTrace.length())));
TmfContext context = seekLocation(location);
context.setRank(ITmfContext.UNKNOWN_RANK);
return context;
TmfExperiment<?> experiment = signal.getExperiment();
if (experiment == this) {
setCurrentExperiment(experiment);
- fEndSynchReference = new Integer(signal.getReference());
+ fEndSynchReference = Integer.valueOf(signal.getReference());
}
}
@Override
public boolean equals(Object other) {
+ if (this == other)
+ return true;
+ if (!super.equals(other))
+ return false;
if (!(other instanceof TmfExperimentContext)) {
return false;
}
package org.eclipse.linuxtools.tmf.core.experiment;
+import java.util.Arrays;
+
import org.eclipse.linuxtools.tmf.core.trace.TmfLocation;
/**
public long[] getRanks() {
return fRanks;
}
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = super.hashCode();
+ result = prime * result + Arrays.hashCode(fRanks);
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (!super.equals(obj))
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ TmfExperimentLocation other = (TmfExperimentLocation) obj;
+ if (!Arrays.equals(fRanks, other.fRanks))
+ return false;
+ return true;
+ }
+
}
return false ^ fNot;\r
}\r
if (fType == Type.NUM) {\r
- if (fValueNumber instanceof Number) {\r
+ if (fValueNumber != null) {\r
if (value instanceof Number) {\r
Double valueDouble = ((Number) value).doubleValue();\r
return (valueDouble.compareTo(fValueNumber.doubleValue()) == fResult) ^ fNot;\r
String valueString = value.toString();\r
return (valueString.compareTo(fValue.toString()) == fResult) ^ fNot;\r
} else if (fType == Type.TIMESTAMP) {\r
- if (fValueTimestamp instanceof TmfTimestamp) {\r
+ if (fValueTimestamp != null) {\r
if (value instanceof TmfTimestamp) {\r
TmfTimestamp valueTimestamp = (TmfTimestamp) value;\r
return (valueTimestamp.compareTo(fValueTimestamp, false) == fResult) ^ fNot;\r
@Override\r
public ITmfFilterTreeNode clone() {\r
TmfFilterCompareNode clone = (TmfFilterCompareNode) super.clone();\r
- clone.fField = new String(fField);\r
- clone.setValue(new String(fValue));\r
+ clone.fField = fField;\r
+ clone.setValue(fValue);\r
return clone;\r
}\r
}\r
@Override\r
public ITmfFilterTreeNode clone() {\r
TmfFilterContainsNode clone = (TmfFilterContainsNode) super.clone();\r
- clone.fField = new String(fField);\r
- clone.setValue(new String(fValue));\r
+ clone.fField = fField;\r
+ clone.setValue(fValue);\r
return clone;\r
}\r
}\r
@Override\r
public ITmfFilterTreeNode clone() {\r
TmfFilterEqualsNode clone = (TmfFilterEqualsNode) super.clone();\r
- clone.fField = new String(fField);\r
- clone.fValue = new String(fValue);\r
+ clone.fField = fField;\r
+ clone.fValue = fValue;\r
return clone;\r
}\r
}\r
@Override\r
public ITmfFilterTreeNode clone() {\r
TmfFilterMatchesNode clone = (TmfFilterMatchesNode) super.clone();\r
- clone.fField = new String(fField);\r
- clone.setRegex(new String(fRegex));\r
+ clone.fField = fField;\r
+ clone.setRegex(fRegex);\r
return clone;\r
}\r
\r
*
* @param <T> Type of the array content.
*/
-public final class TmfFixedArray<T> extends AbstractList<T> implements RandomAccess {
+public final class TmfFixedArray<T> extends AbstractList<T> implements RandomAccess, Cloneable {
/**
* Replace {@link java.util.Arrays#copyOf(Object[], int)} that do not exist in java 5.
* @param <E> Content of the array.
\r
import java.text.ParseException;\r
import java.text.SimpleDateFormat;\r
+import java.util.Arrays;\r
import java.util.Date;\r
import java.util.HashMap;\r
import java.util.Map;\r
}\r
fData = null;\r
}\r
+\r
}\r
// Object
// ------------------------------------------------------------------------
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((fChildren == null) ? 0 : fChildren.hashCode());
+ result = prime * result + ((fLocation == null) ? 0 : fLocation.hashCode());
+ result = prime * result + ((fName == null) ? 0 : fName.hashCode());
+ result = prime * result + ((fParent == null) ? 0 : fParent.hashCode());
+ result = prime * result + ((fPath == null) ? 0 : fPath.hashCode());
+ result = prime * result + ((fResource == null) ? 0 : fResource.hashCode());
+ return result;
+ }
+
@Override
public boolean equals(Object other) {
if (this == other)
return true;
+ if (other == null)
+ return false;
if (!(other instanceof TmfProjectModelElement))
return false;
- TmfProjectModelElement o = (TmfProjectModelElement) other;
- return o.fName.equals(fName) && o.fLocation.equals(fLocation);
+ TmfProjectModelElement element = (TmfProjectModelElement) other;
+ return element.fName.equals(fName) && element.fLocation.equals(fLocation);
}
}
// new OpenCallStackViewAction().openView(false);\r
// Replaced by event notification\r
// updateModelSelection();\r
- notifySelectionListeners(TmfTimeSelectionEvent.type.WIDGET_DEF_SEL);\r
+ notifySelectionListeners(TmfTimeSelectionEvent.Type.WIDGET_DEF_SEL);\r
}\r
\r
@Override\r
public void widgetSelected(SelectionEvent e) {\r
// Replace by event notification\r
// updateModelSelection();\r
- notifySelectionListeners(TmfTimeSelectionEvent.type.WIDGET_SEL);\r
+ notifySelectionListeners(TmfTimeSelectionEvent.Type.WIDGET_SEL);\r
}\r
\r
@Override\r
}\r
\r
private synchronized void notifySelectionListeners(\r
- TmfTimeSelectionEvent.type rtype) {\r
+ TmfTimeSelectionEvent.Type rtype) {\r
// Any listeners out there ?\r
if (widgetSelectionListners.size() > 0) {\r
// Locate the event selected\r
*/\r
private static final long serialVersionUID = 1L;\r
\r
- public enum type {WIDGET_DEF_SEL, WIDGET_SEL}\r
- type dType;\r
+ public enum Type {WIDGET_DEF_SEL, WIDGET_SEL}\r
+ Type dType;\r
Object selection = null;\r
long selTime = 0;\r
int index = 0;\r
\r
- public TmfTimeSelectionEvent(Object arg0, type rType, Object sel, long selectedTime) {\r
+ public TmfTimeSelectionEvent(Object arg0, Type rType, Object sel, long selectedTime) {\r
super(arg0);\r
dType = rType;\r
selection = sel;\r
selTime = selectedTime;\r
}\r
\r
- public type getDType() {\r
+ public Type getDType() {\r
return dType;\r
}\r
\r
projects / deliverable / tracecompass.git / commitdiff
