<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="stubs"/>
org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
org.eclipse.jdt.core.compiler.annotation.nullanalysis=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.7
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.discouragedReference=error
org.eclipse.jdt.core.compiler.problem.emptyStatement=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=error
org.eclipse.jdt.core.compiler.problem.fallthroughCase=error
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=error
org.eclipse.jdt.core.compiler.problem.rawTypeReference=error
org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=error
-org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=error
org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=error
org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=error
org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedWarningToken=error
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=error
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.7
org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
Bundle-SymbolicName: org.eclipse.linuxtools.tmf.core.tests;singleton:=true
Bundle-Activator: org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin
Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
Require-Bundle: org.junit;bundle-version="4.0.0",
org.eclipse.core.runtime,
org.eclipse.core.resources,
@Test
public void testGetPlainEvents() {
final int NB_EVENTS = 1000;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
// Get the TmfSyntheticEventStub provider
ITmfEventProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class,
final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1 = 10;
final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2 = 800;
- final Vector<ITmfEvent> requestedEventsReq1 = new Vector<ITmfEvent>();
- final Vector<ITmfEvent> requestedEventsReq2 = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEventsReq1 = new Vector<>();
+ final Vector<ITmfEvent> requestedEventsReq2 = new Vector<>();
// Get the TmfSyntheticEventStub provider
ITmfEventProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class,
private static void getSyntheticData(final TmfTimeRange range,
final int nbEvents) throws InterruptedException {
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
// Get the event provider
ITmfEventProvider[] eventProviders = TmfProviderManager
public void testTooManyContexts() throws InterruptedException {
final int lwcCount = 101;
double increment = (end - begin) / lwcCount;
- final ArrayList<Long> vals = new ArrayList<Long>();
- final ArrayList<Thread> threads = new ArrayList<Thread>();
- final ArrayList<CtfTmfContext> tooManyContexts = new ArrayList<CtfTmfContext>();
+ final ArrayList<Long> vals = new ArrayList<>();
+ final ArrayList<Thread> threads = new ArrayList<>();
+ final ArrayList<CtfTmfContext> tooManyContexts = new ArrayList<>();
for (double i = begin; i < end; i += increment) {
SeekerThread thread = new SeekerThread() {
// Work variables
Long nbEvent = 0L;
- final Vector<Double> benchs = new Vector<Double>();
+ final Vector<Double> benchs = new Vector<>();
CtfTmfTrace trace = null;
long start, stop;
for (int loops = 0; loops < NUM_LOOPS; loops++) {
// Work variables
private static int nbEvent = 0;
private static TmfExperiment fExperiment = null;
- private static Vector<Double> benchs = new Vector<Double>();
+ private static Vector<Double> benchs = new Vector<>();
/**
* Run the benchmark
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
final long REQUEST_OFFSET = 1000;
- requestedEvents1 = new Vector<ITmfEvent>();
+ requestedEvents1 = new Vector<>();
request1 = new TmfEventRequest(ITmfEvent.class, range, signal.fIndex,
NB_EVENTS, ExecutionType.FOREGROUND) {
@Override
}
};
- requestedEvents2 = new Vector<ITmfEvent>();
+ requestedEvents2 = new Vector<>();
request2 = new TmfEventRequest(ITmfEvent.class, range,
signal.fIndex + REQUEST_OFFSET, NB_EVENTS, ExecutionType.FOREGROUND) {
@Override
}
};
- requestedEvents3 = new Vector<ITmfEvent>();
+ requestedEvents3 = new Vector<>();
request3 = new TmfEventRequest(ITmfEvent.class, range,
signal.fIndex + 2 * REQUEST_OFFSET, NB_EVENTS, ExecutionType.FOREGROUND) {
@Override
private long fEndTime;
private TmfTimeRange fForegroundTimeRange;
- private final List<String> fOrderList = new ArrayList<String>();
+ private final List<String> fOrderList = new ArrayList<>();
private int fForegroundId = 0;
private int fBackgroundId = 0;
@Ignore
@Test
public void executionOrder() {
- List<String> expectedOrder = new LinkedList<String>();
+ List<String> expectedOrder = new LinkedList<>();
expectedOrder.add("FOREGROUND1");
expectedOrder.add("FOREGROUND2");
expectedOrder.add("FOREGROUND3");
*/
@Test
public void testMultipleChannels() {
- List<MySignal> signals = new ArrayList<MySignal>();
+ List<MySignal> signals = new ArrayList<>();
signals.add(new MySignal(sender, 0));
signals.add(new MySignal(sender, 0));
signals.add(new MySignal(sender, 0));
*/
@Test
public void testDoQuery() {
- List<ITmfStateInterval> interval = new ArrayList<ITmfStateInterval>(NUMBER_OF_ATTRIBUTES);
+ List<ITmfStateInterval> interval = new ArrayList<>(NUMBER_OF_ATTRIBUTES);
for (int i = 0; i < NUMBER_OF_ATTRIBUTES; i++) {
interval.add(null);
}
testInterval(interval[8], 908, 998, 9);
testInterval(interval[9], 909, 999, 9);
- List<ITmfStateInterval> intervalQuery = new ArrayList<ITmfStateInterval>(NUMBER_OF_ATTRIBUTES);
+ List<ITmfStateInterval> intervalQuery = new ArrayList<>(NUMBER_OF_ATTRIBUTES);
for (int i = 0; i < NUMBER_OF_ATTRIBUTES; i++) {
intervalQuery.add(null);
}
*/
@Test
public void testEquality() {
- Map<ITmfTimestampTransform, String> map = new HashMap<ITmfTimestampTransform, String>();
+ Map<ITmfTimestampTransform, String> map = new HashMap<>();
ITmfTimestampTransform ttl = new TmfTimestampTransformLinear(BigDecimal.valueOf(2.0), BigDecimal.valueOf(3));
ITmfTimestampTransform ttl2 = new TmfTimestampTransformLinear(BigDecimal.valueOf(2.0), BigDecimal.valueOf(3));
ITmfTimestampTransform ttl3 = new TmfTimestampTransformLinear(BigDecimal.valueOf(3), BigDecimal.valueOf(3));
@Test
public void testProcessRequestForNbEvents() throws InterruptedException {
final int nbEvents = 1000;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
@Test
public void testProcessRequestForAllEvents() throws InterruptedException {
final int nbEvents = ITmfEventRequest.ALL_DATA;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final long nbExpectedEvents = NB_EVENTS;
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
public void testCancel() throws InterruptedException {
final int nbEvents = NB_EVENTS;
final int limit = BLOCK_SIZE;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
@Test
public void testProcessRequestForNbEvents() throws InterruptedException {
final int nbEvents = 1000;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
@Test
public void testProcessRequestForAllEvents() throws InterruptedException {
final int nbEvents = ITmfEventRequest.ALL_DATA;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final long nbExpectedEvents = NB_EVENTS;
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
public void testCancel() throws InterruptedException {
final int nbEvents = NB_EVENTS;
final int limit = BLOCK_SIZE;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
@Test
public void testProcessEventRequestForAllEvents() throws InterruptedException {
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
@Test
public void testProcessEventRequestForNbEvents() throws InterruptedException {
final int nbEvents = 1000;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
public void testProcessEventRequestForSomeEvents() throws InterruptedException {
final long startTime = 100;
final int nbEvents = 1000;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
final int startIndex = 99;
final long startTime = 100;
final int nbEvents = 1000;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
public void testProcessDataRequestForSomeEvents() throws InterruptedException {
final int startIndex = 100;
final int nbEvents = 1000;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
TmfTimeRange.ETERNITY,
@Test
public void testCancel() throws InterruptedException {
final int limit = 500;
- final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
public void testVersionChange() throws IOException {
fCheckpointCollection.setIndexComplete();
fCheckpointCollection.dispose();
- RandomAccessFile f = new RandomAccessFile(fFile, "rw");
- f.writeInt(-1);
- f.close();
+ try (RandomAccessFile f = new RandomAccessFile(fFile, "rw");) {
+ f.writeInt(-1);
+ }
fCheckpointCollection = createCollection();
assertTrue(fCheckpointCollection.isCreatedFromScratch());
}
boolean random = true;
- ArrayList<Integer> list = new ArrayList<Integer>();
+ ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < CHECKPOINTS_INSERT_NUM; i++) {
if (random) {
Random rand = new Random();
}
boolean random = true;
- ArrayList<Integer> list = new ArrayList<Integer>();
+ ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < CHECKPOINTS_INSERT_NUM; i++) {
if (random) {
Random rand = new Random();
private static void generateDataFile(ArrayList<Integer> list, int checkpointsNums) throws IOException {
File randomDataFile = new File("data" + checkpointsNums);
- RandomAccessFile f = new RandomAccessFile(randomDataFile, "rw");
- if (randomDataFile.exists()) {
- for (int i = 0; i < checkpointsNums; i++) {
- Random rand = new Random();
- int nextInt = rand.nextInt(checkpointsNums);
- list.add(nextInt);
- f.writeInt(nextInt);
- }
- } else {
- for (int i = 0; i < checkpointsNums; i++) {
- list.add(f.readInt());
+ try (RandomAccessFile f = new RandomAccessFile(randomDataFile, "rw");) {
+ if (randomDataFile.exists()) {
+ for (int i = 0; i < checkpointsNums; i++) {
+ Random rand = new Random();
+ int nextInt = rand.nextInt(checkpointsNums);
+ list.add(nextInt);
+ f.writeInt(nextInt);
+ }
+ } else {
+ for (int i = 0; i < checkpointsNums; i++) {
+ list.add(f.readInt());
+ }
}
}
- f.close();
}
@SuppressWarnings("javadoc")
public static void main(String[] args) throws IOException {
int checkpointsNums [] = new int [] { 5000, 50000, 500000, 1000000 };
- nums = new ArrayList<ArrayList<Integer>>(checkpointsNums.length);
+ nums = new ArrayList<>(checkpointsNums.length);
System.out.println("DEGREE: " + BTREE_DEGREE);
AllBench b = new AllBench();
b.setUp();
for (int i = 0; i < checkpointsNums.length; i++) {
- ArrayList<Integer> list = new ArrayList<Integer>();
+ ArrayList<Integer> list = new ArrayList<>();
generateDataFile(list, checkpointsNums[i]);
nums.add(list);
writeCheckpoints(checkpointsNum);
- ArrayList<Integer> list = new ArrayList<Integer>();
+ ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < checkpointsNum; i++) {
list.add(i);
}
writeCheckpointsArray(checkpointsNum);
- ArrayList<Integer> list = new ArrayList<Integer>();
+ ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < checkpointsNum; i++) {
list.add(i);
}
// Field(s)
// ------------------------------------------------------------------------
- Pair<String, Long> fPair1 = new Pair<String, Long>("String 1", 1L);
- Pair<String, Long> fPair2 = new Pair<String, Long>("String 2", 2L);
+ Pair<String, Long> fPair1 = new Pair<>("String 1", 1L);
+ Pair<String, Long> fPair2 = new Pair<>("String 2", 2L);
// ------------------------------------------------------------------------
// to String
@Test
public void testAccessors() {
- Pair<String, Long> myPair = new Pair<String, Long>("String 1", 1L);
+ Pair<String, Long> myPair = new Pair<>("String 1", 1L);
assertEquals("String 1", myPair.getFirst());
assertEquals(Long.valueOf(1L), myPair.getSecond());
@Test
public void testEqualsSymmetry() {
- Pair<String, Long> info1 = new Pair<String, Long>(fPair1.getFirst(), fPair1.getSecond().longValue());
- Pair<String, Long> info2 = new Pair<String, Long>(fPair2.getFirst(), fPair2.getSecond().longValue());
+ Pair<String, Long> info1 = new Pair<>(fPair1.getFirst(), fPair1.getSecond().longValue());
+ Pair<String, Long> info2 = new Pair<>(fPair2.getFirst(), fPair2.getSecond().longValue());
assertTrue("equals", info1.equals(fPair1));
assertTrue("equals", fPair1.equals(info1));
@Test
public void testEqualsTransivity() {
- Pair<String, Long> info1 = new Pair<String, Long>(fPair1.getFirst(), fPair1.getSecond().longValue());
- Pair<String, Long> info2 = new Pair<String, Long>(fPair1.getFirst(), fPair1.getSecond().longValue());
- Pair<String, Long> info3 = new Pair<String, Long>(fPair1.getFirst(), fPair1.getSecond().longValue());
+ Pair<String, Long> info1 = new Pair<>(fPair1.getFirst(), fPair1.getSecond().longValue());
+ Pair<String, Long> info2 = new Pair<>(fPair1.getFirst(), fPair1.getSecond().longValue());
+ Pair<String, Long> info3 = new Pair<>(fPair1.getFirst(), fPair1.getSecond().longValue());
assertTrue("equals", info1.equals(info2));
assertTrue("equals", info2.equals(info3));
@Test
public void testEqualsDifferentObj() {
- Pair<Long, String> info = new Pair<Long, String>(1L, "String1");
+ Pair<Long, String> info = new Pair<>(1L, "String1");
assertTrue("equals", !fPair1.equals(info));
}
@Test
public void testHashCode() {
- Pair<String, Long> info1 = new Pair<String, Long>(fPair1.getFirst(), fPair1.getSecond().longValue());
- Pair<String, Long> info2 = new Pair<String, Long>(fPair2.getFirst(), fPair2.getSecond().longValue());
+ Pair<String, Long> info1 = new Pair<>(fPair1.getFirst(), fPair1.getSecond().longValue());
+ Pair<String, Long> info2 = new Pair<>(fPair2.getFirst(), fPair2.getSecond().longValue());
assertTrue("hashCode", fPair1.hashCode() == info1.hashCode());
assertTrue("hashCode", fPair2.hashCode() == info2.hashCode());
* @throws FileNotFoundException
* @throws IOException
*/
- private static void createTestFile(final String file, final int size, final boolean monotonic, final boolean odd) throws FileNotFoundException, IOException {
- DataOutputStream out;
+ private static void createTestFile(final String file, final int size,
+ final boolean monotonic, final boolean odd)
+ throws IOException {
System.out.println("Creating " + file);
- out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
+ try (DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));) {
- final Random generator = new Random(19580427 + size);
- long ts = (monotonic && odd) ? -1 : 0;
- for (int i = 0; i < size; i++) {
- ts += monotonic ? 2 : generator.nextInt(10);
- final int sourceIndex = i % NB_SOURCES;
- final int typeIndex = i % NB_TYPES;
- out.writeLong(ts); // Timestamp
- out.writeUTF("Source-" + sourceIndex); // Source
- out.writeUTF("Type-" + typeIndex); // Type
- out.writeInt(i + 1); // Reference (event #)
- for (int j = 0; j < typeIndex; j++) {
- out.writeUTF("Field-" + sourceIndex + "-" + j);
+ final Random generator = new Random(19580427 + size);
+ long ts = (monotonic && odd) ? -1 : 0;
+ for (int i = 0; i < size; i++) {
+ ts += monotonic ? 2 : generator.nextInt(10);
+ final int sourceIndex = i % NB_SOURCES;
+ final int typeIndex = i % NB_TYPES;
+ out.writeLong(ts); // Timestamp
+ out.writeUTF("Source-" + sourceIndex); // Source
+ out.writeUTF("Type-" + typeIndex); // Type
+ out.writeInt(i + 1); // Reference (event #)
+ for (int j = 0; j < typeIndex; j++) {
+ out.writeUTF("Field-" + sourceIndex + "-" + j);
+ }
}
+ out.flush();
}
- out.flush();
- out.close();
}
}
fEventStream = eventStream;
fTypes = new TmfEventType[NB_TYPES];
for (int i = 0; i < NB_TYPES; i++) {
- final Vector<String> fields = new Vector<String>();
+ final Vector<String> fields = new Vector<>();
for (int j = 1; j <= i; j++) {
final String field = "Fmt-" + i + "-Fld-" + j;
fields.add(field);
projects / deliverable / tracecompass.git / commitdiff
