kieker.analysis.plugin.reader.list.ListReader.<init> java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 List l =new LinkedList()
Collections.emptyList()
new ArrayList()
Smart code suggestions by Tabnine
}

  @Override
  protected AbstractReaderPlugin createReader(final IAnalysisController analysisController) {
    final Configuration listReaderConfig = new Configuration();
    listReaderConfig.setProperty(ListReader.CONFIG_PROPERTY_NAME_AWAIT_TERMINATION,
        Boolean.toString(Boolean.FALSE));
    final ListReader<IMonitoringRecord> listReader = new ListReader<>(listReaderConfig,
        analysisController);
    listReader.addAllObjects(this.replayList);
    return listReader;
  }
}

private void executeAnalysis(final File tempFile, final boolean append, final List<Integer> objectsToWrite) throws IllegalStateException,
    AnalysisConfigurationException {
  final Configuration configuration = new Configuration();
  configuration.setProperty(TeeFilter.CONFIG_PROPERTY_NAME_APPEND, Boolean.toString(append));
  configuration.setProperty(TeeFilter.CONFIG_PROPERTY_NAME_STREAM, tempFile.getAbsolutePath());
  final IAnalysisController analysisController = new AnalysisController();
  final TeeFilter teeFilter = new TeeFilter(configuration, analysisController);
  final ListReader<Integer> simpleListReader = new ListReader<Integer>(new Configuration(), analysisController);
  analysisController.connect(simpleListReader, ListReader.OUTPUT_PORT_NAME, teeFilter, TeeFilter.INPUT_PORT_NAME_EVENTS);
  simpleListReader.addAllObjects(objectsToWrite);
  analysisController.run();
}

/**
 * This method initializes the setup.
 */
@Before
public void before() {
  this.controller = new AnalysisController();
  this.reader = new ListReader<>(new Configuration(), this.controller);
  this.sinkPlugin = new ListCollectionFilter<>(new Configuration(), this.controller);
}

/**
 * A test for the counting filter with multiple readers.
 * 
 * @throws IllegalStateException
 *             If the test setup is somehow invalid (should not happen).
 * @throws AnalysisConfigurationException
 *             If the test setup is somehow invalid (should not happen).
 */
@Test
public void testConcurrently() throws IllegalStateException, AnalysisConfigurationException {
  this.simpleListReader.addObject(new Object());
  // register multiple readers (they fire concurrently)
  final ListReader<Object> reader2 = new ListReader<Object>(new Configuration(), this.analysisController);
  this.analysisController.connect(reader2, ListReader.OUTPUT_PORT_NAME, this.countingFilter, CountingFilter.INPUT_PORT_NAME_EVENTS);
  reader2.addObject(new Object());
  final ListReader<Object> reader3 = new ListReader<Object>(new Configuration(), this.analysisController);
  this.analysisController.connect(reader3, ListReader.OUTPUT_PORT_NAME, this.countingFilter, CountingFilter.INPUT_PORT_NAME_EVENTS);
  reader3.addObject(new Object());
  Assert.assertEquals(0, this.countingFilter.getMessageCount());
  this.analysisController.run();
  Assert.assertEquals(AnalysisController.STATE.TERMINATED, this.analysisController.getState());
  Assert.assertEquals(3, this.countingFilter.getMessageCount());
}

/**
 * This method prepares the test setup.
 * 
 * @throws IllegalStateException
 *             If something went wrong during the test setup (should not happen).
 * @throws AnalysisConfigurationException
 *             If something went wrong during the test setup (should not happen).
 */
@Before
public void before() throws IllegalStateException, AnalysisConfigurationException {
  this.analysisController = new AnalysisController();
  this.countingFilter = new CountingFilter(new Configuration(), this.analysisController);
  this.simpleListReader = new ListReader<Object>(new Configuration(), this.analysisController);
  this.analysisController.connect(this.simpleListReader, ListReader.OUTPUT_PORT_NAME, this.countingFilter, CountingFilter.INPUT_PORT_NAME_EVENTS);
}

