fix(historian): #680 lane A — time-weighted aggregates follow Part 13

TimeAverage/Total: Uncertain when a Bad value is skipped, an Uncertain value
is used, the value is extrapolated or the interval is not covered; an
interval wholly inside an outage bridges (Uncertain); Total integrates only
the covered part. TimeAverage2/Total2 stop at the end of the data (Partial,
then BadNoData). PercentGood/PercentBad become duration-based and move to
the time-weighted family (now subject to MaxTimeWeightedRawRows). Reverse
reads set Partial on the interval holding the latest sample when nothing
follows (SDK m_startOfData). Parity tests gain end-of-data and outage
datasets; pre-existing #680 masks removed.

tests/Drivers/Historian.Conformance/ProcessedConformance.cs

@@ -68,13 +68,17 @@ public abstract class ProcessedConformance : ConformanceBase
     [Theory]
     [InlineData(HistoryAggregateType.PercentGood, 100d, 50d, 100d)]
     [InlineData(HistoryAggregateType.PercentBad, 0d, 50d, 0d)]
-    public async Task Percent_aggregates_count_every_sample(HistoryAggregateType agg, double b0, double b1, double b2)
+    public async Task Percent_aggregates_are_shares_of_the_interval_duration(HistoryAggregateType agg, double b0, double b1,
+        double b2)
     {
+        // #680 (Part 13 §5.4.3.31-34): stepped regions, each with the status of the sample starting it. B1: [20,30) Bad,
+        // [30,40) Good. B2 holds the end of the data (+40, nothing after) ⇒ its region runs to the interval end, Partial;
+        // B3 is after the end of the data ⇒ BadNoData.
         await ConformanceData.SeedAAsync(B);
         var s = (await ReadA(agg)).Samples;
         s.Select(x => x.Value).ShouldBe([b0, b1, b2, null]);
         // A percentage is a statement about quality, so it is not itself degraded by the Bad input.
-        s.Select(x => x.StatusCode).ShouldBe([GoodCalc, GoodCalc, GoodCalc, NoDataCalc]);
+        s.Select(x => x.StatusCode).ShouldBe([GoodCalc, GoodCalc, GoodCalc | 0x4u, NoDataCalc]);
     }
 
     [Fact]
@@ -169,9 +173,10 @@ public abstract class ProcessedConformance : ConformanceBase
         // An interval wider than the window (here TimeSpan.MaxValue) is the same single interval, no overflow.
         (await src.ReadProcessedAsync("A", start, end, TimeSpan.MaxValue, HistoryAggregateType.Count, Ct))
             .Samples.Single().Value.ShouldBe(4);
-        // The time-weighted path over the whole range: ≈ the extrapolated 50 that dominates eight millennia.
+        // The time-weighted path over the whole range. TimeAverage2 is not extrapolated past the end of the data (+40, #680):
+        // (150 + 200 + 450) value·s over the 30 non-Bad seconds = 80/3.
         var tw = (await src.ReadProcessedAsync("A", start, end, TimeSpan.Zero, HistoryAggregateType.TimeAverage2, Ct)).Samples.Single();
-        ((double)tw.Value!).ShouldBe(50d, 1e-6);
+        ((double)tw.Value!).ShouldBe(80d / 3d, 1e-6);
         // The data starts (+0) strictly inside the one interval ⇒ Partial as well (#677, the SDK's m_startOfData rule).
         tw.StatusCode.ShouldBe(UncertainCalc | 0x4u);
         src.GetHealthSnapshot().TotalFailures.ShouldBe(0);
@@ -347,15 +352,17 @@ public abstract class ProcessedConformance : ConformanceBase
                     }
             }
             var reverseInterpolative = agg == HistoryAggregateType.Interpolative && from > to;
+            // Documented SDK divergence (#680, see SdkAggregateParityTests): on a reverse read the SDK files a sample exactly
+            // on an interval's later edge as its early bound, so TimeAverage/Total there take the status of the segment
+            // beyond it (Dense: +20 next to the Bad +22.5).
+            var reverseEdgeStatus = from > to && agg is HistoryAggregateType.TimeAverage or HistoryAggregateType.Total;
             SdkAggregateOracle.ShouldMatch(ours, SdkAggregateOracle.Run(agg, start, end, interval, rows),
                 $"{agg} {from}→{to}/{intervalS}s",
                 compareCalculatedInterpolatedBits: tw && !reverseInterpolative,
-                // pre-existing, #680: TimeAverage/Total status rule; Start/End raw-sample timestamp + status; Delta status;
-                // PercentGood/Bad per-sample vs per-duration values (see SdkAggregateParityTests).
-                compareCodeBits: agg is not (HistoryAggregateType.TimeAverage or HistoryAggregateType.Total
-                                     or HistoryAggregateType.Delta) && !reverseInterpolative && !startOrEnd,
-                compareTimestamps: !startOrEnd,
-                compareValues: agg is not (HistoryAggregateType.PercentGood or HistoryAggregateType.PercentBad));
+                // pre-existing, #680: Start/End raw-sample timestamp + status; Delta status (see SdkAggregateParityTests).
+                compareCodeBits: agg != HistoryAggregateType.Delta && !reverseInterpolative && !startOrEnd
+                                 && !reverseEdgeStatus,
+                compareTimestamps: !startOrEnd);
         }
     }
 
@@ -383,7 +390,8 @@ public abstract class ProcessedConformance : ConformanceBase
         avg.StatusCode.ShouldBe(UncertainCalc);
         (await One(HistoryAggregateType.Count)).Value.ShouldBe(2);
         (await One(HistoryAggregateType.Start)).Value.ShouldBe(10d);
-        ((double)(await One(HistoryAggregateType.PercentBad)).Value!).ShouldBe(33.333333333333336, 1e-9); // 100 × 1/3
+        // #680: duration-based — [0,5) Good, [5,10) Bad, [10,20) Good (no end bound: the last region runs to the interval end).
+        ((double)(await One(HistoryAggregateType.PercentBad)).Value!).ShouldBe(25d, 1e-9);
     }
 
     [Fact]
@@ -611,6 +619,9 @@ public abstract class ProcessedConformance : ConformanceBase
         var ex = await Should.ThrowAsync<HistoryReadLimitExceededException>(
             () => under.ReadProcessedAsync("A", At(0), At(80), Twenty, HistoryAggregateType.Total, Ct));
         ex.Limit.ShouldBe(4);
+        // #680: PercentGood/PercentBad are duration-based, served by the same window stream ⇒ capped too.
+        (await Should.ThrowAsync<HistoryReadLimitExceededException>(
+            () => under.ReadProcessedAsync("A", At(0), At(80), Twenty, HistoryAggregateType.PercentGood, Ct))).Limit.ShouldBe(4);
         // Pushed-down (per-sample) aggregates are not capped; the bound rows outside the window do not count.
         (await under.ReadProcessedAsync("A", At(0), At(80), Twenty, HistoryAggregateType.Average, Ct)).Samples.Count.ShouldBe(4);
         (await B.CreateDataSource(3).ReadProcessedAsync("W", At(0), At(80), Twenty, HistoryAggregateType.TimeAverage, Ct))