feat: init Config in BrokerageDataDownloader (#8482)

* Add unit test

* First potential solution

* Add regression tests

* Nit change

* Address requested changes

* Nit change

* Nit change

* Improve implementation

* Fix bugs

* Address requested changes

.github/workflows/api-tests.yml

@@ -9,14 +9,19 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     # Only run on push events (not on pull_request) for security reasons in order to be able to use secrets
     if: ${{ github.event_name == 'push' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
       - name: Run API Tests
         uses: addnab/docker-run-action@v3
         with:

.github/workflows/gh-actions.yml

@@ -9,12 +9,18 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
 
       - uses: addnab/docker-run-action@v3
         with:

.github/workflows/rebase-org-branches.yml

@@ -7,7 +7,7 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v2
         with:

.github/workflows/regression-tests.yml

@@ -9,12 +9,17 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
 
       - uses: addnab/docker-run-action@v3
         with:

.github/workflows/report-generator.yml

@@ -9,12 +9,17 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
 
       - uses: addnab/docker-run-action@v3
         with:

.github/workflows/research-regression-tests.yml

@@ -9,12 +9,17 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
 
       - uses: addnab/docker-run-action@v3
         with:

.github/workflows/virtual-environments.yml

@@ -9,12 +9,17 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v2
-      - name: Free space
-        run: df -h && rm -rf /usr/share/dotnet && sudo rm -rf /usr/local/lib/android && sudo rm -rf /opt/ghc && rm -rf /opt/hostedtoolcache* && df -h
+      - name: Liberate disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          tool-cache: true
+          large-packages: false
+          docker-images: false
+          swap-storage: false
 
       - uses: addnab/docker-run-action@v3
         with:
@@ -48,10 +53,10 @@ jobs:
             dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.TensorflowProbabilityTest" --blame-hang-timeout 120seconds --blame-crash && \
             # Run Hvplot Python Package Test
             dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.HvplotTest" --blame-hang-timeout 120seconds --blame-crash && \
-            # Run Keras Python Package Test
-            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.KerasTest" --blame-hang-timeout 120seconds --blame-crash && \
             # Run Transformers
             dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.Transformers" --blame-hang-timeout 120seconds --blame-crash && \
             dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.XTransformers" --blame-hang-timeout 120seconds --blame-crash && \
             # Run Shap
-            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.ShapTest" --blame-hang-timeout 120seconds --blame-crash
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.ShapTest|KerasTest|PyvinecopulibTest" --blame-hang-timeout 120seconds --blame-crash && \
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.Mlforecast" --blame-hang-timeout 120seconds --blame-crash && \
+            dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "FullyQualifiedName=QuantConnect.Tests.Python.PythonPackagesTests.MlxtendTest|Thinc" --blame-hang-timeout 120seconds --blame-crash

Algorithm.CSharp/AddBetaIndicatorNewAssetsRegressionAlgorithm.cs

@@ -0,0 +1,151 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); 
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+using QuantConnect.Brokerages;
+
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression test to explain how Beta indicator works
+    /// </summary>
+    public class AddBetaIndicatorNewAssetsRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Beta _beta;
+        private SimpleMovingAverage _sma;
+        private decimal _lastSMAValue;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 05, 08);
+            SetEndDate(2017, 06, 15);
+            SetCash(10000);
+
+            AddCrypto("BTCUSD", Resolution.Daily);
+            AddEquity("SPY", Resolution.Daily);
+
+            EnableAutomaticIndicatorWarmUp = true;
+            _beta = B("BTCUSD", "SPY", 3, Resolution.Daily);
+            _sma = SMA("SPY", 3, Resolution.Daily);
+            _lastSMAValue = 0;
+
+            if (!_beta.IsReady)
+            {
+                throw new RegressionTestException("Beta indicator was expected to be ready");
+            }
+        }
+
+        public override void OnData(Slice slice)
+        {
+            var price = Securities["BTCUSD"].Price;
+
+            if (!Portfolio.Invested)
+            {
+                var quantityToBuy = (int)(Portfolio.Cash * 0.05m / price);
+                Buy("BTCUSD", quantityToBuy);
+            }
+
+            if (Math.Abs(_beta.Current.Value) > 2)
+            {
+                Liquidate("BTCUSD");
+                Log("Liquidated BTCUSD due to high Beta");
+            }
+
+            Log($"Beta between BTCUSD and SPY is: {_beta.Current.Value}");
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            var order = Transactions.GetOrderById(orderEvent.OrderId);
+            var goUpwards = _lastSMAValue < _sma.Current.Value;
+            _lastSMAValue = _sma.Current.Value;
+
+            if (order.Status == OrderStatus.Filled)
+            {
+                if (order.Type == OrderType.Limit && Math.Abs(_beta.Current.Value - 1) < 0.2m && goUpwards)
+                {
+                    Transactions.CancelOpenOrders(order.Symbol);
+                }
+            }
+
+            if (order.Status == OrderStatus.Canceled)
+            {
+                Log(orderEvent.ToString());
+            }
+        }
+
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual List<Language> Languages { get; } = new() { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 5798;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 77;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "436"},
+            {"Average Win", "0.28%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "1.926%"},
+            {"Drawdown", "1.000%"},
+            {"Expectancy", "1.650"},
+            {"Start Equity", "10000.00"},
+            {"End Equity", "10411.11"},
+            {"Net Profit", "4.111%"},
+            {"Sharpe Ratio", "0.332"},
+            {"Sortino Ratio", "0.313"},
+            {"Probabilistic Sharpe Ratio", "74.084%"},
+            {"Loss Rate", "90%"},
+            {"Win Rate", "10%"},
+            {"Profit-Loss Ratio", "25.26"},
+            {"Alpha", "0.003"},
+            {"Beta", "0.001"},
+            {"Annual Standard Deviation", "0.01"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-0.495"},
+            {"Tracking Error", "0.111"},
+            {"Treynor Ratio", "2.716"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$87000.00"},
+            {"Lowest Capacity Asset", "BTCUSD 2XR"},
+            {"Portfolio Turnover", "2.22%"},
+            {"OrderListHash", "4fcffc45d82203bb6ded8a0e86070b4f"}
+        };
+    }
+}

Algorithm.CSharp/AddBetaIndicatorRegressionAlgorithm.cs

@@ -47,7 +47,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             if (!_beta.IsReady)
             {
-                throw new RegressionTestException("_beta indicator was expected to be ready");
+                throw new RegressionTestException("Beta indicator was expected to be ready");
             }
         }
 
@@ -60,7 +60,7 @@ namespace QuantConnect.Algorithm.CSharp
                 LimitOrder("IBM", 10, price * 0.1m);
                 StopMarketOrder("IBM", 10, price / 0.1m);
             }
-            
+
             if (_beta.Current.Value < 0m || _beta.Current.Value > 2.80m)
             {
                 throw new RegressionTestException($"_beta value was expected to be between 0 and 2.80 but was {_beta.Current.Value}");

Algorithm.CSharp/AddFutureContractWithContinuousRegressionAlgorithm.cs

@@ -115,7 +115,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 73;
+        public long DataPoints => 76;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -164,7 +164,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 311879;
+        public long DataPoints => 311881;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/AddFutureOptionContractFromFutureChainRegressionAlgorithm.cs

@@ -93,7 +93,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 12169;
+        public long DataPoints => 12172;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -220,7 +220,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 608377;
+        public long DataPoints => 608380;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/AddOptionContractFromUniverseRegressionAlgorithm.cs

@@ -117,7 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
                                                       && optionContract.ID.OptionStyle == OptionStyle.American);
                 AddOptionContract(option);
 
-                foreach (var symbol in new[] { option.Symbol, option.Underlying.Symbol })
+                foreach (var symbol in new[] { option.Symbol, option.UnderlyingSymbol })
                 {
                     var config = SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol).ToList();
 

Algorithm.CSharp/BasicTemplateContinuousFutureAlgorithm.cs

@@ -118,7 +118,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 713369;
+        public long DataPoints => 713375;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/BasicTemplateContinuousFutureWithExtendedMarketAlgorithm.cs

@@ -123,7 +123,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 2217299;
+        public long DataPoints => 2217328;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/BasicTemplateEurexFuturesAlgorithm.cs

@@ -190,7 +190,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 133945;
+        public long DataPoints => 133947;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/BasicTemplateFutureRolloverAlgorithm.cs

@@ -176,7 +176,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1190;
+        public long DataPoints => 1185;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -219,7 +219,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Portfolio Turnover", "0.13%"},
-            {"OrderListHash", "273dd05b937c075b75baf8af46d3c7de"}
+            {"OrderListHash", "7c8700a9baa24f6f76d866e7d88cc19c"}
         };
     }  
 }

Algorithm.CSharp/BasicTemplateFuturesDailyAlgorithm.cs

@@ -117,7 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 12452;
+        public virtual long DataPoints => 12474;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -134,33 +134,33 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "32"},
+            {"Total Orders", "34"},
             {"Average Win", "0.33%"},
             {"Average Loss", "-0.04%"},
-            {"Compounding Annual Return", "0.110%"},
+            {"Compounding Annual Return", "0.106%"},
             {"Drawdown", "0.300%"},
-            {"Expectancy", "0.184"},
+            {"Expectancy", "0.178"},
             {"Start Equity", "1000000"},
-            {"End Equity", "1001108"},
-            {"Net Profit", "0.111%"},
-            {"Sharpe Ratio", "-1.688"},
-            {"Sortino Ratio", "-0.772"},
-            {"Probabilistic Sharpe Ratio", "14.944%"},
+            {"End Equity", "1001066.2"},
+            {"Net Profit", "0.107%"},
+            {"Sharpe Ratio", "-1.695"},
+            {"Sortino Ratio", "-0.804"},
+            {"Probabilistic Sharpe Ratio", "14.797%"},
             {"Loss Rate", "88%"},
             {"Win Rate", "12%"},
-            {"Profit-Loss Ratio", "8.47"},
+            {"Profit-Loss Ratio", "9.01"},
             {"Alpha", "-0.007"},
             {"Beta", "0.002"},
             {"Annual Standard Deviation", "0.004"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-1.353"},
             {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "-4.099"},
-            {"Total Fees", "$72.00"},
+            {"Treynor Ratio", "-4.112"},
+            {"Total Fees", "$76.30"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
-            {"Portfolio Turnover", "0.87%"},
-            {"OrderListHash", "168731c8f3a19f230cc1410818b3b573"}
+            {"Portfolio Turnover", "0.92%"},
+            {"OrderListHash", "9507abc8348ff3cb1e2a9a5f48d128a7"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesFrameworkWithExtendedMarketAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 163415;
+        public override long DataPoints => 163416;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/BasicTemplateFuturesHourlyAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 87289;
+        public override long DataPoints => 87292;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketDailyAlgorithm.cs

@@ -14,14 +14,7 @@
  *
 */
 
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using QuantConnect.Data;
-using QuantConnect.Interfaces;
-using QuantConnect.Orders;
-using QuantConnect.Securities;
-using QuantConnect.Securities.Future;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -43,40 +36,40 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 14790;
+        public override long DataPoints => 14713;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
         public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "36"},
+            {"Total Orders", "32"},
             {"Average Win", "0.33%"},
-            {"Average Loss", "-0.03%"},
-            {"Compounding Annual Return", "0.102%"},
+            {"Average Loss", "-0.04%"},
+            {"Compounding Annual Return", "0.110%"},
             {"Drawdown", "0.300%"},
-            {"Expectancy", "0.171"},
+            {"Expectancy", "0.184"},
             {"Start Equity", "1000000"},
-            {"End Equity", "1001024.4"},
-            {"Net Profit", "0.102%"},
-            {"Sharpe Ratio", "-1.702"},
-            {"Sortino Ratio", "-0.836"},
-            {"Probabilistic Sharpe Ratio", "14.653%"},
-            {"Loss Rate", "89%"},
-            {"Win Rate", "11%"},
-            {"Profit-Loss Ratio", "9.54"},
+            {"End Equity", "1001108"},
+            {"Net Profit", "0.111%"},
+            {"Sharpe Ratio", "-1.688"},
+            {"Sortino Ratio", "-0.772"},
+            {"Probabilistic Sharpe Ratio", "14.944%"},
+            {"Loss Rate", "88%"},
+            {"Win Rate", "12%"},
+            {"Profit-Loss Ratio", "8.47"},
             {"Alpha", "-0.007"},
             {"Beta", "0.002"},
             {"Annual Standard Deviation", "0.004"},
             {"Annual Variance", "0"},
             {"Information Ratio", "-1.353"},
             {"Tracking Error", "0.089"},
-            {"Treynor Ratio", "-4.126"},
-            {"Total Fees", "$80.60"},
+            {"Treynor Ratio", "-4.099"},
+            {"Total Fees", "$72.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "ES VRJST036ZY0X"},
-            {"Portfolio Turnover", "0.97%"},
-            {"OrderListHash", "52c852d720692fab1e12212b2aba03d4"}
+            {"Portfolio Turnover", "0.87%"},
+            {"OrderListHash", "ea6fdf3133bde7063e4fc0fa809ae260"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesWithExtendedMarketHourlyAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 228834;
+        public override long DataPoints => 228935;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/BasicTemplateIndexDailyAlgorithm.cs

@@ -70,7 +70,7 @@ namespace QuantConnect.Algorithm.CSharp
             }
 
             var openInterest = Securities[SpxOption].Cache.GetAll<OpenInterest>();
-            if (openInterest.Single().EndTime != new DateTime(2021, 1, 15, 23, 0, 0))
+            if (openInterest.Single().EndTime != new DateTime(2021, 1, 15, 15, 15, 0))
             {
                 throw new ArgumentException($"Unexpected open interest time: {openInterest.Single().EndTime}");
             }
@@ -106,7 +106,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 121;
+        public override long DataPoints => 122;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -126,7 +126,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "11"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "621.484%"},
+            {"Compounding Annual Return", "653.545%"},
             {"Drawdown", "0%"},
             {"Expectancy", "0"},
             {"Start Equity", "1000000"},

Algorithm.CSharp/BasicTemplateIndexOptionsDailyAlgorithm.cs

@@ -67,7 +67,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 356;
+        public override long DataPoints => 360;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/CallbackCommandRegressionAlgorithm.cs

@@ -0,0 +1,159 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System;
+using QuantConnect.Commands;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting the behavior of different callback commands call
+    /// </summary>
+    public class CallbackCommandRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 07);
+            SetEndDate(2013, 10, 11);
+
+            AddEquity("SPY");
+            AddEquity("BAC");
+            AddEquity("IBM");
+            AddCommand<BoolCommand>();
+            AddCommand<VoidCommand>();
+
+            var potentialCommand = new VoidCommand
+            {
+                Target = new[] { "BAC" },
+                Quantity = 10,
+                Parameters = new() { { "tag", "Signal X" } }
+            };
+            var commandLink = Link(potentialCommand);
+            Notify.Email("email@address", "Trade Command Event", $"Signal X trade\nFollow link to trigger: {commandLink}");
+
+            var commandLink2 = Link(new { Symbol = "SPY", Parameters = new Dictionary<string, int>() { { "Quantity", 10 } } });
+            Notify.Email("email@address", "Untyped Command Event", $"Signal Y trade\nFollow link to trigger: {commandLink2}");
+        }
+
+        /// <summary>
+        /// Handle generic command callback
+        /// </summary>
+        public override bool? OnCommand(dynamic data)
+        {
+            Buy(data.Symbol, data.parameters["quantity"]);
+            return true;
+        }
+
+        private class VoidCommand : Command
+        {
+            public DateTime TargetTime { get; set; }
+            public string[] Target { get; set; }
+            public decimal Quantity { get; set; }
+            public Dictionary<string, string> Parameters { get; set; }
+            public override bool? Run(IAlgorithm algorithm)
+            {
+                if (TargetTime != algorithm.Time)
+                {
+                    return null;
+                }
+
+                ((QCAlgorithm)algorithm).Order(Target[0], Quantity, tag: Parameters["tag"]);
+                return null;
+            }
+        }
+        private class BoolCommand : Command
+        {
+            public bool? Result { get; set; }
+            public override bool? Run(IAlgorithm algorithm)
+            {
+                var shouldTrade = MyCustomMethod();
+                if (shouldTrade.HasValue && shouldTrade.Value)
+                {
+                    ((QCAlgorithm)algorithm).Buy("IBM", 1);
+                }
+                return shouldTrade;
+            }
+
+            private bool? MyCustomMethod()
+            {
+                return Result;
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 3943;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "271.453%"},
+            {"Drawdown", "2.200%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "101691.92"},
+            {"Net Profit", "1.692%"},
+            {"Sharpe Ratio", "8.854"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "67.609%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.005"},
+            {"Beta", "0.996"},
+            {"Annual Standard Deviation", "0.222"},
+            {"Annual Variance", "0.049"},
+            {"Information Ratio", "-14.565"},
+            {"Tracking Error", "0.001"},
+            {"Treynor Ratio", "1.97"},
+            {"Total Fees", "$3.44"},
+            {"Estimated Strategy Capacity", "$56000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Portfolio Turnover", "19.93%"},
+            {"OrderListHash", "3da9fa60bf95b9ed148b95e02e0cfc9e"}
+        };
+    }
+}