@Test
public void testIt() throws Exception {
  final AbstractTraceProcessingFilter filter = this.provideWriterFilter(this.outputFile.getAbsolutePath(), this.analysisController);
  final ListReader<Object> reader = new ListReader<Object>(new Configuration(), this.analysisController);
  final List<Object> eventList = this.createTraces();
  reader.addAllObjects(eventList);
  this.analysisController.connect(reader, ListReader.OUTPUT_PORT_NAME, filter, this.provideFilterInputName());
  this.analysisController.connect(filter, AbstractTraceAnalysisFilter.REPOSITORY_PORT_NAME_SYSTEM_MODEL, this.modelRepo);
  this.analysisController.run();
  final String actualFileContent = StringUtils.readOutputFileAsString(this.outputFile);
  final String expectedFileContent = this.provideExpectedFileContent(eventList);
  Assert.assertEquals("Unexpected file content", expectedFileContent, actualFileContent);
}

final ListReader<Object> reader = new ListReader<Object>(new Configuration(), controller);
final TypeFilter typeFilter = new TypeFilter(typeFilterConfiguration, controller);
final ListCollectionFilter<Object> sinkPluginValidElements = new ListCollectionFilter<Object>(new Configuration(), controller);

final AnalysisController analysisController = new AnalysisController();
final ListReader<IMonitoringRecord> reader = new ListReader<>(new Configuration(), analysisController);
reader.addAllObjects(eventsToWrite);

private void runTestFailed(final TraceEventRecords records, final long maxTraceDuration, final long maxTraceTimeout) throws IllegalStateException,
AnalysisConfigurationException {
  final IAnalysisController controller = new AnalysisController();
  final ListReader<Object> reader = new ListReader<>(new Configuration(), controller);
  final Configuration configuration = new Configuration();
  configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_DURATION, Long.toString(maxTraceDuration));
  configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_TIMEOUT, Long.toString(maxTraceTimeout));
  final EventRecordTraceReconstructionFilter traceFilter = new EventRecordTraceReconstructionFilter(configuration, controller);
  final ListCollectionFilter<TraceEventRecords> sinkPlugin = new ListCollectionFilter<>(new Configuration(), controller);
  Assert.assertTrue(sinkPlugin.getList().isEmpty());
  controller.connect(reader, ListReader.OUTPUT_PORT_NAME, traceFilter, EventRecordTraceReconstructionFilter.INPUT_PORT_NAME_TRACE_RECORDS);
  controller.connect(traceFilter, EventRecordTraceReconstructionFilter.OUTPUT_PORT_NAME_TRACE_VALID, sinkPlugin, ListCollectionFilter.INPUT_PORT_NAME);
  reader.addObject(records.getTraceMetadata());
  for (final AbstractTraceEvent e : records.getTraceEvents()) {
    reader.addObject(e);
  }
  controller.run();
  Assert.assertEquals(AnalysisController.STATE.TERMINATED, controller.getState());
  // Make sure that no trace is generated
  Assert.assertEquals("There should be no trace", 0, sinkPlugin.getList().size());
}

final IAnalysisController controller = new AnalysisController();
final ListReader<Object> reader = new ListReader<>(new Configuration(), controller);

final ListReader<TraceEventRecords> reader = new ListReader<TraceEventRecords>(readerConfiguration, this.analysisController);
reader.addObject(traceEvents);

