Update to pythonNet 2.0.14 (#6322)

* Update to pythonNet 2.0.14

* Add unit test reproducing issue

.github/workflows/gh-actions.yml

@@ -19,7 +19,7 @@ jobs:
         run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
 
       - name: Run Tests
-        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter TestCategory!=TravisExclude -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\)
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter "TestCategory!=TravisExclude&TestCategory!=ResearchRegressionTests" -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\)
 
       - name: Generate & Publish python stubs
         if: startsWith(github.ref, 'refs/tags/')
@@ -28,3 +28,5 @@ jobs:
           ./ci_build_stubs.sh -t -g -p
         env:
           PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+          ADDITIONAL_STUBS_REPOS: ${{ secrets.ADDITIONAL_STUBS_REPOS }}
+          QC_GIT_TOKEN: ${{ secrets.QC_GIT_TOKEN }}

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

@@ -0,0 +1,35 @@
+name: Research Regression Tests
+
+on:
+  push:
+    branches: ['*']
+    tags: ['*']
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    container:
+        image: quantconnect/lean:foundation
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: install dependencies
+        run: |
+          pip3 install papermill clr-loader
+
+      - name: install kernel
+        run: dotnet tool install --global Microsoft.dotnet-interactive --version 1.0.317502
+
+      - name: Add dotnet tools to Path
+        run: echo "$HOME/.dotnet/tools" >> $GITHUB_PATH
+
+      - name: activate kernel for jupyter
+        run: dotnet interactive jupyter install
+
+      - name: Build
+        run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+
+      - name: Run Tests
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter TestCategory=ResearchRegressionTests -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\) TestRunParameters.Parameter\(name=\"reduced-disk-size\", value=\"true\"\)

.vscode/readme.md

@@ -95,7 +95,7 @@ Python algorithms require a little extra work in order to be able to debug them.
 First in order to debug a Python algorithm in VS Code we must make the following change to our configuration (Launcher\config.json) under the comment debugging configuration:
 
     "debugging": true,
-    "debugging-method": "DebugPy,
+    "debugging-method": "DebugPy",
 
 In setting this we are telling Lean to expect a debugger connection using ‘Python Tools for Visual Studio Debugger’. Once this is set Lean will stop upon initialization and await a connection to the debugger via port 5678.
 

Algorithm.CSharp/AccumulativeInsightPortfolioRegressionAlgorithm.cs

@@ -69,6 +69,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { 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>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/AddAlphaModelAlgorithm.cs

@@ -105,6 +105,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 58;
+
+        /// <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>

Algorithm.CSharp/AddAndRemoveOptionContractRegressionAlgorithm.cs

@@ -82,6 +82,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 24;
+
+        /// <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>

Algorithm.CSharp/AddAndRemoveSecuritySameLoopRegressionAlgorithm.cs

@@ -79,6 +79,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 24;
+
+        /// <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>

Algorithm.CSharp/AddBetaIndicatorRegressionAlgorithm.cs

@@ -99,6 +99,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Language[] Languages { get; } = { Language.CSharp};
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 10977;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 11;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/AddFutureContractWithContinuousRegressionAlgorithm.cs

@@ -113,6 +113,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 59;
+
+        /// <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>

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -160,6 +160,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 210329;
+
+        /// <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>

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -219,6 +219,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 779544;
+
+        /// <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>

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -114,6 +114,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 37597;
+
+        /// <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>

Algorithm.CSharp/AddOptionContractFromUniverseRegressionAlgorithm.cs

@@ -166,6 +166,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 5797;
+
+        /// <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>

Algorithm.CSharp/AddOptionContractTwiceRegressionAlgorithm.cs

@@ -113,6 +113,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 4677;
+
+        /// <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>
@@ -159,7 +169,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "7fbcd12db40304d50b3a34d7878eb3cf"}
+            {"OrderListHash", "546b6182e1df2d222178454d8f311566"}
         };
     }
 }

Algorithm.CSharp/AddRemoveOptionUniverseRegressionAlgorithm.cs

@@ -210,6 +210,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 200618;
+
+        /// <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>

Algorithm.CSharp/AddRemoveSecurityCacheRegressionAlgorithm.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 QuantConnect.Data;
+using QuantConnect.Interfaces;
+using System.Collections.Generic;
+using QuantConnect.Orders;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm making sure the securities cache is reset correctly once it's removed from the algorithm
+    /// </summary>
+    public class AddRemoveSecurityCacheRegressionAlgorithm : 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);  //Set Start Date
+            SetEndDate(2013, 10, 11);    //Set End Date
+            SetCash(100000);             //Set Strategy Cash
+
+            AddEquity("SPY", Resolution.Minute, extendedMarketHours: true);
+        }
+
+        /// <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 data)
+        {
+            if (!Portfolio.Invested)
+            {
+                SetHoldings("SPY", 1);
+            }
+
+            if (Time.Day == 11)
+            {
+                return;
+            }
+            if (!ActiveSecurities.ContainsKey("AIG"))
+            {
+                var aig = AddEquity("AIG", Resolution.Minute);
+
+                var ticket = MarketOrder("AIG", 1);
+
+                if (ticket.Status != OrderStatus.Invalid)
+                {
+                    throw new Exception("Expected order to always be invalid because there is no data yet!");
+                }
+            }
+            else
+            {
+                RemoveSecurity("AIG");
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 11202;
+
+        /// <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 Trades", "19"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "271.720%"},
+            {"Drawdown", "2.500%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "1.754%"},
+            {"Sharpe Ratio", "11.994"},
+            {"Probabilistic Sharpe Ratio", "74.160%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.618"},
+            {"Beta", "0.81"},
+            {"Annual Standard Deviation", "0.185"},
+            {"Annual Variance", "0.034"},
+            {"Information Ratio", "3.961"},
+            {"Tracking Error", "0.061"},
+            {"Treynor Ratio", "2.746"},
+            {"Total Fees", "$21.45"},
+            {"Estimated Strategy Capacity", "$830000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.204"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "43.135"},
+            {"Return Over Maximum Drawdown", "261.238"},
+            {"Portfolio Turnover", "0.204"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "6ee62edf1ac883882b0fcef8cb3e9bae"}
+        };
+    }
+}