Algorithm.CSharp/ConsolidateHourBarsIntoDailyBarsRegressionAlgorithm.cs

@@ -0,0 +1,166 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using System;
+using System.Collections.Generic;
+using QuantConnect.Data.Market;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This regression algorithm asserts the consolidated US equity daily bars from the hour bars exactly matches
+    /// the daily bars returned from the database
+    /// </summary>
+    public class ConsolidateHourBarsIntoDailyBarsRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spy;
+        private RelativeStrengthIndex _rsi;
+        private RelativeStrengthIndex _rsiTimeDelta;
+        private Dictionary<DateTime, decimal> _values = new();
+        private int _count;
+        private bool _indicatorsCompared;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 5, 1);
+            SetEndDate(2020, 6, 5);
+
+            _spy = AddEquity("SPY", Resolution.Hour).Symbol;
+
+            // We will use these two indicators to compare the daily consolidated bars equals
+            // the ones returned from the database. We use this specific type of indicator as
+            // it depends on its previous values. Thus, if at some point the bars received by
+            // the indicators differ, so will their final values
+            _rsi = new RelativeStrengthIndex("FIRST", 15, MovingAverageType.Wilders);
+            RegisterIndicator(_spy, _rsi, Resolution.Daily, selector: (bar) =>
+            {
+                var tradeBar = (TradeBar)bar;
+                return (tradeBar.Close + tradeBar.Open) / 2;
+            });
+
+            // We won't register this indicator as we will update it manually at the end of the
+            // month, so that we can compare the values of the indicator that received consolidated
+            // bars and the values of this one
+            _rsiTimeDelta = new RelativeStrengthIndex("SECOND" ,15, MovingAverageType.Wilders);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (IsWarmingUp) return;
+
+            if (slice.ContainsKey(_spy) && slice[_spy] != null)
+            {
+                if (Time.Month == EndDate.Month)
+                {
+                    var history = History(_spy, _count, Resolution.Daily);
+                    foreach (var bar in history)
+                    {
+                        var time = bar.EndTime.Date;
+                        var average = (bar.Close + bar.Open) / 2;
+                        _rsiTimeDelta.Update(bar.EndTime, average);
+                        if (_rsiTimeDelta.Current.Value != _values[time])
+                        {
+                            throw new RegressionTestException($"Both {_rsi.Name} and {_rsiTimeDelta.Name} should have the same values, but they differ. {_rsi.Name}: {_values[time]} | {_rsiTimeDelta.Name}: {_rsiTimeDelta.Current.Value}");
+                        }
+                    }
+                    _indicatorsCompared = true;
+                    Quit();
+                }
+                else
+                {
+                    _values[Time.Date] = _rsi.Current.Value;
+
+                    // Since the symbol resolution is hour and the symbol is equity, we know the last bar received in a day will
+                    // be at the market close, this is 16h. We need to count how many daily bars were consolidated in order to know
+                    // how many we need to request from the history
+                    if (Time.Hour == 16)
+                    {
+                        _count++;
+                    }
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_indicatorsCompared)
+            {
+                throw new RegressionTestException($"Indicators {_rsi.Name} and {_rsiTimeDelta.Name} should have been compared, but they were not. Please make sure the indicators are getting SPY data");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 290;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 20;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "100000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-5.215"},
+            {"Tracking Error", "0.159"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/ConsolidateRegressionAlgorithm.cs

@@ -22,6 +22,7 @@ using QuantConnect.Data.Market;
 using QuantConnect.Indicators;
 using QuantConnect.Interfaces;
 using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -31,69 +32,83 @@ namespace QuantConnect.Algorithm.CSharp
     public class ConsolidateRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
         private List<int> _consolidationCounts;
+        private List<int> _expectedConsolidationCounts;
         private List<SimpleMovingAverage> _smas;
         private List<DateTime> _lastSmaUpdates;
-        private int _expectedConsolidations;
-        private int _customDataConsolidator;
-        private Symbol _symbol;
+        private int _customDataConsolidatorCount;
+        private Future _future;
 
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
         /// </summary>
         public override void Initialize()
         {
-            SetStartDate(2013, 10, 08);
-            SetEndDate(2013, 10, 20);
+            SetStartDate(2020, 01, 05);
+            SetEndDate(2020, 01, 20);
 
             var SP500 = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
-            _symbol = FutureChainProvider.GetFutureContractList(SP500, StartDate).First();
-            var security = AddFutureContract(_symbol);
+            var symbol = FutureChainProvider.GetFutureContractList(SP500, StartDate).First();
+            _future = AddFutureContract(symbol);
 
-            _consolidationCounts = Enumerable.Repeat(0, 9).ToList();
+            var tradableDatesCount = QuantConnect.Time.EachTradeableDayInTimeZone(_future.Exchange.Hours,
+                StartDate,
+                EndDate,
+                _future.Exchange.TimeZone,
+                false).Count();
+            _expectedConsolidationCounts = new(10);
+
+            Consolidate<QuoteBar>(symbol, time => new CalendarInfo(time.RoundDown(TimeSpan.FromDays(1)), TimeSpan.FromDays(1)),
+                bar => UpdateQuoteBar(bar, 0));
+            // The consolidator will respect the full 1 day bar span and will not consolidate the last tradable date,
+            // since scan will not be called at 202/01/21 12am
+            _expectedConsolidationCounts.Add(tradableDatesCount - 1);
+
+            Consolidate<QuoteBar>(symbol, time => new CalendarInfo(time.RoundDown(TimeSpan.FromDays(1)), TimeSpan.FromDays(1)),
+                TickType.Quote, bar => UpdateQuoteBar(bar, 1));
+            _expectedConsolidationCounts.Add(tradableDatesCount - 1);
+
+            Consolidate<QuoteBar>(symbol, TimeSpan.FromDays(1), bar => UpdateQuoteBar(bar, 2));
+            _expectedConsolidationCounts.Add(tradableDatesCount - 1);
+
+            Consolidate(symbol, Resolution.Daily, TickType.Quote, (Action<QuoteBar>)(bar => UpdateQuoteBar(bar, 3)));
+            _expectedConsolidationCounts.Add(tradableDatesCount);
+
+            Consolidate(symbol, TimeSpan.FromDays(1), bar => UpdateTradeBar(bar, 4));
+            _expectedConsolidationCounts.Add(tradableDatesCount - 1);
+
+            Consolidate<TradeBar>(symbol, TimeSpan.FromDays(1), bar => UpdateTradeBar(bar, 5));
+            _expectedConsolidationCounts.Add(tradableDatesCount - 1);
+
+            // Test using abstract T types, through defining a 'BaseData' handler
+
+            Consolidate(symbol, Resolution.Daily, null, (Action<BaseData>)(bar => UpdateBar(bar, 6)));
+            _expectedConsolidationCounts.Add(tradableDatesCount);
+
+            Consolidate(symbol, TimeSpan.FromDays(1), null, (Action<BaseData>)(bar => UpdateBar(bar, 7)));
+            _expectedConsolidationCounts.Add(tradableDatesCount - 1);
+
+            Consolidate(symbol, TimeSpan.FromDays(1), (Action<BaseData>)(bar => UpdateBar(bar, 8)));
+            _expectedConsolidationCounts.Add(tradableDatesCount - 1);
+
+            _consolidationCounts = Enumerable.Repeat(0, _expectedConsolidationCounts.Count).ToList();
             _smas = _consolidationCounts.Select(_ => new SimpleMovingAverage(10)).ToList();
             _lastSmaUpdates = _consolidationCounts.Select(_ => DateTime.MinValue).ToList();
 
-            Consolidate<QuoteBar>(_symbol, time => new CalendarInfo(time.RoundDown(TimeSpan.FromDays(1)), TimeSpan.FromDays(1)),
-                bar => UpdateQuoteBar(bar, 0));
-
-            Consolidate<QuoteBar>(_symbol, time => new CalendarInfo(time.RoundDown(TimeSpan.FromDays(1)), TimeSpan.FromDays(1)),
-                TickType.Quote, bar => UpdateQuoteBar(bar, 1));
-
-            Consolidate<QuoteBar>(_symbol, TimeSpan.FromDays(1), bar => UpdateQuoteBar(bar, 2));
-
-            Consolidate(_symbol, Resolution.Daily, TickType.Quote, (Action<QuoteBar>)(bar => UpdateQuoteBar(bar, 3)));
-
-            Consolidate(_symbol, TimeSpan.FromDays(1), bar => UpdateTradeBar(bar, 4));
-
-            Consolidate<TradeBar>(_symbol, TimeSpan.FromDays(1), bar => UpdateTradeBar(bar, 5));
-
             // custom data
-            var symbol = AddData<CustomDataRegressionAlgorithm.Bitcoin>("BTC", Resolution.Minute).Symbol;
-            Consolidate<TradeBar>(symbol, TimeSpan.FromDays(1), bar => _customDataConsolidator++);
+            var customSecurity = AddData<CustomDataRegressionAlgorithm.Bitcoin>("BTC", Resolution.Minute);
+            Consolidate<TradeBar>(customSecurity.Symbol, TimeSpan.FromDays(1), bar => _customDataConsolidatorCount++);
 
             try
             {
-                Consolidate<QuoteBar>(symbol, TimeSpan.FromDays(1), bar => { UpdateQuoteBar(bar, -1); });
+                Consolidate<QuoteBar>(customSecurity.Symbol, TimeSpan.FromDays(1), bar => { UpdateQuoteBar(bar, -1); });
                 throw new RegressionTestException($"Expected {nameof(ArgumentException)} to be thrown");
             }
             catch (ArgumentException)
             {
                 // will try to use BaseDataConsolidator for which input is TradeBars not QuoteBars
             }
-
-            // Test using abstract T types, through defining a 'BaseData' handler
-            Consolidate(_symbol, Resolution.Daily, null, (Action<BaseData>)(bar => UpdateBar(bar, 6)));
-
-            Consolidate(_symbol, TimeSpan.FromDays(1), null, (Action<BaseData>)(bar => UpdateBar(bar, 7)));
-
-            Consolidate(_symbol, TimeSpan.FromDays(1), (Action<BaseData>)(bar => UpdateBar(bar, 8)));
-
-            _expectedConsolidations = QuantConnect.Time.EachTradeableDayInTimeZone(security.Exchange.Hours,
-                StartDate,
-                EndDate,
-                security.Exchange.TimeZone,
-                false).Count();
         }
+
         private void UpdateBar(BaseData tradeBar, int position)
         {
             if (!(tradeBar is TradeBar))
@@ -119,16 +134,27 @@ namespace QuantConnect.Algorithm.CSharp
 
         public override void OnEndOfAlgorithm()
         {
-            if (_consolidationCounts.Any(i => i != _expectedConsolidations) || _customDataConsolidator == 0)
+            for (var i = 0; i < _consolidationCounts.Count; i++)
             {
-                throw new RegressionTestException("Unexpected consolidation count");
+                var consolidationCount = _consolidationCounts[i];
+                var expectedConsolidationCount = _expectedConsolidationCounts[i];
+
+                if (consolidationCount != expectedConsolidationCount)
+                {
+                    throw new RegressionTestException($"Expected {expectedConsolidationCount} consolidations for consolidator {i} but received {consolidationCount}");
+                }
+            }
+
+            if (_customDataConsolidatorCount == 0)
+            {
+                throw new RegressionTestException($"Unexpected custom data consolidation count: {_customDataConsolidatorCount}");
             }
 
             for (var i = 0; i < _smas.Count; i++)
             {
-                if (_smas[i].Samples != _expectedConsolidations)
+                if (_smas[i].Samples != _expectedConsolidationCounts[i])
                 {
-                    throw new RegressionTestException($"Expected {_expectedConsolidations} samples in each SMA but found {_smas[i].Samples} in SMA in index {i}");
+                    throw new RegressionTestException($"Expected {_expectedConsolidationCounts} samples in each SMA but found {_smas[i].Samples} in SMA in index {i}");
                 }
 
                 if (_smas[i].Current.Time != _lastSmaUpdates[i])
@@ -144,9 +170,9 @@ namespace QuantConnect.Algorithm.CSharp
         /// <param name="data">Slice object keyed by symbol containing the stock data</param>
         public override void OnData(Slice slice)
         {
-            if (!Portfolio.Invested)
+            if (!Portfolio.Invested && _future.HasData)
             {
-                SetHoldings(_symbol, 0.5);
+                SetHoldings(_future.Symbol, 0.5);
             }
         }
 
@@ -163,7 +189,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 12244;
+        public long DataPoints => 14228;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -183,30 +209,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "6636.699%"},
-            {"Drawdown", "15.900%"},
+            {"Compounding Annual Return", "665.524%"},
+            {"Drawdown", "1.500%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},
-            {"End Equity", "116177.7"},
-            {"Net Profit", "16.178%"},
-            {"Sharpe Ratio", "640.313"},
+            {"End Equity", "109332.4"},
+            {"Net Profit", "9.332%"},
+            {"Sharpe Ratio", "9.805"},
             {"Sortino Ratio", "0"},
-            {"Probabilistic Sharpe Ratio", "99.824%"},
+            {"Probabilistic Sharpe Ratio", "93.474%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "636.164"},
-            {"Beta", "5.924"},
-            {"Annual Standard Deviation", "1.012"},
-            {"Annual Variance", "1.024"},
-            {"Information Ratio", "696.123"},
-            {"Tracking Error", "0.928"},
-            {"Treynor Ratio", "109.404"},
-            {"Total Fees", "$23.65"},
-            {"Estimated Strategy Capacity", "$210000000.00"},
-            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Portfolio Turnover", "81.19%"},
-            {"OrderListHash", "dfd9a280d3c6470b305c03e0b72c234e"}
+            {"Alpha", "3.164"},
+            {"Beta", "0.957"},
+            {"Annual Standard Deviation", "0.383"},
+            {"Annual Variance", "0.146"},
+            {"Information Ratio", "8.29"},
+            {"Tracking Error", "0.379"},
+            {"Treynor Ratio", "3.917"},
+            {"Total Fees", "$15.05"},
+            {"Estimated Strategy Capacity", "$2100000000.00"},
+            {"Lowest Capacity Asset", "ES XCZJLC9NOB29"},
+            {"Portfolio Turnover", "64.34%"},
+            {"OrderListHash", "d814db6d5a9c97ee6de477ea06cd3834"}
         };
     }
 }

Algorithm.CSharp/ContinuousBackMonthRawFutureRegressionAlgorithm.cs

@@ -139,7 +139,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 713369;
+        public long DataPoints => 713371;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ContinuousFutureBackMonthRegressionAlgorithm.cs

@@ -155,7 +155,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 723496;
+        public long DataPoints => 723498;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ContinuousFutureHistoryRegressionAlgorithm.cs

@@ -120,7 +120,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 9951;
+        public virtual long DataPoints => 9953;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ContinuousFutureImmediateUniverseSelectionRegressionAlgorithm.cs

@@ -184,7 +184,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 596356;
+        public long DataPoints => 596358;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ContinuousFutureLimitIfTouchedOrderRegressionAlgorithm.cs

@@ -78,7 +78,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 19886;
+        public long DataPoints => 19888;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ContinuousFutureOpenPositionsLiquidationOnDelistingRegressionAlgorithm.cs

@@ -0,0 +1,237 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing GH issue #8386 and other related bugs.
+    /// It asserts that open positions are liquidated when a contract is delisted, even if the contract was added as an internal subscription.
+    /// It also asserts that the contract is not tradable after being delisted.
+    /// </summary>
+    public class ContinuousFutureOpenPositionsLiquidationOnDelistingRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Future _continuousContract;
+        private Symbol _prevContractSymbol;
+        private bool _traded;
+        private bool _mapped;
+        private bool _delistedContractChecked;
+        private DateTime _firstMappedContractRemovalTime;
+        private int _removalCount;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 08);
+            SetEndDate(2013, 12, 30);
+
+            _continuousContract = AddFuture(Futures.Indices.SP500EMini,
+                dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
+                dataMappingMode: DataMappingMode.OpenInterest,
+                contractDepthOffset: 0
+            );
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (!_traded && _continuousContract.HasData)
+            {
+                var ticket = MarketOrder(_continuousContract.Mapped, 1);
+                if (ticket.Status == OrderStatus.Invalid)
+                {
+                    throw new RegressionTestException($"Order should be valid: {ticket}");
+                }
+                _traded = true;
+            }
+
+            if (slice.SymbolChangedEvents.Count > 0)
+            {
+                foreach (var change in slice.SymbolChangedEvents.Values)
+                {
+                    Debug($"[{Time}] :: Mapping: {change}");
+                    _prevContractSymbol = Symbol(change.OldSymbol);
+                    _mapped = true;
+                }
+            }
+
+            if (!_delistedContractChecked &&
+                _prevContractSymbol  != null &&
+                Time.Date > _prevContractSymbol.ID.Date &&
+                IsMarketOpen(_prevContractSymbol))
+            {
+                _delistedContractChecked = true;
+                var delistedContract = Securities.Total.Single(sec => sec.Symbol == _prevContractSymbol);
+
+                if (delistedContract.Invested)
+                {
+                    throw new RegressionTestException($"Position should be closed when {_prevContractSymbol} got delisted {_prevContractSymbol.ID.Date}");
+                }
+
+                if (!delistedContract.IsDelisted)
+                {
+                    throw new RegressionTestException($"Contract should be delisted: {delistedContract.Symbol}");
+                }
+
+                if (delistedContract.IsTradable)
+                {
+                    throw new RegressionTestException($"Contract should not be tradable: {delistedContract.Symbol}");
+                }
+
+                var ticket = MarketOrder(_prevContractSymbol, 1);
+
+                if (ticket.Status != OrderStatus.Invalid)
+                {
+                    throw new RegressionTestException($"Delisted contract order should be invalid: {ticket}");
+                }
+            }
+        }
+
+        public override void OnSecuritiesChanged(SecurityChanges changes)
+        {
+            if (_prevContractSymbol != null)
+            {
+                if (changes.RemovedSecurities.Any(x => x.Symbol == _prevContractSymbol))
+                {
+                    throw new RegressionTestException($"Previous contract symbol {_prevContractSymbol} should not be removed as a non-internal security");
+                }
+
+                changes.FilterInternalSecurities = false;
+
+                if (!changes.RemovedSecurities.Any(x => x.Symbol == _prevContractSymbol))
+                {
+                    throw new RegressionTestException($"Previous contract symbol {_prevContractSymbol} should be removed as an internal security");
+                }
+
+                _firstMappedContractRemovalTime = Time;
+                _removalCount++;
+            }
+
+            changes.FilterInternalSecurities = false;
+            Debug($"[{Time}] :: {changes}");
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Debug($"[{Time}] :: Order event: {orderEvent}");
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_traded)
+            {
+                throw new RegressionTestException("No trades have been made");
+            }
+
+            if (!_mapped)
+            {
+                throw new RegressionTestException("No mapping events have been fired");
+            }
+
+            if (!_delistedContractChecked)
+            {
+                throw new RegressionTestException("No delisted contract has been checked");
+            }
+
+            if (_prevContractSymbol == null)
+            {
+                throw new RegressionTestException("No previous contract symbol has been set");
+            }
+
+            var tradedContract = Securities.Total.Single(sec => sec.Symbol == _prevContractSymbol);
+            if (tradedContract.Invested)
+            {
+                throw new RegressionTestException($"Position should be closed when {_prevContractSymbol} got delisted on {_prevContractSymbol.ID.Date}");
+            }
+
+            if (_firstMappedContractRemovalTime == default || _firstMappedContractRemovalTime >= _prevContractSymbol.ID.Date)
+            {
+                throw new RegressionTestException($"First mapped contract should have been removed before it's expiry date");
+            }
+
+            if (_removalCount != 1)
+            {
+                throw new RegressionTestException($"The mapped contract should have been removed once only");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 396945;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "2"},
+            {"Average Win", "7.02%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "34.386%"},
+            {"Drawdown", "1.500%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "107016.6"},
+            {"Net Profit", "7.017%"},
+            {"Sharpe Ratio", "3.217"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "99.828%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "100%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.227"},
+            {"Beta", "0.109"},
+            {"Annual Standard Deviation", "0.084"},
+            {"Annual Variance", "0.007"},
+            {"Information Ratio", "-1.122"},
+            {"Tracking Error", "0.112"},
+            {"Treynor Ratio", "2.49"},
+            {"Total Fees", "$2.15"},
+            {"Estimated Strategy Capacity", "$1700000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Portfolio Turnover", "2.01%"},
+            {"OrderListHash", "838e662caaa5a385c43ef27df1efbaf4"}
+        };
+    }
+}

Algorithm.CSharp/ContinuousFutureRegressionAlgorithm.cs

@@ -19,7 +19,6 @@ using QuantConnect.Data;
 using QuantConnect.Orders;
 using QuantConnect.Interfaces;
 using QuantConnect.Securities;
-using QuantConnect.Data.Market;
 using System.Collections.Generic;
 using QuantConnect.Securities.Future;
 using QuantConnect.Data.UniverseSelection;
@@ -31,7 +30,7 @@ namespace QuantConnect.Algorithm.CSharp
     /// </summary>
     public class ContinuousFutureRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
-        private List<SymbolChangedEvent> _mappings = new();
+        private List<Symbol> _previousMappedContractSymbols = new();
         private Symbol _currentMappedSymbol;
         private Future _continuousContract;
         private DateTime _lastMonth;
@@ -77,7 +76,7 @@ namespace QuantConnect.Algorithm.CSharp
             {
                 if (changedEvent.Symbol == _continuousContract.Symbol)
                 {
-                    _mappings.Add(changedEvent);
+                    _previousMappedContractSymbols.Add(Symbol(changedEvent.OldSymbol));
                     Log($"{Time} - SymbolChanged event: {changedEvent}");
 
                     if (_currentMappedSymbol == _continuousContract.Mapped)
@@ -144,15 +143,20 @@ namespace QuantConnect.Algorithm.CSharp
         public override void OnEndOfAlgorithm()
         {
             var expectedMappingCounts = 2;
-            if (_mappings.Count != expectedMappingCounts)
+            if (_previousMappedContractSymbols.Count != expectedMappingCounts)
             {
-                throw new RegressionTestException($"Unexpected symbol changed events: {_mappings.Count}, was expecting {expectedMappingCounts}");
+                throw new RegressionTestException($"Unexpected symbol changed events: {_previousMappedContractSymbols.Count}, was expecting {expectedMappingCounts}");
             }
 
-            var securities = Securities.Total.Where(sec => !sec.IsTradable && !sec.Symbol.IsCanonical() && sec.Symbol.SecurityType == SecurityType.Future).ToList();
-            if (securities.Count != 1)
+            var delistedSecurities = _previousMappedContractSymbols
+                .Select(x => Securities.Total.Single(sec => sec.Symbol == x))
+                .Where(x => x.Symbol.ID.Date < Time)
+                .ToList();
+            var markedDelistedSecurities = delistedSecurities.Where(x => x.IsDelisted && !x.IsTradable).ToList();
+            if (markedDelistedSecurities.Count != delistedSecurities.Count)
             {
-                throw new RegressionTestException($"We should have a single non tradable future contract security! found: {securities.Count}");
+                throw new RegressionTestException($"Not all delisted contracts are properly market as delisted and non-tradable: " +
+                    $"only {markedDelistedSecurities.Count} are marked, was expecting {delistedSecurities.Count}");
             }
         }
 
@@ -169,7 +173,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 713369;
+        public long DataPoints => 713375;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -186,18 +190,18 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Orders", "3"},
-            {"Average Win", "1.50%"},
+            {"Total Orders", "4"},
+            {"Average Win", "0.84%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "3.337%"},
+            {"Compounding Annual Return", "3.380%"},
             {"Drawdown", "1.600%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},
-            {"End Equity", "101666.4"},
-            {"Net Profit", "1.666%"},
-            {"Sharpe Ratio", "0.594"},
-            {"Sortino Ratio", "0.198"},
-            {"Probabilistic Sharpe Ratio", "44.801%"},
+            {"End Equity", "101687.3"},
+            {"Net Profit", "1.687%"},
+            {"Sharpe Ratio", "0.605"},
+            {"Sortino Ratio", "0.202"},
+            {"Probabilistic Sharpe Ratio", "45.198%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
@@ -205,14 +209,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0.134"},
             {"Annual Standard Deviation", "0.027"},
             {"Annual Variance", "0.001"},
-            {"Information Ratio", "-2.69"},
+            {"Information Ratio", "-2.687"},
             {"Tracking Error", "0.075"},
-            {"Treynor Ratio", "0.119"},
+            {"Treynor Ratio", "0.121"},
             {"Total Fees", "$6.45"},
-            {"Estimated Strategy Capacity", "$8000000000.00"},
+            {"Estimated Strategy Capacity", "$2600000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
-            {"Portfolio Turnover", "1.39%"},
-            {"OrderListHash", "40c1137e0bc83b2bc920495af119c8fc"}
+            {"Portfolio Turnover", "1.88%"},
+            {"OrderListHash", "1287c3b983c5bac6491bb5ac296c4b55"}
         };
     }
 }

Algorithm.CSharp/ContinuousFutureRolloverBaseRegressionAlgorithm.cs

@@ -0,0 +1,262 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using QuantConnect.Data;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Future;
+using System;
+using QuantConnect.Util;
+using System.Linq;
+using NodaTime;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base class for regression algorithms testing that when a continuous future rollover happens,
+    /// the continuous contract is updated correctly with the new contract data, regardless of the
+    /// offset between the exchange time zone and the data time zone.
+    /// </summary>
+    public abstract class ContinuousFutureRolloverBaseRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        const string Ticker = Futures.Indices.SP500EMini;
+
+        private Future _continuousContract;
+
+        private DateTime _rolloverTime;
+
+        private MarketHoursDatabase.Entry _originalMhdbEntry;
+
+        protected abstract Resolution Resolution { get; }
+
+        protected abstract Offset ExchangeToDataTimeZoneOffset { get; }
+
+        private DateTimeZone DataTimeZone => TimeZones.Utc;
+
+        private DateTimeZone ExchangeTimeZone => DateTimeZone.ForOffset(ExchangeToDataTimeZoneOffset);
+
+        private bool RolloverHappened => _rolloverTime != DateTime.MinValue;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 8);
+            SetEndDate(2013, 12, 20);
+
+            _originalMhdbEntry = MarketHoursDatabase.GetEntry(Market.CME, Ticker, SecurityType.Future);
+            var exchangeHours = new SecurityExchangeHours(ExchangeTimeZone,
+                _originalMhdbEntry.ExchangeHours.Holidays,
+                _originalMhdbEntry.ExchangeHours.MarketHours.ToDictionary(),
+                _originalMhdbEntry.ExchangeHours.EarlyCloses,
+                _originalMhdbEntry.ExchangeHours.LateOpens);
+            MarketHoursDatabase.SetEntry(Market.CME, Ticker, SecurityType.Future, exchangeHours, DataTimeZone);
+
+            SetTimeZone(ExchangeTimeZone);
+
+            _continuousContract = AddFuture(Ticker,
+                Resolution,
+                extendedMarketHours: true,
+                dataNormalizationMode: DataNormalizationMode.Raw,
+                dataMappingMode: DataMappingMode.OpenInterest,
+                contractDepthOffset: 0
+            );
+
+            SetBenchmark(x => 0);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            try
+            {
+                var receivedRollover = false;
+                foreach (var (symbol, symbolChangedEvent) in slice.SymbolChangedEvents)
+                {
+                    if (RolloverHappened)
+                    {
+                        throw new RegressionTestException($"[{Time}] -- Unexpected symbol changed event for {symbol}. Expected only one mapping.");
+                    }
+
+                    receivedRollover = true;
+                    _rolloverTime = symbolChangedEvent.EndTime;
+
+                    var oldSymbol = symbolChangedEvent.OldSymbol;
+                    var newSymbol = symbolChangedEvent.NewSymbol;
+                    Debug($"[{Time}] -- Rollover: {oldSymbol} -> {newSymbol}");
+
+                    if (symbol != _continuousContract.Symbol)
+                    {
+                        throw new RegressionTestException($"[{Time}] -- Unexpected symbol changed event for {symbol}");
+                    }
+
+                    var expectedMappingDate = new DateTime(2013, 12, 18);
+                    if (_rolloverTime != expectedMappingDate)
+                    {
+                        throw new RegressionTestException($"[{Time}] -- Unexpected date {_rolloverTime}. Expected {expectedMappingDate}");
+                    }
+
+                    var expectedMappingOldSymbol = "ES VMKLFZIH2MTD";
+                    var expectedMappingNewSymbol = "ES VP274HSU1AF5";
+                    if (symbolChangedEvent.OldSymbol != expectedMappingOldSymbol || symbolChangedEvent.NewSymbol != expectedMappingNewSymbol)
+                    {
+                        throw new RegressionTestException($"[{Time}] -- Unexpected mapping. " +
+                            $"Expected {expectedMappingOldSymbol} -> {expectedMappingNewSymbol} " +
+                            $"but was {symbolChangedEvent.OldSymbol} -> {symbolChangedEvent.NewSymbol}");
+                    }
+                }
+
+                var mappedFuture = Securities[_continuousContract.Mapped];
+                var mappedFuturePrice = mappedFuture.Price;
+
+                var otherFuture = Securities.Values.SingleOrDefault(x => !x.Symbol.IsCanonical() && x.Symbol != _continuousContract.Mapped);
+                var otherFuturePrice = otherFuture?.Price;
+
+                var continuousContractPrice = _continuousContract.Price;
+
+                Debug($"[{Time}] Contracts prices:\n" +
+                    $"  -- Mapped future: {mappedFuture.Symbol} :: {mappedFuture.Price} :: {mappedFuture.GetLastData()}\n" +
+                    $"  -- Other future: {otherFuture?.Symbol} :: {otherFuture?.Price} :: {otherFuture?.GetLastData()}\n" +
+                    $"  -- Mapped future from continuous contract: {_continuousContract.Symbol} :: {_continuousContract.Mapped} :: " +
+                    $"{_continuousContract.Price} :: {_continuousContract.GetLastData()}\n");
+
+                if (receivedRollover)
+                {
+                    if (continuousContractPrice != otherFuturePrice)
+                    {
+                        var continuousContractLastData = _continuousContract.GetLastData();
+                        throw new RegressionTestException($"[{Time}] -- Prices do not match. " +
+                            $"At the time of the rollover, expected continuous future price to be the same as " +
+                            $"the previously mapped contract since no data for the new mapped contract has been received:\n" +
+                            $"   Continuous contract ({_continuousContract.Symbol}) price: " +
+                            $"{continuousContractPrice} :: {continuousContractLastData.Symbol.Underlying} :: " +
+                            $"{continuousContractLastData.Time} - {continuousContractLastData.EndTime} :: {continuousContractLastData}. \n" +
+                            $"   Mapped contract ({mappedFuture.Symbol}) price: {mappedFuturePrice} :: {mappedFuture.GetLastData()}. \n" +
+                            $"   Other contract ({otherFuture?.Symbol}) price: {otherFuturePrice} :: {otherFuture?.GetLastData()}\n");
+                    }
+                }
+                else if (mappedFuturePrice != 0 || !RolloverHappened)
+                {
+                    if (continuousContractPrice != mappedFuturePrice)
+                    {
+                        var continuousContractLastData = _continuousContract.GetLastData();
+                        throw new RegressionTestException($"[{Time}] -- Prices do not match. " +
+                            $"Expected continuous future price to be the same as the mapped contract:\n" +
+                            $"   Continuous contract ({_continuousContract.Symbol}) price: {continuousContractPrice} :: " +
+                            $"{continuousContractLastData.Symbol.Underlying} :: {continuousContractLastData}. \n" +
+                            $"   Mapped contract ({mappedFuture.Symbol}) price: {mappedFuturePrice} :: {mappedFuture.GetLastData()}. \n" +
+                            $"   Other contract ({otherFuture?.Symbol}) price: {otherFuturePrice} :: {otherFuture?.GetLastData()}\n");
+                    }
+                }
+                // No data for the mapped future yet after rollover
+                else
+                {
+                    if (otherFuture == null)
+                    {
+                        throw new RegressionTestException($"[{Time}] --" +
+                            $" Mapped future price is 0 (no data has arrived) so the previous mapped contract is expected to be there");
+                    }
+
+                    var continuousContractLastData = _continuousContract.GetLastData();
+
+                    if (continuousContractLastData.EndTime > _rolloverTime)
+                    {
+                        throw new RegressionTestException($"[{Time}] -- Expected continuous future contract last data to be from the previously " +
+                            $"mapped contract until the new mapped contract gets data:\n" +
+                            $"   Rollover time: {_rolloverTime}\n" +
+                            $"   Continuous contract ({_continuousContract.Symbol}) last data: " +
+                            $"{continuousContractLastData.Symbol.Underlying} :: " +
+                            $"{continuousContractLastData.Time} - {continuousContractLastData.EndTime} :: {continuousContractLastData}.");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                ResetMarketHoursDatabase();
+                throw;
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            ResetMarketHoursDatabase();
+
+            if (!RolloverHappened)
+            {
+                throw new RegressionTestException($"[{Time}] -- Rollover did not happen.");
+            }
+        }
+
+        private void ResetMarketHoursDatabase()
+        {
+            MarketHoursDatabase.SetEntry(Market.CME, Ticker, SecurityType.Future, _originalMhdbEntry.ExchangeHours, _originalMhdbEntry.DataTimeZone);
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 0;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "100000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+    }
+}

Algorithm.CSharp/ContinuousFutureRolloverDailyExchangeTimeZoneAheadOfDataRegressionAlgorithm.cs

@@ -0,0 +1,38 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using NodaTime;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base class for regression algorithms testing that when a continuous future rollover happens,
+    /// the continuous contract is updated correctly with the new contract data.
+    /// The algorithms asserts the behavior for the case when the exchange time zone is ahead of the data time zone.
+    /// </summary>
+    public class ContinuousFutureRolloverDailyExchangeTimeZoneAheadOfDataRegressionAlgorithm
+        : ContinuousFutureRolloverBaseRegressionAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Daily;
+
+        protected override Offset ExchangeToDataTimeZoneOffset => Offset.FromHours(2);
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 1002;
+    }
+}

Algorithm.CSharp/ContinuousFutureRolloverDailyExchangeTimeZoneBehindOfDataRegressionAlgorithm.cs

@@ -0,0 +1,38 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using NodaTime;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base class for regression algorithms testing that when a continuous future rollover happens,
+    /// the continuous contract is updated correctly with the new contract data.
+    /// The algorithms asserts the behavior for the case when the exchange time zone is behind of the data time zone.
+    /// </summary>
+    public class ContinuousFutureRolloverDailyExchangeTimeZoneBehindOfDataRegressionAlgorithm
+        : ContinuousFutureRolloverBaseRegressionAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Daily;
+
+        protected override Offset ExchangeToDataTimeZoneOffset => Offset.FromHours(-2);
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 1004;
+    }
+}

Algorithm.CSharp/ContinuousFutureRolloverDailyExchangeTimeZoneSameAsDataRegressionAlgorithm.cs

@@ -0,0 +1,38 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using NodaTime;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base class for regression algorithms testing that when a continuous future rollover happens,
+    /// the continuous contract is updated correctly with the new contract data.
+    /// The algorithms asserts the behavior for the case when the data time zone is the same as the exchange time zone.
+    /// </summary>
+    public class ContinuousFutureRolloverDailyExchangeTimeZoneSameAsDataRegressionAlgorithm
+        : ContinuousFutureRolloverBaseRegressionAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Daily;
+
+        protected override Offset ExchangeToDataTimeZoneOffset => Offset.Zero;
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 995;
+    }
+}