private void runTestEventBasedTraceRepair(final TraceEventRecords records, final long maxTraceDuration, final long maxTraceTimeout)
    throws IllegalStateException,
    AnalysisConfigurationException {
  final IAnalysisController controller = new AnalysisController();
  final ListReader<Object> reader = new ListReader<>(new Configuration(), controller);
  final Configuration configuration = new Configuration();
  configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_DURATION, Long.toString(maxTraceDuration));
  configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_TIMEOUT, Long.toString(maxTraceTimeout));
  configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_REPAIR_EVENT_BASED_TRACES, "true");
  final EventRecordTraceReconstructionFilter traceFilter = new EventRecordTraceReconstructionFilter(configuration, controller);
  final ListCollectionFilter<TraceEventRecords> sinkPlugin = new ListCollectionFilter<>(new Configuration(), controller);
  Assert.assertTrue(sinkPlugin.getList().isEmpty());
  controller.connect(reader, ListReader.OUTPUT_PORT_NAME, traceFilter, EventRecordTraceReconstructionFilter.INPUT_PORT_NAME_TRACE_RECORDS);
  controller.connect(traceFilter, EventRecordTraceReconstructionFilter.OUTPUT_PORT_NAME_TRACE_VALID, sinkPlugin, ListCollectionFilter.INPUT_PORT_NAME);
  reader.addObject(records.getTraceMetadata());
  for (final AbstractTraceEvent e : records.getTraceEvents()) {
    reader.addObject(e);
  }
  controller.run();
  Assert.assertEquals(AnalysisController.STATE.TERMINATED, controller.getState());
  Assert.assertEquals("No trace passed filter", 1, sinkPlugin.getList().size());
  Assert.assertTrue("Repair failed", records.getTraceEvents().length < sinkPlugin.getList().get(0).getTraceEvents().length);
  Assert.assertEquals("Did not repair all BeforeEvents", sinkPlugin.getList().get(0).getTraceEvents().length, 10);
}

final ListReader<NamedDoubleTimeSeriesPoint> theReaderForecast = new ListReader<>(readerForecastConfiguration, this.controller);
theReaderForecast.addAllObjects(this.createInputEventSetForecast());

/**
 * Set up for the AnomalyScoreCalculationFilterTest.
 *
 * @throws IllegalStateException
 *             If illegal state
 * @throws AnalysisConfigurationException
 *             If wrong configuration
 */
@Before
public void setUp() throws IllegalStateException,
    AnalysisConfigurationException {
  this.controller = new AnalysisController();
  // READER
  final Configuration readerScoreCalcConfiguration = new Configuration();
  readerScoreCalcConfiguration.setProperty(ListReader.CONFIG_PROPERTY_NAME_AWAIT_TERMINATION, Boolean.TRUE.toString());
  final ListReader<ForecastMeasurementPair> theReaderScoreCalc = new ListReader<>(readerScoreCalcConfiguration, this.controller);
  theReaderScoreCalc.addAllObjects(this.createInputEventSetScoreCalc());
  final Configuration scoreConfiguration = new Configuration();
  final AnomalyScoreCalculationFilter scoreCalc = new AnomalyScoreCalculationFilter(scoreConfiguration, this.controller);
  // SINK 1
  this.sinkAnomalyScore = new ListCollectionFilter<>(new Configuration(), this.controller);
  // CONNECTION
  this.controller
      .connect(theReaderScoreCalc, ListReader.OUTPUT_PORT_NAME, scoreCalc, AnomalyScoreCalculationFilter.INPUT_PORT_CURRENT_FORECAST_PAIR);
  this.controller
      .connect(scoreCalc, AnomalyScoreCalculationFilter.OUTPUT_PORT_ANOMALY_SCORE, this.sinkAnomalyScore, ListCollectionFilter.INPUT_PORT_NAME);
}

