public void Setup()
{
var sunday = new LocalMarketHours(DayOfWeek.Sunday, new TimeSpan(17, 0, 0), TimeSpan.FromTicks(Time.OneDay.Ticks - 1));
var monday = LocalMarketHours.OpenAllDay(DayOfWeek.Monday);
var tuesday = LocalMarketHours.OpenAllDay(DayOfWeek.Tuesday);
var wednesday = LocalMarketHours.OpenAllDay(DayOfWeek.Wednesday);
var thursday = LocalMarketHours.OpenAllDay(DayOfWeek.Thursday);
var friday = new LocalMarketHours(DayOfWeek.Friday, TimeSpan.Zero, new TimeSpan(17, 0, 0));
var earlyCloses = new Dictionary <DateTime, TimeSpan>();
var lateOpens = new Dictionary <DateTime, TimeSpan>();
_exchangeHours = new SecurityExchangeHours(TimeZones.NewYork, USHoliday.Dates.Select(x => x.Date), new[]
{
sunday, monday, tuesday, wednesday, thursday, friday
}.ToDictionary(x => x.DayOfWeek), earlyCloses, lateOpens);
_liveTradingDataFeed = new TestableLiveTradingDataFeed();
var jobPacket = new LiveNodePacket()
{
DeployId = "",
Brokerage = BrokerageName.OandaBrokerage.ToString(),
DataQueueHandler = "LiveDataQueue"
};
var algo = new TestAlgorithm();
var marketHoursDatabase = MarketHoursDatabase.FromDataFolder();
var symbolPropertiesDataBase = SymbolPropertiesDatabase.FromDataFolder();
var dataPermissionManager = new DataPermissionManager();
var dataManager = new DataManager(_liveTradingDataFeed,
new UniverseSelection(
algo,
new SecurityService(algo.Portfolio.CashBook, marketHoursDatabase, symbolPropertiesDataBase, algo, RegisteredSecurityDataTypesProvider.Null, new SecurityCacheProvider(algo.Portfolio)),
dataPermissionManager),
algo,
algo.TimeKeeper,
marketHoursDatabase,
true,
RegisteredSecurityDataTypesProvider.Null,
dataPermissionManager);
algo.SubscriptionManager.SetDataManager(dataManager);
var synchronizer = new LiveSynchronizer();
synchronizer.Initialize(algo, dataManager);
_liveTradingDataFeed.Initialize(algo, jobPacket, new LiveTradingResultHandler(), new LocalDiskMapFileProvider(),
null, new DefaultDataProvider(), dataManager, synchronizer, new DataChannelProvider());
algo.Initialize();
_config = SecurityTests.CreateTradeBarConfig();
}
public void LoadsHoldingsForExpectedMarket()
{
var symbol = Symbol.Create("AUDUSD", SecurityType.Forex, Market.Oanda);
var algorithm = new TestAlgorithm();
algorithm.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage);
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = new LiveNodePacket
{
UserId = 1,
ProjectId = 1,
DeployId = "1",
Brokerage = "PaperBrokerage",
DataQueueHandler = "none"
};
// Increasing RAM limit, else the tests fail. This is happening in master, when running all the tests together, locally (not travis).
job.Controls.RamAllocation = 1024 * 1024 * 1024;
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var brokerage = new Mock <IBrokerage>();
var objectStore = new Mock <IObjectStore>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount>());
brokerage.Setup(x => x.GetAccountHoldings()).Returns(new List <Holding>
{
new Holding {
Symbol = symbol, Type = symbol.SecurityType, Quantity = 100
}
});
brokerage.Setup(x => x.GetOpenOrders()).Returns(new List <Order>());
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
Assert.IsTrue(setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object)));
Security security;
Assert.IsTrue(algorithm.Portfolio.Securities.TryGetValue(symbol, out security));
Assert.AreEqual(symbol, security.Symbol);
}
public void LoadsExistingHoldingsAndOrders(Func <List <Holding> > getHoldings, Func <List <Order> > getOrders, bool expected)
{
var algorithm = new TestAlgorithm();
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = new LiveNodePacket
{
UserId = 1,
ProjectId = 1,
DeployId = "1",
Brokerage = "PaperBrokerage",
DataQueueHandler = "none"
};
// Increasing RAM limit, else the tests fail. This is happening in master, when running all the tests together, locally (not travis).
job.Controls.RamAllocation = 1024 * 1024 * 1024;
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var objectStore = new Mock <IObjectStore>();
var brokerage = new Mock <IBrokerage>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount>());
brokerage.Setup(x => x.GetAccountHoldings()).Returns(getHoldings);
brokerage.Setup(x => x.GetOpenOrders()).Returns(getOrders);
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
var result = setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object));
Assert.AreEqual(expected, result);
foreach (var security in algorithm.Securities.Values)
{
if (security.Symbol.SecurityType == SecurityType.Option)
{
Assert.AreEqual(DataNormalizationMode.Raw, security.DataNormalizationMode);
var underlyingSecurity = algorithm.Securities[security.Symbol.Underlying];
Assert.AreEqual(DataNormalizationMode.Raw, underlyingSecurity.DataNormalizationMode);
}
}
}
private static void Main(string[] args)
{
Write("Select a size field row: ");
var sizeRow = int.Parse(ReadLine());
Write("Select a size field column: ");
var sizeColumn = int.Parse(ReadLine());
Write("Select a count mine: ");
var mine = int.Parse(ReadLine());
var game = new GameField(sizeRow, sizeColumn, mine);
game.GenerateMines();
var field = new Сell(0, 0);
do
{
Clear();
WriteLine("Size: R ={0,4} C ={1,4}; Count mine: {2,4};", game.Size.Row, game.Size.Column, game.CountMines);
Write(game);
if (game.Status == GameStatus.Play)
{
WriteLine("Press the key");
WriteLine("1. Enter your cell");
WriteLine("2. Use the algorithm");
switch (ReadKey().Key)
{
case ConsoleKey.NumPad1:
WriteLine();
field = SelectCell();
break;
default:
field = TestAlgorithm.GetСhoice(game.VisibleСells, game.Marks, game.Size, game.CountMines);
break;
}
WriteLine(field);
game.OpenCell(field);
Write(game);
}
else
{
WriteLine(field);
Write(game.Status);
}
}while (ReadKey().Key != ConsoleKey.Q);
}
public void AlgorithmTimeIsSetToUtcNowBeforePostInitialize()
{
var time = DateTime.UtcNow;
TestAlgorithm algorithm = null;
algorithm = new TestAlgorithm(() =>
{
Assert.That(algorithm.UtcTime > time);
});
Assert.AreEqual(new DateTime(1998, 1, 1), algorithm.UtcTime);
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = new LiveNodePacket
{
UserId = 1,
ProjectId = 1,
DeployId = "1",
Brokerage = "PaperBrokerage",
DataQueueHandler = "none",
Controls = new Controls {
RamAllocation = 4096
} // no real limit
};
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var brokerage = new Mock <IBrokerage>();
var objectStore = new Mock <IObjectStore>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount>());
brokerage.Setup(x => x.GetAccountHoldings()).Returns(new List <Holding>());
brokerage.Setup(x => x.GetOpenOrders()).Returns(new List <Order>());
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
Assert.IsTrue(setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object)));
Assert.Greater(algorithm.UtcTime, time);
}
public void SortsEventsAfterSetup()
{
var realTimeHandler = new BacktestingRealTimeHandler();
var algo = new TestAlgorithm();
algo.SubscriptionManager.SetDataManager(new DataManagerStub(algo));
algo.AddEquity("SPY");
var startDate = new DateTime(2019, 1, 1);
algo.SetStartDate(startDate);
algo.SetDateTime(startDate);
algo.SetEndDate(2020, 1, 1);
var firstCalled = false;
var secondCalled = false;
var events = new List <ScheduledEvent>
{
new ScheduledEvent("1", new List <DateTime> {
startDate.AddMinutes(-10), startDate.AddMinutes(5)
},
(s, time) => { firstCalled = true; }),
new ScheduledEvent("2", new List <DateTime> {
startDate.AddMinutes(1)
},
(s, time) => { secondCalled = true; }),
new ScheduledEvent("3", new List <DateTime> {
startDate.AddMinutes(10)
}, (s, time) => { })
};
foreach (var scheduledEvent in events)
{
realTimeHandler.Add(scheduledEvent);
}
realTimeHandler.Setup(algo,
new AlgorithmNodePacket(PacketType.AlgorithmNode),
new BacktestingResultHandler(),
null,
null);
realTimeHandler.SetTime(startDate.AddMinutes(1));
realTimeHandler.Exit();
Assert.IsTrue(secondCalled);
// 'first' should of been called and should be moved behind 'second' after setup
Assert.IsFalse(firstCalled);
}
public void SkipsLoadingHoldingsAndOrders()
{
var symbol = Symbol.Create("AUDUSD", SecurityType.Forex, Market.Oanda);
var algorithm = new TestAlgorithm();
algorithm.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage);
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = GetJob();
job.BrokerageData["load-existing-holdings"] = "false";
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var brokerage = new Mock <IBrokerage>();
var objectStore = new Mock <IObjectStore>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount>());
brokerage.Setup(x => x.GetAccountHoldings()).Returns(new List <Holding>
{
new Holding {
Symbol = symbol, Type = symbol.SecurityType, Quantity = 100
}
});
brokerage.Setup(x => x.GetOpenOrders()).Returns(new List <Order>
{
new LimitOrder(Symbols.SPY, 1, 1, DateTime.UtcNow)
});
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
Assert.IsTrue(setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object)));
Security security;
Assert.IsFalse(algorithm.Portfolio.Securities.TryGetValue(symbol, out security));
Assert.IsFalse(algorithm.Portfolio.Securities.TryGetValue(Symbols.SPY, out security));
}
public void SeedsSecurityCorrectly()
{
var symbol = Symbol.Create("AUDUSD", SecurityType.Forex, Market.Oanda);
var algorithm = new TestAlgorithm();
algorithm.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage);
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = GetJob();
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var brokerage = new Mock <IBrokerage>();
var objectStore = new Mock <IObjectStore>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount>());
brokerage.Setup(x => x.GetAccountHoldings()).Returns(new List <Holding>
{
new Holding {
Symbol = symbol, Quantity = 100, MarketPrice = 99
}
});
brokerage.Setup(x => x.GetOpenOrders()).Returns(new List <Order>());
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
Assert.IsTrue(setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object, TestGlobals.DataCacheProvider, TestGlobals.MapFileProvider)));
Security security;
Assert.IsTrue(algorithm.Portfolio.Securities.TryGetValue(symbol, out security));
Assert.AreEqual(symbol, security.Symbol);
Assert.AreEqual(99, security.Price);
var last = security.GetLastData();
Assert.IsTrue((DateTime.UtcNow.ConvertFromUtc(security.Exchange.TimeZone) - last.Time) < TimeSpan.FromSeconds(1));
}
public void MetricsChart_OnPopulationChanged_FromOtherPopulation()
{
TestPopulation population = new TestPopulation();
TestAlgorithm algorithm = new TestAlgorithm();
Metric metric1 = Mock.Of <Metric>();
List <MetricResult> metric1Results = new List <MetricResult>
{
new MetricResult(0, 0, 1, metric1),
new MetricResult(0, 1, 2, metric1)
};
metric1.GetResults(0).AddRange(metric1Results);
Metric metric2 = Mock.Of <Metric>();
List <MetricResult> metric2Results = new List <MetricResult>
{
new MetricResult(0, 0, 3, metric1),
new MetricResult(0, 1, 4, metric1)
};
metric2.GetResults(0).AddRange(metric2Results);
algorithm.Metrics.Add(metric1);
algorithm.Metrics.Add(metric2);
VerifyChartRefresh(chart =>
{
chart.Algorithm = new TestAlgorithm();
chart.Population = new TestPopulation();
}, chart =>
{
chart.Algorithm = algorithm;
chart.Population = population;
}, (metric, series) =>
{
if (metric == metric1)
{
Assert.Equal(metric1Results, (ICollection)series.ItemsSource);
}
else if (metric == metric2)
{
Assert.Equal(metric2Results, (ICollection)series.ItemsSource);
}
});
}
private static GeneticAlgorithm CreateTestAlgorithm(bool runsInfinitely = false)
{
TestAlgorithm algorithm = new TestAlgorithm
{
CrossoverOperator = new Mock <CrossoverOperator>(2).Object,
FitnessEvaluator = Mock.Of <FitnessEvaluator>(),
GeneticEntitySeed = new TestEntity(),
PopulationSeed = new TestPopulation(),
SelectionOperator = Mock.Of <SelectionOperator>(),
Terminator = new TestTerminator
{
IsCompleteValue = !runsInfinitely
}
};
return(algorithm);
}
public void MetricsChart_OnSelectedMetricsChanged()
{
TestPopulation population = new TestPopulation();
TestAlgorithm algorithm = new TestAlgorithm();
Metric metric1 = Mock.Of <Metric>();
List <MetricResult> metric1Results = new List <MetricResult>
{
new MetricResult(0, 0, 3, metric1),
new MetricResult(0, 1, 4, metric1)
};
metric1.GetResults(0).AddRange(metric1Results);
algorithm.Metrics.Add(metric1);
Metric metric2 = Mock.Of <Metric>();
List <MetricResult> metric2Results = new List <MetricResult>
{
new MetricResult(0, 0, 3, metric1),
new MetricResult(0, 1, 4, metric1)
};
metric2.GetResults(0).AddRange(metric2Results);
algorithm.Metrics.Add(metric2);
MetricsChart chart = new MetricsChart
{
Algorithm = algorithm,
Population = population
};
Assert.Equal(2, chart.PlotModel.Series.Count);
chart.PlotModel.Series.Clear();
chart.SelectedMetrics = new List <Metric> {
algorithm.Metrics[0]
};
Assert.Single(chart.PlotModel.Series);
}
public void RegisterAndUnregisterCustomAlgorithmTest()
{
Graph graph = new Graph();
IAlgorithm testAlgorithm = new TestAlgorithm();
graph.AlgorithmLibrary.RegisterAlgorithm(testAlgorithm);
Assert.IsTrue(graph.AlgorithmLibrary.ContainsAlgorithm(testAlgorithm.Name));
IAlgorithm retrievedAlgorithm = graph.AlgorithmLibrary.GetAlgorithm(testAlgorithm.Name);
Assert.AreEqual(testAlgorithm, retrievedAlgorithm);
bool result = graph.AlgorithmLibrary.UnregisterAlgorithm(testAlgorithm);
Assert.IsTrue(result);
Assert.IsFalse(graph.AlgorithmLibrary.ContainsAlgorithm(testAlgorithm.Name));
}
public void ToggleSetAttributesTest()
{
Graph graph = new Graph();
Vertex one = graph.GraphStructure.AddVertex(1);
Vertex two = graph.GraphStructure.AddVertex(2);
graph.GraphStructure.AddLine(one, two);
TestAlgorithm test = new TestAlgorithm();
graph.AlgorithmLibrary.RegisterAlgorithm(test);
graph.AlgorithmLibrary.ToggleAlgorithmsShouldSetDynamicAttributesToItems(true);
string visistedAttributeName = test.ReservedDynamicAttributeNames.First();
graph.AlgorithmLibrary.ExecuteBase(test.Name, one);
TestHelper.AssertAttributeValueForVertexIsSet(graph, one, visistedAttributeName, true);
TestHelper.AssertAttributeValueForVertexIsSet(graph, two, visistedAttributeName, true);
}
public void SingleScheduledEventFires_SetTime()
{
var realTimeHandler = new BacktestingRealTimeHandler();
var algo = new TestAlgorithm();
algo.SubscriptionManager.SetDataManager(new DataManagerStub(algo));
algo.AddEquity("SPY");
algo.SetStartDate(2019, 1, 1);
algo.SetDateTime(new DateTime(2019, 1, 1));
algo.SetEndDate(2020, 1, 1);
realTimeHandler.Setup(algo,
new AlgorithmNodePacket(PacketType.AlgorithmNode),
new BacktestingResultHandler(),
null,
null);
realTimeHandler.SetTime(DateTime.UtcNow);
Assert.IsTrue(algo.OnEndOfDayFired);
}
public void LoadsHoldingsForExpectedMarket()
{
var symbol = Symbol.Create("AUDUSD", SecurityType.Forex, Market.Oanda);
var algorithm = new TestAlgorithm();
algorithm.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage);
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = GetJob();
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var brokerage = new Mock <IBrokerage>();
var objectStore = new Mock <IObjectStore>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount>());
brokerage.Setup(x => x.GetAccountHoldings()).Returns(new List <Holding>
{
new Holding {
Symbol = symbol, Quantity = 100
}
});
brokerage.Setup(x => x.GetOpenOrders()).Returns(new List <Order>());
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
Assert.IsTrue(setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object, TestGlobals.DataProvider)));
Security security;
Assert.IsTrue(algorithm.Portfolio.Securities.TryGetValue(symbol, out security));
Assert.AreEqual(symbol, security.Symbol);
}
public void AddsOnEndOfDayEventsIfImplemented(Language language)
{
Security security;
IAlgorithm algorithm;
if (language == Language.CSharp)
{
algorithm = new TestAlgorithm();
security = (algorithm as QCAlgorithm).AddEquity("SPY");
}
else
{
algorithm = new AlgorithmPythonWrapper("OnEndOfDayRegressionAlgorithm");
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(new MockDataFeed(), algorithm));
security = algorithm.AddSecurity(SecurityType.Equity,
"SPY",
Resolution.Daily,
Market.USA,
false,
1,
false);
}
var realTimeHandler = new TestBacktestingRealTimeHandler();
realTimeHandler.Setup(algorithm,
new AlgorithmNodePacket(PacketType.AlgorithmNode)
{
Language = language
},
_resultHandler,
null,
new TestTimeLimitManager());
// the generic OnEndOfDay()
Assert.AreEqual(1, realTimeHandler.GetScheduledEventsCount);
realTimeHandler.OnSecuritiesChanged(
new SecurityChanges(new[] { security }, Enumerable.Empty <Security>()));
Assert.AreEqual(2, realTimeHandler.GetScheduledEventsCount);
realTimeHandler.Exit();
}
public void ExecuteAlgorithmTest()
{
Graph graph = new Graph();
Vertex one = graph.GraphStructure.AddVertex(1);
Vertex two = graph.GraphStructure.AddVertex(2);
graph.GraphStructure.AddLine(one, two);
TestAlgorithm testAlgorithm = new TestAlgorithm();
graph.AlgorithmLibrary.RegisterAlgorithm(testAlgorithm);
Vertex result = graph.AlgorithmLibrary.Execute <Vertex, Vertex>(testAlgorithm.Name, one);
Assert.AreEqual(two, result);
object resultAsObject = graph.AlgorithmLibrary.ExecuteBase(testAlgorithm.Name, one);
Assert.AreEqual(two, resultAsObject);
}
public void LoadsExistingHoldingsAndOrders(Func <List <Holding> > getHoldings, Func <List <Order> > getOrders, bool expected)
{
var algorithm = new TestAlgorithm();
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = GetJob();
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var objectStore = new Mock <IObjectStore>();
var brokerage = new Mock <IBrokerage>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount>());
brokerage.Setup(x => x.GetAccountHoldings()).Returns(getHoldings);
brokerage.Setup(x => x.GetOpenOrders()).Returns(getOrders);
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
var result = setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object, TestGlobals.DataCacheProvider, TestGlobals.MapFileProvider));
Assert.AreEqual(expected, result);
foreach (var security in algorithm.Securities.Values)
{
if (security.Symbol.SecurityType == SecurityType.Option)
{
Assert.AreEqual(DataNormalizationMode.Raw, security.DataNormalizationMode);
var underlyingSecurity = algorithm.Securities[security.Symbol.Underlying];
Assert.AreEqual(DataNormalizationMode.Raw, underlyingSecurity.DataNormalizationMode);
}
}
}
public void EnforcesCashAmounts()
{
var algorithm = new TestAlgorithm();
algorithm.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage);
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = GetJob();
job.BrokerageData["max-cash-limit"] = "[{\"amount\":20, \"currency\": \"USD\"}, {\"Amount\":1, \"Currency\": \"EUR\"}]";
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var brokerage = new Mock <IBrokerage>();
var objectStore = new Mock <IObjectStore>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount> {
new CashAmount(10000, Currencies.USD), new CashAmount(11, Currencies.GBP)
});
brokerage.Setup(x => x.GetAccountHoldings()).Returns(new List <Holding>());
brokerage.Setup(x => x.GetOpenOrders()).Returns(new List <Order>());
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
Assert.IsTrue(setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object)));
Assert.AreEqual(20, algorithm.Portfolio.CashBook[Currencies.USD].Amount);
Assert.IsFalse(algorithm.Portfolio.CashBook.ContainsKey(Currencies.GBP));
Assert.IsFalse(algorithm.Portfolio.CashBook.ContainsKey(Currencies.EUR));
}
public void AlgorithmTimeIsSetToUtcNowBeforePostInitialize()
{
var time = DateTime.UtcNow;
TestAlgorithm algorithm = null;
algorithm = new TestAlgorithm(() =>
{
Assert.That(algorithm.UtcTime > time);
});
Assert.AreEqual(new DateTime(1998, 1, 1), algorithm.UtcTime);
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = GetJob();
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var brokerage = new Mock <IBrokerage>();
var objectStore = new Mock <IObjectStore>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount>());
brokerage.Setup(x => x.GetAccountHoldings()).Returns(new List <Holding>());
brokerage.Setup(x => x.GetOpenOrders()).Returns(new List <Order>());
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
Assert.IsTrue(setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object, TestGlobals.DataCacheProvider, TestGlobals.MapFileProvider)));
Assert.Greater(algorithm.UtcTime, time);
}
public void EnforcesTotalPortfolioValue(bool fails)
{
var algorithm = new TestAlgorithm();
algorithm.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage);
algorithm.SetHistoryProvider(new TestHistoryProvider());
var job = GetJob();
job.BrokerageData[BrokerageSetupHandler.MaxAllocationLimitConfig] = fails ? "1" : "1000000000";
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var brokerage = new Mock <IBrokerage>();
var objectStore = new Mock <IObjectStore>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount> {
new CashAmount(10000, Currencies.USD), new CashAmount(11, Currencies.GBP)
});
brokerage.Setup(x => x.GetAccountHoldings()).Returns(new List <Holding>());
brokerage.Setup(x => x.GetOpenOrders()).Returns(new List <Order>());
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
Assert.AreEqual(!fails, setupHandler.Setup(new SetupHandlerParameters(algorithm.DataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object, TestGlobals.DataCacheProvider, TestGlobals.MapFileProvider)));
Assert.AreEqual(10000, algorithm.Portfolio.CashBook[Currencies.USD].Amount);
Assert.AreEqual(11, algorithm.Portfolio.CashBook[Currencies.GBP].Amount);
}
public void ExistingHoldingsAndOrdersResolution(Func <List <Holding> > getHoldings, Func <List <Order> > getOrders, bool expected, Resolution resolution)
{
var algorithm = new TestAlgorithm {
UniverseSettings = { Resolution = resolution }
};
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = GetJob();
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var objectStore = new Mock <IObjectStore>();
var brokerage = new Mock <IBrokerage>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount>());
brokerage.Setup(x => x.GetAccountHoldings()).Returns(getHoldings);
brokerage.Setup(x => x.GetOpenOrders()).Returns(getOrders);
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
var result = setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object, TestGlobals.DataCacheProvider, TestGlobals.MapFileProvider));
Assert.AreEqual(expected, result);
foreach (var symbol in algorithm.Securities.Keys)
{
var configs = algorithm.SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol);
Assert.AreEqual(algorithm.UniverseSettings.Resolution, configs.First().Resolution);
}
}
public void ClearSetAttributesTest()
{
Graph graph = new Graph();
Vertex one = graph.GraphStructure.AddVertex(1);
Vertex two = graph.GraphStructure.AddVertex(2);
graph.GraphStructure.AddLine(one, two);
TestAlgorithm test = new TestAlgorithm();
test.SetDynamicAttributesInStructure = true;
graph.AlgorithmLibrary.RegisterAlgorithm(test);
string visistedAttributeName = test.ReservedDynamicAttributeNames.First();
graph.AlgorithmLibrary.ExecuteBase(test.Name, one);
TestHelper.AssertAttributeValueForVertexIsSet(graph, one, visistedAttributeName, true);
TestHelper.AssertAttributeValueForVertexIsSet(graph, two, visistedAttributeName, true);
graph.AlgorithmLibrary.ClearDynamicAttributesSetByAlgorithm(test.Name);
TestHelper.AssertAttributeValueForVertexIsNotSet(graph, one, visistedAttributeName);
TestHelper.AssertAttributeValueForVertexIsNotSet(graph, two, visistedAttributeName);
}
private async Task TestRefreshChartScenario(FitnessType fitnessType, FitnessSortOption fitnessSortOption,
bool switchPopulations, bool createNewGeneration, bool completeAlgorithm, bool elapseTime)
{
TimeSpan elapsedTime = TimeSpan.FromSeconds(0);
Mock <IStopwatch> stopwatchMock = new Mock <IStopwatch>();
stopwatchMock
.SetupGet(o => o.Elapsed)
.Returns(() => elapsedTime);
Mock <IStopwatchFactory> stopwatchFactoryMock = new Mock <IStopwatchFactory>();
stopwatchFactoryMock
.Setup(o => o.Create())
.Returns(stopwatchMock.Object);
FitnessChart chart = new FitnessChart(stopwatchFactoryMock.Object)
{
FitnessSortOption = fitnessSortOption,
FitnessType = fitnessType
};
PlotModel model = chart.PlotModel;
CategoryAxis axis = (CategoryAxis)model.Axes[0];
axis.Labels.Add("test"); // Add test label to ensure it gets cleared
TestAlgorithm algorithm = new TestAlgorithm
{
MinimumEnvironmentSize = 2,
PopulationSeed = new TestPopulation()
{
MinimumPopulationSize = 5
},
FitnessEvaluator = new TestFitnessEvaluator(),
GeneticEntitySeed = new TestEntity(),
SelectionOperator = new TestSelectionOperator(),
Terminator = new TestTerminator()
};
await algorithm.InitializeAsync();
if (switchPopulations)
{
chart.Population = algorithm.Environment.Populations[1];
}
Population population = algorithm.Environment.Populations[0];
TestEntity[] entities = population.Entities.Cast <TestEntity>().ToArray();
entities[0].RawFitnessValue = 2;
entities[1].RawFitnessValue = 0;
entities[2].RawFitnessValue = 1;
entities[3].RawFitnessValue = 4;
entities[4].RawFitnessValue = 3;
entities[0].ScaledFitnessValue = 0;
entities[1].ScaledFitnessValue = 3;
entities[2].ScaledFitnessValue = 2;
entities[3].ScaledFitnessValue = 4;
entities[4].ScaledFitnessValue = 1;
entities[0].CompareFactor = 4;
entities[1].CompareFactor = 0;
entities[2].CompareFactor = 3;
entities[3].CompareFactor = 2;
entities[4].CompareFactor = 1;
// Set the Population which will trigger the logic to test
chart.Population = population;
stopwatchFactoryMock.Verify(o => o.Create(), Times.Once());
stopwatchMock.Verify(o => o.Start(), Times.Once());
stopwatchMock.Verify(o => o.Restart(), switchPopulations ? Times.Exactly(2) : Times.Once());
List <GeneticEntity> sortedEntities;
if (fitnessSortOption == FitnessSortOption.Entity)
{
sortedEntities = new List <GeneticEntity>
{
entities[1],
entities[4],
entities[3],
entities[2],
entities[0],
};
}
else
{
if (fitnessType == FitnessType.Raw)
{
sortedEntities = new List <GeneticEntity>
{
entities[1],
entities[2],
entities[0],
entities[4],
entities[3],
};
}
else
{
sortedEntities = new List <GeneticEntity>
{
entities[0],
entities[4],
entities[2],
entities[1],
entities[3],
};
}
}
ColumnSeries columnSeries = (ColumnSeries)model.Series[0];
if (fitnessType == FitnessType.Scaled)
{
Assert.Equal(nameof(GeneticEntity.ScaledFitnessValue), columnSeries.ValueField);
}
else
{
Assert.Equal(nameof(GeneticEntity.RawFitnessValue), columnSeries.ValueField);
}
Assert.Equal(sortedEntities, columnSeries.ItemsSource.Cast <object>().ToList());
Assert.Equal(algorithm.PopulationSeed.MinimumPopulationSize, axis.Labels.Count);
for (int i = 0; i < algorithm.PopulationSeed.MinimumPopulationSize; i++)
{
Assert.Equal("", axis.Labels[i]);
}
if (createNewGeneration)
{
if (elapseTime)
{
// Ensure that enough time has passed for refresh to occur
elapsedTime = TimeSpan.FromSeconds(5);
}
// Create next generation to cause the chart to be refresh again
await algorithm.StepAsync();
if (elapseTime)
{
Assert.NotEqual(sortedEntities,
columnSeries.ItemsSource.Cast <object>().ToList());
}
}
if (completeAlgorithm)
{
if (elapseTime)
{
// Ensure that enough time has passed for refresh to occur
elapsedTime = TimeSpan.FromSeconds(5);
}
((TestTerminator)algorithm.Terminator).IsCompleteValue = true;
// Create next generation to cause the chart to be refresh again
await algorithm.StepAsync();
if (createNewGeneration && elapseTime)
{
Assert.NotEqual(sortedEntities,
columnSeries.ItemsSource.Cast <object>().ToList());
}
else
{
Assert.Equal(sortedEntities,
columnSeries.ItemsSource.Cast <object>().ToList());
}
}
// Set the population to null to verify the series gets cleared
chart.Population = null;
Assert.Null(columnSeries.ItemsSource);
}
public void Play()
{
for (var direction = Move.None; gameField.Status == GameStatus.Play; direction = TestAlgorithm.GetMove(gameField.Kite.Body, gameField.Kite.Head, gameField.Food))
{
Clear();
ShowGameField();
gameField.MakeMove(direction);
ReadKey();
}
}
public static void DepthFirstSearch_Test4()
{
TestAlgorithm(Algorithms.Other.FloodFill.DepthFirstSearch, (1, 1), green, orange, (6, 4), white);
}
public static void DepthFirstSearch_Test3()
{
TestAlgorithm(Algorithms.Other.FloodFill.DepthFirstSearch, (1, 1), green, orange, (0, 1), violet);
}
public static void BreadthFirstSearch_Test1()
{
TestAlgorithm(Algorithms.Other.FloodFill.BreadthFirstSearch, (1, 1), green, orange, (1, 1), orange);
}
public void HasErrorWithZeroTotalPortfolioValue(bool hasCashBalance, bool hasHoldings)
{
var algorithm = new TestAlgorithm();
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = new LiveNodePacket
{
UserId = 1,
ProjectId = 1,
DeployId = "1",
Brokerage = "TestBrokerage",
DataQueueHandler = "none",
Controls = new Controls {
RamAllocation = 4096
} // no real limit
};
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var brokerage = new Mock <IBrokerage>();
var objectStore = new Mock <IObjectStore>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.GetCashBalance()).Returns(
hasCashBalance
? new List <CashAmount>
{
new CashAmount(1000, "USD")
}
: new List <CashAmount>()
);
brokerage.Setup(x => x.GetAccountHoldings()).Returns(
hasHoldings
? new List <Holding>
{
new Holding {
Type = SecurityType.Equity, Symbol = Symbols.SPY, Quantity = 1, AveragePrice = 100, MarketPrice = 100
}
}
: new List <Holding>());
brokerage.Setup(x => x.GetOpenOrders()).Returns(new List <Order>());
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
var dataManager = new DataManagerStub(algorithm, new MockDataFeed(), true);
Assert.IsTrue(setupHandler.Setup(new SetupHandlerParameters(dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object)));
if (hasCashBalance || hasHoldings)
{
Assert.AreEqual(0, algorithm.DebugMessages.Count);
}
else
{
Assert.AreEqual(1, algorithm.DebugMessages.Count);
Assert.That(algorithm.DebugMessages.First().Contains("No cash balances or holdings were found in the brokerage account."));
}
}
public void ExistingHoldingsAndOrdersUniverseSettings(Func <List <Holding> > getHoldings, Func <List <Order> > getOrders, bool expected)
{
// Set our universe settings
var hasCrypto = false;
try
{
hasCrypto = getHoldings().Any(x => x.Symbol.Value == "BTCUSD");
}
catch
{
}
var algorithm = new TestAlgorithm {
UniverseSettings = { Resolution = Resolution.Daily, Leverage = (hasCrypto ? 1 : 20), FillForward = false, ExtendedMarketHours = true }
};
algorithm.SetHistoryProvider(new BrokerageTransactionHandlerTests.BrokerageTransactionHandlerTests.EmptyHistoryProvider());
var job = GetJob();
var resultHandler = new Mock <IResultHandler>();
var transactionHandler = new Mock <ITransactionHandler>();
var realTimeHandler = new Mock <IRealTimeHandler>();
var objectStore = new Mock <IObjectStore>();
var brokerage = new Mock <IBrokerage>();
brokerage.Setup(x => x.IsConnected).Returns(true);
brokerage.Setup(x => x.AccountBaseCurrency).Returns(Currencies.USD);
brokerage.Setup(x => x.GetCashBalance()).Returns(new List <CashAmount>());
brokerage.Setup(x => x.GetAccountHoldings()).Returns(getHoldings);
brokerage.Setup(x => x.GetOpenOrders()).Returns(getOrders);
var setupHandler = new BrokerageSetupHandler();
IBrokerageFactory factory;
setupHandler.CreateBrokerage(job, algorithm, out factory);
var result = setupHandler.Setup(new SetupHandlerParameters(_dataManager.UniverseSelection, algorithm, brokerage.Object, job, resultHandler.Object,
transactionHandler.Object, realTimeHandler.Object, objectStore.Object, TestGlobals.DataCacheProvider, TestGlobals.MapFileProvider));
if (result != expected)
{
Assert.Fail("SetupHandler result did not match expected value");
}
foreach (var symbol in algorithm.Securities.Keys)
{
var config = algorithm.SubscriptionManager.SubscriptionDataConfigService.GetSubscriptionDataConfigs(symbol).First();
// Assert Resolution and FillForward settings persisted
Assert.AreEqual(algorithm.UniverseSettings.Resolution, config.Resolution);
Assert.AreEqual(algorithm.UniverseSettings.FillForward, config.FillDataForward);
// Assert ExtendedHours setting persisted for equities
if (config.SecurityType == SecurityType.Equity)
{
Assert.AreEqual(algorithm.UniverseSettings.ExtendedMarketHours, config.ExtendedMarketHours);
}
// Assert Leverage setting persisted for non options or futures (Blocked from setting leverage in Security.SetLeverage())
if (!symbol.SecurityType.IsOption() && symbol.SecurityType != SecurityType.Future)
{
var security = algorithm.Securities[symbol];
Assert.AreEqual(algorithm.UniverseSettings.Leverage, security.Leverage);
}
}
}
