fix: stopped measure should use initial measure's processors by default

Author: metacosm

measure/src/main/java/net/laprun/sustainability/power/measure/OngoingPowerMeasure.java

@@ -8,6 +8,7 @@
 import java.util.stream.Stream;
 
 import net.laprun.sustainability.power.SensorMetadata;
+import net.laprun.sustainability.power.analysis.Processors;
 
 public class OngoingPowerMeasure extends ProcessorAware implements PowerMeasure {
     private static final int DEFAULT_SIZE = 32;
@@ -19,6 +20,8 @@ public class OngoingPowerMeasure extends ProcessorAware implements PowerMeasure
     private long[] timestamps;
 
     public OngoingPowerMeasure(SensorMetadata metadata) {
+        super(Processors.empty);
+
         startedAt = System.currentTimeMillis();
         this.metadata = metadata;
 

measure/src/main/java/net/laprun/sustainability/power/measure/ProcessorAware.java

@@ -7,7 +7,11 @@
 import net.laprun.sustainability.power.analysis.Processors;
 
 abstract class ProcessorAware {
-    private Processors processors = Processors.empty;
+    private Processors processors;
+
+    public ProcessorAware(Processors processors) {
+        this.processors = processors == null ? Processors.empty : processors;
+    }
 
     public abstract SensorMetadata metadata();
 

measure/src/main/java/net/laprun/sustainability/power/measure/StoppedPowerMeasure.java

@@ -14,6 +14,8 @@ public class StoppedPowerMeasure extends ProcessorAware implements PowerMeasure
     private final Duration duration;
 
     public StoppedPowerMeasure(OngoingPowerMeasure powerMeasure) {
+        super(powerMeasure.processors());
+
         this.measure = powerMeasure;
         this.duration = powerMeasure.duration();
         this.samples = powerMeasure.numberOfSamples();

measure/src/test/java/net/laprun/sustainability/power/measure/OngoingPowerMeasureTest.java

@@ -11,6 +11,7 @@
 
 import net.laprun.sustainability.power.SensorMetadata;
 import net.laprun.sustainability.power.analysis.ComponentProcessor;
+import net.laprun.sustainability.power.analysis.MeasureProcessor;
 
 public class OngoingPowerMeasureTest {
     private final static SensorMetadata metadata = SensorMetadata
@@ -71,7 +72,9 @@ void processorsShouldBeCalled() {
 
         final var measure = new OngoingPowerMeasure(metadata);
         final var testProc = new TestComponentProcessor();
+        final var measureProc = new TestMeasureProcessor();
         measure.registerProcessorFor(0, testProc);
+        measure.registerMeasureProcessor(measureProc);
 
         final var components = new double[metadata.componentCardinality()];
         components[0] = m1c1;
@@ -86,9 +89,12 @@ void processorsShouldBeCalled() {
         assertThat(processors.processorsFor(0)).hasSize(1);
         assertThat(processors.processorsFor(1)).isEmpty();
         assertThat(processors.processorsFor(2)).isEmpty();
+        assertThat(processors.measureProcessors()).hasSize(1);
 
         assertThat(testProc.values.getFirst().value()).isEqualTo(m1c1);
         assertThat(testProc.values.getLast().value()).isEqualTo(m2c1);
+        assertThat(measureProc.values.getFirst().measures()).isEqualTo(new double[] { m1c1, m1c2, 0 });
+        assertThat(measureProc.values.getLast().measures()).isEqualTo(new double[] { m2c1, m2c2, 0 });
     }
 
     private static class TestComponentProcessor implements ComponentProcessor {
@@ -99,4 +105,15 @@ public void recordComponentValue(double value, long timestamp) {
             values.add(new PowerMeasure.TimestampedValue(timestamp, value));
         }
     }
+
+    private static class TestMeasureProcessor implements MeasureProcessor {
+        final List<PowerMeasure.TimestampedMeasures> values = new ArrayList<>();
+
+        @Override
+        public void recordMeasure(double[] measure, long timestamp) {
+            final var copy = new double[measure.length];
+            System.arraycopy(measure, 0, copy, 0, measure.length);
+            values.add(new PowerMeasure.TimestampedMeasures(timestamp, copy));
+        }
+    }
 }

measure/src/test/java/net/laprun/sustainability/power/measure/StoppedPowerMeasureTest.java

@@ -0,0 +1,101 @@
+package net.laprun.sustainability.power.measure;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+import net.laprun.sustainability.power.SensorMetadata;
+import net.laprun.sustainability.power.SensorUnit;
+import net.laprun.sustainability.power.analysis.ComponentProcessor;
+import net.laprun.sustainability.power.analysis.MeasureProcessor;
+import net.laprun.sustainability.power.analysis.Processors;
+import net.laprun.sustainability.power.analysis.TotalMeasureProcessor;
+
+public class StoppedPowerMeasureTest {
+    private final static SensorMetadata metadata = SensorMetadata
+            .withNewComponent("cp1", null, true, "mW")
+            .withNewComponent("cp2", null, true, "mW")
+            .withNewComponent("cp3", null, true, "mW")
+            .build();
+
+    @Test
+    void shouldUseInitialProcessorsIfAvailable() {
+        final var measure = new OngoingPowerMeasure(metadata);
+        final var processor = new TotalMeasureProcessor(metadata, SensorUnit.mW, 0);
+        measure.registerMeasureProcessor(processor);
+        final var compProc = new ComponentProcessor() {
+        };
+        measure.registerProcessorFor(0, compProc);
+
+        final var stopped = new StoppedPowerMeasure(measure);
+        final var stoppedProcs = stopped.processors();
+        assertThat(stoppedProcs).isNotEqualTo(Processors.empty);
+        assertThat(stoppedProcs.measureProcessors()).hasSize(1);
+        assertThat(stoppedProcs.measureProcessors().getFirst()).isEqualTo(processor);
+        assertThat(stoppedProcs.processorsFor(0)).hasSize(1);
+        assertThat(stoppedProcs.processorsFor(0).getFirst()).isEqualTo(compProc);
+    }
+
+    @Test
+    void shouldAlsoUseOwnProcessorsIfAvailable() {
+        final var measure = new OngoingPowerMeasure(metadata);
+        final var processor = new TotalMeasureProcessor(metadata, SensorUnit.mW, 0);
+        measure.registerMeasureProcessor(processor);
+        final var ongoingCompProcOutput = "component from ongoing";
+        final var compProc = new ComponentProcessor() {
+            @Override
+            public String output() {
+                return ongoingCompProcOutput;
+            }
+        };
+        measure.registerProcessorFor(0, compProc);
+
+        final var stopped = new StoppedPowerMeasure(measure);
+        final var stoppedCompProcName = "stopped component processor";
+        final var stoppedCompProcOutput = "component from stopped";
+        final var stoppedProc = new ComponentProcessor() {
+            @Override
+            public String name() {
+                return stoppedCompProcName;
+            }
+
+            @Override
+            public String output() {
+                return stoppedCompProcOutput;
+            }
+        };
+        stopped.registerProcessorFor(0, stoppedProc);
+        final var stoppedMeasureOutput = "measure from stopped";
+        final var stoppedMeasureProcName = "stopped measure processor";
+        final var stoppedMeasureProc = new MeasureProcessor() {
+            @Override
+            public String name() {
+                return stoppedMeasureProcName;
+            }
+
+            @Override
+            public String output() {
+                return stoppedMeasureOutput;
+            }
+        };
+        stopped.registerMeasureProcessor(stoppedMeasureProc);
+        final var stoppedProcs = stopped.processors();
+        assertThat(stoppedProcs).isNotEqualTo(Processors.empty);
+        final var measureProcessors = stoppedProcs.measureProcessors();
+        assertThat(measureProcessors).hasSize(2);
+        assertThat(measureProcessors.getFirst()).isEqualTo(processor);
+        assertThat(measureProcessors.getLast()).isEqualTo(stoppedMeasureProc);
+        final var componentProcessors = stoppedProcs.processorsFor(0);
+        assertThat(componentProcessors).hasSize(2);
+        assertThat(componentProcessors.getFirst()).isEqualTo(compProc);
+        assertThat(componentProcessors.getLast()).isEqualTo(stoppedProc);
+
+        final var output = PowerMeasure.asString(stopped);
+        assertThat(output).contains(stoppedCompProcOutput, stoppedMeasureOutput, ongoingCompProcOutput);
+        // second anonymous class
+        assertThat(output).contains(stoppedCompProcName, stoppedMeasureProcName, "Aggregated total from (cp1)",
+                getClass().getName() + "$2");
+        assertThat(output).contains("0.00mW");
+        assertThat(output).doesNotContain("Infinity");
+    }
+}