@Ignore // NOCS
@Test
public void testRecordsWithoutStringSame() throws IllegalStateException, AnalysisConfigurationException {
  final AnalysisController analysisController = new AnalysisController();
  final ListReader<IMonitoringRecord> reader = new ListReader<>(new Configuration(), analysisController);
  final StringBufferFilter stringBufferFilter = new StringBufferFilter(new Configuration(), analysisController);
  final ListCollectionFilter<IMonitoringRecord> collectionFilter = new ListCollectionFilter<>(new Configuration(), analysisController);
  analysisController.connect(reader, ListReader.OUTPUT_PORT_NAME, stringBufferFilter, StringBufferFilter.INPUT_PORT_NAME_EVENTS);
  analysisController.connect(stringBufferFilter, StringBufferFilter.OUTPUT_PORT_NAME_RELAYED_EVENTS, collectionFilter, ListCollectionFilter.INPUT_PORT_NAME);
  final IMonitoringRecord recordIn1 = new EmptyRecord();
  reader.addObject(recordIn1);
  analysisController.run();
  Assert.assertEquals(AnalysisController.STATE.TERMINATED, analysisController.getState());
  final List<IMonitoringRecord> records = collectionFilter.getList();
  Assert.assertEquals("Unexpected number of records", 1, records.size());
  final IMonitoringRecord recordOut1 = records.get(0);
  Assert.assertSame("First output record not same as first input record", recordIn1, recordOut1); // includes no String, hence "as-is"
}

private void runTestFailedInterleaved(final TraceEventRecords trace1, final TraceEventRecords trace2, final long maxTraceDuration, final long maxTraceTimeout)
    throws IllegalStateException, AnalysisConfigurationException {
  final IAnalysisController controller = new AnalysisController();
  final ListReader<Object> reader = new ListReader<>(new Configuration(), controller);
  final Configuration configuration = new Configuration();
  configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_DURATION, Long.toString(maxTraceDuration));
  configuration.setProperty(EventRecordTraceReconstructionFilter.CONFIG_PROPERTY_NAME_MAX_TRACE_TIMEOUT, Long.toString(maxTraceTimeout));
  final EventRecordTraceReconstructionFilter traceFilter = new EventRecordTraceReconstructionFilter(configuration, controller);
  final ListCollectionFilter<TraceEventRecords> sinkPlugin = new ListCollectionFilter<>(new Configuration(), controller);
  Assert.assertTrue(sinkPlugin.getList().isEmpty());
  final ListCollectionFilter<TraceEventRecords> sinkPluginFailed = new ListCollectionFilter<>(new Configuration(), controller);
  Assert.assertTrue(sinkPluginFailed.getList().isEmpty());
  controller.connect(reader, ListReader.OUTPUT_PORT_NAME, traceFilter, EventRecordTraceReconstructionFilter.INPUT_PORT_NAME_TRACE_RECORDS);
  controller.connect(traceFilter, EventRecordTraceReconstructionFilter.OUTPUT_PORT_NAME_TRACE_VALID, sinkPlugin, ListCollectionFilter.INPUT_PORT_NAME);
  controller.connect(traceFilter, EventRecordTraceReconstructionFilter.OUTPUT_PORT_NAME_TRACE_INVALID, sinkPluginFailed, ListCollectionFilter.INPUT_PORT_NAME);
  reader.addObject(trace1.getTraceMetadata());
  reader.addObject(trace2.getTraceMetadata());
  final AbstractTraceEvent[] events1 = trace1.getTraceEvents();
  final AbstractTraceEvent[] events2 = trace2.getTraceEvents();
  for (int i = 0; i < events1.length; i++) {
    reader.addObject(events1[i]);
    reader.addObject(events2[i]);
  }
  controller.run();
  Assert.assertEquals(AnalysisController.STATE.TERMINATED, controller.getState());
  // Make sure that only one of the two traces is generated
  Assert.assertEquals("There should be no trace", 1, sinkPlugin.getList().size());
}

final ListReader<StorableDetectionResult> theReader = new ListReader<>(readerConfiguration, this.controller);
theReader.addAllObjects(this.createInputEventSet());

