public DataCash3DSecureRequestBuilder(DataCash3DSecureConfiguration configuration, HttpRequestBase httpRequest)
: base(configuration)
{
if (httpRequest == null) throw new ArgumentNullException("httpRequest");
_configuration = configuration;
_httpRequest = httpRequest;
SystemTime = new TimeProvider();
}
protected TimerState(MainWindow mainWindow, TimeProvider timeProvider, State state)
{
mainWindow.Should().NotBeNull();
timeProvider.Should().NotBeNull();
this.MainWindow = mainWindow;
this.Timer = timeProvider.GetTime();
this.State = state;
this.UpdateMainWindow();
}
private TimerState CreateTimerState(State nextState, TimeProvider timeProvider)
{
timeProvider.Should().NotBeNull();
(State != nextState).Should().BeTrue();
switch (nextState)
{
case State.Idle: return new Idle (MainWindow, timeProvider);
case State.PreparationRunning: return new PreparationRunning (MainWindow, timeProvider);
case State.PreparationPaused: return new PreparationPaused (MainWindow, timeProvider);
case State.PresentationRunning: return new PresentationRunning(MainWindow, timeProvider);
case State.PresentationPaused: return new PresentationPaused (MainWindow, timeProvider);
case State.QuestionsRunning: return new QuestionsRunning (MainWindow, timeProvider);
case State.QuestionsPaused: return new QuestionsPaused (MainWindow, timeProvider);
default: throw new ArgumentException("Requested state doesn't exist.");
}
}
public void GetInfo_JustCreated_ReturnsValidResult()
{
// Arrange
using IJobManager jobManager = TestHelper.CreateJobManager(true);
var start = "2000-01-01Z".ToUtcDateOffset();
var timeMachine = ShiftedTimeProvider.CreateTimeMachine(start);
TimeProvider.Override(timeMachine);
var job = jobManager.Create("my-job");
// Act
var info = job.GetInfo(null);
// Assert
Assert.That(info.CurrentRun, Is.Null);
Assert.That(info.NextDueTime, Is.EqualTo(TestHelper.NeverCopy));
Assert.That(info.NextDueTimeIsOverridden, Is.False);
Assert.That(info.RunCount, Is.Zero);
Assert.That(info.Runs, Is.Empty);
}
public void Callback_UInt32_MultipleIntervalHitInSingleAdvance()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
object expectedState = new object();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }, null, 100u, 50u))
{
delorean.Advance(100);
Assert.AreEqual(1, fired);
delorean.Advance(150);
Assert.AreEqual(4, fired);
}
}
}
public FilterSpecCompilerArgs(
IContainer container,
IDictionary<string, Pair<EventType, string>> taggedEventTypes,
IDictionary<string, Pair<EventType, string>> arrayEventTypes,
ExprEvaluatorContext exprEvaluatorContext,
string statementName,
int statementId,
StreamTypeService streamTypeService,
EngineImportService engineImportService,
TimeProvider timeProvider,
VariableService variableService,
TableService tableService,
EventAdapterService eventAdapterService,
FilterBooleanExpressionFactory filterBooleanExpressionFactory,
ScriptingService scriptingService,
Attribute[] annotations,
ContextDescriptor contextDescriptor,
ConfigurationInformation configurationInformation,
StatementExtensionSvcContext statementExtensionSvcContext)
{
Container = container;
TaggedEventTypes = taggedEventTypes;
ArrayEventTypes = arrayEventTypes;
ExprEvaluatorContext = exprEvaluatorContext;
StatementName = statementName;
StatementId = statementId;
StreamTypeService = streamTypeService;
EngineImportService = engineImportService;
TimeProvider = timeProvider;
VariableService = variableService;
TableService = tableService;
EventAdapterService = eventAdapterService;
FilterBooleanExpressionFactory = filterBooleanExpressionFactory;
ScriptingService = scriptingService;
Annotations = annotations;
ContextDescriptor = contextDescriptor;
ConfigurationInformation = configurationInformation;
StatementExtensionSvcContext = statementExtensionSvcContext;
}
public void Change_TimeSpan_HasInitialAndInterval()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }))
{
timer.Change(TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100));
delorean.Advance(100);
Assert.AreEqual(1, fired);
delorean.Advance(100);
Assert.AreEqual(2, fired);
}
}
}
public void LocationShouldAllowUserToPlaceMoreOrdersAfterTwoHours()
{
var location = new Location(100);
var user = CreateUser(location);
var orders = new List <IOrder>
{
location.SuggestOrder(user),
location.SuggestOrder(user),
location.SuggestOrder(user)
};
var overTwoHoursAgo = new PastTimeProvider(new TimeSpan(hours: 2, minutes: 10, seconds: 0));
ICollection <IOrder> rejected = null;
try
{
// order 130 minutes in the past
TimeProvider.Current = overTwoHoursAgo;
rejected = location.Order(user, orders);
}
finally
{
// reset time
TimeProvider.ResetToDefault();
}
// first order accepted
Assert.Empty(rejected);
// place more orders again in the present
var orders2 = new List <IOrder>
{
location.SuggestOrder(user),
location.SuggestOrder(user),
location.SuggestOrder(user)
};
rejected = location.Order(user, orders2);
// all orders should be accepted
Assert.Empty(rejected);
}
public async Task ForceStart_IsEnabledAndNotRunning_Starts()
{
// Arrange
using IJobManager jobManager = TestHelper.CreateJobManager(true);
var start = "2000-01-01Z".ToUtcDateOffset();
var timeMachine = ShiftedTimeProvider.CreateTimeMachine(start);
TimeProvider.Override(timeMachine);
var job = jobManager.Create("my-job");
job.IsEnabled = true;
job.Routine = async(parameter, tracker, output, token) =>
{
await output.WriteAsync("Hello!");
await Task.Delay(300, token);
};
// Act
job.ForceStart();
var info1 = job.GetInfo(null);
await timeMachine.WaitUntilSecondsElapse(start, 0.6);
var info2 = job.GetInfo(null);
// Assert
Assert.That(info1.CurrentRun, Is.Not.Null);
Assert.That(info1.CurrentRun.Value.StartReason, Is.EqualTo(JobStartReason.Force));
var run = info2.Runs.Single();
Assert.That(run.StartReason, Is.EqualTo(JobStartReason.Force));
}
//Test when three shots are taken with 6 seconds between shots
public void ShootGruntWithPulseRifle()
{
Weapon testWeapon = new PulseRifle();
Enemy testEnemy = new Grunt();
var timeMock = new Mock <TimeProvider>();
timeMock.SetupGet(tp => tp.UtcNow).Returns(DateTime.UtcNow);
TimeProvider.Current = timeMock.Object;
testWeapon.AddAmmo(3);
for (int i = 0; i < 3; i++)
{
testWeapon.Shoot(testEnemy);
timeMock.SetupGet(tp => tp.UtcNow).Returns(DateTime.UtcNow.AddSeconds(6));
TimeProvider.Current = timeMock.Object;
}
TimeProvider.ResetToDefault();
int test = Grunt.Grunt_Starting_Energy - (3 * PulseRifle.Pulse_Rifle_Damage_Points);
Assert.AreEqual(test, testEnemy.EnergyRemaining);
}
public void TwoNotificationAtSameTime()
{
var time = new TimeProvider();
Message result = null;
var manager =
new Scheduler((t, b, n) => { result = new Message {
Title = t, Body = b, Name = n
}; }, time.GetNow);
manager.Enqueue("遠征終了", 1, "防空射撃演習");
manager.Enqueue("疲労回復49", 1, "cond49");
manager.Flush();
PAssert.That(() => new Message {
Title = "遠征が終わりました", Body = "第二艦隊 防空射撃演習", Name = "遠征終了"
}.Equals(result));
result = null;
manager.Flush();
PAssert.That(() => result == null);
manager.Flush();
PAssert.That(() => new Message {
Title = "疲労が回復しました", Body = "第二艦隊", Name = "疲労回復"
}.Equals(result));
}
public void TestSetup()
{
// protect against external changes on TimeProvider
TimeProvider.ResetToDefault();
TestBlockchain.InitializeMockNeoSystem();
// Create a MemoryPool with capacity of 100
_unit = new MemoryPool(new NeoSystem(ProtocolSettings.Default with {
MemoryPoolMaxTransactions = 100
}));
// Verify capacity equals the amount specified
_unit.Capacity.Should().Be(100);
_unit.VerifiedCount.Should().Be(0);
_unit.UnVerifiedCount.Should().Be(0);
_unit.Count.Should().Be(0);
_unit2 = new MemoryPool(new NeoSystem(ProtocolSettings.Default with {
MemoryPoolMaxTransactions = 0
}));
plugin = new TestIMemoryPoolTxObserverPlugin();
}
protected override void DoWork()
{
CurrentTask.State = ExecutionState.Running;
if (CurrentTask.StartTime.Value + CurrentTask.Estimation > TimeProvider.GetUtcNow())
{
return;
}
int FailNumber = int.Parse(CurrentTask.From.CustomFormat.Substring(CurrentTask.From.CustomFormat.Length - 1));
//CurrentTask.EndTime = TimeProvider.GetUtcNow();
if (CurrentTask.NumberOfRetries < FailNumber)
{
CurrentTask.State = ExecutionState.Failed;
Release(CurrentTask);
}
else
{
CurrentTask.State = ExecutionState.Done;
Debug.WriteLine($"{Urn} > {CurrentTask.Urn} done @ {CurrentTask.EndTime:s}.");
}
}
public async Task GetInfo_ArgumentIsZero_ReturnsEmptyRuns()
{
// Arrange
using IJobManager jobManager = TestHelper.CreateJobManager(true);
var start = "2000-01-01Z".ToUtcDateOffset();
var timeMachine = ShiftedTimeProvider.CreateTimeMachine(start);
TimeProvider.Override(timeMachine);
var job = jobManager.Create("my-job");
job.IsEnabled = true;
job.Routine = async(parameter, tracker, output, token) =>
{
await output.WriteAsync(parameter.ToString());
};
for (var i = 0; i < 10; i++)
{
var copy = i;
job.Parameter = copy;
job.ForceStart();
await Task.Delay(100); // let job finish.
}
// Act
var info = job.GetInfo(0);
// Assert
Assert.That(info.CurrentRun, Is.Null);
Assert.That(info.NextDueTime, Is.EqualTo(TestHelper.NeverCopy));
Assert.That(info.NextDueTimeIsOverridden, Is.False);
Assert.That(info.RunCount, Is.EqualTo(10));
Assert.That(info.Runs, Is.Empty);
}
public bool Update(PotUser entity)
{
Check.IsNotNull(entity, "Pot participant should be provided");
var updated = false;
entity.ModificationDate = TimeProvider.Now();
_logger.Info("Start updating user pot");
try
{
using (var con = new DatabaseConnection(DatabaseType.PostgreSql, GetConnectionString()))
{
using (var cmd = con.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = UpdateQuery;
cmd.AddIntParameter(":pPOTIDT", entity.PotId);
cmd.AddIntParameter(":pUSRIDT", entity.UserId);
cmd.AddStringParameter(":pINDPAY", ConverterHelper.BoolToYesNoString(entity.HasPayed));
cmd.AddDoubleParameter(":pCURMNT", entity.Amount);
cmd.AddDoubleParameter(":pTGTMNT", entity.TargetAmount);
cmd.AddStringParameter(":pCANCELRSN", entity.CancellationReason);
cmd.AddStringParameter(":pINDCANCEL", ConverterHelper.BoolToYesNoString(entity.HasCancelled));
cmd.AddStringParameter(":pINDVAL", ConverterHelper.BoolToYesNoString(entity.HasValidated));
cmd.AddDateTimeParameter(":pDATEFT", entity.ModificationDate);
updated = cmd.ExecuteNonQuery() > 0;
_logger.Info("End updating user pot : " + (updated ? "Success" : "Failure"));
}
}
}
catch (Exception ex)
{
_logger.Error("Error while trying to update user pot with query : " + UpdateQuery, ex);
throw new ImportExportException("Error occured during database access " + ex.Message, ex);
}
return(updated);
}
/// <summary>
/// Retrieves the date time from specified provider and defend against flooding
/// </summary>
internal static DateTime?GetTime(TimeProvider provider)
{
//Max requests are every 4 seconds
if (!CanRequestTime(provider))
{
throw new Exception("Too many time requests!");
}
DateTime?dateTime;
switch (provider)
{
case TimeProvider.Nist:
dateTime = TimeRetrieverNtp.GetNtpTime("time-a.nist.gov");
break;
case TimeProvider.Microsoft:
dateTime = TimeRetrieverNtp.GetNtpTime("time.windows.com");
break;
case TimeProvider.Google:
dateTime = TimeRetrieverNtp.GetNtpTime("time.google.com");
break;
case TimeProvider.NtpOrg:
dateTime = TimeRetrieverNtp.GetNtpTime("pool.ntp.org");
break;
default:
throw new ArgumentOutOfRangeException(nameof(provider), provider, null);
}
//We don't use the LunaComputerTime as we need that this value is not affected by offsets
TimeProviderLastRequests[provider] = DateTime.UtcNow;
return(dateTime);
}
public void ProgressTracker_JobIsDisposedThenValueIsSet_ThrowsJobObjectDisposedException()
{
// Arrange
using IJobManager jobManager = TestHelper.CreateJobManager(true);
var start = "2000-01-01Z".ToUtcDateOffset();
var timeMachine = ShiftedTimeProvider.CreateTimeMachine(start);
TimeProvider.Override(timeMachine);
var job = jobManager.Create("my-job");
var tracker1 = new MockProgressTracker();
var tracker2 = new MockProgressTracker();
// Act
job.ProgressTracker = tracker1;
job.Dispose();
var ex = Assert.Throws <JobObjectDisposedException>(() => job.ProgressTracker = tracker2);
// Assert
Assert.That(job.ProgressTracker, Is.EqualTo(tracker1));
Assert.That(ex.ObjectName, Is.EqualTo("my-job"));
}
public void Callback_TimeSpan_HasInitialGreaterThanInterval()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => fired++, null, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(50)))
{
delorean.Advance(50);
Assert.AreEqual(0, fired);
delorean.Advance(50);
Assert.AreEqual(1, fired);
delorean.Advance(50);
Assert.AreEqual(2, fired);
}
}
}
public bool Update(UserTrip entity)
{
Check.IsNotNull(entity, "UserTrip should not be null");
bool updated = false;
entity.ModificationDate = TimeProvider.Now();
_logger.Info("Start update user's trip");
try
{
using (var con = new DatabaseConnection(DatabaseType.PostgreSql, GetConnectionString()))
{
using (var cmd = con.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = UpdateQuery;
cmd.AddStringParameter(":pINDUSRPAR", ConverterHelper.BoolToYesNoString(entity.HasParticipated));
cmd.AddStringParameter(":pINDUSRORG", ConverterHelper.BoolToYesNoString(entity.HasOrganized));
cmd.AddDoubleParameter(":pUSRNOT", entity.UserNote);
cmd.AddDoubleParameter(":pTRPMNT", entity.TripAmount);
cmd.AddIntParameter(":pUSRIDT", entity.UserId);
cmd.AddStringParameter(":pTRPNAM", entity.TripName);
cmd.AddDateTimeParameter(":pDATEFT", entity.ModificationDate);
updated = cmd.ExecuteNonQuery() > 0;
_logger.Info("End update user's trip : " + (updated ? "Success" : "Failure"));
}
}
}
catch (Exception ex)
{
_logger.Error("Error while updating user's trip with query" + UpdateQuery, ex);
throw new ImportExportException("Error occured during database access " + ex.Message, ex);
}
return(updated);
}
void Update()
{
if (!gameRunning)
{
return;
}
var elapsed = DateTime.Now.TimeOfDay - realStartTime;
var simulationTime = simulationStartTime + elapsed + TimeSpan.FromSeconds(penaltyTime);
if (simulationTime >= TimeSpan.FromHours(12))
{
gameRunning = false;
simulationTime = TimeSpan.FromHours(12);
StopAllCoroutines();
ClearAllGoblins();
gameOverText.text = "Game Over!\nScore: " + (int)elapsed.TotalSeconds;
gameOverText.gameObject.SetActive(true);
}
TimeProvider.UpdateOverrideTime(simulationTime);
}
public void Get_Set_OColor()
{
TimeProvider.SetToday(new DateTime(2008, 1, 1));
Alert alert = new Alert {
EffectDate = new DateTime(2006, 1, 1), Amount = 1000
};
Assert.AreEqual(OAlertColors.Color1, alert.Color);
alert.EffectDate = new DateTime(2007, 4, 1);
Assert.AreEqual(OAlertColors.Color2, alert.Color);
alert.EffectDate = new DateTime(2007, 10, 1);
Assert.AreEqual(OAlertColors.Color3, alert.Color);
alert.EffectDate = new DateTime(2007, 11, 1);
Assert.AreEqual(OAlertColors.Color4, alert.Color);
alert.EffectDate = new DateTime(2007, 12, 1);
Assert.AreEqual(OAlertColors.Color5, alert.Color);
alert.EffectDate = new DateTime(2007, 12, 6);
Assert.AreEqual(OAlertColors.Color6, alert.Color);
alert.EffectDate = new DateTime(2008, 1, 1);
Assert.AreEqual(OAlertColors.Color7, alert.Color);
Alert alertSavings = new Alert {
EffectDate = new DateTime(2006, 1, 1), Amount = -1000
};
Assert.AreEqual(OAlertColors.Color1, alertSavings.Color);
TimeProvider.SetToday(DateTime.Today);
}
public void Callback_UInt32_HasInitialGreaterThanInterval()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => fired++, null, 100u, 50u))
{
delorean.Advance(50);
Assert.AreEqual(0, fired);
delorean.Advance(50);
Assert.AreEqual(1, fired);
delorean.Advance(50);
Assert.AreEqual(2, fired);
}
}
}
public void ManualFlashTest()
{
var cs = new CherryService();
var tp = new TimeProvider();
var ps = new PomodoroSensor();
var ic = new IconController();
var icn = new CherryTomato.Reminders.SystrayIconNotifier.IconNotifier();
cs.PluginRepository.RegisterPlugin(tp);
cs.PluginRepository.RegisterPlugin(ps);
cs.PluginRepository.RegisterPlugin(ic);
cs.PluginRepository.RegisterPlugin(icn);
cs.InitializeCherryServiceEventsAndCommands();
cs.PluginRepository.TieEvents();
icn.Notify(new IconNotification {
FlashCount = 10, FlashIconPath = "res://pomodoro.ico", NotificationText = "Flash test"
});
Assert.That(MessageBox.Show("Did the icon flash?", "Manual assert", MessageBoxButtons.YesNo),
Is.EqualTo(DialogResult.Yes));
cs.Dispose();
}
public void Output_JobIsDisposedThenValueIsSet_ThrowsJobObjectDisposedException()
{
// Arrange
using IJobManager jobManager = TestHelper.CreateJobManager(true);
var start = "2000-01-01Z".ToUtcDateOffset();
var timeMachine = ShiftedTimeProvider.CreateTimeMachine(start);
TimeProvider.Override(timeMachine);
var job = jobManager.Create("my-job");
var writer1 = new StringWriterWithEncoding(Encoding.UTF8);
var writer2 = new StringWriterWithEncoding(Encoding.UTF8);
// Act
job.Output = writer1;
job.Dispose();
var ex = Assert.Throws <JobObjectDisposedException>(() => job.Output = writer2);
// Assert
Assert.That(job.Output, Is.EqualTo(writer1));
Assert.That(ex.ObjectName, Is.EqualTo("my-job"));
}
public async Task Routine_SetAfterPreviousRunCompleted_SetsValueAndRunsWithIt()
{
// Arrange
using IJobManager jobManager = TestHelper.CreateJobManager(true);
var job = jobManager.Create("my-job");
var start = "2000-01-01Z".ToUtcDateOffset();
var timeMachine = ShiftedTimeProvider.CreateTimeMachine(start);
TimeProvider.Override(timeMachine);
var output = new StringWriterWithEncoding(Encoding.UTF8);
job.Output = output;
JobDelegate routine1 = async(parameter, tracker, writer, token) =>
{
await writer.WriteAsync("First Routine!");
await Task.Delay(1500, token);
};
JobDelegate routine2 = async(parameter, tracker, writer, token) =>
{
await writer.WriteAsync("Second Routine!");
await Task.Delay(1500, token);
};
job.Schedule = new ConcreteSchedule(
start.AddSeconds(1),
start.AddSeconds(4));
job.IsEnabled = true;
// Act
job.Routine = routine1;
var updatedRoutine1 = job.Routine;
await timeMachine.WaitUntilSecondsElapse(start, 2.9); // job with routine1 will complete
var output1 = output.ToString();
await timeMachine.WaitUntilSecondsElapse(start, 3.0);
job.Routine = routine2;
var updatedRoutine2 = job.Routine;
await timeMachine.WaitUntilSecondsElapse(start, 6.0);
var output2 = output.ToString();
// Assert
try
{
Assert.That(updatedRoutine1, Is.SameAs(routine1));
Assert.That(output1, Is.EqualTo("First Routine!"));
Assert.That(updatedRoutine2, Is.SameAs(routine2));
Assert.That(output2, Is.EqualTo("First Routine!Second Routine!"));
}
catch (Exception ex)
{
var sb = new StringBuilder();
sb.AppendLine("*** Test Failed ***");
sb.AppendLine(ex.ToString());
sb.AppendLine("*** Log: ***");
var log = _logWriter.ToString();
sb.AppendLine(log);
Assert.Fail(sb.ToString());
}
}
public async Task CanOperateFridge()
{
using (TimeProvider.StartUsing(timeProvider))
{
fridge.StateString.Should().Be("Closed Idle Light off");
await fridge.TemperatureChanges(40);
fridge.StateString.Should().Be("Closed Cooling Light off");
await fridge.TemperatureChanges(33);
fridge.StateString.Should().Be("Closed Idle Light off");
await fridge.DoorOpens();
fridge.StateString.Should().Be("Open Idle Light on");
await fridge.TemperatureChanges(40);
fridge.StateString.Should().Be("Open Idle Light on");
await fridge.DoorCloses();
fridge.StateString.Should().Be("Closed Idle Light off");
timeProvider.Add(minutes: 5);
await fridge.Tick();
fridge.StateString.Should().Be("Closed Cooling Light off");
await fridge.DoorOpens();
timeProvider.Add(minutes: 5);
await fridge.Tick();
await fridge.DoorCloses();
fridge.StateString.Should().Be("Closed Idle Light off");
await fridge.TemperatureChanges(40);
fridge.StateString.Should().Be("Closed Cooling Light off");
await fridge.DoorOpens();
fridge.StateString.Should().Be("Open Idle Light on");
timeProvider.Add(minutes: 60);
await fridge.Tick();
fridge.StateString.Should().Be("Open Defrosting Light on");
timeProvider.Add(minutes: 5);
await fridge.Tick();
fridge.StateString.Should().Be("Open Cooling Light on");
await fridge.DoorCloses();
fridge.StateString.Should().Be("Closed Cooling Light off");
timeProvider.Add(minutes: 60);
await fridge.Tick();
fridge.StateString.Should().Be("Closed Defrosting Light off");
await fridge.DoorOpens();
fridge.StateString.Should().Be("Open Defrosting Light on");
await fridge.TemperatureChanges(40);
fridge.StateString.Should().Be("Open Defrosting Light on");
await fridge.DoorCloses();
fridge.StateString.Should().Be("Closed Defrosting Light off");
await fridge.TemperatureChanges(33);
fridge.StateString.Should().Be("Closed Defrosting Light off");
}
}
public void SetUp()
{
_mockProvider = Substitute.For<TimeProvider>();
TimeProvider.Current = _mockProvider;
}
private async void setButtonTimeCaption(TimeProvider timeProvider)
{
// update the button's text
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => {
Button button = (Button)timeProvider.getSender();
ButtonDataServer buttonDataContext = (ButtonDataServer)button.DataContext;
buttonDataContext.TimeValue = timeProvider.formatTime();
buttonDataContext.MoveValue = loader.GetString("button_moves") + ": " + timeProvider.iterationCount.ToString();
});
}
public void RunBeforeEveryTest()
{
this.TestProvider = new TimeProvider();
}
public PreparationRunning(MainWindow mainWindow, TimeProvider timeProvider)
: base(mainWindow, timeProvider, State.PreparationRunning)
{
}
public void TestCleanup()
{
// important to leave TimeProvider correct
TimeProvider.ResetToDefault();
}
/// <summary>
/// Class for playing back audio into a user supplied IWavePlayer, using an NAudio BufferedWaveProvider
/// </summary>
/// <param name="outputDeviceFactory">Func for creating the output device</param>
/// <param name="dacLatency">Output device latency</param>
/// <param name="bufferDurationMs">Length of our output buffer (ms)</param>
/// <param name="offsetToleranceMs">How far we can be off before resorting to a hard sync (this causes an audible pop)</param>
public NAudioPlayer(int dacLatency, int bufferDurationMs, int offsetToleranceMs, Func <IWavePlayer> outputDeviceFactory, TimeProvider customTimeProvider = null)
: base(dacLatency, bufferDurationMs, offsetToleranceMs)
{
m_OutputDeviceFactory = outputDeviceFactory;
m_TimeProvider = customTimeProvider;
}
public async Task Routine_ReturnsFaultedTask_LogsFaultedTask()
{
// Arrange
using IJobManager jobManager = TestHelper.CreateJobManager(true);
var job = jobManager.Create("my-job");
var start = "2000-01-01Z".ToUtcDateOffset();
var timeMachine = ShiftedTimeProvider.CreateTimeMachine(start);
TimeProvider.Override(timeMachine);
var output = new StringWriterWithEncoding(Encoding.UTF8);
job.Output = output;
var exception = new NotSupportedException("Bye baby!");
JobDelegate routine = (parameter, tracker, writer, token) =>
{
writer.WriteLine("Hi there!");
return(Task.FromException(exception));
};
job.Schedule = new ConcreteSchedule(
start.AddSeconds(1));
job.IsEnabled = true;
// Act
job.Routine = routine;
var updatedRoutine = job.Routine;
await timeMachine.WaitUntilSecondsElapse(start, 1.5); // will fail by this time
var outputResult = output.ToString();
var info = job.GetInfo(null);
// Assert
try
{
Assert.That(updatedRoutine, Is.SameAs(routine));
Assert.That(outputResult, Does.Contain("Hi there!"));
Assert.That(outputResult, Does.Contain(exception.ToString()));
Assert.That(info.CurrentRun, Is.Null);
Assert.That(info.RunCount, Is.EqualTo(1));
var run = info.Runs.Single();
Assert.That(run.Status, Is.EqualTo(JobRunStatus.Faulted));
Assert.That(run.Exception, Is.SameAs(exception));
Assert.That(run.Output, Does.Contain(exception.ToString()));
var log = _logWriter.ToString();
Assert.That(log,
Does.Contain($"Job 'my-job' completed synchronously. Reason of start was 'ScheduleDueTime'."));
}
catch (Exception ex)
{
var sb = new StringBuilder();
sb.AppendLine("*** Test Failed ***");
sb.AppendLine(ex.ToString());
sb.AppendLine("*** Log: ***");
var log = _logWriter.ToString();
sb.AppendLine(log);
Assert.Fail(sb.ToString());
}
}
public void onTimeProviderTick(TimeProvider timeProvider)
{
setButtonTimeCaption(timeProvider);
}
public async Task Routine_SetOnTheFly_CompletesWithOldRoutineAndThenStartsWithNewRoutine()
{
// Arrange
using IJobManager jobManager = TestHelper.CreateJobManager(true);
var start = "2000-01-01Z".ToUtcDateOffset();
var timeMachine = ShiftedTimeProvider.CreateTimeMachine(start);
TimeProvider.Override(timeMachine);
var job = jobManager.Create("my-job");
var output = new StringWriterWithEncoding(Encoding.UTF8);
job.Output = output;
job.Schedule = new SimpleSchedule(SimpleScheduleKind.Second, 1, start);
async Task Routine1(object parameter, IProgressTracker tracker, TextWriter writer, CancellationToken token)
{
await writer.WriteAsync("First Routine!");
await Task.Delay(1500, token);
}
async Task Routine2(object parameter, IProgressTracker tracker, TextWriter writer, CancellationToken token)
{
await writer.WriteAsync("Second Routine!");
await Task.Delay(1500, token);
}
job.IsEnabled = true;
job.Routine = Routine1;
// Act
await timeMachine.WaitUntilSecondsElapse(start, 1.4);
job.Routine = Routine2;
await timeMachine.WaitUntilSecondsElapse(start, 2.8);
var output1 = output.ToString();
await timeMachine.WaitUntilSecondsElapse(start, 4.8);
var output2 = output.ToString();
jobManager.Dispose();
var info = job.GetInfo(null);
// Assert
try
{
Assert.That(info.NextDueTime, Is.EqualTo(start.AddSeconds(5)));
Assert.That(info.CurrentRun, Is.Null);
Assert.That(info.RunCount, Is.EqualTo(2));
Assert.That(info.Runs, Has.Count.EqualTo(2));
var run0 = info.Runs[0];
Assert.That(run0.DueTime, Is.EqualTo(start.AddSeconds(1)));
Assert.That(run0.Output, Is.EqualTo("First Routine!"));
Assert.That(output1, Is.EqualTo("First Routine!"));
var run1 = info.Runs[1];
Assert.That(run1.DueTime, Is.EqualTo(start.AddSeconds(3)));
Assert.That(run1.Output, Is.EqualTo("Second Routine!"));
Assert.That(output2, Is.EqualTo("First Routine!Second Routine!"));
}
catch (Exception ex)
{
var sb = new StringBuilder();
sb.AppendLine("*** Test Failed ***");
sb.AppendLine(ex.ToString());
sb.AppendLine("*** Log: ***");
var log = _logWriter.ToString();
sb.AppendLine(log);
Assert.Fail(sb.ToString());
}
}
public PresentationPaused(MainWindow mainWindow, TimeProvider timeProvider)
: base(mainWindow, timeProvider, State.PresentationPaused)
{
}
public IPizzaMessageMapper(BasicMessageFieldFinder basicMessageFieldFinder, MacCalculatorFactory macCalculatorFactory, TimeProvider timeProvider)
{
_macCalculatorFactory = macCalculatorFactory;
_basicMessageFieldFinder = basicMessageFieldFinder;
_timeProvider = timeProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="CachedMonitor" /> class.
/// </summary>
/// <param name="baseMonitor">The monitor to wrap.</param>
/// <param name="sec">The update interval in seconds.</param>
/// <param name="timeProvider">The custom time provider to use.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="baseMonitor" /> is <see langword="null" />.
/// </exception>
public CachedMonitor(IMonitor baseMonitor, double sec, TimeProvider timeProvider = null)
: this(baseMonitor: baseMonitor,
updateInterval: TimeSpan.FromSeconds(sec),
timeProvider: timeProvider)
{
}
public void ConsensusService_Primary_Sends_PrepareRequest_After_OnStart()
{
TestProbe subscriber = CreateTestProbe();
var mockWallet = new Mock <Wallet>();
mockWallet.Setup(p => p.GetAccount(It.IsAny <UInt160>())).Returns <UInt160>(p => new TestWalletAccount(p));
ConsensusContext context = new ConsensusContext(mockWallet.Object, TestBlockchain.GetStore());
int timeIndex = 0;
var timeValues = new[] {
//new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc), // For tests here
new DateTime(1968, 06, 01, 0, 0, 1, DateTimeKind.Utc), // For receiving block
new DateTime(1968, 06, 01, 0, 0, (int)Blockchain.SecondsPerBlock, DateTimeKind.Utc), // For Initialize
new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc), // unused
new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc) // unused
};
//TimeProvider.Current.UtcNow.ToTimestamp().Should().Be(4244941711); //1968-06-01 00:00:15
Console.WriteLine($"time 0: {timeValues[0].ToString()} 1: {timeValues[1].ToString()} 2: {timeValues[2].ToString()} 3: {timeValues[3].ToString()}");
var timeMock = new Mock <TimeProvider>();
timeMock.SetupGet(tp => tp.UtcNow).Returns(() => timeValues[timeIndex])
.Callback(() => timeIndex++);
//new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc));
TimeProvider.Current = timeMock.Object;
//public void Log(string message, LogLevel level)
// TODO: create ILogPlugin for Tests
/*
* mockConsensusContext.Setup(mr => mr.Log(It.IsAny<string>(), It.IsAny<LogLevel>()))
* .Callback((string message, LogLevel level) => {
* Console.WriteLine($"CONSENSUS LOG: {message}");
* }
* );
*/
// Creating proposed block
Header header = new Header();
TestUtils.SetupHeaderWithValues(header, UInt256.Zero, out UInt256 merkRootVal, out UInt160 val160, out uint timestampVal, out uint indexVal, out Witness scriptVal);
header.Size.Should().Be(101);
Console.WriteLine($"header {header} hash {header.Hash} timstamp {timestampVal}");
timestampVal.Should().Be(4244941696); //1968-06-01 00:00:00
// check basic ConsensusContext
//mockConsensusContext.Object.block_received_time.ToTimestamp().Should().Be(4244941697); //1968-06-01 00:00:01
// ============================================================================
// creating ConsensusService actor
// ============================================================================
TestActorRef <ConsensusService> actorConsensus = ActorOfAsTestActorRef <ConsensusService>(
Akka.Actor.Props.Create(() => (ConsensusService)Activator.CreateInstance(typeof(ConsensusService), BindingFlags.Instance | BindingFlags.NonPublic, null, new object[] { subscriber, subscriber, context }, null))
);
Console.WriteLine("will trigger OnPersistCompleted!");
actorConsensus.Tell(new Blockchain.PersistCompleted
{
Block = new Block
{
Version = header.Version,
PrevHash = header.PrevHash,
MerkleRoot = header.MerkleRoot,
Timestamp = header.Timestamp,
Index = header.Index,
NextConsensus = header.NextConsensus
}
});
// OnPersist will not launch timer, we need OnStart
Console.WriteLine("will start consensus!");
actorConsensus.Tell(new ConsensusService.Start
{
IgnoreRecoveryLogs = true
});
Console.WriteLine("OnTimer should expire!");
Console.WriteLine("Waiting for subscriber message!");
// Timer should expire in one second (block_received_time at :01, initialized at :02)
var answer = subscriber.ExpectMsg <LocalNode.SendDirectly>();
Console.WriteLine($"MESSAGE 1: {answer}");
//var answer2 = subscriber.ExpectMsg<LocalNode.SendDirectly>(); // expects to fail!
// ============================================================================
// finalize ConsensusService actor
// ============================================================================
//Thread.Sleep(4000);
Sys.Stop(actorConsensus);
TimeProvider.ResetToDefault();
Assert.AreEqual(1, 1);
}
public QuestionsRunning(MainWindow mainWindow, TimeProvider timeProvider)
: base(mainWindow, timeProvider, State.QuestionsRunning)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CachedMonitor" /> class.
/// </summary>
/// <param name="baseMonitor">The monitor to wrap.</param>
/// <param name="updateInterval">The update interval.</param>
/// <param name="timeProvider">The custom time provider to use.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="baseMonitor" /> is <see langword="null" />.
/// </exception>
public CachedMonitor(IMonitor baseMonitor, TimeSpan updateInterval, TimeProvider timeProvider = null)
: base(baseMonitor: baseMonitor)
{
_TIME_PROVIDER = timeProvider ?? GetNow;
_UPDATE_INTERVAL = updateInterval;
}
public Idle(MainWindow mainWindow, TimeProvider timeProvider)
: base(mainWindow, timeProvider, State.Idle)
{
}