Algorithm.CSharp/ContinuousFutureRolloverHourExchangeTimeZoneAheadOfDataRegressionAlgorithm.cs

@@ -0,0 +1,38 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using NodaTime;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base class for regression algorithms testing that when a continuous future rollover happens,
+    /// the continuous contract is updated correctly with the new contract data.
+    /// The algorithms asserts the behavior for the case when the exchange time zone is ahead of the data time zone.
+    /// </summary>
+    public class ContinuousFutureRolloverHourExchangeTimeZoneAheadOfDataRegressionAlgorithm
+        : ContinuousFutureRolloverBaseRegressionAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Hour;
+
+        protected override Offset ExchangeToDataTimeZoneOffset => Offset.FromHours(2);
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 18850;
+    }
+}

Algorithm.CSharp/ContinuousFutureRolloverHourExchangeTimeZoneBehindOfDataRegressionAlgorithm.cs

@@ -0,0 +1,38 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using NodaTime;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base class for regression algorithms testing that when a continuous future rollover happens,
+    /// the continuous contract is updated correctly with the new contract data.
+    /// The algorithms asserts the behavior for the case when the exchange time zone is behind of the data time zone.
+    /// </summary>
+    public class ContinuousFutureRolloverHourExchangeTimeZoneBehindOfDataRegressionAlgorithm
+        : ContinuousFutureRolloverBaseRegressionAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Hour;
+
+        protected override Offset ExchangeToDataTimeZoneOffset => Offset.FromHours(-2);
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 18844;
+    }
+}