@Ignore // NOCS
@Test
public void testRecordsWithStringEqualButNeverSame() throws IllegalStateException, AnalysisConfigurationException {
  final IAnalysisController analysisController = new AnalysisController();
  final ListReader<IMonitoringRecord> reader = new ListReader<>(new Configuration(), analysisController);
  final StringBufferFilter stringBufferFilter = new StringBufferFilter(new Configuration(), analysisController);
  final ListCollectionFilter<IMonitoringRecord> collectionFilter = new ListCollectionFilter<>(new Configuration(), analysisController);
  analysisController.connect(reader, ListReader.OUTPUT_PORT_NAME, stringBufferFilter, StringBufferFilter.INPUT_PORT_NAME_EVENTS);
  analysisController.connect(stringBufferFilter, StringBufferFilter.OUTPUT_PORT_NAME_RELAYED_EVENTS, collectionFilter, ListCollectionFilter.INPUT_PORT_NAME);
  long timestamp = 3268936L;
  final IMonitoringRecord recordIn1 = TestStringBufferFilter.createOperationExecutionRecord(timestamp);
  timestamp++;
  final IMonitoringRecord recordIn2 = TestStringBufferFilter.createOperationExecutionRecord(timestamp);
  reader.addObject(recordIn1);
  reader.addObject(recordIn2);
  analysisController.run();
  Assert.assertEquals(AnalysisController.STATE.TERMINATED, analysisController.getState());
  final List<IMonitoringRecord> records = collectionFilter.getList();
  Assert.assertEquals("Unexpected number of records", 2, records.size());
  final IMonitoringRecord recordOut1 = records.get(0);
  final IMonitoringRecord recordOut2 = records.get(1);
  Assert.assertNotSame("First output record same as first input record", recordIn1, recordOut1); // includes String, hence NOT "as-is"
  Assert.assertEquals("First output record doesn't equal first input record", recordIn1, recordOut1); // ... but must be equal
  Assert.assertNotSame("Second output record same as second input record", recordIn2, recordOut2); // includes String, hence NOT "as-is"
  Assert.assertEquals("Second output record doesn't equal second input record", recordIn2, recordOut2); // ... but must be equal
}

/**
 * Sets up a simple test filter structure (SimpleListReader -> RecordConverter -> ListCollectionFilter)
 * and creates an OperationExecutionRecord that will be converterd for testing reasons.
 * 
 * @throws Exception
 *             throws exceptions that are thrown while setting up the filter structure
 */
@Before
public void setUp() throws Exception {
  final OperationExecutionRecord oer;
  final RecordConverter recordConverter;
  this.analysisController = new AnalysisController();
  recordConverter = new RecordConverter(new Configuration(), this.analysisController);
  this.simpleListReader = new ListReader<OperationExecutionRecord>(new Configuration(), this.analysisController);
  this.listCollectionfilter = new ListCollectionFilter<NamedDoubleRecord>(new Configuration(), this.analysisController);
  this.analysisController.connect(this.simpleListReader, ListReader.OUTPUT_PORT_NAME, recordConverter, RecordConverter.INPUT_PORT_NAME_OER);
  this.analysisController.connect(recordConverter, RecordConverter.OUTPUT_PORT_NAME_NDR, this.listCollectionfilter, ListCollectionFilter.INPUT_PORT_NAME);
  oer = new OperationExecutionRecord(RecordConverterTest.operationSignature,
      OperationExecutionRecord.NO_SESSION_ID,
      OperationExecutionRecord.NO_TRACE_ID,
      RecordConverterTest.timeIn,
      RecordConverterTest.timeOut,
      RecordConverterTest.hostAppInput,
      OperationExecutionRecord.NO_EOI_ESS,
      OperationExecutionRecord.NO_EOI_ESS);
  oer.setLoggingTimestamp(RecordConverterTest.loggingTimestamp);
  this.convertRecord(oer);
}

