fix: resolve build and test errors

- Sar.Quantower.Tests.cs: add missing opening quote on string literal (line 48)
- Exports.cs: rename Correlation.Batch → Correl.Batch (CS0103)
- Ad.Validation.Tests.cs: fix Ooples OutputValues key "Ad" → "Adl"

lib/channels/dc/tests/Dc.Quantower.Tests.cs

@@ -0,0 +1,139 @@
+using TradingPlatform.BusinessLayer;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class DcIndicatorTests
+{
+    [Fact]
+    public void Constructor_SetsDefaults()
+    {
+        var ind = new DcIndicator();
+
+        Assert.Equal(20, ind.Period);
+        Assert.True(ind.ShowColdValues);
+        Assert.Equal("Dc - Donchian Channels", ind.Name);
+        Assert.False(ind.SeparateWindow);
+        Assert.True(ind.OnBackGround);
+    }
+
+    [Fact]
+    public void MinHistoryDepths_EqualsPeriod()
+    {
+        var ind = new DcIndicator { Period = 15 };
+        Assert.Equal(15, ind.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void ShortName_ReflectsParameters()
+    {
+        var ind = new DcIndicator { Period = 12 };
+        Assert.Contains("12", ind.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Initialize_AddsThreeLineSeries()
+    {
+        var ind = new DcIndicator { Period = 14 };
+        ind.Initialize();
+
+        Assert.Equal(3, ind.LinesSeries.Count);
+        Assert.Equal("Middle", ind.LinesSeries[0].Name);
+        Assert.Equal("Upper", ind.LinesSeries[1].Name);
+        Assert.Equal("Lower", ind.LinesSeries[2].Name);
+    }
+
+    [Fact]
+    public void ProcessUpdate_Historical_ComputesValues()
+    {
+        var ind = new DcIndicator { Period = 3 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 110, 90, 102);
+
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        Assert.Equal(1, ind.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(ind.LinesSeries[0].GetValue(0)));
+        Assert.True(double.IsFinite(ind.LinesSeries[1].GetValue(0)));
+        Assert.True(double.IsFinite(ind.LinesSeries[2].GetValue(0)));
+    }
+
+    [Fact]
+    public void ProcessUpdate_NewBar_Appends()
+    {
+        var ind = new DcIndicator { Period = 3 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 110, 90, 102);
+        ind.HistoricalData.AddBar(now.AddMinutes(1), 102, 112, 92, 104);
+
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, ind.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void ProcessUpdate_NewTick_DoesNotThrow()
+    {
+        var ind = new DcIndicator { Period = 5 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+
+        Assert.Equal(2, ind.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void MultipleUpdates_ProducesFiniteSeries()
+    {
+        var ind = new DcIndicator { Period = 5 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            ind.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 102 + i);
+            ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        Assert.Equal(10, ind.LinesSeries[0].Count);
+        Assert.Equal(10, ind.LinesSeries[1].Count);
+        Assert.Equal(10, ind.LinesSeries[2].Count);
+
+        for (int i = 0; i < 10; i++)
+        {
+            Assert.True(double.IsFinite(ind.LinesSeries[0].GetValue(i)));
+            Assert.True(double.IsFinite(ind.LinesSeries[1].GetValue(i)));
+            Assert.True(double.IsFinite(ind.LinesSeries[2].GetValue(i)));
+        }
+    }
+
+    [Fact]
+    public void Bands_Order_Correct()
+    {
+        var ind = new DcIndicator { Period = 3 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 6; i++)
+        {
+            ind.HistoricalData.AddBar(now.AddMinutes(i), 100, 110 + i, 90 - i, 100, 1000);
+            ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        double middle = ind.LinesSeries[0].GetValue(0);
+        double upper = ind.LinesSeries[1].GetValue(0);
+        double lower = ind.LinesSeries[2].GetValue(0);
+
+        Assert.True(upper >= middle, $"Upper ({upper}) should be >= Middle ({middle})");
+        Assert.True(lower <= middle, $"Lower ({lower}) should be <= Middle ({middle})");
+    }
+}

lib/channels/dc/tests/Dc.Tests.cs

@@ -0,0 +1,246 @@
+using System;
+using QuanTAlib;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class DcTests
+{
+    [Fact]
+    public void Dc_Constructor_ValidatesInput()
+    {
+        Assert.Throws<ArgumentException>(() => new Dc(0));
+        Assert.Throws<ArgumentException>(() => new Dc(-5));
+
+        var d = new Dc(10);
+        Assert.Equal(10, d.WarmupPeriod);
+        Assert.Contains("Dc", d.Name, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void Dc_InitialState_Defaults()
+    {
+        var d = new Dc(5);
+
+        Assert.Equal(0, d.Last.Value);
+        Assert.Equal(0, d.Upper.Value);
+        Assert.Equal(0, d.Lower.Value);
+        Assert.False(d.IsHot);
+    }
+
+    [Fact]
+    public void Dc_CalculatesBands()
+    {
+        var d = new Dc(3);
+
+        d.Update(new TBar(DateTime.UtcNow, 100, 110, 90, 105, 1000));
+        d.Update(new TBar(DateTime.UtcNow, 105, 115, 95, 110, 1000));
+        d.Update(new TBar(DateTime.UtcNow, 110, 120, 100, 115, 1000));
+
+        // Highest High = 120, Lowest Low = 90, Middle = 105
+        Assert.Equal(120.0, d.Upper.Value, 1e-10);
+        Assert.Equal(90.0, d.Lower.Value, 1e-10);
+        Assert.Equal(105.0, d.Last.Value, 1e-10);
+        Assert.True(d.IsHot);
+    }
+
+    [Fact]
+    public void Dc_SlidingWindow_Updates()
+    {
+        var d = new Dc(2);
+
+        d.Update(new TBar(DateTime.UtcNow, 100, 110, 90, 100, 1000));
+        d.Update(new TBar(DateTime.UtcNow, 101, 111, 91, 101, 1000));
+        double mid1 = d.Last.Value;
+
+        d.Update(new TBar(DateTime.UtcNow, 102, 109, 95, 102, 1000));
+        Assert.NotEqual(mid1, d.Last.Value);
+
+        // Period=2: last 2 bars have H=[111,109], L=[91,95]
+        // Upper=111, Lower=91, Middle=101
+        Assert.Equal(111.0, d.Upper.Value, 1e-10);
+        Assert.Equal(91.0, d.Lower.Value, 1e-10);
+        Assert.Equal(101.0, d.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Dc_IsHot_TurnsTrueAfterWarmup()
+    {
+        var d = new Dc(4);
+
+        for (int i = 0; i < 3; i++)
+        {
+            d.Update(new TBar(DateTime.UtcNow, 100 + i, 101 + i, 99 + i, 100 + i, 1000));
+            Assert.False(d.IsHot);
+        }
+
+        d.Update(new TBar(DateTime.UtcNow, 200, 201, 199, 200, 1000));
+        Assert.True(d.IsHot);
+    }
+
+    [Fact]
+    public void Dc_IsNewFalse_RebuildsState()
+    {
+        var d = new Dc(3);
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 7);
+
+        TBar remembered = default;
+        for (int i = 0; i < 6; i++)
+        {
+            remembered = gbm.Next(isNew: true);
+            d.Update(remembered, isNew: true);
+        }
+
+        double mid = d.Last.Value;
+        double up = d.Upper.Value;
+        double lo = d.Lower.Value;
+
+        for (int i = 0; i < 3; i++)
+        {
+            var corrected = gbm.Next(isNew: false);
+            d.Update(corrected, isNew: false);
+        }
+
+        d.Update(remembered, isNew: false);
+
+        Assert.Equal(mid, d.Last.Value, 1e-10);
+        Assert.Equal(up, d.Upper.Value, 1e-10);
+        Assert.Equal(lo, d.Lower.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Dc_NaN_UsesLastValid()
+    {
+        var d = new Dc(3);
+
+        d.Update(new TBar(DateTime.UtcNow, 100, 110, 90, 105, 1000));
+        d.Update(new TBar(DateTime.UtcNow, 101, 111, 91, 106, 1000));
+
+        var result = d.Update(new TBar(DateTime.UtcNow, 102, double.NaN, 92, 107, 1000));
+        Assert.True(double.IsFinite(result.Value));
+        Assert.True(double.IsFinite(d.Upper.Value));
+        Assert.True(double.IsFinite(d.Lower.Value));
+
+        var result2 = d.Update(new TBar(DateTime.UtcNow, 103, 113, double.PositiveInfinity, 108, 1000));
+        Assert.True(double.IsFinite(result2.Value));
+    }
+
+    [Fact]
+    public void Dc_Reset_Clears()
+    {
+        var d = new Dc(3);
+        d.Update(new TBar(DateTime.UtcNow, 100, 110, 90, 100, 1000));
+        d.Update(new TBar(DateTime.UtcNow, 101, 111, 91, 101, 1000));
+
+        d.Reset();
+
+        Assert.Equal(0, d.Last.Value);
+        Assert.Equal(0, d.Upper.Value);
+        Assert.Equal(0, d.Lower.Value);
+        Assert.False(d.IsHot);
+
+        d.Update(new TBar(DateTime.UtcNow, 50, 60, 40, 55, 1000));
+        Assert.NotEqual(0, d.Last.Value);
+    }
+
+    [Fact]
+    public void Dc_BatchVsStreaming_Match()
+    {
+        var dStream = new Dc(10);
+        var gbm = new GBM(startPrice: 100, mu: 0.02, sigma: 0.1, seed: 42);
+        var series = new TBarSeries();
+
+        for (int i = 0; i < 200; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            series.Add(bar);
+            dStream.Update(bar, isNew: true);
+        }
+
+        double expectedMid = dStream.Last.Value;
+        double expectedUp = dStream.Upper.Value;
+        double expectedLo = dStream.Lower.Value;
+
+        var (midBatch, upBatch, loBatch) = Dc.Batch(series, 10);
+
+        Assert.Equal(expectedMid, midBatch.Last.Value, 1e-10);
+        Assert.Equal(expectedUp, upBatch.Last.Value, 1e-10);
+        Assert.Equal(expectedLo, loBatch.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Dc_SpanBatch_Validates()
+    {
+        double[] high = [110, 115, 120];
+        double[] low = [90, 95, 100];
+        double[] middle = new double[3];
+        double[] upper = new double[3];
+        double[] lower = new double[3];
+
+        double[] highShort = [110, 115];
+        double[] smallOut = new double[1];
+
+        Assert.Throws<ArgumentException>(() => Dc.Batch(high.AsSpan(), low.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 0));
+        Assert.Throws<ArgumentException>(() => Dc.Batch(high.AsSpan(), low.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), -1));
+        Assert.Throws<ArgumentException>(() => Dc.Batch(highShort.AsSpan(), low.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 2));
+        Assert.Throws<ArgumentException>(() => Dc.Batch(high.AsSpan(), low.AsSpan(), smallOut.AsSpan(), upper.AsSpan(), lower.AsSpan(), 2));
+    }
+
+    [Fact]
+    public void Dc_SpanBatch_ComputesCorrectly()
+    {
+        double[] high = [110, 115, 120, 125];
+        double[] low = [90, 95, 100, 105];
+        double[] middle = new double[4];
+        double[] upper = new double[4];
+        double[] lower = new double[4];
+
+        Dc.Batch(high.AsSpan(), low.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 3);
+
+        // Period=3: index 2 is first valid (indices 0,1,2)
+        // H=[110,115,120], L=[90,95,100] → Upper=120, Lower=90, Middle=105
+        Assert.Equal(120.0, upper[2], 1e-10);
+        Assert.Equal(90.0, lower[2], 1e-10);
+        Assert.Equal(105.0, middle[2], 1e-10);
+
+        // Index 3: H=[115,120,125], L=[95,100,105] → Upper=125, Lower=95, Middle=110
+        Assert.Equal(125.0, upper[3], 1e-10);
+        Assert.Equal(95.0, lower[3], 1e-10);
+        Assert.Equal(110.0, middle[3], 1e-10);
+    }
+
+    [Fact]
+    public void Dc_Calculate_ReturnsIndicatorAndResults()
+    {
+        var series = new TBarSeries();
+        series.Add(DateTime.UtcNow, 100, 110, 90, 100, 1000);
+        series.Add(DateTime.UtcNow, 105, 115, 95, 105, 1000);
+        series.Add(DateTime.UtcNow, 110, 120, 100, 110, 1000);
+
+        var ((mid, up, lo), ind) = Dc.Calculate(series, 2);
+
+        Assert.True(ind.IsHot);
+        // Period=2: last 2 bars H=[115,120], L=[95,100] → Upper=120, Lower=95, Middle=107.5
+        Assert.Equal(120.0, up.Last.Value, 1e-10);
+        Assert.Equal(95.0, lo.Last.Value, 1e-10);
+        Assert.Equal(107.5, mid.Last.Value, 1e-10);
+
+        ind.Update(new TBar(DateTime.UtcNow, 120, 130, 110, 120, 1000));
+        // Period=2: last 2 bars H=[120,130], L=[100,110] → Upper=130, Lower=100, Middle=115
+        Assert.Equal(130.0, ind.Upper.Value, 1e-10);
+        Assert.Equal(100.0, ind.Lower.Value, 1e-10);
+        Assert.Equal(115.0, ind.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Dc_Event_Publishes()
+    {
+        var src = new TBarSeries();
+        var d = new Dc(src, 2);
+        bool fired = false;
+        d.Pub += (object? sender, in TValueEventArgs args) => fired = true;
+
+        src.Add(new TBar(DateTime.UtcNow, 100, 110, 90, 100, 1000));
+        Assert.True(fired);
+    }
+}

lib/channels/dc/tests/Dc.Validation.Tests.cs

@@ -0,0 +1,350 @@
+using Skender.Stock.Indicators;
+using Xunit.Abstractions;
+
+using OoplesFinance.StockIndicators;
+using OoplesFinance.StockIndicators.Models;
+
+namespace QuanTAlib.Tests;
+
+public sealed class DcValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private readonly ITestOutputHelper _output;
+    private bool _disposed;
+
+    public DcValidationTests(ITestOutputHelper output)
+    {
+        _output = output;
+        _testData = new ValidationTestData();
+    }
+
+    public void Dispose() => Dispose(true);
+
+    private void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _disposed = true;
+
+        if (disposing)
+        {
+            _testData?.Dispose();
+        }
+    }
+
+    [Fact]
+    public void Validate_ManualCalculation_Period3()
+    {
+        var series = new TBarSeries();
+        var t0 = DateTime.UtcNow;
+        series.Add(new TBar(t0, 0, 12, 8, 10, 100));
+        series.Add(new TBar(t0.AddMinutes(1), 0, 14, 10, 12, 100));
+        series.Add(new TBar(t0.AddMinutes(2), 0, 16, 12, 14, 100));
+
+        var ind = new Dc(3);
+        var (mid, up, lo) = ind.Update(series);
+
+        Assert.Equal(16.0, up.Last.Value, 1e-10);
+        Assert.Equal(8.0, lo.Last.Value, 1e-10);
+        Assert.Equal(12.0, mid.Last.Value, 1e-10);
+        Assert.True(ind.IsHot);
+
+        _output.WriteLine("Dc manual period-3 calculation validated");
+    }
+
+    [Fact]
+    public void Validate_AllModes_Consistency()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+
+        foreach (int period in periods)
+        {
+            // Batch (instance)
+            var inst = new Dc(period);
+            var (bMid, bUp, bLo) = inst.Update(_testData.Bars);
+
+            // Static batch
+            var (sMid, sUp, sLo) = Dc.Batch(_testData.Bars, period);
+
+            ValidationHelper.VerifySeriesEqual(bMid, sMid);
+            ValidationHelper.VerifySeriesEqual(bUp, sUp);
+            ValidationHelper.VerifySeriesEqual(bLo, sLo);
+
+            // Streaming
+            var streaming = new Dc(period);
+            var sMidStream = new TSeries();
+            var sUpStream = new TSeries();
+            var sLoStream = new TSeries();
+            foreach (var bar in _testData.Bars)
+            {
+                streaming.Update(bar);
+                sMidStream.Add(streaming.Last);
+                sUpStream.Add(streaming.Upper);
+                sLoStream.Add(streaming.Lower);
+            }
+
+            ValidationHelper.VerifySeriesEqual(sMid, sMidStream);
+            ValidationHelper.VerifySeriesEqual(sUp, sUpStream);
+            ValidationHelper.VerifySeriesEqual(sLo, sLoStream);
+
+            // Span
+            double[] high = _testData.HighPrices.ToArray();
+            double[] low = _testData.LowPrices.ToArray();
+            double[] spanMid = new double[high.Length];
+            double[] spanUp = new double[high.Length];
+            double[] spanLo = new double[high.Length];
+            Dc.Batch(high.AsSpan(), low.AsSpan(),
+                spanMid.AsSpan(), spanUp.AsSpan(), spanLo.AsSpan(), period);
+
+            for (int i = 0; i < high.Length; i++)
+            {
+                Assert.Equal(sMid[i].Value, spanMid[i], 9);
+                Assert.Equal(sUp[i].Value, spanUp[i], 9);
+                Assert.Equal(sLo[i].Value, spanLo[i], 9);
+            }
+        }
+
+        _output.WriteLine("Dc mode consistency validated (batch/stream/span)");
+    }
+
+    [Fact]
+    public void Validate_EventingMode_MatchesBatch()
+    {
+        const int period = 20;
+        var pub = new TBarSeries();
+        var evtInd = new Dc(pub, period);
+        var evtMid = new TSeries();
+        var evtUp = new TSeries();
+        var evtLo = new TSeries();
+
+        foreach (var bar in _testData.Bars)
+        {
+            pub.Add(bar);
+            evtMid.Add(evtInd.Last);
+            evtUp.Add(evtInd.Upper);
+            evtLo.Add(evtInd.Lower);
+        }
+
+        var (bMid, bUp, bLo) = Dc.Batch(_testData.Bars, period);
+
+        ValidationHelper.VerifySeriesEqual(bMid, evtMid);
+        ValidationHelper.VerifySeriesEqual(bUp, evtUp);
+        ValidationHelper.VerifySeriesEqual(bLo, evtLo);
+
+        _output.WriteLine("Dc eventing mode validated");
+    }
+
+    [Fact]
+    public void Validate_Calculate_ReturnsHotIndicator()
+    {
+        const int period = 15;
+        var ((mid, up, lo), ind) = Dc.Calculate(_testData.Bars, period);
+
+        Assert.True(ind.IsHot);
+        Assert.Equal(period, ind.WarmupPeriod);
+        Assert.Equal(mid.Last.Value, ind.Last.Value, 1e-10);
+        Assert.Equal(up.Last.Value, ind.Upper.Value, 1e-10);
+        Assert.Equal(lo.Last.Value, ind.Lower.Value, 1e-10);
+
+        // Continue streaming
+        var next = new TBar(DateTime.UtcNow, 0, 150, 50, 100, 1000);
+        ind.Update(next);
+        Assert.True(ind.IsHot);
+
+        _output.WriteLine("Dc Calculate validated");
+    }
+
+    [Fact]
+    public void Validate_Prime_MatchesBatch()
+    {
+        const int period = 25;
+
+        var (bMid, bUp, bLo) = Dc.Batch(_testData.Bars, period);
+
+        var primed = new Dc(period);
+        var subset = new TBarSeries();
+        for (int i = 0; i < 200; i++)
+        {
+            subset.Add(_testData.Bars[i]);
+        }
+
+        primed.Prime(subset);
+
+        for (int i = 200; i < _testData.Bars.Count; i++)
+        {
+            primed.Update(_testData.Bars[i]);
+        }
+
+        Assert.Equal(bMid.Last.Value, primed.Last.Value, 1e-9);
+        Assert.Equal(bUp.Last.Value, primed.Upper.Value, 1e-9);
+        Assert.Equal(bLo.Last.Value, primed.Lower.Value, 1e-9);
+
+        _output.WriteLine("Dc Prime validated against batch");
+    }
+
+    [Fact]
+    public void Validate_LargeDataset_FiniteOutputs()
+    {
+        var (mid, up, lo) = Dc.Batch(_testData.Bars, 50);
+
+        ValidationHelper.VerifyAllFinite(mid, startIndex: 0);
+        ValidationHelper.VerifyAllFinite(up, startIndex: 0);
+        ValidationHelper.VerifyAllFinite(lo, startIndex: 0);
+
+        for (int i = 50; i < mid.Count; i++)
+        {
+            Assert.True(up[i].Value >= lo[i].Value, $"Upper >= Lower at {i}");
+        }
+
+        _output.WriteLine("Dc large dataset validated");
+    }
+
+    [Fact]
+    public void Validate_Skender_Batch_UpperBand()
+    {
+        // Convention difference: Skender Donchian uses prior N bars [i-N, i-1] (excludes current bar)
+        // QuanTAlib Dc uses inclusive N bars [i-N+1, i] (includes current bar).
+        // Therefore: QuanTAlib[i] should match Skender[i+1] for converged values.
+        int[] periods = { 5, 10, 20, 50, 100 };
+
+        foreach (var period in periods)
+        {
+            var (_, qUp, _) = Dc.Batch(_testData.Bars, period);
+            var sResult = _testData.SkenderQuotes.GetDonchian(period).ToList();
+
+            int count = Math.Min(qUp.Count, sResult.Count);
+            int start = Math.Max(period + 1, count - 100);
+            for (int i = start; i < count - 1; i++)
+            {
+                double qValue = qUp[i].Value;
+                double? sValue = (double?)sResult[i + 1].UpperBand;
+                if (!sValue.HasValue)
+                {
+                    continue;
+                }
+
+                Assert.True(
+                    Math.Abs(qValue - sValue.Value) <= ValidationHelper.SkenderTolerance,
+                    $"Period={period}, Mismatch at q[{i}] vs s[{i + 1}]: QuanTAlib={qValue:G17}, Skender={sValue.Value:G17}");
+            }
+        }
+        _output.WriteLine("Dc upper band validated against Skender GetDonchian (offset +1)");
+    }
+
+    [Fact]
+    public void Validate_Skender_Batch_LowerBand()
+    {
+        // Same offset convention: QuanTAlib[i] == Skender[i+1]
+        int[] periods = { 5, 10, 20, 50, 100 };
+
+        foreach (var period in periods)
+        {
+            var (_, _, qLo) = Dc.Batch(_testData.Bars, period);
+            var sResult = _testData.SkenderQuotes.GetDonchian(period).ToList();
+
+            int count = Math.Min(qLo.Count, sResult.Count);
+            int start = Math.Max(period + 1, count - 100);
+            for (int i = start; i < count - 1; i++)
+            {
+                double qValue = qLo[i].Value;
+                double? sValue = (double?)sResult[i + 1].LowerBand;
+                if (!sValue.HasValue)
+                {
+                    continue;
+                }
+
+                Assert.True(
+                    Math.Abs(qValue - sValue.Value) <= ValidationHelper.SkenderTolerance,
+                    $"Period={period}, Mismatch at q[{i}] vs s[{i + 1}]: QuanTAlib={qValue:G17}, Skender={sValue.Value:G17}");
+            }
+        }
+        _output.WriteLine("Dc lower band validated against Skender GetDonchian (offset +1)");
+    }
+
+    [Fact]
+    public void Validate_Skender_Batch_Centerline()
+    {
+        // Same offset convention: QuanTAlib[i] == Skender[i+1]
+        int[] periods = { 5, 10, 20, 50, 100 };
+
+        foreach (var period in periods)
+        {
+            var (qMid, _, _) = Dc.Batch(_testData.Bars, period);
+            var sResult = _testData.SkenderQuotes.GetDonchian(period).ToList();
+
+            int count = Math.Min(qMid.Count, sResult.Count);
+            int start = Math.Max(period + 1, count - 100);
+            for (int i = start; i < count - 1; i++)
+            {
+                double qValue = qMid[i].Value;
+                double? sValue = (double?)sResult[i + 1].Centerline;
+                if (!sValue.HasValue)
+                {
+                    continue;
+                }
+
+                Assert.True(
+                    Math.Abs(qValue - sValue.Value) <= ValidationHelper.SkenderTolerance,
+                    $"Period={period}, Mismatch at q[{i}] vs s[{i + 1}]: QuanTAlib={qValue:G17}, Skender={sValue.Value:G17}");
+            }
+        }
+        _output.WriteLine("Dc centerline validated against Skender GetDonchian (offset +1)");
+    }
+
+    [Fact]
+    public void Validate_Skender_Streaming_UpperBand()
+    {
+        // Same offset convention: QuanTAlib[i] == Skender[i+1]
+        int[] periods = { 10, 20, 50 };
+
+        foreach (var period in periods)
+        {
+            var dc = new Dc(period);
+            var qUpResults = new TSeries();
+            foreach (var bar in _testData.Bars)
+            {
+                dc.Update(bar);
+                qUpResults.Add(dc.Upper);
+            }
+
+            var sResult = _testData.SkenderQuotes.GetDonchian(period).ToList();
+
+            int count = Math.Min(qUpResults.Count, sResult.Count);
+            int start = Math.Max(period + 1, count - 100);
+            for (int i = start; i < count - 1; i++)
+            {
+                double qValue = qUpResults[i].Value;
+                double? sValue = (double?)sResult[i + 1].UpperBand;
+                if (!sValue.HasValue)
+                {
+                    continue;
+                }
+
+                Assert.True(
+                    Math.Abs(qValue - sValue.Value) <= ValidationHelper.SkenderTolerance,
+                    $"Period={period}, Mismatch at q[{i}] vs s[{i + 1}]: QuanTAlib={qValue:G17}, Skender={sValue.Value:G17}");
+            }
+        }
+        _output.WriteLine("Dc streaming upper band validated against Skender GetDonchian (offset +1)");
+    }
+
+    [Fact]
+    public void Dc_MatchesOoples_Structural()
+    {
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.15, seed: 42);
+        var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var ooplesData = bars.Select(b => new TickerData
+        {
+            Date = new DateTime(b.Time, DateTimeKind.Utc),
+            Open = b.Open, High = b.High, Low = b.Low,
+            Close = b.Close, Volume = b.Volume
+        }).ToList();
+        var result = new StockData(ooplesData).CalculateDonchianChannels();
+        var values = result.OutputValues.Values.First();
+        int finiteCount = values.Count(v => double.IsFinite(v));
+        Assert.True(finiteCount > 100, $"Expected >100 finite values, got {finiteCount}");
+    }
+}