Algorithm.CSharp/ContinuousFutureRolloverHourExchangeTimeZoneSameAsDataRegressionAlgorithm.cs

@@ -0,0 +1,38 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using NodaTime;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base class for regression algorithms testing that when a continuous future rollover happens,
+    /// the continuous contract is updated correctly with the new contract data.
+    /// The algorithms asserts the behavior for the case when the data time zone is the same as the exchange time zone.
+    /// </summary>
+    public class ContinuousFutureRolloverHourExchangeTimeZoneSameAsDataRegressionAlgorithm
+        : ContinuousFutureRolloverBaseRegressionAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Hour;
+
+        protected override Offset ExchangeToDataTimeZoneOffset => Offset.Zero;
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 18846;
+    }
+}

Algorithm.CSharp/ContinuousFutureRolloverMinuteExchangeTimeZoneAheadOfDataRegressionAlgorithm.cs

@@ -0,0 +1,38 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using NodaTime;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base class for regression algorithms testing that when a continuous future rollover happens,
+    /// the continuous contract is updated correctly with the new contract data.
+    /// The algorithms asserts the behavior for the case when the exchange time zone is ahead of the data time zone.
+    /// </summary>
+    public class ContinuousFutureRolloverMinuteExchangeTimeZoneAheadOfDataRegressionAlgorithm
+        : ContinuousFutureRolloverBaseRegressionAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Minute;
+
+        protected override Offset ExchangeToDataTimeZoneOffset => Offset.FromHours(2);
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 1127376;
+    }
+}

Algorithm.CSharp/ContinuousFutureRolloverMinuteExchangeTimeZoneBehindOfDataRegressionAlgorithm.cs

@@ -0,0 +1,38 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using NodaTime;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base class for regression algorithms testing that when a continuous future rollover happens,
+    /// the continuous contract is updated correctly with the new contract data.
+    /// The algorithms asserts the behavior for the case when the exchange time zone is behind of the data time zone.
+    /// </summary>
+    public class ContinuousFutureRolloverMinuteExchangeTimeZoneBehindOfDataRegressionAlgorithm
+        : ContinuousFutureRolloverBaseRegressionAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Minute;
+
+        protected override Offset ExchangeToDataTimeZoneOffset => Offset.FromHours(-2);
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 1127374;
+    }
+}

Algorithm.CSharp/ContinuousFutureRolloverMinuteExchangeTimeZoneSameAsDataRegressionAlgorithm.cs

@@ -0,0 +1,38 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using NodaTime;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base class for regression algorithms testing that when a continuous future rollover happens,
+    /// the continuous contract is updated correctly with the new contract data.
+    /// The algorithms asserts the behavior for the case when the data time zone is the same as the exchange time zone.
+    /// </summary>
+    public class ContinuousFutureRolloverMinuteExchangeTimeZoneSameAsDataRegressionAlgorithm
+        : ContinuousFutureRolloverBaseRegressionAlgorithm
+    {
+        protected override Resolution Resolution => Resolution.Minute;
+
+        protected override Offset ExchangeToDataTimeZoneOffset => Offset.Zero;
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 1127488;
+    }
+}

Algorithm.CSharp/ContinuousFuturesDailyRegressionAlgorithm.cs

@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1267;
+        public long DataPoints => 1276;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/CorrelationTypeComparisonRegressionAlgorithm.cs

