This is an automated email from the ASF dual-hosted git repository.

zehnder pushed a commit to branch dev
in repository https://gitbox.apache.org/repos/asf/streampipes.git


The following commit(s) were added to refs/heads/dev by this push:
     new 3fc9e44e3f #2545 migrated TestBooleanCounterProcessor parameterized 
test to junit5 (#2683)
3fc9e44e3f is described below

commit 3fc9e44e3fbd67839ccea67393c7d184b852214c
Author: Isaak Krut <[email protected]>
AuthorDate: Thu Apr 4 03:15:09 2024 -0400

    #2545 migrated TestBooleanCounterProcessor parameterized test to junit5 
(#2683)
---
 .../pom.xml                                        |   4 +
 .../counter/TestBooleanCounterProcessor.java       | 266 +++++++++++----------
 2 files changed, 150 insertions(+), 120 deletions(-)

diff --git 
a/streampipes-extensions/streampipes-processors-transformation-jvm/pom.xml 
b/streampipes-extensions/streampipes-processors-transformation-jvm/pom.xml
index 922698838f..fc060d8a13 100644
--- a/streampipes-extensions/streampipes-processors-transformation-jvm/pom.xml
+++ b/streampipes-extensions/streampipes-processors-transformation-jvm/pom.xml
@@ -65,6 +65,10 @@
             <artifactId>mockito-core</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+        </dependency>
     </dependencies>
 
     <build>
diff --git 
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/booloperator/counter/TestBooleanCounterProcessor.java
 
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/booloperator/counter/TestBooleanCounterProcessor.java
index 536812db19..a9fb7f39c8 100644
--- 
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/booloperator/counter/TestBooleanCounterProcessor.java
+++ 
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/booloperator/counter/TestBooleanCounterProcessor.java
@@ -18,129 +18,155 @@
 
 package 
org.apache.streampipes.processors.transformation.jvm.processor.booloperator.counter;
 
-//@RunWith(Parameterized.class)
+import org.apache.streampipes.commons.exceptions.SpRuntimeException;
+import org.apache.streampipes.extensions.api.pe.routing.SpOutputCollector;
+import org.apache.streampipes.messaging.InternalEventProcessor;
+import org.apache.streampipes.model.graph.DataProcessorDescription;
+import org.apache.streampipes.model.graph.DataProcessorInvocation;
+import org.apache.streampipes.model.runtime.Event;
+import org.apache.streampipes.model.runtime.EventFactory;
+import org.apache.streampipes.model.runtime.SchemaInfo;
+import org.apache.streampipes.model.runtime.SourceInfo;
+import org.apache.streampipes.model.staticproperty.MappingPropertyUnary;
+import org.apache.streampipes.model.staticproperty.OneOfStaticProperty;
+import org.apache.streampipes.test.generator.EventStreamGenerator;
+import org.apache.streampipes.test.generator.InvocationGraphGenerator;
+import org.apache.streampipes.test.generator.grounding.EventGroundingGenerator;
+import org.apache.streampipes.wrapper.params.compat.ProcessorParams;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 public class TestBooleanCounterProcessor {
-//  private static final Logger LOG = 
LoggerFactory.getLogger(TestBooleanCounterProcessor.class);
-//
-//  @org.junit.runners.Parameterized.Parameters
-//  public static Iterable<Object[]> data() {
-//    return Arrays.asList(new Object[][]{
-//            {"Test", "BOTH", Arrays.asList(false, true), 1},
-//            {"Test", "BOTH", Arrays.asList(false, true, false), 2},
-//            {"Test", "BOTH", Arrays.asList(false), 0},
-//            {"Test", "TRUE -> FALSE", Arrays.asList(false, true, false, 
false, true), 2},
-//            {"Test", "TRUE -> FALSE", Arrays.asList(true, false), 1},
-//            {"Test", "TRUE -> FALSE", Arrays.asList(false), 1},
-//            {"Test", "FALSE -> TRUE", Arrays.asList(false), 0},
-//            {"Test", "FALSE -> TRUE", Arrays.asList(false, false, true), 1},
-//            {"Test", "FALSE -> TRUE", Arrays.asList(false, true, true, 
false), 1},
-//    });
-//  }
-//
-//  @org.junit.runners.Parameterized.Parameter
-//  public String invertFieldName;
-//
-//  /**
-//   * Defines which boolean changes should be counted
+  private static final Logger LOG = 
LoggerFactory.getLogger(TestBooleanCounterProcessor.class);
+
+  static Stream<Arguments> data() {
+    return Stream.of(
+        Arguments.of("Test", "BOTH", Arrays.asList(false, true), 1),
+        Arguments.of("Test", "BOTH", Arrays.asList(false, true, false), 2),
+        Arguments.of("Test", "BOTH", Arrays.asList(false), 0),
+        Arguments.of("Test", "TRUE -> FALSE", Arrays.asList(false, true, 
false, false, true), 2),
+        Arguments.of("Test", "TRUE -> FALSE", Arrays.asList(true, false), 1),
+        Arguments.of("Test", "TRUE -> FALSE", Arrays.asList(false), 1),
+        Arguments.of("Test", "FALSE -> TRUE", Arrays.asList(false), 0),
+        Arguments.of("Test", "FALSE -> TRUE", Arrays.asList(false, false, 
true), 1),
+        Arguments.of("Test", "FALSE -> TRUE", Arrays.asList(false, false, 
true), 1),
+        Arguments.of("Test", "FALSE -> TRUE", Arrays.asList(false, true, true, 
false), 1)
+    );
+  }
+
+  //  /**
+//   * flankUp defines which boolean changes should be counted
 //   * 0: BOTH
 //   * 1: TRUE -> FALSE
 //   * 2: FALSE -> TRUE
 //   */