Algorithm.CSharp/AddRemoveSecurityRegressionAlgorithm.cs

@@ -106,6 +106,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 7063;
+
+        /// <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>

Algorithm.CSharp/AddRiskManagementAlgorithm.cs

@@ -59,6 +59,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { 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>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/AddTwoAndRemoveOneOptionContractRegressionAlgorithm.cs

@@ -0,0 +1,160 @@
+/*
+ * 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 QuantConnect.Interfaces;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing issue where underlying option contract would be removed with the first call
+    /// too RemoveOptionContract
+    /// </summary>
+    public class AddTwoAndRemoveOneOptionContractRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _contract1;
+        private Symbol _contract2;
+        private bool _hasRemoved;
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 06, 06);
+            SetEndDate(2014, 06, 06);
+
+            UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;
+            UniverseSettings.MinimumTimeInUniverse = TimeSpan.Zero;
+
+            var aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
+
+            var contracts = OptionChainProvider.GetOptionContractList(aapl, Time)
+                .OrderBy(symbol => symbol.ID.Symbol)
+                .Where(optionContract => optionContract.ID.OptionRight == OptionRight.Call
+                    && optionContract.ID.OptionStyle == OptionStyle.American)
+                .Take(2)
+                .ToList();
+
+            _contract1 = contracts[0];
+            _contract2 = contracts[1];
+            AddOptionContract(_contract1);
+            AddOptionContract(_contract2);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (slice.HasData)
+            {
+                if (!_hasRemoved)
+                {
+                    RemoveOptionContract(_contract1);
+                    _hasRemoved = true;
+                }
+                else
+                {
+                    var subscriptions =
+                        SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs("AAPL");
+                    if (subscriptions.Count == 0)
+                    {
+                        throw new Exception("No configuration for underlying was found!");
+                    }
+
+                    if (!Portfolio.Invested)
+                    {
+                        Buy(_contract2, 1);
+                    }
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_hasRemoved)
+            {
+                throw new Exception("Expect a single call to OnData where we removed the option and underlying");
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1578;
+
+        /// <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 Trades", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$2.00"},
+            {"Estimated Strategy Capacity", "$230000.00"},
+            {"Lowest Capacity Asset", "AAPL VXBK4QQIRLZA|AAPL R735QTJ8XC9X"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "228194dcc6fd8689a67f383577ee2d85"}
+        };
+    }
+}

Algorithm.CSharp/AddUniverseSelectionModelAlgorithm.cs

@@ -78,6 +78,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 53;
+
+        /// <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>

Algorithm.CSharp/AddUniverseSelectionModelCoarseAlgorithm.cs

@@ -89,6 +89,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 234018;
+
+        /// <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>

Algorithm.CSharp/AdjustedVolumeRegressionAlgorithm.cs

@@ -153,6 +153,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 795;
+
+        /// <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>

Algorithm.CSharp/AllShortableSymbolsCoarseSelectionRegressionAlgorithm.cs

@@ -186,6 +186,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 35410;
+
+        /// <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>

Algorithm.CSharp/AlphaStreamsBasicTemplateAlgorithm.cs

@@ -65,6 +65,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 890;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public virtual int AlgorithmHistoryDataPoints => 12;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/AlphaStreamsDifferentAccountCurrencyBasicTemplateAlgorithm.cs

@@ -41,6 +41,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 6214;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 61;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/AlphaStreamsUniverseSelectionTemplateAlgorithm.cs

@@ -78,6 +78,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 893;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 2;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/AlphaStreamsWithHoldingsBasicTemplateAlgorithm.cs

@@ -92,6 +92,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 2313;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 1;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/Alphas/RebalancingLeveragedETFAlpha.cs

@@ -82,6 +82,16 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>
@@ -195,4 +205,4 @@ namespace QuantConnect.Algorithm.CSharp.Alphas
             UltraShort = ultraShort;
         }
     }
-}
+}

Algorithm.CSharp/AutoRegressiveIntegratedMovingAverageRegressionAlgorithm.cs

@@ -73,6 +73,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1893;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 100;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs

@@ -143,6 +143,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 14531;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 84;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/AutomaticIndicatorWarmupRegressionAlgorithm.cs

@@ -105,6 +105,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <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 => 40;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -293,6 +293,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1753491;
+
+        /// <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>

Algorithm.CSharp/BasicSetAccountCurrencyAlgorithm.cs

@@ -14,6 +14,7 @@
 */
 
 using System.Collections.Generic;
+using QuantConnect.Brokerages;
 using QuantConnect.Data;
 using QuantConnect.Interfaces;
 
@@ -33,6 +34,7 @@ namespace QuantConnect.Algorithm.CSharp
         {
             SetStartDate(2018, 04, 04);  //Set Start Date
             SetEndDate(2018, 04, 04);    //Set End Date
+            SetBrokerageModel(BrokerageName.GDAX, AccountType.Cash);
             //Before setting any cash or adding a Security call SetAccountCurrency
             SetAccountCurrency("EUR");
             SetCash(100000);             //Set Strategy Cash
@@ -63,6 +65,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 4324;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 120;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
@@ -87,14 +99,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$0.00"},
+            {"Total Fees", "$298.35"},
             {"Estimated Strategy Capacity", "$85000.00"},
             {"Lowest Capacity Asset", "BTCEUR XJ"},
             {"Fitness Score", "0.506"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-14.148"},
+            {"Return Over Maximum Drawdown", "-13.614"},
             {"Portfolio Turnover", "1.073"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -109,7 +121,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "18dc611407abec4ea47092e71f33f983"}
+            {"OrderListHash", "2ba443899dcccc79dc0f04441f797bf9"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateAlgorithm.cs

@@ -72,6 +72,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { 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>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/BasicTemplateAtreyuAlgorithm.cs

@@ -43,9 +43,6 @@ namespace QuantConnect.Algorithm.CSharp
 
             DefaultOrderProperties = new AtreyuOrderProperties
             {
-                // Can specify the default exchange to execute an order on.
-                // If not specified will default to the primary exchange
-                Exchange = Exchange.BATS,
                 // Currently only support order for the day
                 TimeInForce = TimeInForce.Day
             };
@@ -59,10 +56,8 @@ namespace QuantConnect.Algorithm.CSharp
         {
             if (!Portfolio.Invested)
             {
-                // will set 25% of our buying power with a market order that will be routed to exchange set in the default order properties (BATS)
+                // will set 25% of our buying power with a market order
                 SetHoldings("SPY", 0.25m);
-                // will increase our SPY holdings to 50% of our buying power with a market order that will be routed to ARCA
-                SetHoldings("SPY", 0.50m, orderProperties: new AtreyuOrderProperties { Exchange = Exchange.ARCA });
 
                 Debug("Purchased SPY!");
             }
@@ -78,39 +73,49 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 3901;
+
+        /// <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 Trades", "2"},
+            {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "93.340%"},
-            {"Drawdown", "1.100%"},
+            {"Compounding Annual Return", "39.143%"},
+            {"Drawdown", "0.500%"},
             {"Expectancy", "0"},
-            {"Net Profit", "0.846%"},
-            {"Sharpe Ratio", "6.515"},
-            {"Probabilistic Sharpe Ratio", "67.535%"},
+            {"Net Profit", "0.423%"},
+            {"Sharpe Ratio", "5.634"},
+            {"Probabilistic Sharpe Ratio", "67.498%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0"},
             {"Beta", "0"},
-            {"Annual Standard Deviation", "0.11"},
-            {"Annual Variance", "0.012"},
-            {"Information Ratio", "6.515"},
-            {"Tracking Error", "0.11"},
+            {"Annual Standard Deviation", "0.055"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "5.634"},
+            {"Tracking Error", "0.055"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$1.20"},
-            {"Estimated Strategy Capacity", "$8600000.00"},
+            {"Total Fees", "$0.60"},
+            {"Estimated Strategy Capacity", "$150000000.00"},
             {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
-            {"Fitness Score", "0.124"},
+            {"Fitness Score", "0.062"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "78.222"},
-            {"Portfolio Turnover", "0.124"},
+            {"Return Over Maximum Drawdown", "71.634"},
+            {"Portfolio Turnover", "0.062"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -124,7 +129,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "01a751a837beafd90015b2fd82edf994"}
+            {"OrderListHash", "d549c64ee7f5e3866712b3c7dbd64caa"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateContinuousFutureAlgorithm.cs

@@ -13,6 +13,7 @@
  * limitations under the License.
 */
 
+using System;
 using QuantConnect.Data;
 using QuantConnect.Orders;
 using QuantConnect.Interfaces;
@@ -62,7 +63,11 @@ namespace QuantConnect.Algorithm.CSharp
         {
             foreach (var changedEvent in data.SymbolChangedEvents.Values)
             {
-                Log($"{Time} - SymbolChanged event: {changedEvent}");
+                Debug($"{Time} - SymbolChanged event: {changedEvent}");
+                if (Time.TimeOfDay != TimeSpan.Zero)
+                {
+                    throw new Exception($"{Time} unexpected symbol changed event {changedEvent}!");
+                }
             }
 
             if (!Portfolio.Invested)
@@ -109,6 +114,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 875590;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateCryptoAlgorithm.cs

@@ -198,6 +198,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 12970;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 240;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/BasicTemplateDailyAlgorithm.cs

@@ -63,6 +63,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 73;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateFrameworkAlgorithm.cs

@@ -84,6 +84,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Language[] Languages { get; } = { 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>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/BasicTemplateFuturesAlgorithm.cs

@@ -76,6 +76,15 @@ namespace QuantConnect.Algorithm.CSharp
         /// <param name="slice">The current slice of data keyed by symbol string</param>
         public override void OnData(Slice slice)
         {
+            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
+            {
+                Debug($"{Time} - SymbolChanged event: {changedEvent}");
+                if (Time.TimeOfDay != TimeSpan.Zero)
+                {
+                    throw new Exception($"{Time} unexpected symbol changed event {changedEvent}!");
+                }
+            }
+
             if (!Portfolio.Invested)
             {
                 foreach(var chain in slice.FutureChains)
@@ -139,6 +148,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 203367;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 518;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/BasicTemplateFuturesDailyAlgorithm.cs

@@ -46,7 +46,7 @@ namespace QuantConnect.Algorithm.CSharp
         public override void Initialize()
         {
             SetStartDate(2013, 10, 08);
-            SetEndDate(2013, 10, 10);
+            SetEndDate(2014, 10, 10);
             SetCash(1000000);
 
             var futureSP500 = AddFuture(RootSP500, Resolution);
@@ -77,7 +77,7 @@ namespace QuantConnect.Algorithm.CSharp
                     ).FirstOrDefault();
 
                     // if found, trade it
-                    if (contract != null)
+                    if (contract != null && IsMarketOpen(contract.Symbol))
                     {
                         _contractSymbol = contract.Symbol;
                         MarketOrder(_contractSymbol, 1);
@@ -88,6 +88,14 @@ namespace QuantConnect.Algorithm.CSharp
             {
                 Liquidate();
             }
+
+            foreach (var changedEvent in slice.SymbolChangedEvents.Values)
+            {
+                if (Time.TimeOfDay != TimeSpan.Zero)
+                {
+                    throw new Exception($"{Time} unexpected symbol changed event {changedEvent}!");
+                }
+            }
         }
 
         /// <summary>
@@ -100,39 +108,49 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 17041;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public virtual 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 virtual Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "6"},
-            {"Average Win", "0%"},
-            {"Average Loss", "-0.10%"},
-            {"Compounding Annual Return", "-23.119%"},
-            {"Drawdown", "0.300%"},
-            {"Expectancy", "-1"},
-            {"Net Profit", "-0.276%"},
-            {"Sharpe Ratio", "-13.736"},
+            {"Total Trades", "92"},
+            {"Average Win", "0.08%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "-0.450%"},
+            {"Drawdown", "0.500%"},
+            {"Expectancy", "-0.824"},
+            {"Net Profit", "-0.453%"},
+            {"Sharpe Ratio", "-1.803"},
             {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "100%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.526"},
-            {"Beta", "0.057"},
-            {"Annual Standard Deviation", "0.015"},
+            {"Loss Rate", "98%"},
+            {"Win Rate", "2%"},
+            {"Profit-Loss Ratio", "7.09"},
+            {"Alpha", "-0.003"},
+            {"Beta", "-0.001"},
+            {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-31.088"},
-            {"Tracking Error", "0.189"},
-            {"Treynor Ratio", "-3.51"},
-            {"Total Fees", "$11.10"},
-            {"Estimated Strategy Capacity", "$200000000.00"},
-            {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
-            {"Fitness Score", "0"},
+            {"Information Ratio", "-1.394"},
+            {"Tracking Error", "0.089"},
+            {"Treynor Ratio", "4.298"},
+            {"Total Fees", "$170.20"},
+            {"Estimated Strategy Capacity", "$36000.00"},
+            {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
+            {"Fitness Score", "0.009"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-17.118"},
-            {"Return Over Maximum Drawdown", "-83.844"},
-            {"Portfolio Turnover", "0.16"},
+            {"Sortino Ratio", "-0.8"},
+            {"Return Over Maximum Drawdown", "-0.992"},
+            {"Portfolio Turnover", "0.025"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -146,7 +164,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "512f55519e5221c7e82e1d9f5ddd1b9f"}
+            {"OrderListHash", "09b2f274fa2385597a803e58b784f675"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesFrameworkAlgorithm.cs

@@ -130,6 +130,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 123378;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateFuturesHistoryAlgorithm.cs

@@ -135,6 +135,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 133616;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 5539;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/BasicTemplateFuturesHourlyAlgorithm.cs

@@ -44,39 +44,49 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 249038;
+
+        /// <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 Trades", "140"},
+            {"Total Trades", "1988"},
             {"Average Win", "0.01%"},
-            {"Average Loss", "-0.02%"},
-            {"Compounding Annual Return", "-38.171%"},
-            {"Drawdown", "0.400%"},
-            {"Expectancy", "-0.369"},
-            {"Net Profit", "-0.394%"},
-            {"Sharpe Ratio", "-24.82"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "-4.120%"},
+            {"Drawdown", "4.200%"},
+            {"Expectancy", "-0.870"},
+            {"Net Profit", "-4.150%"},
+            {"Sharpe Ratio", "-6.061"},
             {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "66%"},
-            {"Win Rate", "34%"},
-            {"Profit-Loss Ratio", "0.84"},
-            {"Alpha", "0.42"},
-            {"Beta", "-0.041"},
-            {"Annual Standard Deviation", "0.01"},
+            {"Loss Rate", "97%"},
+            {"Win Rate", "3%"},
+            {"Profit-Loss Ratio", "2.92"},
+            {"Alpha", "-0.027"},
+            {"Beta", "-0.006"},
+            {"Annual Standard Deviation", "0.005"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-65.112"},
-            {"Tracking Error", "0.253"},
-            {"Treynor Ratio", "6.024"},
-            {"Total Fees", "$259.00"},
-            {"Estimated Strategy Capacity", "$130000.00"},
-            {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
-            {"Fitness Score", "0"},
+            {"Information Ratio", "-1.66"},
+            {"Tracking Error", "0.089"},
+            {"Treynor Ratio", "4.919"},
+            {"Total Fees", "$3677.80"},
+            {"Estimated Strategy Capacity", "$2000.00"},
+            {"Lowest Capacity Asset", "ES VP274HSU1AF5"},
+            {"Fitness Score", "0.128"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-43.422"},
-            {"Return Over Maximum Drawdown", "-100.459"},
-            {"Portfolio Turnover", "4.716"},
+            {"Sortino Ratio", "-6.856"},
+            {"Return Over Maximum Drawdown", "-0.995"},
+            {"Portfolio Turnover", "0.648"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -90,7 +100,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "320067074c8dd771f69602ab07001f1e"}
+            {"OrderListHash", "87d2b127c9859cad9d2c65ac9d76deb5"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateHourlyAlgorithm.cs

@@ -72,6 +72,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 78;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateIndexAlgorithm.cs

@@ -109,6 +109,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 16690;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public virtual int AlgorithmHistoryDataPoints => 0;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/BasicTemplateIndexDailyAlgorithm.cs

@@ -56,6 +56,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 122;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateIndexHourlyAlgorithm.cs

@@ -20,6 +20,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 408;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateIndexOptionsAlgorithm.cs

@@ -131,6 +131,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <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 virtual int AlgorithmHistoryDataPoints => 0;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/BasicTemplateIndexOptionsDailyAlgorithm.cs

@@ -65,6 +65,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 381;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateIndexOptionsHourlyAlgorithm.cs

@@ -35,6 +35,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public override Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 2212;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateIndiaAlgorithm.cs

@@ -82,6 +82,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 29524;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateIndiaIndexAlgorithm.cs

@@ -106,6 +106,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public virtual Language[] Languages { get; } = { 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 => 0;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/BasicTemplateOptionEquityStrategyAlgorithm.cs

@@ -99,6 +99,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 884208;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateOptionStrategyAlgorithm.cs

@@ -109,6 +109,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 884616;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateOptionsAlgorithm.cs

@@ -106,6 +106,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 884197;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateOptionsDailyAlgorithm.cs

@@ -69,7 +69,7 @@ namespace QuantConnect.Algorithm.CSharp
                     var contractsByExpiration = chain.Where(x => x.Expiry != Time.Date).OrderBy(x => x.Expiry);
                     var contract = contractsByExpiration.FirstOrDefault();
 
-                    if (contract != null)
+                    if (contract != null && IsMarketOpen(contract.Symbol))
                     {
                         // if found, trade it
                         MarketOrder(contract.Symbol, 1);
@@ -119,6 +119,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 41730;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateOptionsFilterUniverseAlgorithm.cs

@@ -97,6 +97,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1722373;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateOptionsFrameworkAlgorithm.cs

@@ -136,6 +136,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 990979;
+
+        /// <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>

Algorithm.CSharp/BasicTemplateOptionsHourlyAlgorithm.cs

@@ -76,7 +76,7 @@ namespace QuantConnect.Algorithm.CSharp
                         .ThenByDescending(x => x.Right)
                         .FirstOrDefault();
 
-                    if (atmContract != null)
+                    if (atmContract != null && IsMarketOpen(atmContract.Symbol))
                     {
                         // if found, trade it
                         MarketOrder(atmContract.Symbol, 1);
@@ -106,6 +106,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 64216;
+
+        /// <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>

Algorithm.CSharp/BinanceCashAccountFeeRegressionAlgorithm.cs

@@ -0,0 +1,100 @@
+/*
+ * 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.Brokerages;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Binance cash account regression algorithm, reproduces issue https://github.com/QuantConnect/Lean/issues/6123
+    /// </summary>
+    public class BinanceCashAccountFeeRegressionAlgorithm : CryptoBaseCurrencyFeeRegressionAlgorithm
+    {
+        /// <summary>
+        /// The target account type
+        /// </summary>
+        protected override AccountType AccountType { get; } = AccountType.Cash;
+
+        public override void Initialize()
+        {
+            SetAccountCurrency("USDT");
+            SetStartDate(2018, 05, 02);
+            SetEndDate(2018, 05, 03);
+            BrokerageName = BrokerageName.Binance;
+            Pair = "BTCUSDT";
+            base.Initialize();
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 50;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 28;
+
+        /// <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()
+        {
+            {"Total Trades", "49"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$45.62"},
+            {"Estimated Strategy Capacity", "$220000.00"},
+            {"Lowest Capacity Asset", "BTCUSDT 18N"},
+            {"Fitness Score", "0.208"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "26.189"},
+            {"Portfolio Turnover", "0.208"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "USDT0"},
+            {"Total Accumulated Estimated Alpha Value", "USDT0"},
+            {"Mean Population Estimated Insight Value", "USDT0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "7417649395922ff3791471b4f3b5c021"}
+        };
+    }
+}

Algorithm.CSharp/BinanceMarginAccountFeeRegressionAlgorithm.cs

@@ -0,0 +1,100 @@
+/*
+ * 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.Brokerages;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Binance margin account regression algorithm, reproduces issue https://github.com/QuantConnect/Lean/issues/6123
+    /// </summary>
+    public class BinanceMarginAccountFeeRegressionAlgorithm : CryptoBaseCurrencyFeeRegressionAlgorithm
+    {
+        /// <summary>
+        /// The target account type
+        /// </summary>
+        protected override AccountType AccountType { get; } = AccountType.Margin;
+
+        public override void Initialize()
+        {
+            SetAccountCurrency("USDT");
+            SetStartDate(2018, 05, 02);
+            SetEndDate(2018, 05, 03);
+            BrokerageName = BrokerageName.Binance;
+            Pair = "BTCUSDT";
+            base.Initialize();
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 50;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 28;
+
+        /// <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()
+        {
+            {"Total Trades", "49"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$45.62"},
+            {"Estimated Strategy Capacity", "$12000000.00"},
+            {"Lowest Capacity Asset", "BTCUSDT 18N"},
+            {"Fitness Score", "0.208"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "26.189"},
+            {"Portfolio Turnover", "0.208"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "USDT0"},
+            {"Total Accumulated Estimated Alpha Value", "USDT0"},
+            {"Mean Population Estimated Insight Value", "USDT0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "7417649395922ff3791471b4f3b5c021"}
+        };
+    }
+}

Algorithm.CSharp/BitfinexCashAccountFeeRegressionAlgorithm.cs

@@ -0,0 +1,99 @@
+/*
+ * 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.Brokerages;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Bitfinex cash account regression algorithm, reproduces issue https://github.com/QuantConnect/Lean/issues/6123
+    /// </summary>
+    public class BitfinexCashAccountFeeRegressionAlgorithm : CryptoBaseCurrencyFeeRegressionAlgorithm
+    {
+        /// <summary>
+        /// The target account type
+        /// </summary>
+        protected override AccountType AccountType { get; } = AccountType.Cash;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 02);
+            SetEndDate(2013, 10, 03);
+            BrokerageName = BrokerageName.Bitfinex;
+            Pair = "BTCUSD";
+            base.Initialize();
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 126;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 28;
+
+        /// <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()
+        {
+            {"Total Trades", "49"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$1.13"},
+            {"Estimated Strategy Capacity", "$2000.00"},
+            {"Lowest Capacity Asset", "BTCUSD E3"},
+            {"Fitness Score", "0.002"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.002"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "7f892f0c42d8826ff770ee602fe207a2"}
+        };
+    }
+}

Algorithm.CSharp/BitfinexMarginAccountFeeRegressionAlgorithm.cs

@@ -0,0 +1,99 @@
+/*
+ * 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.Brokerages;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Bitfinex margin account regression algorithm, reproduces issue https://github.com/QuantConnect/Lean/issues/6123
+    /// </summary>
+    public class BitfinexMarginAccountFeeRegressionAlgorithm : CryptoBaseCurrencyFeeRegressionAlgorithm
+    {
+        /// <summary>
+        /// The target account type
+        /// </summary>
+        protected override AccountType AccountType { get; } = AccountType.Margin;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 02);
+            SetEndDate(2013, 10, 03);
+            BrokerageName = BrokerageName.Bitfinex;
+            Pair = "BTCUSD";
+            base.Initialize();
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 126;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public override int AlgorithmHistoryDataPoints => 28;
+
+        /// <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()
+        {
+            {"Total Trades", "49"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$1.13"},
+            {"Estimated Strategy Capacity", "$640000.00"},
+            {"Lowest Capacity Asset", "BTCUSD E3"},
+            {"Fitness Score", "0.002"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.002"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "7f892f0c42d8826ff770ee602fe207a2"}
+        };
+    }
+}

Algorithm.CSharp/BlackLittermanPortfolioOptimizationFrameworkAlgorithm.cs

@@ -73,6 +73,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 14082;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 256;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/CancelOpenOrdersRegressionAlgorithm.cs

@@ -122,6 +122,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 5765;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 120;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/CapacityTests/BeastVsPenny.cs

@@ -51,6 +51,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/CheeseMilkHourlyRebalance.cs

@@ -96,6 +96,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/EmaPortfolioRebalance100.cs

@@ -180,6 +180,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/IntradayMinuteScalping.cs

@@ -66,6 +66,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/IntradayMinuteScalpingBTCETH.cs

@@ -72,6 +72,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/IntradayMinuteScalpingEURUSD.cs

@@ -66,6 +66,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/IntradayMinuteScalpingFuturesES.cs

@@ -92,6 +92,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/IntradayMinuteScalpingGBPJPY.cs

@@ -67,6 +67,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/IntradayMinuteScalpingTRYJPY.cs

@@ -67,6 +67,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/MonthlyRebalanceDaily.cs

@@ -60,6 +60,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/MonthlyRebalanceHourly.cs

@@ -60,6 +60,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/SplitTestingStrategy.cs

@@ -61,6 +61,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CapacityTests/SpyBondPortfolioRebalance.cs

@@ -52,6 +52,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public 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>

Algorithm.CSharp/CfdTimeZonesRegressionAlgorithm.cs

@@ -70,6 +70,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 2776;
+
+        /// <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>

Algorithm.CSharp/ClassicRenkoConsolidatorAlgorithm.cs

@@ -111,6 +111,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 2003;
+
+        /// <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>

Algorithm.CSharp/CoarseFineFundamentalRegressionAlgorithm.cs

@@ -156,6 +156,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 7239;
+
+        /// <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>

Algorithm.CSharp/CoarseFineOptionUniverseChainRegressionAlgorithm.cs

@@ -139,6 +139,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 998462;
+
+        /// <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>

Algorithm.CSharp/CoarseFundamentalTop3Algorithm.cs

@@ -111,6 +111,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 78091;
+
+        /// <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>

Algorithm.CSharp/CoarseNoLookAheadBiasAlgorithm.cs

@@ -89,6 +89,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 70952;
+
+        /// <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>

Algorithm.CSharp/CoarseSelectionTimeRegressionAlgorithm.cs

@@ -95,6 +95,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 49662;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 6;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/CompositeAlphaModelFrameworkAlgorithm.cs

@@ -66,45 +66,55 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = {Language.CSharp, Language.Python};
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 15643;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 208;
+
         /// <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 Trades", "7"},
-            {"Average Win", "0.01%"},
-            {"Average Loss", "-0.40%"},
-            {"Compounding Annual Return", "1143.086%"},
+            {"Total Trades", "18"},
+            {"Average Win", "0.00%"},
+            {"Average Loss", "-0.02%"},
+            {"Compounding Annual Return", "88.032%"},
             {"Drawdown", "1.800%"},
-            {"Expectancy", "-0.319"},
-            {"Net Profit", "3.275%"},
-            {"Sharpe Ratio", "23.495"},
-            {"Probabilistic Sharpe Ratio", "80.494%"},
-            {"Loss Rate", "33%"},
-            {"Win Rate", "67%"},
-            {"Profit-Loss Ratio", "0.02"},
-            {"Alpha", "4.366"},
-            {"Beta", "1.255"},
-            {"Annual Standard Deviation", "0.292"},
-            {"Annual Variance", "0.085"},
-            {"Information Ratio", "47.955"},
-            {"Tracking Error", "0.102"},
-            {"Treynor Ratio", "5.461"},
-            {"Total Fees", "$71.37"},
-            {"Estimated Strategy Capacity", "$3500000.00"},
+            {"Expectancy", "-0.679"},
+            {"Net Profit", "0.811%"},
+            {"Sharpe Ratio", "5.833"},
+            {"Probabilistic Sharpe Ratio", "65.782%"},
+            {"Loss Rate", "73%"},
+            {"Win Rate", "27%"},
+            {"Profit-Loss Ratio", "0.18"},
+            {"Alpha", "-0.473"},
+            {"Beta", "0.725"},
+            {"Annual Standard Deviation", "0.165"},
+            {"Annual Variance", "0.027"},
+            {"Information Ratio", "-14.297"},
+            {"Tracking Error", "0.071"},
+            {"Treynor Ratio", "1.331"},
+            {"Total Fees", "$31.70"},
+            {"Estimated Strategy Capacity", "$5900000.00"},
             {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
             {"Fitness Score", "0.501"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "148.07"},
-            {"Return Over Maximum Drawdown", "1487.238"},
-            {"Portfolio Turnover", "0.501"},
-            {"Total Insights Generated", "2"},
+            {"Sortino Ratio", "13.543"},
+            {"Return Over Maximum Drawdown", "75.664"},
+            {"Portfolio Turnover", "0.505"},
+            {"Total Insights Generated", "6"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
-            {"Long Insight Count", "2"},
-            {"Short Insight Count", "0"},
-            {"Long/Short Ratio", "100%"},
+            {"Long Insight Count", "5"},
+            {"Short Insight Count", "1"},
+            {"Long/Short Ratio", "500%"},
             {"Estimated Monthly Alpha Value", "$0"},
             {"Total Accumulated Estimated Alpha Value", "$0"},
             {"Mean Population Estimated Insight Value", "$0"},
@@ -112,7 +122,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "5a171f804d47cd27f84aaef791da8594"}
+            {"OrderListHash", "f25344c69f9b9476ae5a834616a65c82"}
         };
     }
 }

Algorithm.CSharp/CompositeRiskManagementModelFrameworkAlgorithm.cs

@@ -60,6 +60,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { 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>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/ConfidenceWeightedFrameworkAlgorithm.cs

@@ -73,6 +73,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { 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>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>

Algorithm.CSharp/ConsolidateRegressionAlgorithm.cs

@@ -139,6 +139,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 8091;
+
+        /// <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>

Algorithm.CSharp/ConstituentsUniverseRegressionAlgorithm.cs

@@ -165,6 +165,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 59;
+
+        /// <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>

Algorithm.CSharp/ContinuousBackMonthRawFutureRegressionAlgorithm.cs

@@ -90,8 +90,7 @@ namespace QuantConnect.Algorithm.CSharp
                 }
                 else
                 {
-                    // This works because we set this contract as tradable, even if it's a canonical security
-                    Buy(_continuousContract.Symbol, 1);
+                    Buy(_continuousContract.Mapped, 1);
                 }
 
                 if(Time.Month == 1 && Time.Year == 2013)
@@ -132,38 +131,48 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 815242;
+
+        /// <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 Trades", "2"},
-            {"Average Win", "1.16%"},
+            {"Average Win", "1.21%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "2.311%"},
+            {"Compounding Annual Return", "2.412%"},
             {"Drawdown", "1.600%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.159%"},
-            {"Sharpe Ratio", "0.753"},
-            {"Probabilistic Sharpe Ratio", "39.483%"},
+            {"Net Profit", "1.209%"},
+            {"Sharpe Ratio", "0.782"},
+            {"Probabilistic Sharpe Ratio", "40.528%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.006"},
+            {"Alpha", "-0.005"},
             {"Beta", "0.099"},
             {"Annual Standard Deviation", "0.022"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-2.732"},
+            {"Information Ratio", "-2.724"},
             {"Tracking Error", "0.076"},
-            {"Treynor Ratio", "0.165"},
+            {"Treynor Ratio", "0.171"},
             {"Total Fees", "$3.70"},
-            {"Estimated Strategy Capacity", "$3900000.00"},
-            {"Lowest Capacity Asset", "ES 1S1"},
+            {"Estimated Strategy Capacity", "$810000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Fitness Score", "0.007"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0.563"},
-            {"Return Over Maximum Drawdown", "1.87"},
+            {"Sortino Ratio", "0.587"},
+            {"Return Over Maximum Drawdown", "1.952"},
             {"Portfolio Turnover", "0.01"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -178,7 +187,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "8aa2ed1319e8bb5beb403476a5aebfef"}
+            {"OrderListHash", "95c62255290b4ad375579b398290230c"}
         };
     }
 }

Algorithm.CSharp/ContinuousFutureBackMonthRegressionAlgorithm.cs

@@ -103,8 +103,7 @@ namespace QuantConnect.Algorithm.CSharp
                 }
                 else
                 {
-                    // This works because we set this contract as tradable, even if it's a canonical security
-                    Buy(_continuousContract.Symbol, 1);
+                    Buy(_continuousContract.Mapped, 1);
                 }
 
                 if(Time.Month == 1 && Time.Year == 2013)
@@ -145,39 +144,49 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 875590;
+
+        /// <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 Trades", "3"},
-            {"Average Win", "1.16%"},
+            {"Average Win", "1.21%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "2.229%"},
+            {"Compounding Annual Return", "2.392%"},
             {"Drawdown", "1.600%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.118%"},
-            {"Sharpe Ratio", "0.726"},
-            {"Probabilistic Sharpe Ratio", "38.511%"},
+            {"Net Profit", "1.199%"},
+            {"Sharpe Ratio", "0.775"},
+            {"Probabilistic Sharpe Ratio", "40.287%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.007"},
+            {"Alpha", "-0.006"},
             {"Beta", "0.099"},
             {"Annual Standard Deviation", "0.022"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-2.74"},
+            {"Information Ratio", "-2.726"},
             {"Tracking Error", "0.076"},
-            {"Treynor Ratio", "0.159"},
+            {"Treynor Ratio", "0.169"},
             {"Total Fees", "$5.55"},
-            {"Estimated Strategy Capacity", "$290000.00"},
-            {"Lowest Capacity Asset", "ES 1S1"},
-            {"Fitness Score", "0.009"},
+            {"Estimated Strategy Capacity", "$67000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Fitness Score", "0.01"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "0.498"},
-            {"Return Over Maximum Drawdown", "1.803"},
-            {"Portfolio Turnover", "0.014"},
+            {"Sortino Ratio", "0.516"},
+            {"Return Over Maximum Drawdown", "1.935"},
+            {"Portfolio Turnover", "0.016"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -191,7 +200,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "e669103cc598f59d85f5e8d5f0b8df30"}
+            {"OrderListHash", "5fc26c7f1f2d9fff97d36a5b58853840"}
         };
     }
 }

Algorithm.CSharp/ContinuousFutureHistoryRegressionAlgorithm.cs

@@ -77,9 +77,9 @@ namespace QuantConnect.Algorithm.CSharp
                 throw new Exception($"We are getting data for more than one symbols! {string.Join(",", data.Keys.Select(symbol => symbol))}");
             }
 
-            if (!Portfolio.Invested)
+            if (!Portfolio.Invested && !IsWarmingUp)
             {
-                Buy(_continuousContract.Symbol, 1);
+                Buy(_continuousContract.Mapped, 1);
             }
         }
 
@@ -111,6 +111,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 25858;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 10;
+
         /// <summary>
         /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
         /// </summary>
@@ -136,14 +146,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$1.85"},
-            {"Estimated Strategy Capacity", "$42000000.00"},
-            {"Lowest Capacity Asset", "ES 1S1"},
-            {"Fitness Score", "0.76"},
+            {"Estimated Strategy Capacity", "$400000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
+            {"Fitness Score", "0.816"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
             {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0.76"},
+            {"Portfolio Turnover", "0.816"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -157,7 +167,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "4de9344671d542e30066338e2bf9d400"}
+            {"OrderListHash", "f3bf9e78fa238cf98344d12839b36705"}
         };
     }
 }

Algorithm.CSharp/ContinuousFutureRegressionAlgorithm.cs

@@ -160,6 +160,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 875590;
+
+        /// <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>
@@ -185,7 +195,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0.076"},
             {"Treynor Ratio", "0.169"},
             {"Total Fees", "$5.55"},
-            {"Estimated Strategy Capacity", "$0"},
+            {"Estimated Strategy Capacity", "$67000000.00"},
             {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Fitness Score", "0.01"},
             {"Kelly Criterion Estimate", "0"},

Algorithm.CSharp/ConvertToFrameworkAlgorithm.cs

@@ -121,6 +121,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 22137;
+
+        /// <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>

Algorithm.CSharp/CryptoBaseCurrencyFeeRegressionAlgorithm.cs

@@ -0,0 +1,120 @@
+/*
+ * 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.Util;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Brokerages;
+using System.Collections.Generic;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Base crypto account regression algorithm trading in and out
+    /// </summary>
+    public abstract class CryptoBaseCurrencyFeeRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _symbol;
+
+        /// <summary>
+        /// The target account type
+        /// </summary>
+        protected abstract  AccountType AccountType { get; }
+
+        /// <summary>
+        /// The target brokerage model name
+        /// </summary>
+        protected BrokerageName BrokerageName { get; set; }
+
+        /// <summary>
+        /// The pair to add and trade
+        /// </summary>
+        protected string Pair { get; set; }
+
+        /// <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()
+        {
+            SetBrokerageModel(BrokerageName, AccountType);
+            _symbol = AddCrypto(Pair, Resolution.Hour).Symbol;
+        }
+
+        /// <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 data)
+        {
+            if (!Portfolio.Invested)
+            {
+                CurrencyPairUtil.DecomposeCurrencyPair(_symbol, out var baseCurrency, out var quoteCurrency);
+
+                var initialQuoteCurrency = Portfolio.CashBook[quoteCurrency].Amount;
+                var ticket = Buy(_symbol, 0.1m);
+                var filledEvent = ticket.OrderEvents.Single(orderEvent => orderEvent.Status == OrderStatus.Filled);
+
+                if (Portfolio.CashBook[baseCurrency].Amount != ticket.QuantityFilled
+                    || filledEvent.FillQuantity != ticket.QuantityFilled
+                    || (0.1m - filledEvent.OrderFee.Value.Amount) != ticket.QuantityFilled)
+                {
+                    throw new Exception($"Unexpected BaseCurrency porfoltio status. Event {filledEvent}. CashBook: {Portfolio.CashBook}. ");
+                }
+
+                if (Portfolio.CashBook[quoteCurrency].Amount != (initialQuoteCurrency - 0.1m * filledEvent.FillPrice))
+                {
+                    throw new Exception($"Unexpected QuoteCurrency porfoltio status. Event {filledEvent}. CashBook: {Portfolio.CashBook}. ");
+                }
+
+                if (Securities[_symbol].Holdings.Quantity != (0.1m - filledEvent.OrderFee.Value.Amount))
+                {
+                    throw new Exception($"Unexpected Holdings: {Securities[_symbol].Holdings}. Event {filledEvent}");
+                }
+            }
+            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 Language[] Languages { get; } = { 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 virtual 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 abstract Dictionary<string, string> ExpectedStatistics { get; }
+    }
+}

Algorithm.CSharp/CustomBenchmarkAlgorithm.cs

@@ -74,6 +74,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 234043;
+
+        /// <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>

Algorithm.CSharp/CustomBenchmarkRegressionAlgorithm.cs

@@ -71,6 +71,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 1965;
+
+        /// <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>

Algorithm.CSharp/CustomBuyingPowerModelAlgorithm.cs

@@ -92,6 +92,16 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Language[] Languages { get; } = { Language.CSharp, Language.Python };
 
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public long DataPoints => 330;
+
+        /// <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>