@@ -0,0 +1,134 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); 
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Compares two correlation types and asserts they are not equal during the algorithm's execution.
+    /// </summary>
+    public class CorrelationTypeComparisonRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Correlation _correlationPearson;
+        private Correlation _correlationSpearman;
+
+        /// <summary>
+        /// Initialise the data and resolution required, as well as the start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 08);  //Set Start Date
+            SetEndDate(2013, 10, 17);    //Set End Date
+            var symbol = AddEquity("AAPL", Resolution.Daily).Symbol;
+            var spy = AddEquity("SPY", Resolution.Daily).Symbol;
+            _correlationPearson = C(symbol, spy, 5, CorrelationType.Pearson);
+            _correlationSpearman = C(symbol, spy, 5, CorrelationType.Spearman);
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            if (_correlationPearson.IsReady && _correlationSpearman.IsReady)
+            {
+                var pearsonValue = _correlationPearson.Current.Value;
+                var spearmanValue = _correlationSpearman.Current.Value;
+
+                // Check that the correlation values are not the same
+                if (pearsonValue == spearmanValue)
+                {
+                    // Throw an exception if the correlation values are equal
+                    throw new RegressionTestException($"Error: Pearson and Spearman correlation values are the same: Pearson = {pearsonValue}, Spearman = {spearmanValue}. This should not happen.");
+                }
+            }
+        }
+
+        /// <summary>
+        /// End of algorithm run event handler. This method is called at the end of a backtest or live trading operation. Intended for closing out logs.
+        /// </summary>
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_correlationPearson.IsReady || !_correlationSpearman.IsReady)
+            {
+                throw new RegressionTestException("Error: Both correlation values should be ready at the end of the algorithm.");
+            }
+        }
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 80;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "100000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-19.184"},
+            {"Tracking Error", "0.138"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/CustomDataPropertiesRegressionAlgorithm.cs

@@ -40,8 +40,8 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override void Initialize()
         {
-            SetStartDate(2011, 9, 13);
-            SetEndDate(2015, 12, 01);
+            SetStartDate(2020, 01, 05);
+            SetEndDate(2020, 01, 10);
 
             //Set the cash for the strategy:
             SetCash(100000);
@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 10491;
+        public long DataPoints => 57;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -129,30 +129,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "155.211%"},
-            {"Drawdown", "84.800%"},
+            {"Compounding Annual Return", "34781.071%"},
+            {"Drawdown", "4.300%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},
-            {"End Equity", "5223241.65"},
-            {"Net Profit", "5123.242%"},
-            {"Sharpe Ratio", "2.058"},
-            {"Sortino Ratio", "2.492"},
-            {"Probabilistic Sharpe Ratio", "68.833%"},
+            {"End Equity", "110102.2"},
+            {"Net Profit", "10.102%"},
+            {"Sharpe Ratio", "283.719"},
+            {"Sortino Ratio", "1123.876"},
+            {"Probabilistic Sharpe Ratio", "81.716%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.724"},
-            {"Beta", "0.043"},
-            {"Annual Standard Deviation", "0.841"},
-            {"Annual Variance", "0.707"},
-            {"Information Ratio", "1.902"},
-            {"Tracking Error", "0.848"},
-            {"Treynor Ratio", "40.293"},
+            {"Alpha", "184.11"},
+            {"Beta", "-6.241"},
+            {"Annual Standard Deviation", "0.635"},
+            {"Annual Variance", "0.403"},
+            {"Information Ratio", "260.511"},
+            {"Tracking Error", "0.689"},
+            {"Treynor Ratio", "-28.849"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "BTC.Bitcoin 2S"},
-            {"Portfolio Turnover", "0.06%"},
-            {"OrderListHash", "999305e00ec9861f5ff261794e81213d"}
+            {"Portfolio Turnover", "16.73%"},
+            {"OrderListHash", "b890a8e73bf118e943ad2f2e712f12d0"}
         };
 
         /// <summary>
@@ -168,6 +168,7 @@ namespace QuantConnect.Algorithm.CSharp
             public decimal High { get; set; }
             [JsonProperty("low")]
             public decimal Low { get; set; }
+            public decimal Mid { get; set; }
             [JsonProperty("last")]
             public decimal Close { get; set; }
             [JsonProperty("bid")]
@@ -217,7 +218,10 @@ namespace QuantConnect.Algorithm.CSharp
 
                 //return "http://my-ftp-server.com/futures-data-" + date.ToString("Ymd") + ".zip";
                 // OR simply return a fixed small data file. Large files will slow down your backtest
-                return new SubscriptionDataSource("https://www.quantconnect.com/api/v2/proxy/quandl/api/v3/datasets/BCHARTS/BITSTAMPUSD.csv?order=asc&api_key=WyAazVXnq7ATy_fefTqm", SubscriptionTransportMedium.RemoteFile);
+                return new SubscriptionDataSource("https://www.quantconnect.com/api/v2/proxy/nasdaq/api/v3/datatables/QDL/BITFINEX.csv?code=BTCUSD&api_key=WyAazVXnq7ATy_fefTqm")
+                {
+                    Sort = true
+                };
             }
 
             /// <summary>
@@ -248,20 +252,20 @@ namespace QuantConnect.Algorithm.CSharp
                 }
 
                 //Example Line Format:
-                //Date      Open   High    Low     Close   Volume (BTC)    Volume (Currency)   Weighted Price
-                //2011-09-13 5.8    6.0     5.65    5.97    58.37138238,    346.0973893944      5.929230648356
+                // code    date        high     low      mid      last     bid      ask      volume
+                // BTCUSD  2024-10-08  63248.0  61940.0  62246.5  62245.0  62246.0  62247.0       5.929230648356
                 try
                 {
                     string[] data = line.Split(',');
-                    coin.Time = DateTime.Parse(data[0], CultureInfo.InvariantCulture);
+                    coin.Time = DateTime.Parse(data[1], CultureInfo.InvariantCulture);
                     coin.EndTime = coin.Time.AddDays(1);
-                    coin.Open = Convert.ToDecimal(data[1], CultureInfo.InvariantCulture);
                     coin.High = Convert.ToDecimal(data[2], CultureInfo.InvariantCulture);
                     coin.Low = Convert.ToDecimal(data[3], CultureInfo.InvariantCulture);
-                    coin.Close = Convert.ToDecimal(data[4], CultureInfo.InvariantCulture);
-                    coin.VolumeBTC = Convert.ToDecimal(data[5], CultureInfo.InvariantCulture);
-                    coin.VolumeUSD = Convert.ToDecimal(data[6], CultureInfo.InvariantCulture);
-                    coin.WeightedPrice = Convert.ToDecimal(data[7], CultureInfo.InvariantCulture);
+                    coin.Mid = Convert.ToDecimal(data[4], CultureInfo.InvariantCulture);
+                    coin.Close = Convert.ToDecimal(data[5], CultureInfo.InvariantCulture);
+                    coin.Bid = Convert.ToDecimal(data[6], CultureInfo.InvariantCulture);
+                    coin.Ask = Convert.ToDecimal(data[7], CultureInfo.InvariantCulture);
+                    coin.VolumeBTC = Convert.ToDecimal(data[8], CultureInfo.InvariantCulture);
                     coin.Value = coin.Close;
                 }
                 catch { /* Do nothing, skip first title row */ }

Algorithm.CSharp/CustomDataRegressionAlgorithm.cs

@@ -33,15 +33,15 @@ namespace QuantConnect.Algorithm.CSharp
     /// <meta name="tag" content="regression test" />
     public class CustomDataRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
-        private bool _warmedUpChecked = false;
+        private bool _warmedUpChecked;
 
         /// <summary>
         /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
         /// </summary>
         public override void Initialize()
         {
-            SetStartDate(2011, 9, 14);
-            SetEndDate(2015, 12, 01);
+            SetStartDate(2020, 01, 05);
+            SetEndDate(2020, 01, 10);
 
             //Set the cash for the strategy:
             SetCash(100000);
@@ -110,7 +110,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 8943;
+        public long DataPoints => 50;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -130,30 +130,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "155.365%"},
-            {"Drawdown", "84.800%"},
+            {"Compounding Annual Return", "27587.925%"},
+            {"Drawdown", "4.200%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},
-            {"End Equity", "5223170.23"},
-            {"Net Profit", "5123.170%"},
-            {"Sharpe Ratio", "2.094"},
-            {"Sortino Ratio", "2.535"},
-            {"Probabilistic Sharpe Ratio", "69.967%"},
+            {"End Equity", "109685"},
+            {"Net Profit", "9.685%"},
+            {"Sharpe Ratio", "238.834"},
+            {"Sortino Ratio", "945.079"},
+            {"Probabilistic Sharpe Ratio", "81.660%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.753"},
-            {"Beta", "0.055"},
-            {"Annual Standard Deviation", "0.84"},
-            {"Annual Variance", "0.706"},
-            {"Information Ratio", "1.942"},
-            {"Tracking Error", "0.848"},
-            {"Treynor Ratio", "32.18"},
+            {"Alpha", "149.482"},
+            {"Beta", "-6.002"},
+            {"Annual Standard Deviation", "0.61"},
+            {"Annual Variance", "0.371"},
+            {"Information Ratio", "218.36"},
+            {"Tracking Error", "0.664"},
+            {"Treynor Ratio", "-24.253"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
             {"Lowest Capacity Asset", "BTC.Bitcoin 2S"},
-            {"Portfolio Turnover", "0.06%"},
-            {"OrderListHash", "e69e78cd6fe7bc4627da2f51e25539d0"}
+            {"Portfolio Turnover", "16.03%"},
+            {"OrderListHash", "dde8821614d33c89e6e75c536447b7da"}
         };
 
         /// <summary>
@@ -169,6 +169,8 @@ namespace QuantConnect.Algorithm.CSharp
             public decimal High { get; set; }
             [JsonProperty("low")]
             public decimal Low { get; set; }
+            public decimal Mid { get; set; }
+
             [JsonProperty("last")]
             public decimal Close { get; set; }
             [JsonProperty("bid")]
@@ -179,7 +181,6 @@ namespace QuantConnect.Algorithm.CSharp
             public decimal WeightedPrice { get; set; }
             [JsonProperty("volume")]
             public decimal VolumeBTC { get; set; }
-            public decimal VolumeUSD { get; set; }
 
             /// <summary>
             /// The end time of this data. Some data covers spans (trade bars)
@@ -218,7 +219,10 @@ namespace QuantConnect.Algorithm.CSharp
 
                 //return "http://my-ftp-server.com/futures-data-" + date.ToString("Ymd") + ".zip";
                 // OR simply return a fixed small data file. Large files will slow down your backtest
-                return new SubscriptionDataSource("https://www.quantconnect.com/api/v2/proxy/quandl/api/v3/datasets/BCHARTS/BITSTAMPUSD.csv?order=asc&api_key=WyAazVXnq7ATy_fefTqm", SubscriptionTransportMedium.RemoteFile);
+                return new SubscriptionDataSource("https://www.quantconnect.com/api/v2/proxy/nasdaq/api/v3/datatables/QDL/BITFINEX.csv?code=BTCUSD&api_key=qAWKpUfmSVFnU3bRQwKy")
+                {
+                    Sort = true
+                };
             }
 
             /// <summary>
@@ -249,20 +253,20 @@ namespace QuantConnect.Algorithm.CSharp
                 }
 
                 //Example Line Format:
-                //Date      Open   High    Low     Close   Volume (BTC)    Volume (Currency)   Weighted Price
-                //2011-09-13 5.8    6.0     5.65    5.97    58.37138238,    346.0973893944      5.929230648356
+                // code    date        high     low      mid      last     bid      ask      volume
+                // BTCUSD  2024-10-08  63248.0  61940.0  62246.5  62245.0  62246.0  62247.0  477.91102114
                 try
                 {
                     string[] data = line.Split(',');
-                    coin.Time = DateTime.Parse(data[0], CultureInfo.InvariantCulture);
+                    coin.Time = DateTime.Parse(data[1], CultureInfo.InvariantCulture);
                     coin.EndTime = coin.Time.AddDays(1);
-                    coin.Open = Convert.ToDecimal(data[1], CultureInfo.InvariantCulture);
                     coin.High = Convert.ToDecimal(data[2], CultureInfo.InvariantCulture);
                     coin.Low = Convert.ToDecimal(data[3], CultureInfo.InvariantCulture);
-                    coin.Close = Convert.ToDecimal(data[4], CultureInfo.InvariantCulture);
-                    coin.VolumeBTC = Convert.ToDecimal(data[5], CultureInfo.InvariantCulture);
-                    coin.VolumeUSD = Convert.ToDecimal(data[6], CultureInfo.InvariantCulture);
-                    coin.WeightedPrice = Convert.ToDecimal(data[7], CultureInfo.InvariantCulture);
+                    coin.Mid = Convert.ToDecimal(data[4], CultureInfo.InvariantCulture);
+                    coin.Close = Convert.ToDecimal(data[5], CultureInfo.InvariantCulture);
+                    coin.Bid = Convert.ToDecimal(data[6], CultureInfo.InvariantCulture);
+                    coin.Ask = Convert.ToDecimal(data[7], CultureInfo.InvariantCulture);
+                    coin.VolumeBTC = Convert.ToDecimal(data[8], CultureInfo.InvariantCulture);
                     coin.Value = coin.Close;
                 }
                 catch { /* Do nothing, skip first title row */ }

Algorithm.CSharp/DailyOptionChainOpenInterestDataWithStrictDailyEndTimesRegressionAlgorithm.cs