-//  @org.junit.runners.Parameterized.Parameter(1)
-//  public String flankUp;
-//
-//  @org.junit.runners.Parameterized.Parameter(2)
-//  public List<Boolean> eventBooleans;
-//
-//  @org.junit.runners.Parameterized.Parameter(3)
-//  public Integer expectedBooleanCount;
-//
-//  @Test
-//  public void testBooleanCounter() {
-//    BooleanCounterProcessor booleanCounter = new BooleanCounterProcessor();
-//    DataProcessorDescription originalGraph = 
booleanCounter.declareConfig().getDescription();
-//    
originalGraph.setSupportedGrounding(EventGroundingGenerator.makeDummyGrounding());
-//
-//    DataProcessorInvocation graph =
-//            InvocationGraphGenerator.makeEmptyInvocation(originalGraph);
-//
-//    graph.setInputStreams(Collections
-//            .singletonList(EventStreamGenerator
-//                    
.makeStreamWithProperties(Collections.singletonList(invertFieldName))));
-//
-//    
graph.setOutputStream(EventStreamGenerator.makeStreamWithProperties(Collections.singletonList(invertFieldName)));
-//
-//    
graph.getOutputStream().getEventGrounding().getTransportProtocol().getTopicDefinition()
-//            .setActualTopicName("output-topic");
-//
-//    graph.getStaticProperties().stream()
-//            .filter(p -> p instanceof MappingPropertyUnary)
-//            .map((p -> (MappingPropertyUnary) p))
-//            .filter(p -> 
p.getInternalName().equals(BooleanCounterProcessor.FIELD_ID))
-//            .findFirst().get().setSelectedProperty("s0::" + invertFieldName);
-//    ProcessorParams params = new ProcessorParams(graph);
-//    params.extractor().getStaticPropertyByName("flank", 
OneOfStaticProperty.class).getOptions()
-//            .stream().filter(ot -> ot.getName().equals(flankUp)).findFirst()
-//            .get().setSelected(true);
-//
-//
-//    SpOutputCollector spOut = new SpOutputCollector() {
-//      @Override
-//      public void collect(Event event) {}
-//      @Override
-//      public void registerConsumer(String routeId, 
InternalEventProcessor<Map<String, Object>> consumer) {}
-//      @Override
-//      public void unregisterConsumer(String routeId) {}
-//      @Override
-//      public void connect() throws SpRuntimeException {}
-//      @Override
-//      public void disconnect() throws SpRuntimeException {}
-//    };
-//
-//    booleanCounter.onPipelineStarted(params, spOut, null);
-//    Integer counter = sendEvents(booleanCounter, spOut);
-//    LOG.info("Expected match count is {}", expectedBooleanCount);
-//    LOG.info("Actual match count is {}", counter);
-//    assertEquals(expectedBooleanCount, counter);
-//  }
-//
-//  private Integer sendEvents(BooleanCounterProcessor booleanCounter, 
SpOutputCollector spOut) {
-//    int counter = 0;
-//    List<Event> events = makeEvents();
-//    for (Event event : events) {
-//      LOG.info("Sending event with value "
-//          + event.getFieldBySelector("s0::" + 
invertFieldName).getAsPrimitive().getAsBoolean());
-//      booleanCounter.onEvent(event, spOut);
-//      try {
-//        Thread.sleep(100);
-//      } catch (InterruptedException e) {
-//        e.printStackTrace();
-//      }
-//      try {
-//        counter = 
event.getFieldBySelector(BooleanCounterProcessor.COUNT_FIELD_RUNTIME_NAME)
-//                .getAsPrimitive()
-//                .getAsInt();
-//      } catch (IllegalArgumentException e) {
-//
-//      }
-//    }
-//
-//    return counter;
-//  }
-//
-//  private List<Event> makeEvents() {
-//    List<Event> events = new ArrayList<>();
-//    for (Boolean eventSetting : eventBooleans) {
-//      events.add(makeEvent(eventSetting));
-//    }
-//    return events;
-//  }
-//
-//  private Event makeEvent(Boolean value) {
-//    Map<String, Object> map = new HashMap<>();
-//    map.put(invertFieldName, value);
-//    return EventFactory.fromMap(map,
-//            new SourceInfo("test" + "-topic", "s0"),
-//            new SchemaInfo(null, new ArrayList<>()));
-//  }
+  @ParameterizedTest
+  @MethodSource("data")
+  public void testBooleanCounter(
+      String invertFieldName,
+      String flankUp,
+      List<Boolean> eventBooleans,
+      Integer expectedBooleanCount
+  ) {
+    BooleanCounterProcessor booleanCounter = new BooleanCounterProcessor();
+    DataProcessorDescription originalGraph = 
booleanCounter.declareConfig().getDescription();
+    
originalGraph.setSupportedGrounding(EventGroundingGenerator.makeDummyGrounding());
+
+    DataProcessorInvocation graph =
+            InvocationGraphGenerator.makeEmptyInvocation(originalGraph);
+
+    graph.setInputStreams(Collections
+            .singletonList(EventStreamGenerator
+                    
.makeStreamWithProperties(Collections.singletonList(invertFieldName))));
+
+    
graph.setOutputStream(EventStreamGenerator.makeStreamWithProperties(Collections.singletonList(invertFieldName)));
+
+    
graph.getOutputStream().getEventGrounding().getTransportProtocol().getTopicDefinition()
+            .setActualTopicName("output-topic");
+
+    graph.getStaticProperties().stream()
+            .filter(p -> p instanceof MappingPropertyUnary)
+            .map((p -> (MappingPropertyUnary) p))
+            .filter(p -> 
p.getInternalName().equals(BooleanCounterProcessor.FIELD_ID))
+            .findFirst().get().setSelectedProperty("s0::" + invertFieldName);
+    ProcessorParams params = new ProcessorParams(graph);
+    params.extractor().getStaticPropertyByName("flank", 
OneOfStaticProperty.class).getOptions()
+            .stream().filter(ot -> ot.getName().equals(flankUp)).findFirst()
+            .get().setSelected(true);
+
+
+    SpOutputCollector spOut = new SpOutputCollector() {
+      @Override
+      public void collect(Event event) {}
+      @Override
+      public void registerConsumer(String routeId, 
InternalEventProcessor<Map<String, Object>> consumer) {}
+      @Override
+      public void unregisterConsumer(String routeId) {}
+      @Override
+      public void connect() throws SpRuntimeException {}
+      @Override
+      public void disconnect() throws SpRuntimeException {}
+    };
+
+    booleanCounter.onPipelineStarted(params, spOut, null);
+    Integer counter = sendEvents(booleanCounter, spOut, eventBooleans, 
invertFieldName);
+    LOG.info("Expected match count is {}", expectedBooleanCount);
+    LOG.info("Actual match count is {}", counter);
+    assertEquals(expectedBooleanCount, counter);
+  }
+
+  private Integer sendEvents(BooleanCounterProcessor booleanCounter, 
SpOutputCollector spOut,
+                             List<Boolean> eventBooleans, String 
invertFieldName) {
+    int counter = 0;
+    List<Event> events = makeEvents(eventBooleans, invertFieldName);
+    for (Event event : events) {
+      LOG.info("Sending event with value "
+          + event.getFieldBySelector("s0::" + 
invertFieldName).getAsPrimitive().getAsBoolean());
+      booleanCounter.onEvent(event, spOut);
+      try {
+        Thread.sleep(100);
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+      }
+      try {
+        counter = 
event.getFieldBySelector(BooleanCounterProcessor.COUNT_FIELD_RUNTIME_NAME)
+                .getAsPrimitive()
+                .getAsInt();
+      } catch (IllegalArgumentException e) {
+
+      }
+    }
+
+    return counter;
+  }
+
+  private List<Event> makeEvents(List<Boolean> eventBooleans, String 
invertFieldName) {
+    List<Event> events = new ArrayList<>();
+    for (Boolean eventSetting : eventBooleans) {
+      events.add(makeEvent(eventSetting, invertFieldName));
+    }
+    return events;
+  }
+
+  private Event makeEvent(Boolean value, String invertFieldName) {
+    Map<String, Object> map = new HashMap<>();
+    map.put(invertFieldName, value);
+    return EventFactory.fromMap(map,
+            new SourceInfo("test" + "-topic", "s0"),
+            new SchemaInfo(null, new ArrayList<>()));
+  }
 }

Reply via email to