private static GraphTestSetup prepareEnvironment(final AnalysisController analysisController, final AbstractGraphProducingFilter<?> graphProducer,
    final String inputPortName, final String systemModelRepositoryPortName, final List<OperationExecutionRecord> executionRecords,
    final AbstractGraphFilter<?, ?, ?, ?>... graphFilters) throws AnalysisConfigurationException {
  final SystemModelRepository systemModelRepository = new SystemModelRepository(new Configuration(), analysisController);
  final ListReader<OperationExecutionRecord> readerPlugin = new ListReader<>(new Configuration(), analysisController);
  readerPlugin.addAllObjects(executionRecords);
  final ExecutionRecordTransformationFilter transformationFilter = new ExecutionRecordTransformationFilter(new Configuration(), analysisController);
  final TraceReconstructionFilter traceReconstructionFilter = new TraceReconstructionFilter(new Configuration(), analysisController);
  // Correct the behavior of the extended list filter as properties are not inherited.
  final Configuration graphReceiverConfiguration = new Configuration();
  graphReceiverConfiguration.setProperty(ListCollectionFilter.CONFIG_PROPERTY_NAME_MAX_NUMBER_OF_ENTRIES,
      ListCollectionFilter.CONFIG_PROPERTY_VALUE_NUMBER_OF_ENTRIES);
  final GraphReceiverPlugin graphReceiver = new GraphReceiverPlugin(graphReceiverConfiguration, analysisController);
  // Connect repositories
  analysisController.connect(transformationFilter, AbstractTraceAnalysisFilter.REPOSITORY_PORT_NAME_SYSTEM_MODEL, systemModelRepository);
  analysisController.connect(traceReconstructionFilter, AbstractTraceAnalysisFilter.REPOSITORY_PORT_NAME_SYSTEM_MODEL, systemModelRepository);
  if (systemModelRepositoryPortName != null) {
    analysisController.connect(graphProducer, systemModelRepositoryPortName, systemModelRepository);
  }
  // Connect plugins
  analysisController.connect(readerPlugin, ListReader.OUTPUT_PORT_NAME,
      transformationFilter, ExecutionRecordTransformationFilter.INPUT_PORT_NAME_RECORDS);
  analysisController.connect(transformationFilter, ExecutionRecordTransformationFilter.OUTPUT_PORT_NAME_EXECUTIONS,
      traceReconstructionFilter, TraceReconstructionFilter.INPUT_PORT_NAME_EXECUTIONS);
  analysisController.connect(traceReconstructionFilter, TraceReconstructionFilter.OUTPUT_PORT_NAME_MESSAGE_TRACE,
      graphProducer, inputPortName);
  DependencyGraphTestUtil.connectGraphFilters(analysisController, graphProducer, graphFilters, graphReceiver);
  return new GraphTestSetup(analysisController, graphReceiver);
}

Javadoc

Creates a new instance of this class using the given parameters.

Popular methods of ListReader

addAllObjects
This method adds all given records to our list.
addObject
This method adds the given object to our list.

Popular in Java

Reactive rest calls using spring rest template
getApplicationContext (Context)
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
runOnUiThread (Activity)
InputStream (java.io)
A readable source of bytes.Most clients will use input streams that read data from the file system (
PrintWriter (java.io)
Wraps either an existing OutputStream or an existing Writerand provides convenience methods for prin
StringTokenizer (java.util)
Breaks a string into tokens; new code should probably use String#split.> // Legacy code: StringTo
Modifier (javassist)
The Modifier class provides static methods and constants to decode class and member access modifiers
BoxLayout (javax.swing)
StringUtils (org.apache.commons.lang)
Operations on java.lang.String that arenull safe. * IsEmpty/IsBlank - checks if a String contains
21 Best IntelliJ Plugins

How to use kieker.analysis.plugin.reader.list.ListReaderconstructor

Best Java code snippets using kieker.analysis.plugin.reader.list.ListReader.<init> (Showing top 20 results out of 315)

How to use
kieker.analysis.plugin.reader.list.ListReader
constructor