@@ -0,0 +1,130 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting that the option chain data has valid open interest values for daily resolution.
+    /// Reproduces GH issue #8421.
+    /// </summary>
+    public class DailyOptionChainOpenInterestDataWithStrictDailyEndTimesRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _symbol;
+
+        private List<decimal> _openInterests = new();
+
+        public virtual bool DailyPreciseEndTime => true;
+
+        public override void Initialize()
+        {
+            Settings.DailyPreciseEndTime = DailyPreciseEndTime;
+
+            SetStartDate(2014, 06, 01);
+            SetEndDate(2014, 07, 06);
+
+            var option = AddOption("AAPL", Resolution.Daily);
+            option.SetFilter(-5, +5, 0, 365);
+
+            _symbol = option.Symbol;
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (slice.OptionChains.TryGetValue(_symbol, out var chain) && chain.Contracts.Count > 0)
+            {
+                var openInterest = chain.Sum(x => x.OpenInterest);
+                _openInterests.Add(openInterest);
+                Debug($"[{Time}] Sum of open interest: {openInterest}");
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_openInterests.Count == 0)
+            {
+                throw new RegressionTestException("No option chain data was received by the algorithm.");
+            }
+
+            if (_openInterests.All(x => x == 0))
+            {
+                throw new RegressionTestException("Contracts received didn't have valid open interest values.");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 47132;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "100000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-5.732"},
+            {"Tracking Error", "0.05"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/DailyOptionChainOpenInterestDataWithoutStrictDailyEndTimesRegressionAlgorithm.cs

@@ -0,0 +1,31 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting that the option chain data has valid open interest values for daily resolution.
+    /// Reproduces GH issue #8421.
+    /// </summary>
+    public class DailyOptionChainOpenInterestDataWithoutStrictDailyEndTimesRegressionAlgorithm : DailyOptionChainOpenInterestDataWithStrictDailyEndTimesRegressionAlgorithm
+    {
+        public override bool DailyPreciseEndTime => false;
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 46264;
+    }
+}

Algorithm.CSharp/DelistedFutureLiquidateDailyRegressionAlgorithm.cs

@@ -28,7 +28,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 1679;
+        public override long DataPoints => 1690;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
@@ -38,7 +38,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Orders", "2"},
             {"Average Win", "7.78%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "38.564%"},
+            {"Compounding Annual Return", "38.609%"},
             {"Drawdown", "0.200%"},
             {"Expectancy", "0"},
             {"Start Equity", "100000"},

Algorithm.CSharp/DelistedFutureLiquidateRegressionAlgorithm.cs

@@ -92,7 +92,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 525809;
+        public virtual long DataPoints => 525811;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/DescendingCustomDataObjectStoreRegressionAlgorithm.cs

@@ -0,0 +1,211 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Linq;
+using QuantConnect.Data;
+using System.Globalization;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// The regression algorithm showcases the utilization of a custom data source with the Sort flag set to true.
+    /// This means that the source initially provides data in descending order, which is then organized into ascending order and returned in the <see cref="OnData(Slice)"/> function.
+    /// </summary>
+    public class DescendingCustomDataObjectStoreRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        protected virtual string CustomDataKey => "CustomData/SortCustomData";
+
+        protected readonly static string[] descendingCustomData = new string[]
+        {
+            "2024-10-03 19:00:00,173.5,176.0,172.0,175.2,120195681,4882.29",
+            "2024-10-02 18:00:00,174.0,177.0,173.0,175.8,116275729,4641.97",
+            "2024-10-01 17:00:00,175.0,178.0,172.5,174.5,127707078,6591.27",
+            "2024-09-30 11:00:00,174.8,176.5,172.8,175.0,127707078,6591.27",
+            "2024-09-27 10:00:00,172.5,175.0,171.5,173.5,120195681,4882.29",
+            "2024-09-26 09:00:00,171.0,172.5,170.0,171.8,117516350,4820.53",
+            "2024-09-25 08:00:00,169.5,172.0,169.0,171.0,110427867,4661.55",
+            "2024-09-24 07:00:00,170.0,171.0,168.0,169.5,127624733,4823.52",
+            "2024-09-23 06:00:00,172.0,173.5,169.5,171.5,123586417,4303.93",
+            "2024-09-20 05:00:00,168.0,171.0,167.5,170.5,151929179,5429.87",
+            "2024-09-19 04:00:00,170.5,171.5,166.0,167.0,160523863,5219.24",
+            "2024-09-18 03:00:00,173.0,174.0,169.0,172.0,145721790,5163.09",
+            "2024-09-17 02:00:00,171.0,173.5,170.0,172.5,144794030,5405.72",
+            "2024-09-16 01:00:00,168.0,171.0,167.0,170.0,214402430,8753.33",
+            "2024-09-13 16:00:00,173.5,176.0,172.0,175.2,120195681,4882.29",
+            "2024-09-12 15:00:00,174.5,177.5,173.5,176.5,171728134,7774.83",
+            "2024-09-11 14:00:00,175.0,178.0,174.0,175.5,191516153,8349.59",
+            "2024-09-10 13:00:00,174.5,176.0,173.0,174.0,151162819,5915.8",
+            "2024-09-09 12:00:00,176.0,178.0,175.0,177.0,116275729,4641.97"
+        };
+
+        private Symbol _customSymbol;
+
+        private List<SortCustomData> _receivedData = new();
+
+        public override void Initialize()
+        {
+            SetStartDate(2024, 09, 09);
+            SetEndDate(2024, 10, 03);
+            SetCash(100000);
+
+            SetBenchmark(x => 0);
+
+            SortCustomData.CustomDataKey = CustomDataKey;
+
+            _customSymbol = AddData<SortCustomData>("SortCustomData", Resolution.Daily).Symbol;
+
+            // Saving data here for demonstration and regression testing purposes.
+            // In real scenarios, data has to be saved to the object store before the algorithm starts.
+            ObjectStore.Save(CustomDataKey, string.Join("\n", descendingCustomData));
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (slice.ContainsKey(_customSymbol))
+            {
+                var sortCustomData = slice.Get<SortCustomData>(_customSymbol);
+                if (sortCustomData.Open == 0 || sortCustomData.High == 0 || sortCustomData.Low == 0 || sortCustomData.Close == 0 || sortCustomData.Price == 0)
+                {
+                    throw new RegressionTestException("One or more custom data fields (Open, High, Low, Close, Price) are zero.");
+                }
+
+                _receivedData.Add(sortCustomData);
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (_receivedData.Count == 0)
+            {
+                throw new RegressionTestException("Custom data was not fetched");
+            }
+
+            var history = History<SortCustomData>(_customSymbol, StartDate, EndDate, Resolution.Hour).ToList();
+
+            if (history.Count != _receivedData.Count)
+            {
+                throw new RegressionTestException("History request returned different data than expected");
+            }
+
+            // Iterate through the history collection, checking if the EndTime is in ascending order.
+            for (int i = 0; i < history.Count - 1; i++)
+            {
+                if (history[i].EndTime > history[i + 1].EndTime)
+                {
+                    throw new RegressionTestException($"Order failure: {history[i].EndTime} > {history[i + 1].EndTime} at index {i}.");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages => new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all TimeSlices of algorithm
+        /// </summary>
+        public long DataPoints => 20;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 19;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new ()
+        {
+            {"Total Orders", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "100000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+
+    public class SortCustomData : BaseData
+    {
+        public static string CustomDataKey { get; set; }
+
+        public decimal Open { get; set; }
+        public decimal High { get; set; }
+        public decimal Low { get; set; }
+        public decimal Close { get; set; }
+
+        public override SubscriptionDataSource GetSource(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
+        {
+            return new SubscriptionDataSource(CustomDataKey, SubscriptionTransportMedium.ObjectStore, FileFormat.Csv)
+            {
+                // Indicate that the data from the subscription will be returned in descending order.
+                Sort = true
+            };
+        }
+
+        public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode)
+        {
+            var csv = line.Split(",");
+            var data = new SortCustomData()
+            {
+                Symbol = config.Symbol,
+                Time = DateTime.ParseExact(csv[0], DateFormat.DB, CultureInfo.InvariantCulture),
+                Value = csv[4].ToDecimal(),
+                Open = csv[1].ToDecimal(),
+                High = csv[2].ToDecimal(),
+                Low = csv[3].ToDecimal(),
+                Close = csv[4].ToDecimal()
+            };
+
+            return data;
+        }
+    }
+}

Algorithm.CSharp/FutureMarketOpenAndCloseWithExtendedMarketRegressionAlgorithm.cs

@@ -50,7 +50,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 41466;
+        public override long DataPoints => 41467;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/FutureMarketOpenConsolidatorRegressionAlgorithm.cs

@@ -93,7 +93,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public virtual long DataPoints => 32071;
+        public virtual long DataPoints => 32073;
 
         /// </summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FutureMarketOpenConsolidatorWithExtendedMarketRegressionAlgorithm.cs

@@ -52,7 +52,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 103816;
+        public override long DataPoints => 103818;
 
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm

Algorithm.CSharp/FutureOptionBuySellCallIntradayRegressionAlgorithm.cs

@@ -112,7 +112,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 309280;
+        public long DataPoints => 309282;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -150,7 +150,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.005"},
             {"Information Ratio", "-0.134"},
             {"Tracking Error", "0.385"},
-            {"Treynor Ratio", "3.784"},
+            {"Treynor Ratio", "3.785"},
             {"Total Fees", "$2.84"},
             {"Estimated Strategy Capacity", "$120000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UPBIJ7O|ES XFH59UK0MYO1"},

Algorithm.CSharp/FutureOptionCallITMExpiryRegressionAlgorithm.cs

@@ -200,7 +200,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212195;
+        public long DataPoints => 212196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -238,7 +238,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.004"},
             {"Information Ratio", "-0.226"},
             {"Tracking Error", "0.378"},
-            {"Treynor Ratio", "-21.838"},
+            {"Treynor Ratio", "-21.841"},
             {"Total Fees", "$1.42"},
             {"Estimated Strategy Capacity", "$120000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UPBIJ7O|ES XFH59UK0MYO1"},

Algorithm.CSharp/FutureOptionCallITMGreeksExpiryRegressionAlgorithm.cs

@@ -165,7 +165,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212195;
+        public long DataPoints => 212196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -203,7 +203,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.098"},
             {"Information Ratio", "-0.649"},
             {"Tracking Error", "0.483"},
-            {"Treynor Ratio", "-18.589"},
+            {"Treynor Ratio", "-18.59"},
             {"Total Fees", "$7.10"},
             {"Estimated Strategy Capacity", "$24000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UPBIJ7O|ES XFH59UK0MYO1"},

Algorithm.CSharp/FutureOptionCallOTMExpiryRegressionAlgorithm.cs

@@ -176,7 +176,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212195;
+        public long DataPoints => 212196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -214,7 +214,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.003"},
             {"Information Ratio", "-0.198"},
             {"Tracking Error", "0.377"},
-            {"Treynor Ratio", "-23.06"},
+            {"Treynor Ratio", "-23.065"},
             {"Total Fees", "$1.42"},
             {"Estimated Strategy Capacity", "$180000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UPHGV9G|ES XFH59UK0MYO1"},

Algorithm.CSharp/FutureOptionIndicatorsRegressionAlgorithm.cs

@@ -22,7 +22,7 @@ namespace QuantConnect.Algorithm.CSharp
 {
     public class FutureOptionIndicatorsRegressionAlgorithm : OptionIndicatorsRegressionAlgorithm
     {
-        protected override string ExpectedGreeks { get; set; } = "Implied Volatility: 0.14008,Delta: 0.63466,Gamma: 0.00209,Vega: 5.61442,Theta: -0.48254,Rho: 0.03098";
+        protected override string ExpectedGreeks { get; set; } = "Implied Volatility: 0.13941,Delta: 0.63509,Gamma: 0.00209,Vega: 5.64129,Theta: -0.47731,Rho: 0.03145";
 
         public override void Initialize()
         {

Algorithm.CSharp/FutureOptionMultipleContractsInDifferentContractMonthsWithSameUnderlyingFutureRegressionAlgorithm.cs

@@ -109,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 24378;
+        public long DataPoints => 24379;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FutureOptionPutITMExpiryRegressionAlgorithm.cs

@@ -201,7 +201,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212195;
+        public long DataPoints => 212196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -239,7 +239,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.003"},
             {"Information Ratio", "-0.248"},
             {"Tracking Error", "0.377"},
-            {"Treynor Ratio", "-36.295"},
+            {"Treynor Ratio", "-36.3"},
             {"Total Fees", "$1.42"},
             {"Estimated Strategy Capacity", "$79000000.00"},
             {"Lowest Capacity Asset", "ES 31EL5FAOOQON8|ES XFH59UK0MYO1"},

Algorithm.CSharp/FutureOptionPutOTMExpiryRegressionAlgorithm.cs

@@ -174,7 +174,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212195;
+        public long DataPoints => 212196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -212,7 +212,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.003"},
             {"Information Ratio", "-0.249"},
             {"Tracking Error", "0.377"},
-            {"Treynor Ratio", "-32.551"},
+            {"Treynor Ratio", "-32.556"},
             {"Total Fees", "$1.42"},
             {"Estimated Strategy Capacity", "$290000000.00"},
             {"Lowest Capacity Asset", "ES 31EL5FBZBMXES|ES XFH59UK0MYO1"},

Algorithm.CSharp/FutureOptionShortCallITMExpiryRegressionAlgorithm.cs

@@ -185,7 +185,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212195;
+        public long DataPoints => 212196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -223,7 +223,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.002"},
             {"Information Ratio", "0.064"},
             {"Tracking Error", "0.378"},
-            {"Treynor Ratio", "-13.132"},
+            {"Treynor Ratio", "-13.127"},
             {"Total Fees", "$1.42"},
             {"Estimated Strategy Capacity", "$13000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UP5K75W|ES XFH59UK0MYO1"},

Algorithm.CSharp/FutureOptionShortCallOTMExpiryRegressionAlgorithm.cs

@@ -168,7 +168,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212195;
+        public long DataPoints => 212196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -194,7 +194,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Start Equity", "100000"},
             {"End Equity", "101736.08"},
             {"Net Profit", "1.736%"},
-            {"Sharpe Ratio", "0.597"},
+            {"Sharpe Ratio", "0.596"},
             {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "49.736%"},
             {"Loss Rate", "0%"},
@@ -206,7 +206,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.001"},
             {"Information Ratio", "0.009"},
             {"Tracking Error", "0.375"},
-            {"Treynor Ratio", "-11.057"},
+            {"Treynor Ratio", "-11.048"},
             {"Total Fees", "$1.42"},
             {"Estimated Strategy Capacity", "$100000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UPNF7B8|ES XFH59UK0MYO1"},

Algorithm.CSharp/FutureOptionShortPutITMExpiryRegressionAlgorithm.cs

@@ -182,7 +182,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212195;
+        public long DataPoints => 212196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -220,7 +220,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.001"},
             {"Information Ratio", "0.058"},
             {"Tracking Error", "0.375"},
-            {"Treynor Ratio", "-41.846"},
+            {"Treynor Ratio", "-41.831"},
             {"Total Fees", "$1.42"},
             {"Estimated Strategy Capacity", "$12000000.00"},
             {"Lowest Capacity Asset", "ES 31EL5FAOUP0P0|ES XFH59UK0MYO1"},

Algorithm.CSharp/FutureOptionShortPutOTMExpiryRegressionAlgorithm.cs

@@ -167,7 +167,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212195;
+        public long DataPoints => 212196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -193,7 +193,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Start Equity", "100000"},
             {"End Equity", "103423.58"},
             {"Net Profit", "3.424%"},
-            {"Sharpe Ratio", "1.089"},
+            {"Sharpe Ratio", "1.088"},
             {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "73.287%"},
             {"Loss Rate", "0%"},
@@ -205,7 +205,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.001"},
             {"Information Ratio", "0.075"},
             {"Tracking Error", "0.377"},
-            {"Treynor Ratio", "-24.083"},
+            {"Treynor Ratio", "-24.076"},
             {"Total Fees", "$1.42"},
             {"Estimated Strategy Capacity", "$110000000.00"},
             {"Lowest Capacity Asset", "ES 31EL5FAJQ6SBO|ES XFH59UK0MYO1"},

Algorithm.CSharp/FutureStopMarketOrderOnExtendedHoursRegressionAlgorithm.cs

@@ -113,7 +113,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all time slices of algorithm
         /// </summary>
-        public long DataPoints => 75960;
+        public long DataPoints => 75961;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FuturesAndFuturesOptionsExpiryTimeAndLiquidationRegressionAlgorithm.cs

@@ -178,7 +178,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212941;
+        public long DataPoints => 212942;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -204,7 +204,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Start Equity", "100000"},
             {"End Equity", "98233.93"},
             {"Net Profit", "-1.766%"},
-            {"Sharpe Ratio", "-1.14"},
+            {"Sharpe Ratio", "-1.141"},
             {"Sortino Ratio", "0"},
             {"Probabilistic Sharpe Ratio", "0.020%"},
             {"Loss Rate", "50%"},
@@ -216,7 +216,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0"},
             {"Information Ratio", "-0.602"},
             {"Tracking Error", "0.291"},
-            {"Treynor Ratio", "-16.64"},
+            {"Treynor Ratio", "-16.65"},
             {"Total Fees", "$3.57"},
             {"Estimated Strategy Capacity", "$16000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},

Algorithm.CSharp/FuturesExpiredContractRegression.cs

@@ -89,7 +89,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 268273;
+        public long DataPoints => 268275;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/FuturesExtendedMarketHoursRegressionAlgorithm.cs

@@ -113,7 +113,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 3630;
+        public long DataPoints => 3631;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/HistoryWithDifferentContinuousContractDepthOffsetsRegressionAlgorithm.cs

@@ -129,7 +129,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1423;
+        public long DataPoints => 1432;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/HistoryWithDifferentDataMappingModeRegressionAlgorithm.cs

@@ -101,7 +101,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1423;
+        public long DataPoints => 1432;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/HistoryWithDifferentDataNormalizationModeRegressionAlgorithm.cs

@@ -93,7 +93,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1483;
+        public long DataPoints => 1490;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/ImmediateExecutionModelWorksWithBinanceFeeModel.cs

@@ -0,0 +1,119 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using QuantConnect.Algorithm.Framework.Alphas;
+using QuantConnect.Algorithm.Framework.Execution;
+using QuantConnect.Algorithm.Framework.Portfolio;
+using QuantConnect.Algorithm.Framework.Selection;
+using QuantConnect.Interfaces;
+using QuantConnect.Orders;
+using System;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test ImmediateExecutionModel places orders with the
+    /// correct quantity (taking into account the fee's) so that the fill quantity
+    /// is the expected one.
+    /// </summary>
+    public class ImmediateExecutionModelWorksWithBinanceFeeModel: QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2022, 12, 13);
+            SetEndDate(2022, 12, 14);
+            SetAccountCurrency("BUSD");
+            SetCash("BUSD", 100000, 1);
+
+            UniverseSettings.Resolution = Resolution.Minute;
+
+            var symbols = new List<Symbol>() { QuantConnect.Symbol.Create("BTCBUSD", SecurityType.Crypto, Market.Binance) };
+            SetUniverseSelection(new ManualUniverseSelectionModel(symbols));
+            SetAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromMinutes(20), 0.025, null));
+
+            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel(Resolution.Minute));
+            SetExecution(new ImmediateExecutionModel());
+            SetBrokerageModel(Brokerages.BrokerageName.Binance, AccountType.Margin);
+        }
+
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            if (orderEvent.Status == OrderStatus.Filled)
+            {
+                if (Math.Abs(orderEvent.Quantity - 5.8m) > 0.01m)
+                {
+                    throw new RegressionTestException($"The expected quantity was {5.8m} but the quantity from the order was {orderEvent.Quantity}");
+                }
+            }
+        }
+
+        public bool CanRunLocally => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 2882;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 60;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000.00"},
+            {"End Equity", "103411.39"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "BUSD99.75"},
+            {"Estimated Strategy Capacity", "BUSD600000.00"},
+            {"Lowest Capacity Asset", "BTCBUSD 18N"},
+            {"Portfolio Turnover", "48.18%"},
+            {"OrderListHash", "2ad07f12d7c80fd4a904269d62794e9e"}
+        };
+    }
+}

Algorithm.CSharp/IndexOptionCallITMExpiryDailyRegressionAlgorithm.cs

@@ -38,7 +38,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 194;
+        public override long DataPoints => 195;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/IndexOptionCallOTMExpiryDailyRegressionAlgorithm.cs

@@ -38,7 +38,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 184;
+        public override long DataPoints => 185;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/IndexOptionChainApisConsistencyRegressionAlgorithm.cs

@@ -0,0 +1,40 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using QuantConnect.Securities.Option;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting that the option chain APIs return consistent values for index options
+    /// See <see cref="QCAlgorithm.OptionChain(Symbol)"/> and <see cref="QCAlgorithm.OptionChainProvider"/>
+    /// </summary>
+    public class IndexOptionChainApisConsistencyRegressionAlgorithm : OptionChainApisConsistencyRegressionAlgorithm
+    {
+        protected override DateTime TestDate => new DateTime(2021, 1, 4);
+
+        protected override Option GetOption()
+        {
+            return AddIndexOption("SPX");
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 2862;
+    }
+}

Algorithm.CSharp/IndexOptionIndicatorsRegressionAlgorithm.cs

@@ -20,7 +20,7 @@ namespace QuantConnect.Algorithm.CSharp
 {
     public class IndexOptionIndicatorsRegressionAlgorithm : OptionIndicatorsRegressionAlgorithm
     {
-        protected override string ExpectedGreeks { get; set; } = "Implied Volatility: 0.17702,Delta: 0.19195,Gamma: 0.00247,Vega: 1.69043,Theta: -1.41571,Rho: 0.01686";
+        protected override string ExpectedGreeks { get; set; } = "Implied Volatility: 0.17406,Delta: 0.19196,Gamma: 0.00247,Vega: 1.72195,Theta: -1.3689,Rho: 0.01744";
 
         public override void Initialize()
         {

Algorithm.CSharp/IndexSecurityCanBeTradableRegressionAlgorithm.cs

@@ -0,0 +1,166 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using QuantConnect.Algorithm.Framework.Portfolio;
+using QuantConnect.Algorithm.Framework.Portfolio.SignalExports;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test we can manually set index securities to be tradable without breaking
+    /// SignalExportManager
+    /// </summary>
+    public class IndexSecurityCanBeTradableRegressionAlgorithm: QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private SignalExportManagerTest _signalExportManagerTest;
+        private Symbol _equity;
+        private Symbol _index;
+
+        public virtual bool IsTradable { get; set; } = true;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 7);
+            SetEndDate(2013, 10, 7);
+
+            _index = AddIndex("SPX").Symbol;
+            _equity = AddEquity("SPY").Symbol;
+            _signalExportManagerTest = new SignalExportManagerTest(this);
+            Securities[_index].IsTradable = IsTradable;
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (IsTradable != Securities[_index].IsTradable)
+            {
+                throw new RegressionTestException($"Index.IsTradable should be {IsTradable}, but was {Securities[_index].IsTradable}");
+            }
+
+            _signalExportManagerTest.GetPortfolioTargetsFromPortfolio(out PortfolioTarget[] targets);
+            if (IsTradable)
+            {
+                if (!targets.Where(x => x.Symbol.SecurityType == SecurityType.Index).Any())
+                {
+                    throw new RegressionTestException($"Index {_index} is marked as tradable security, but no portfolio target with index security type was created");
+                }
+            }
+            else
+            {
+                if (targets.Where(x => x.Symbol.SecurityType == SecurityType.Index).Any())
+                {
+                    throw new RegressionTestException($"Index is not a tradable security, so no portfolio target with index security type should have been created");
+                }
+            }
+
+            if (!Portfolio.Invested)
+            {
+                SetHoldings(_equity, 1);
+                RemoveSecurity(_index);
+
+                AssertIndexIsNotTradable();
+
+                AddSecurity(_index);
+                IsTradable = false;
+            }
+
+            AssertIndexIsNotTradable();
+        }
+
+        private void AssertIndexIsNotTradable()
+        {
+            if (Securities[_index].IsTradable)
+            {
+                throw new RegressionTestException($"Index {_index} has already been removed and should be tradable no more");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public virtual bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual List<Language> Languages { get; } = new() { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 796;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public virtual int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "99978.71"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$3.44"},
+            {"Estimated Strategy Capacity", "$56000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Portfolio Turnover", "99.63%"},
+            {"OrderListHash", "3da9fa60bf95b9ed148b95e02e0cfc9e"}
+        };
+
+        private class SignalExportManagerTest: SignalExportManager
+        {
+            public SignalExportManagerTest(IAlgorithm algorithm) : base(algorithm)
+            {
+            }
+
+            public void GetPortfolioTargetsFromPortfolio(out PortfolioTarget[] portfolioTargets)
+            {
+                base.GetPortfolioTargets(out portfolioTargets);
+            }
+        }
+    }
+}

Algorithm.CSharp/IndexSecurityIsNotTradableRegressionAlgorithm.cs

@@ -0,0 +1,27 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test SignalExportManager still works as expected even when index securities
+    /// are not marked as tradable
+    /// </summary>
+    public class IndexSecurityIsNotTradableRegressionAlgorithm: IndexSecurityCanBeTradableRegressionAlgorithm
+    {
+        public override bool IsTradable { get; set; }
+    }
+}

Algorithm.CSharp/IndicatorSelectorsWorkWithDifferentOptions.cs

@@ -186,7 +186,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 1575423;
+        public long DataPoints => 1575349;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/LimitOrdersAreFilledAfterHoursForFuturesRegressionAlgorithm.cs

@@ -113,7 +113,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 82371;
+        public long DataPoints => 82372;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/MarketOrdersAreSupportedOnExtendedHoursForFuturesRegressionAlgorithm.cs

@@ -90,7 +90,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 82371;
+        public long DataPoints => 82372;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/OptionChainApisConsistencyRegressionAlgorithm.cs

@@ -0,0 +1,138 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Option;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm asserting that the option chain APIs return consistent values.
+    /// See <see cref="QCAlgorithm.OptionChain(Symbol)"/> and <see cref="QCAlgorithm.OptionChainProvider"/>
+    /// </summary>
+    public class OptionChainApisConsistencyRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        protected virtual DateTime TestDate => new DateTime(2015, 12, 25);
+
+        public override void Initialize()
+        {
+            SetStartDate(TestDate);
+            SetEndDate(TestDate);
+
+            var option = GetOption();
+
+            var optionChainFromAlgorithmApi = OptionChain(option.Symbol).Contracts.Values.Select(x => x.Symbol).ToList();
+
+            var exchangeTime = UtcTime.ConvertFromUtc(option.Exchange.TimeZone);
+            var optionChainFromProviderApi = OptionChainProvider.GetOptionContractList(option.Symbol, exchangeTime).ToList();
+
+            if (optionChainFromAlgorithmApi.Count == 0)
+            {
+                throw new RegressionTestException("No options in chain from algorithm API");
+            }
+
+            if (optionChainFromProviderApi.Count == 0)
+            {
+                throw new RegressionTestException("No options in chain from provider API");
+            }
+
+            if (optionChainFromAlgorithmApi.Count != optionChainFromProviderApi.Count)
+            {
+                throw new RegressionTestException($"Expected {optionChainFromProviderApi.Count} options in chain from provider API, " +
+                    $"but got {optionChainFromAlgorithmApi.Count}");
+            }
+
+            for (var i = 0; i < optionChainFromAlgorithmApi.Count; i++)
+            {
+                var symbol1 = optionChainFromAlgorithmApi[i];
+                var symbol2 = optionChainFromProviderApi[i];
+
+                if (symbol1 != symbol2)
+                {
+                    throw new RegressionTestException($"Expected {symbol2} in chain from provider API, but got {symbol1}");
+                }
+            }
+        }
+
+        protected virtual Option GetOption()
+        {
+            return AddOption("GOOG");
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public virtual bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 2021;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public virtual int AlgorithmHistoryDataPoints => 2;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public virtual AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "100000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/OptionChainsMultipleFullDataRegressionAlgorithm.cs

@@ -0,0 +1,142 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm illustrating the usage of the <see cref="QCAlgorithm.OptionChains(IEnumerable{Symbol})"/> method
+    /// to get multiple option chains, which contains additional data besides the symbols, including prices, implied volatility and greeks.
+    /// It also shows how this data can be used to filter the contracts based on certain criteria.
+    /// </summary>
+    public class OptionChainsMultipleFullDataRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _googOptionContract;
+        private Symbol _spxOptionContract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 24);
+            SetEndDate(2015, 12, 24);
+            SetCash(100000);
+
+            var goog = AddEquity("GOOG").Symbol;
+            var spx = AddIndex("SPX").Symbol;
+
+            var chains = OptionChains(new[] { goog, spx });
+
+            _googOptionContract = GetContract(chains, goog, TimeSpan.FromDays(10));
+            _spxOptionContract = GetContract(chains, spx, TimeSpan.FromDays(60));
+
+            AddOptionContract(_googOptionContract);
+            AddIndexOptionContract(_spxOptionContract);
+        }
+
+        private Symbol GetContract(OptionChains chains, Symbol underlying, TimeSpan expirySpan)
+        {
+            return chains
+                .Where(kvp => kvp.Key.Underlying == underlying)
+                .Select(kvp => kvp.Value)
+                .Single()
+                // Get contracts expiring within a given span, with an implied volatility greater than 0.5 and a delta less than 0.5
+                .Where(contractData => contractData.ID.Date - Time <= expirySpan &&
+                    contractData.ImpliedVolatility > 0.5m &&
+                    contractData.Greeks.Delta < 0.5m)
+                // Get the contract with the latest expiration date
+                .OrderByDescending(x => x.ID.Date)
+                .First();
+        }
+
+        public override void OnData(Slice slice)
+        {
+            // Do some trading with the selected contract for sample purposes
+            if (!Portfolio.Invested)
+            {
+                MarketOrder(_googOptionContract, 1);
+            }
+            else
+            {
+                Liquidate();
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public virtual List<Language> Languages { get; } = new() { Language.CSharp, Language.Python };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1059;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 2;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "210"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "96041"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$209.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "GOOCV W6U7PD1F2WYU|GOOCV VP83T1ZUHROL"},
+            {"Portfolio Turnover", "85.46%"},
+            {"OrderListHash", "a7ab1a9e64fe9ba76ea33a40a78a4e3b"}
+        };
+    }
+}

Algorithm.CSharp/OptionEquityCallBackspreadRegressionAlgorithm.cs

@@ -0,0 +1,128 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Securities.Option;
+using QuantConnect.Securities.Option.StrategyMatcher;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm exercising an equity Long Call Backspread option strategy and asserting it's being detected by Lean and works as expected
+    /// </summary>
+    public class OptionEquityCallBackspreadRegressionAlgorithm : OptionEquityBaseStrategyRegressionAlgorithm
+    {
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                OptionChain chain;
+                if (IsMarketOpen(_optionSymbol) && slice.OptionChains.TryGetValue(_optionSymbol, out chain))
+                {
+                    var callContracts = chain
+                        .Where(contract => contract.Right == OptionRight.Call);
+                    var expiry = callContracts.Min(x => x.Expiry);
+                    callContracts = callContracts.Where(x => x.Expiry == expiry)
+                        .OrderBy(x => x.Strike)
+                        .ToList();
+
+                    var strike = callContracts.Select(x => x.Strike).Distinct();
+                    if (strike.Count() < 2) return;
+
+                    var lowStrikeCall = callContracts.First();
+                    var highStrikeCall = callContracts.First(contract => contract.Strike > lowStrikeCall.Strike && contract.Expiry == expiry);
+
+                    var initialMargin = Portfolio.MarginRemaining;
+
+                    var optionStrategy = OptionStrategies.CallBackspread(_optionSymbol, lowStrikeCall.Strike, highStrikeCall.Strike, expiry);
+                    Buy(optionStrategy, 5);
+                    var freeMarginPostTrade = Portfolio.MarginRemaining;
+
+                    // It is a combination of bear call spread and long call
+                    AssertOptionStrategyIsPresent(OptionStrategyDefinitions.BearCallSpread.Name, 5);
+                    AssertOptionStrategyIsPresent(OptionStrategyDefinitions.NakedCall.Name, 5);
+
+                    // Should only involve the bear call spread part
+                    var expectedMarginUsage = (highStrikeCall.Strike - lowStrikeCall.Strike) * Securities[highStrikeCall.Symbol].SymbolProperties.ContractMultiplier * 5;
+
+                    if (expectedMarginUsage != Portfolio.TotalMarginUsed)
+                    {
+                        throw new Exception($"Unexpect margin used!:{Portfolio.TotalMarginUsed}");
+                    }
+
+                    // we payed the ask and value using the assets price
+                    var priceLadderDifference = GetPriceSpreadDifference(lowStrikeCall.Symbol, highStrikeCall.Symbol);
+                    if (initialMargin != (freeMarginPostTrade + expectedMarginUsage + _paidFees - priceLadderDifference))
+                    {
+                        throw new Exception("Unexpect margin remaining!");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 15023;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "200000"},
+            {"End Equity", "198565.25"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$9.75"},
+            {"Estimated Strategy Capacity", "$47000.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
+            {"Portfolio Turnover", "11.81%"},
+            {"OrderListHash", "6ece6c59826ea66fa7b0a1094a0021c7"}
+        };
+    }
+}

Algorithm.CSharp/OptionEquityPutBackspreadRegressionAlgorithm.cs

@@ -0,0 +1,128 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Securities.Option;
+using QuantConnect.Securities.Option.StrategyMatcher;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm exercising an equity Long Put Backspread option strategy and asserting it's being detected by Lean and works as expected
+    /// </summary>
+    public class OptionEquityPutBackspreadRegressionAlgorithm : OptionEquityBaseStrategyRegressionAlgorithm
+    {
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                OptionChain chain;
+                if (IsMarketOpen(_optionSymbol) && slice.OptionChains.TryGetValue(_optionSymbol, out chain))
+                {
+                    var putContracts = chain
+                        .Where(contract => contract.Right == OptionRight.Put);
+                    var expiry = putContracts.Min(x => x.Expiry);
+                    putContracts = putContracts.Where(x => x.Expiry == expiry)
+                        .OrderBy(x => x.Strike)
+                        .ToList();
+
+                    var strike = putContracts.Select(x => x.Strike).Distinct();
+                    if (strike.Count() < 2) return;
+
+                    var lowStrikePut = putContracts.First();
+                    var highStrikePut = putContracts.First(contract => contract.Strike > lowStrikePut.Strike && contract.Expiry == lowStrikePut.Expiry);
+
+                    var initialMargin = Portfolio.MarginRemaining;
+
+                    var optionStrategy = OptionStrategies.PutBackspread(_optionSymbol, highStrikePut.Strike, lowStrikePut.Strike, expiry);
+                    Buy(optionStrategy, 5);
+                    var freeMarginPostTrade = Portfolio.MarginRemaining;
+
+                    // It is a combination of bull put spread and long put
+                    AssertOptionStrategyIsPresent(OptionStrategyDefinitions.BullPutSpread.Name, 5);
+                    AssertOptionStrategyIsPresent(OptionStrategyDefinitions.NakedPut.Name, 5);
+
+                    // Should only involve the bull put spread part
+                    var expectedMarginUsage = (highStrikePut.Strike - lowStrikePut.Strike) * Securities[highStrikePut.Symbol].SymbolProperties.ContractMultiplier * 5;
+
+                    if (expectedMarginUsage != Portfolio.TotalMarginUsed)
+                    {
+                        throw new Exception("Unexpect margin used!");
+                    }
+
+                    // we payed the ask and value using the assets price
+                    var priceLadderDifference = GetPriceSpreadDifference(lowStrikePut.Symbol, highStrikePut.Symbol);
+                    if (initialMargin != (freeMarginPostTrade + expectedMarginUsage + _paidFees - priceLadderDifference))
+                    {
+                        throw new Exception("Unexpect margin remaining!");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 15023;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "200000"},
+            {"End Equity", "199015.25"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$9.75"},
+            {"Estimated Strategy Capacity", "$1100000.00"},
+            {"Lowest Capacity Asset", "GOOCV 306CZL2DIL4G6|GOOCV VP83T1ZUHROL"},
+            {"Portfolio Turnover", "9.15%"},
+            {"OrderListHash", "1a51f04db9201f960dc04668b7f5d41d"}
+        };
+    }
+}

Algorithm.CSharp/OptionEquityShortCallBackspreadRegressionAlgorithm.cs

@@ -0,0 +1,130 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Option;
+using QuantConnect.Securities.Option.StrategyMatcher;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm exercising an equity Short Call Backspread option strategy and asserting it's being detected by Lean and works as expected
+    /// </summary>
+    public class OptionEquityShortCallBackspreadRegressionAlgorithm : OptionEquityBaseStrategyRegressionAlgorithm
+    {
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                OptionChain chain;
+                if (IsMarketOpen(_optionSymbol) && slice.OptionChains.TryGetValue(_optionSymbol, out chain))
+                {
+                    var callContracts = chain
+                        .Where(contract => contract.Right == OptionRight.Call);
+                    var expiry = callContracts.Min(x => x.Expiry);
+                    callContracts = callContracts.Where(x => x.Expiry == expiry)
+                        .OrderBy(x => x.Strike)
+                        .ToList();
+
+                    var strike = callContracts.Select(x => x.Strike).Distinct();
+                    if (strike.Count() < 2) return;
+
+                    var lowStrikeCall = callContracts.First();
+                    var highStrikeCall = callContracts.First(contract => contract.Strike > lowStrikeCall.Strike && contract.Expiry == lowStrikeCall.Expiry);
+
+                    var initialMargin = Portfolio.MarginRemaining;
+
+                    var optionStrategy = OptionStrategies.ShortCallBackspread(_optionSymbol, lowStrikeCall.Strike, highStrikeCall.Strike, expiry);
+                    Buy(optionStrategy, 5);
+                    var freeMarginPostTrade = Portfolio.MarginRemaining;
+
+                    // It is a combination of bull call spread and naked call
+                    AssertOptionStrategyIsPresent(OptionStrategyDefinitions.BullCallSpread.Name, 5);
+                    AssertOptionStrategyIsPresent(OptionStrategyDefinitions.NakedCall.Name, 5);
+
+                    // Should only involve the naked call part
+                    var security = Securities[highStrikeCall.Symbol];
+                    var expectedMarginUsage = security.BuyingPowerModel.GetMaintenanceMargin(MaintenanceMarginParameters.ForQuantityAtCurrentPrice(security, -5)).Value;
+
+                    if (expectedMarginUsage != Portfolio.TotalMarginUsed)
+                    {
+                        throw new Exception("Unexpect margin used!");
+                    }
+
+                    // we payed the ask and value using the assets price
+                    var priceLadderDifference = GetPriceSpreadDifference(lowStrikeCall.Symbol, highStrikeCall.Symbol);
+                    if (initialMargin != (freeMarginPostTrade + expectedMarginUsage + _paidFees - priceLadderDifference))
+                    {
+                        throw new Exception("Unexpect margin remaining!");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 15023;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "200000"},
+            {"End Equity", "199915.25"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$9.75"},
+            {"Estimated Strategy Capacity", "$53000.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
+            {"Portfolio Turnover", "11.48%"},
+            {"OrderListHash", "357f13ed9e71c4dd8bb8e51e339ba7c5"}
+        };
+    }
+}

Algorithm.CSharp/OptionEquityShortPutBackspreadRegressionAlgorithm.cs

@@ -0,0 +1,130 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Securities;
+using QuantConnect.Securities.Option;
+using QuantConnect.Securities.Option.StrategyMatcher;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm exercising an equity Short Put Backspread option strategy and asserting it's being detected by Lean and works as expected
+    /// </summary>
+    public class OptionEquityShortPutBackspreadRegressionAlgorithm : OptionEquityBaseStrategyRegressionAlgorithm
+    {
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                OptionChain chain;
+                if (IsMarketOpen(_optionSymbol) && slice.OptionChains.TryGetValue(_optionSymbol, out chain))
+                {
+                    var putContracts = chain
+                        .Where(contract => contract.Right == OptionRight.Put);
+                    var expiry = putContracts.Min(x => x.Expiry);
+                    putContracts = putContracts.Where(x => x.Expiry == expiry)
+                        .OrderBy(x => x.Strike)
+                        .ToList();
+
+                    var strike = putContracts.Select(x => x.Strike).Distinct();
+                    if (strike.Count() < 2) return;
+
+                    var lowStrikePut = putContracts.First();
+                    var highStrikePut = putContracts.First(contract => contract.Strike > lowStrikePut.Strike && contract.Expiry == lowStrikePut.Expiry);
+
+                    var initialMargin = Portfolio.MarginRemaining;
+
+                    var optionStrategy = OptionStrategies.ShortPutBackspread(_optionSymbol, highStrikePut.Strike, lowStrikePut.Strike, expiry);
+                    Buy(optionStrategy, 5);
+                    var freeMarginPostTrade = Portfolio.MarginRemaining;
+
+                    // It is a combination of bear put spread and naked put
+                    AssertOptionStrategyIsPresent(OptionStrategyDefinitions.BearPutSpread.Name, 5);
+                    AssertOptionStrategyIsPresent(OptionStrategyDefinitions.NakedPut.Name, 5);
+
+                    // Should only involve the naked put part
+                    var security = Securities[lowStrikePut.Symbol];
+                    var expectedMarginUsage = security.BuyingPowerModel.GetMaintenanceMargin(MaintenanceMarginParameters.ForQuantityAtCurrentPrice(security, -5)).Value;
+
+                    if (expectedMarginUsage != Portfolio.TotalMarginUsed)
+                    {
+                        throw new Exception("Unexpect margin used!");
+                    }
+
+                    // we payed the ask and value using the assets price
+                    var priceLadderDifference = GetPriceSpreadDifference(lowStrikePut.Symbol, highStrikePut.Symbol);
+                    if (initialMargin != (freeMarginPostTrade + expectedMarginUsage + _paidFees - priceLadderDifference))
+                    {
+                        throw new Exception("Unexpect margin remaining!");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 15023;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public override Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "200000"},
+            {"End Equity", "199165.25"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$9.75"},
+            {"Estimated Strategy Capacity", "$1200000.00"},
+            {"Lowest Capacity Asset", "GOOCV 306CZL2DIL4G6|GOOCV VP83T1ZUHROL"},
+            {"Portfolio Turnover", "8.84%"},
+            {"OrderListHash", "7294da06231632975e97c57721d26442"}
+        };
+    }
+}

Algorithm.CSharp/OptionIndicatorsMirrorContractsRegressionAlgorithm.cs

@@ -100,7 +100,7 @@ Rho: {_rho}");
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 49;
+        public long DataPoints => 51;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/OptionIndicatorsRegressionAlgorithm.cs

@@ -32,7 +32,7 @@ namespace QuantConnect.Algorithm.CSharp
         private Theta _theta;
         private Rho _rho;
 
-        protected virtual string ExpectedGreeks { get; set; } = "Implied Volatility: 0.45252,Delta: -0.0092,Gamma: 0.00036,Vega: 0.03562,Theta: -0.0387,Rho: 0.00045";
+        protected virtual string ExpectedGreeks { get; set; } = "Implied Volatility: 0.44529,Delta: -0.00921,Gamma: 0.00036,Vega: 0.03636,Theta: -0.03747,Rho: 0.00047";
 
         public override void Initialize()
         {

Algorithm.CSharp/OptionOTMExpiryOrderHasZeroPriceRegressionAlgorithm.cs

@@ -153,7 +153,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public long DataPoints => 212195;
+        public long DataPoints => 212196;
 
         /// <summary>
         /// Data Points count of the algorithm history
@@ -191,7 +191,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Annual Variance", "0.003"},
             {"Information Ratio", "-0.198"},
             {"Tracking Error", "0.377"},
-            {"Treynor Ratio", "-23.06"},
+            {"Treynor Ratio", "-23.065"},
             {"Total Fees", "$1.42"},
             {"Estimated Strategy Capacity", "$180000000.00"},
             {"Lowest Capacity Asset", "ES XFH59UPHGV9G|ES XFH59UK0MYO1"},

Algorithm.CSharp/OptionPriceModelForOptionStylesBaseRegressionAlgorithm.cs

@@ -86,7 +86,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             foreach (var contract in contracts)
             {
-                Greeks greeks = new Greeks();
+                Greeks greeks = null;
                 try
                 {
                     greeks = contract.Greeks;
@@ -110,7 +110,8 @@ namespace QuantConnect.Algorithm.CSharp
                 // Greeks should be valid if they were successfuly accessed for supported option style
                 if (_optionStyleIsSupported)
                 {
-                    if (greeks.Delta == 0m && greeks.Gamma == 0m && greeks.Theta == 0m && greeks.Vega == 0m && greeks.Rho == 0m)
+                    if (greeks == null ||
+                        (greeks.Delta == 0m && greeks.Gamma == 0m && greeks.Theta == 0m && greeks.Vega == 0m && greeks.Rho == 0m))
                     {
                         throw new RegressionTestException($"Expected greeks to not be zero simultaneously for {contract.Symbol.Value}, an {_option.Style} style option, using {_option?.PriceModel.GetType().Name}, but they were");
                     }

Algorithm.CSharp/OptionPriceModelForSupportedAmericanOptionRegressionAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 15785;
+        public override long DataPoints => 15787;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/OptionPriceModelForSupportedEuropeanOptionRegressionAlgorithm.cs

@@ -41,7 +41,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 175;
+        public override long DataPoints => 177;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/OptionPriceModelForUnsupportedAmericanOptionRegressionAlgorithm.cs

@@ -40,7 +40,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 15785;
+        public override long DataPoints => 15787;
 
         /// <summary>
         /// Data Points count of the algorithm history

Algorithm.CSharp/OptionPriceModelForUnsupportedEuropeanOptionRegressionAlgorithm.cs

@@ -42,7 +42,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <summary>
         /// Data Points count of all timeslices of algorithm
         /// </summary>
-        public override long DataPoints => 175;
+        public override long DataPoints => 177;
 
         /// <summary>
         /// Data Points count of the algorithm history