public void Equals_ValuesDifferentValue_ReturnsFalse()
{
var some1 = new Some<string>("value 1");
var some2 = new Some<string>("value 2");
Assert.IsFalse(some1.Equals(some2));
}
public void SomeEqualsWorksOnValueTypes()
{
var some1 = new Some<int>(42);
var some2 = new Some<int>(42);
Assert.True(some1.Equals(some2));
Assert.True(some2.Equals(some1));
}
public void SomeEqualsWorkOnReferenceTypesWithCorrectEqualitySemantics()
{
var some1 = new Some<Item>(new Item(42));
var some2 = new Some<Item>(new Item(42));
Assert.True(some1.Equals(some2));
Assert.True(some2.Equals(some1));
}
public void GetHashCode_ReturnsValueHashCode()
{
var value = "some string";
var some = new Some<string>(value);
Assert.AreEqual(value.GetHashCode(), some.GetHashCode());
}
public void GetOrElse_OptionIsSome_ValueReturned()
{
var option = new Some<string>("some value");
var result = option.GetOrElse(() => "default value");
Assert.AreEqual("some value", result);
}
public void Equals_ObjectsNotSameType_ReturnsFalse()
{
var value = "this is a value";
var some1 = new Some<string>(value);
var some2 = new Some<object>(value);
Assert.IsFalse(some1.Equals(some2));
}
public void NoneIsNotEqualToSome()
{
var none = new None<int>();
var some = new Some<int>(42);
Assert.False(none == some);
Assert.False(some == none);
Assert.True(none != some);
Assert.True(some != none);
}
public void Equals_SomeObjectsAreEqual_ReturnsTrue()
{
var value = "this is a value";
var some1 = new Some<string>(value);
var some2 = new Some<string>(value);
Assert.IsTrue(some1.Equals(some2));
}
public void Foo( Some<string> value )
{
if (value.Value == null)
{
failwith<Unit>("Value should never be null");
}
string doesItImplicitlyCastBackToAString = value;
}
// VisitFailure
public virtual void testSomeIdentity()
{
Identity id = new Identity();
Some some = new Some(logVisitor(id));
Logger expected = new Logger(id, new IVisitable[]{n1,n2});
IVisitable nodeReturned = some.visit(n0);
Assertion.AssertEquals(expected, logger);
Assertion.AssertEquals(n0, nodeReturned);
}
public IOption<string> GetString(int id)
{
IOption<string> value = new None<string>();
var convertedId = this.converter.Convert(id);
if(convertedId > 0) {
value = new Some<string>(loader.Load(convertedId));
}
return value;
}
// throws VisitFailure
public virtual void testSomeOneFailure()
{
IVisitor v = new FailAtNodes(n1);
Some some = new Some(logVisitor(v));
Logger expected = new Logger(v, new IVisitable[]{n1,n2});
IVisitable nodeReturned = null;
nodeReturned = some.visit(n0);
Assertion.AssertEquals(expected, logger);
Assertion.AssertEquals(n0, nodeReturned);
}
/// <summary>
/// Attempts to get the config value, if it exists it attempts to convert
/// it to an int and return it as Right(the int) otherwise it returns
/// Left(the string).
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static Either<string, int> GetIntegerValue(Some<string> key) =>
match
(
GetValue(key),
Some: str =>
match
(
parseInt(str),
Some: result => Right<string, int>(result),
None: () => Left<string, int>("Not a valid int: " + str)
),
None: () => Left<string, int>("Key doesn't exist: " + key)
);
public ProcessName(Some<string> name)
{
if (name.Value.Length == 0)
{
throw new InvalidProcessNameException();
}
var invalid = System.IO.Path.GetInvalidFileNameChars();
if ((from c in name.Value where invalid.Contains(c) select c).Count() > 0)
{
throw new InvalidProcessNameException();
}
Value = name.Value.ToLower();
}
public virtual void testSomeAllFailures()
{
Fail f = new Fail();
Some some = new Some(logVisitor(f));
Logger expected = new Logger(f, new IVisitable[]{n1,n2});
IVisitable nodeReturned = null;
try {
nodeReturned = some.visit(n0);
}
catch (VisitFailure)
{
Assertion.AssertEquals(expected, logger);
Assertion.AssertNull(nodeReturned);
}
}
public void SomeEqualitySemanticsTest()
{
var someInt1 = new Some<int>(42);
var someInt2 = new Some<int>(42);
var someInt3 = new Some<int>(100500);
var someItem1 = new Some<Item>(new Item(42));
var someItem2 = new Some<Item>(new Item(42));
var someItem3 = new Some<Item>(new Item(100500));
Assert.True(someInt1 == someInt2);
Assert.False(someInt1 == someInt3);
Assert.False(someInt2 == someInt3);
Assert.True(someItem1 == someItem2);
Assert.False(someItem1 == someItem3);
Assert.False(someItem2 == someItem3);
Assert.False(someInt1 == someItem1);
Assert.True(someInt1 != someItem1);
}
public virtual void testSomeLeaf()
{
Identity id = new Identity();
Some some = new Some(logVisitor(id));
Logger expected = new Logger();
IVisitable nodeReturned = null;
try
{
nodeReturned = some.visit(n11);
Assertion.Fail("Some(leaf) should fail!");
}
catch (VisitFailure)
{
Assertion.AssertEquals(expected, logger);
Assertion.AssertNull(nodeReturned);
}
}
public static void GetAvailability___Should_return_Availability_Unknown___When_last_event_in_AvailabilityCheckEvents_is_CellAvailabilityCheckFailedEvent()
{
// Arrange
var events = new CellAvailabilityCheckEventBase[0]
.Concat(Some.ReadOnlyDummies <CellAvailabilityCheckEventBase>())
.Concat(new[]
{
A.Dummy <CellAvailabilityCheckFailedEvent>(),
})
.ToList();
var cell = A.Dummy <NotSlottedCellBase>().DeepCloneWithAvailabilityCheckEvents(events);
// Act
var actual = cell.GetAvailability();
// Assert
actual.AsTest().Must().BeEqualTo(Availability.Unknown);
}
public static void GetCellOpExecutionStatus___Should_return_CellOpExecutionStatus_NotExecuted___When_last_event_in_OperationExecutionEvents_is_CellOpExecutionClearedEvent()
{
// Arrange
var events = new CellOpExecutionEventBase[0]
.Concat(Some.ReadOnlyDummies <CellOpExecutionEventBase>())
.Concat(new[]
{
A.Dummy <CellOpExecutionClearedEvent>(),
})
.ToList();
var cell = A.Dummy <OperationCell <Version> >().DeepCloneWithOperationExecutionEvents(events);
// Act
var actual = cell.GetCellOpExecutionStatus();
// Assert
actual.AsTest().Must().BeEqualTo(CellOpExecutionStatus.NotExecuted);
}
public static void GetValidity___Should_return_Validity_Aborted___When_last_event_of_ValidationEvents_is_CellValidationAbortedEvent()
{
// Arrange
var events = new CellValidationEventBase[0]
.Concat(Some.ReadOnlyDummies <CellValidationEventBase>())
.Concat(new[]
{
A.Dummy <CellValidationAbortedEvent>(),
})
.ToList();
var cell = A.Dummy <NotSlottedCellBase>().DeepCloneWithValidationEvents(events);
// Act
var actual = cell.GetValidity();
// Assert
actual.AsTest().Must().BeEqualTo(Validity.Aborted);
}
public void DynamicallySwitchingSinkRestrictsOutput()
{
var eventsReceived = 0;
var levelSwitch = new LoggingLevelSwitch();
var logger = new LoggerConfiguration()
.WriteTo.Sink(
new DelegatingSink(e => eventsReceived++),
levelSwitch: levelSwitch)
.CreateLogger();
logger.Write(Some.InformationEvent());
levelSwitch.MinimumLevel = LogEventLevel.Warning;
logger.Write(Some.InformationEvent());
levelSwitch.MinimumLevel = LogEventLevel.Verbose;
logger.Write(Some.InformationEvent());
Assert.Equal(2, eventsReceived);
}
public void Should_write_header_at_start_of_rolling_log_files()
{
var headerWriter = new HeaderWriter(W3C_HEADER);
var logEvents = Some.LogEvents(3);
using (var temp = TempFolder.ForCaller())
{
var path = temp.AllocateFilename("txt");
// Use a rolling log file configuration with a 50-byte size limit, so we roll after writing the header and a single log event
using (var log = new LoggerConfiguration()
.WriteTo.File(path, rollOnFileSizeLimit: true, fileSizeLimitBytes: 50, hooks: headerWriter)
.CreateLogger())
{
log.WriteAll(logEvents);
}
// Get all the files the rolling file sink wrote
var files = Directory.GetFiles(temp.Path)
.OrderBy(p => p, StringComparer.OrdinalIgnoreCase)
.ToArray();
// We should have found a file for each entry in logEvents
files.Length.ShouldBe(logEvents.Length);
// Check each file to ensure it contains our header plus 1 log event
for (var i = 0; i < files.Length; i++)
{
var lines = files[i].ReadAllLines();
// File should contain our header line plus 1 log event
lines.Count.ShouldBe(2);
// Ensure the file starts with the header
lines[0].ShouldBe(W3C_HEADER);
// Ensure the log event was written as normal
lines[1].ShouldEndWith(logEvents[i].MessageTemplate.Text);
}
}
}
public void WrittenDataCanBeRead()
{
var events = new[]
{
new
{
key = Some.KeyWith(3),
value = new { title = "Data 1" }
},
new
{
key = Some.KeyWith(17),
value = new { title = "Data 2" }
}
};
using var tempStore = new TempStore();
using var store = new DataStore(MemoryPool <byte> .Shared, tempStore.Store);
using (var writer = store.BeginWrite())
{
foreach (var data in events)
{
var json = JsonConvert.SerializeObject(data.value);
var utf8Json = Encoding.UTF8.GetBytes(json);
writer.Set(new Data(data.key, new OwnedArray(utf8Json)));
}
}
using var reader = store.BeginRead();
var readData = reader.Data().ToList();
Assert.Equal(events.Length, readData.Count);
foreach (var read in readData)
{
var expected = events.Single(evt => read.Key == evt.key);
Assert.Equal(read.Value.GetProperty("title").GetString(), expected.value.title);
}
}
public void WriteToLoggerMinimumLevelOverrideInheritanceNotSupportedScenarios(
string rootOverrideSource,
int rootOverrideLevelIncrement,
string childOverrideSource,
int childOverrideLevelIncrement)
{
var incomingEventLevel = Information;
var rootOverrideLevel = incomingEventLevel + rootOverrideLevelIncrement;
var childOverrideLevel = incomingEventLevel + childOverrideLevelIncrement;
LogEvent evt = null;
var sink = new DelegatingSink(e => evt = e);
var childLoggerConfig = new LoggerConfiguration()
.MinimumLevel.Is(LevelAlias.Minimum);
if (childOverrideSource != null)
{
childLoggerConfig.MinimumLevel.Override(childOverrideSource, childOverrideLevel);
}
childLoggerConfig.WriteTo.Sink(sink);
var childLogger = childLoggerConfig.CreateLogger();
var rootLoggerConfig = new LoggerConfiguration()
.MinimumLevel.Is(LevelAlias.Minimum);
if (rootOverrideSource != null)
{
rootLoggerConfig.MinimumLevel.Override(rootOverrideSource, rootOverrideLevel);
}
var logger = rootLoggerConfig
.WriteTo.Logger(childLogger)
.CreateLogger();
logger
.ForContext(Constants.SourceContextPropertyName, "Root.N1.N2")
.Write(Some.LogEvent(level: incomingEventLevel));
// even though the use may expect no event
Assert.NotNull(evt);
}
public void CapturesTraceData()
{
var data = new
{
Info = Some.String()
};
_traceListener.TraceData(_traceEventCache, _source, WarningEventType, _id, data);
LogEventAssert.HasMessage(
"\"" + data.ToString() + "\"",
_loggedEvent);
LogEventAssert.HasLevel(LogEventLevel.Warning, _loggedEvent);
LogEventAssert.HasPropertyValue(_id, "TraceEventId", _loggedEvent);
LogEventAssert.HasPropertyValue(_source, "TraceSource", _loggedEvent);
LogEventAssert.HasPropertyValue(data.ToString(), "TraceData", _loggedEvent);
LogEventAssert.HasPropertyValue(WarningEventType, "TraceEventType", _loggedEvent);
}
public void TestExitMatch_removesCssClass()
{
string cssSelector = Some.String();
string markerClass = Some.String();
string markingScript = Some.String();
Mock<IScriptLoader> scriptLoader = new Mock<IScriptLoader>();
Mock<WatiN.Core.DomContainer> domContainer = new Mock<DomContainer>();
scriptLoader.Expect(s => s.GetCssMarkRemovalScript(cssSelector, markerClass)).Returns(markingScript).Verifiable();
var sut = new TestableCssSelectorConstraint(scriptLoader.Object, domContainer.Object, markerClass);
sut.Initialize(cssSelector);
sut.DoEnterMatch();
domContainer.Verify();
}
public Option <List <string> > GetColumnValues(Some <string> fileName, Some <string> column, Some <int> startRow, Some <int> endRow)
{
var excelFile = _excelProvider.OpenFile(fileName);
var sheet = excelFile.Workbook.Worksheets.First();
var list = new List <string>();
for (var i = startRow; i < endRow; i++)
{
var cell = _excelProvider.ReadCell(sheet, column + i);
if (string.IsNullOrEmpty(cell))
{
continue;
}
list.Add(cell);
}
_excelProvider.CloseFile(excelFile);
return(list);
}
public void NextCheck_BonusTrueToBonusTrue_EmitsOnlyOnce()
{
var res = Some.EventStatusResponse() with {
Status = Some.EventStatusListWithoutAnythingAdded()
};
var res2 = Some.EventStatusResponse() with {
Status = Some.EventStatusListBonusTrue()
};
A.CallTo(() => EventStatusClient.GetEventStatus()).Returns(value: res).Once().Then.Returns(res2);
var monitor = CreateMatchDayStatusMonitor();
monitor.EveryFiveMinutesTick(CancellationToken.None);
monitor.EveryFiveMinutesTick(CancellationToken.None);
monitor.EveryFiveMinutesTick(CancellationToken.None);
A.CallTo(() => Mediator.Publish(A <BonusAdded> ._, CancellationToken.None)).MustHaveHappenedOnceExactly();
}
public void SinkWithIConfigurationArguments()
{
var json = @"{
""Serilog"": {
""Using"": [""TestDummies""],
""WriteTo"": [{
""Name"": ""DummyWithConfiguration"",
""Args"": {}
}]
}
}";
DummyConfigurationSink.Reset();
var log = ConfigFromJson(json)
.CreateLogger();
log.Write(Some.InformationEvent());
Assert.NotNull(DummyConfigurationSink.Configuration);
}
public void PushedPropertiesAreAvailableToLoggers()
{
LogEvent lastEvent = null;
var log = new LoggerConfiguration()
.Enrich.FromLogContext()
.WriteTo.Sink(new DelegatingSink(e => lastEvent = e))
.CreateLogger();
using (LogContext.PushProperty("A", 1))
using (LogContext.Push(new PropertyEnricher("B", 2)))
using (LogContext.Push(new PropertyEnricher("C", 3), new PropertyEnricher("D", 4))) // Different overload
{
log.Write(Some.InformationEvent());
Assert.Equal(1, lastEvent.Properties["A"].LiteralValue());
Assert.Equal(2, lastEvent.Properties["B"].LiteralValue());
Assert.Equal(3, lastEvent.Properties["C"].LiteralValue());
Assert.Equal(4, lastEvent.Properties["D"].LiteralValue());
}
}
internal static void ReleaseTemporaryRegistryValue(Some <RegistryKey> baseKey, Some <string> subKeyPath, Some <string> valueName, Option <object> existingValue, RegistryValueKind existingValueKind)
{
Try <Unit> TryReleaseTemporaryRegistryValue() => () =>
{
using (var subKey = baseKey.Value.OpenSubKey(subKeyPath.Value, true))
{
if (subKey == null)
{
throw new ArgumentException($"Sub key '{baseKey.Value.Name}\\{subKeyPath.Value}' does not exist.");
}
return(ReleaseTemporaryRegistryValuePure(valueName, existingValue, existingValueKind,
subKey.SetValue, subKey.DeleteValue));
}
};
TryReleaseTemporaryRegistryValue().Try().Match(unit => unit, exception =>
{
Logging.DefaultLogger.Warn($"Failed to release temporary registry value. {exception.ToExceptionMessage()}");
return(Unit.Default);
});
}
public static async Task <Result <Unit> > RunScheduledTask(Some <ScheduledTaskInfo> scheduledTaskInfo, bool waitForExit)
{
return(await F.AsyncTryFunc <Unit>(async() =>
{
var eventLogResult = await WindowsEventLog.WriteEventLog($"Running scheduled task '{scheduledTaskInfo.Value.TaskName}'", EventLogEntryType.Information, scheduledTaskInfo.Value.EventId).ConfigureAwait(false);
var waitForExitResult =
await eventLogResult
.Match(
async unit =>
{
var res = waitForExit
? WaitForScheduledTaskExit(scheduledTaskInfo.Value.TaskName).ConfigureAwait(false)
: Task.FromResult(new Result <Unit>(Unit.Default)).ConfigureAwait(false);
return await res;
},
async exception => await Task.FromResult(new Result <Unit>(exception)).ConfigureAwait(false)
).ConfigureAwait(false);
return waitForExitResult;
}).ConfigureAwait(false));
}
public void NextCheck_PointsReadyToPointsReady_OnlyEmitsOnce()
{
var first = Some.EventStatusResponse() with {
Status = Some.EventStatusListWithoutAnythingAdded()
};
var then = Some.EventStatusResponse() with {
Status = Some.EventStatusListPointsReady()
};
A.CallTo(() => EventStatusClient.GetEventStatus()).Returns(first).Once().Then.Returns(then);
var monitor = CreateMatchDayStatusMonitor();
monitor.EveryFiveMinutesTick(CancellationToken.None);
monitor.EveryFiveMinutesTick(CancellationToken.None);
monitor.EveryFiveMinutesTick(CancellationToken.None);
A.CallTo(() => Mediator.Publish(A <PointsReady> ._, CancellationToken.None)).MustHaveHappenedOnceExactly();
}
public void then_you_can_check_for_an_item_in_a_list()
{
var warehouse = new Warehouse
{
Engines = new[] { new Engine {
YearBuilt = 2013
}, new Engine {
YearBuilt = 2016
} }
};
warehouse.ShouldLookLike(() => new Warehouse
{
Engines = Some.ListContaining(() => new Engine
{
//Yep, you can use partial matching recursively!
YearBuilt = Some.ValueOf <int>(i => i % 2 == 0)
})
});
}
public void WhenRetentionCountAndArchivingHookIsSetOldFilesAreCopiedAndOriginalDeleted()
{
const string archiveDirectory = "OldLogs";
LogEvent e1 = Some.InformationEvent(),
e2 = Some.InformationEvent(e1.Timestamp.AddDays(1)),
e3 = Some.InformationEvent(e2.Timestamp.AddDays(5));
TestRollingEventSequence(
(pf, wt) => wt.File(pf, retainedFileCountLimit: 2, rollingInterval: RollingInterval.Day, hooks: new ArchiveOldLogsHook(archiveDirectory)),
new[] { e1, e2, e3 },
files =>
{
Assert.Equal(3, files.Count);
Assert.True(!System.IO.File.Exists(files[0]));
Assert.True(System.IO.File.Exists(files[1]));
Assert.True(System.IO.File.Exists(files[2]));
Assert.True(System.IO.File.Exists(ArchiveOldLogsHook.AddTopDirectory(files[0], archiveDirectory)));
});
}
public void NextCheck_PointsReady_EmitsPointsReady()
{
var first = Some.EventStatusResponse() with {
Status = Some.EventStatusListWithoutAnythingAdded()
};
var then = Some.EventStatusResponse() with {
Status = Some.EventStatusListPointsReady()
};
A.CallTo(() => EventStatusClient.GetEventStatus()).Returns(first).Once().Then.Returns(then);
var monitor = CreateMatchDayStatusMonitor();
monitor.EveryFiveMinutesTick(CancellationToken.None);
monitor.EveryFiveMinutesTick(CancellationToken.None);
Assert.Single(Mediator.PublishedMessages);
Assert.IsType <MatchdayMatchPointsAdded>(Mediator.PublishedMessages[0].Message);
}
public void AuditSinksAreConfigured()
{
var settings = new Dictionary <string, string>
{
["using:TestDummies"] = typeof(DummyLoggerConfigurationExtensions).GetTypeInfo().Assembly.FullName,
["audit-to:DummyRollingFile.pathFormat"] = "C:\\"
};
var log = new LoggerConfiguration()
.ReadFrom.KeyValuePairs(settings)
.CreateLogger();
DummyRollingFileSink.Reset();
DummyRollingFileAuditSink.Reset();
log.Write(Some.InformationEvent());
Assert.Empty(DummyRollingFileSink.Emitted);
Assert.Single(DummyRollingFileAuditSink.Emitted);
}
public void MainTest()
{
using (var session = Domain.OpenSession())
using (var t = session.OpenTransaction())
{
var some = new Some {
Tag = 100500, Reference = new Ref {
Tag = 9000
}, Structure = new Struct {
Tag = 777
}
};
var tagObject = some.GetProperty <object>("Tag");
var tagValue = some.GetProperty <uint>("Tag");
var tagIndexed = some["Tag"];
AssertEx.Throws <InvalidCastException>(() => some.GetProperty <long>("Tag"));
Assert.AreEqual(100500, tagValue);
Assert.AreEqual(100500, (uint)tagObject);
Assert.AreEqual(100500, (uint)tagIndexed);
var refObject = some.GetProperty <object>("Reference.Tag");
var refValue = some.Reference.Tag;
Assert.AreEqual(9000, refValue);
Assert.AreEqual(9000, (uint)refObject);
var strObject = some.GetProperty <object>("Structure.Tag");
var strValue = some.Structure.Tag;
Assert.AreEqual(777, strValue);
Assert.AreEqual(777, (uint)strObject);
some.SetProperty("Tag", 111u);
some.SetProperty("Reference.Tag", 111u);
some.SetProperty("Structure.Tag", 111u);
Assert.AreEqual(111u, some.Tag);
Assert.AreEqual(111u, some.Reference.Tag);
Assert.AreEqual(111u, some.Structure.Tag);
t.Complete();
}
}
public void MoveCurrentStatementToSqlTable()
{
var originalStatement = _statementBuilder.GetSqlStatement();
var fakeFromExpressionInfo = CreateFakeFromExpressionInfo(new Ordering[0]);
Func <ITableInfo, SqlTable> tableGenerator = info => new SqlTable(info, JoinSemantics.Inner);
var someOrderingExtractionPolicy = Some.Item(
OrderingExtractionPolicy.DoNotExtractOrderings,
OrderingExtractionPolicy.ExtractOrderingsIntoProjection);
_stageMock
.Expect(mock => mock.PrepareFromExpression(
Arg <SqlSubStatementExpression> .Is.TypeOf,
Arg.Is(_context),
Arg.Is(tableGenerator),
Arg.Is(someOrderingExtractionPolicy)))
.Return(fakeFromExpressionInfo)
.WhenCalled(mi =>
{
var sqlStatement = ((SqlSubStatementExpression)mi.Arguments[0]).SqlStatement;
SqlExpressionTreeComparer.CheckAreEqualTrees(new NamedExpression(null, originalStatement.SelectProjection), sqlStatement.SelectProjection);
Assert.That(sqlStatement.DataInfo, Is.SameAs(originalStatement.DataInfo));
Assert.That(sqlStatement.WhereCondition, Is.SameAs(originalStatement.WhereCondition));
});
_stageMock.Replay();
_handler.MoveCurrentStatementToSqlTable(_statementBuilder, _context, tableGenerator, _stageMock, someOrderingExtractionPolicy);
_stageMock.VerifyAllExpectations();
Assert.That(_statementBuilder.DataInfo, Is.SameAs(originalStatement.DataInfo));
Assert.That(_statementBuilder.SqlTables[0], Is.SameAs(fakeFromExpressionInfo.SqlTable));
Assert.That(_statementBuilder.SelectProjection, Is.SameAs(fakeFromExpressionInfo.ItemSelector));
var mappedItemExpression = _context.GetExpressionMapping(((StreamedSequenceInfo)originalStatement.DataInfo).ItemExpression);
Assert.That(mappedItemExpression, Is.Not.Null);
Assert.That(mappedItemExpression, Is.SameAs(fakeFromExpressionInfo.ItemSelector));
}
public void NextCheck_BonusTrueToBonusTrue_EmitsOnlyOnce()
{
var res = Some.EventStatusResponse() with {
Status = Some.EventStatusListWithoutAnythingAdded()
};
var res2 = Some.EventStatusResponse() with {
Status = Some.EventStatusListBonusTrue()
};
A.CallTo(() => EventStatusClient.GetEventStatus()).Returns(value: res).Once().Then.Returns(res2);
var monitor = CreateMatchDayStatusMonitor();
monitor.EveryFiveMinutesTick(CancellationToken.None);
monitor.EveryFiveMinutesTick(CancellationToken.None);
monitor.EveryFiveMinutesTick(CancellationToken.None);
Assert.Single(Mediator.PublishedMessages);
Assert.IsType <MatchdayBonusPointsAdded>(Mediator.PublishedMessages[0].Message);
}
public void CanHandleIMaybeExpectation()
{
// Arrange
IMaybe <Guid> expectation = new Some <Guid>(Guid.NewGuid());
var context = new EquivalencyValidationContext
{
Expectation = expectation,
CompileTimeType = expectation.GetType()
};
var config = new EquivalencyAssertionOptions <None <int> >();
var sut = new MaybeEquivalencyStep();
// Act
var actual = sut.CanHandle(context, config);
// Assert
actual.Should().BeTrue();
}
public void CapturesTraceEventWithFormatMessage()
{
const string format = "{0}-{1}-{2}";
var args = new object[]
{
Some.Int(),
Some.Int(),
Some.Int()
};
_traceListener.TraceEvent(_traceEventCache, _source, WarningEventType, _id, format, args);
LogEventAssert.HasMessage(string.Format(format, args[0], args[1], args[2]), _loggedEvent);
LogEventAssert.HasLevel(LogEventLevel.Warning, _loggedEvent);
LogEventAssert.HasPropertyValue(_id, "TraceEventId", _loggedEvent);
LogEventAssert.HasPropertyValue(_source, "TraceSource", _loggedEvent);
LogEventAssert.HasPropertyValue(WarningEventType, "TraceEventType", _loggedEvent);
LogEventAssert.HasPropertyValue(args[0], "0", _loggedEvent);
LogEventAssert.HasPropertyValue(args[1], "1", _loggedEvent);
LogEventAssert.HasPropertyValue(args[2], "2", _loggedEvent);
}
public void WrappingIsAppliedWhenCallingMultipleTimes()
{
DummyWrappingSink.Emitted.Clear();
var sink1 = new CollectingSink();
var sink2 = new CollectingSink();
var logger = new LoggerConfiguration()
.WriteTo.Dummy(w =>
{
w.Sink(sink1);
w.Sink(sink2);
})
.CreateLogger();
var evt = Some.InformationEvent();
logger.Write(evt);
Assert.Same(evt, DummyWrappingSink.Emitted.Single());
Assert.Same(evt, sink1.SingleEvent);
Assert.Same(evt, sink2.SingleEvent);
}
public static Try <Unit> RegisterUserScheduledTask(Some <string> taskName, Some <FileInfo> exeFile,
Some <string> arguments, Some <string> taskDescription, Some <List <Trigger> > triggers) => () =>
{
using (var ts = TaskService.Instance)
{
using (var td = ts.NewTask())
{
td.RegistrationInfo.Description = taskDescription.Value;
td.Settings.MultipleInstances = TaskInstancesPolicy.StopExisting;
td.Actions.Add(new ExecAction($"\"{exeFile.Value.FullName}\"", arguments.Value, exeFile.Value.Directory.FullName));
foreach (var trigger in triggers.Value)
{
td.Triggers.Add(trigger);
}
td.Principal.GroupId = ScheduledTasks.BuiltInUsers();
td.Principal.RunLevel = TaskRunLevel.LUA;
ts.RootFolder.RegisterTaskDefinition(taskName.Value, td);
}
}
return(new Result <Unit>(Unit.Default));
};
public static void ReadOnlyDummies___Should_return_random_list_with_specified_number_of_elements_and_zero_or_more_nulls___When_parameter_createWith_is_ZeroOrMoreNulls()
{
// Arrange, Act
const int numberOfElements = 100;
var result1 = Some.ReadOnlyDummies <int?>(numberOfElements, CreateWith.ZeroOrMoreNulls);
var result2 = Some.ReadOnlyDummies <string>(numberOfElements, CreateWith.ZeroOrMoreNulls);
var result3 = Some.ReadOnlyDummies <object>(numberOfElements, CreateWith.ZeroOrMoreNulls);
var result4 = Some.ReadOnlyDummies <double>(numberOfElements, CreateWith.ZeroOrMoreNulls);
// Assert
result1.Should().HaveCount(numberOfElements);
result1.Where(_ => _ != null).Should().OnlyHaveUniqueItems();
result2.Should().HaveCount(numberOfElements);
result2.Where(_ => _ != null).Should().OnlyHaveUniqueItems();
result3.Should().HaveCount(numberOfElements);
result3.Where(_ => _ != null).Should().OnlyHaveUniqueItems();
result4.Should().HaveCount(numberOfElements).And.OnlyHaveUniqueItems();
}
public void SomeItemTests()
{
object[] mixed = new object[] { 1, 2, "3", null, "four", 100 };
object[] strings = new object[] { "abc", "bad", "cab", "bad", "dad" };
// Not available using the classic syntax
// Helper syntax
Ensure.That(mixed, Has.Some.Null);
Ensure.That(mixed, Has.Some.InstanceOfType(typeof(int)));
Ensure.That(mixed, Has.Some.InstanceOfType(typeof(string)));
Ensure.That(strings, Has.Some.StartsWith("ba"));
Ensure.That(strings, Has.Some.Not.StartsWith("ba"));
// Inherited syntax
EnsuranceHelper.Expect(mixed, Some.Null);
EnsuranceHelper.Expect(mixed, Some.InstanceOfType(typeof(int)));
EnsuranceHelper.Expect(mixed, Some.InstanceOfType(typeof(string)));
EnsuranceHelper.Expect(strings, Some.StartsWith("ba"));
EnsuranceHelper.Expect(strings, Some.Not.StartsWith("ba"));
}
public void CaseInsensitiveArgumentNameMatching()
{
var json = @"{
""Serilog"": {
""Using"": [""TestDummies""],
""WriteTo"": [{
""Name"": ""DummyRollingFile"",
""Args"": {""PATHFORMAT"" : ""C:\\""}
}]
}
}";
var log = ConfigFromJson(json)
.CreateLogger();
DummyRollingFileSink.Reset();
log.Write(Some.InformationEvent());
Assert.Equal(1, DummyRollingFileSink.Emitted.Count);
}
public TrackingResult(Option<Vector3D> relPos, Option<Vector3D> angle,
Image<Gray, Byte> smoothedDepth, List<Rectangle> depthBox,
Image<Gray, Byte> skin = null, List<Rectangle> colorBox = null)
{
RightHandRelPos = relPos;
RightHandAngle = angle;
DepthImage = smoothedDepth;
DepthBoundingBoxes = depthBox;
if (DepthBoundingBoxes.Count > 0) {
var rect = DepthBoundingBoxes.Last();
RightHandAbsPos = new Some<window.Point>(rect.Center());
} else {
RightHandAbsPos = new None<window.Point>();
}
ColorImage = skin;
if (colorBox == null)
colorBox = new List<Rectangle>();
ColorBoundingBoxes = colorBox;
}
public void Value_SomeHasValue_ValueReturned()
{
var value = "this is a value";
var some = new Some<string>(value);
Assert.AreEqual(value, some.Value);
}
public void Greet(Some<string> arg)
{
Console.WriteLine(arg);
}
private static void Main(string[] args)
{
#region Exercise 1
Console.WriteLine("Exercise1");
INumberVisitor Vis = new NumberVisitor();
INumber Barry = new MyFloat(2);
INumber Henk = new MyFloat(3);
Barry.Visit(Vis);
Console.WriteLine("");
#endregion Exercise 1
#region Exercise 2
Console.WriteLine("Exercise2");
IMusicLibraryVisitor MusicLibraryVisitor = new MusicLibraryVisitor();
ISong HMSong1 = new HeavyMetal("Super Kill");
ISong JSong1 = new Jazz("Frank Sinatra: The Very Best Of");
List<ISong> SongList = new List<ISong>();
SongList.Add(HMSong1);
SongList.Add(JSong1);
foreach (ISong Song in SongList)
{
Song.Visit(MusicLibraryVisitor);
}
Console.WriteLine("");
#endregion Exercise 2
#region Exercise 3
Console.WriteLine("Exercise3");
IOption<int> TestInt1 = new Some<int>(5);
IOption<int> TestInt2 = new None<int>();
I_IntPrettyPrinterIOptionVisitor IntPrint = new IntPrettyPrinterIOptionVisitor();
string TestString1 = TestInt1.Visit(IntPrint);
Console.WriteLine(TestString1);
Console.WriteLine("");
#endregion Exercise 3
#region Exercise 4
Console.WriteLine("Exercise4");
IOptionLambda<MyFloat> f1 = new NoneLambda<MyFloat>();
string new_number1 = f1.Visit(x => x.value.ToString(), () => "Nothing here, b0ss.");
Console.WriteLine(new_number1);
IOptionLambda<MyFloat> f2 = new SomeLambda<MyFloat>(new MyFloat(5));
string new_number2 = f2.Visit(x => "The number is " + x.value.ToString() + "! :D", () => "Nothing here, b0ss.");
Console.WriteLine(new_number2);
#endregion Exercise 4
Console.ReadKey();
}
public RollbackResponseState(bool success)
{
Response = new Some<IMessageResponse>(new RollbackTransactionResponse(success));
}
public CommitResponseState(bool success, Offset journalSize)
{
Response = new Some<IMessageResponse>(new CommitTransactionResponse(success, journalSize));
}
public NewTransactionResponseState(Offset journalSize, TransactionUID transactionUID)
{
Response = new Some<IMessageResponse>(new NewTransactionResponse(journalSize, transactionUID));
}
public ReadJournalResponseState(int bytes, List<Event> events, bool complete, byte[] bytesLeft)
{
Response = new Some<IMessageResponse>(new ReadJournalResponse(bytes, events));
IsComplete = complete;
BytesLeft = bytesLeft;
}
public JournalExistsResponseState(bool exists)
{
Response = new Some<IMessageResponse>(new JournalExistsResponse(exists));
}
/// <summary>
///
/// </summary>
/// <param name="detphFrame">raw detph data.</param>
/// <param name="skeleton">skeleton object from Kinect SDK. The skeleton coordinate space has
/// the x-axis pointing rightwards, the y-axis pointing upwards, and the z-axis poining outwards
/// relative to the image.</param>
/// <returns>The position of the best bounding box relative to the shoulder joint in skeleton
/// coordinates if the bounding box is valid. Otherwise returns None.</returns>
public TrackingResult Update(short[] depthFrame, byte[] colorFrame, Skeleton skeleton)
{
t++;
Option<Vector3D> relPos = new None<Vector3D>();
Option<Vector3D> angle = new None<Vector3D>();
if (skeleton == null || depthFrame == null)
return new TrackingResult();
playerDetector.FilterPlayerContourSkin(depthFrame, colorFrame);
var depthImage = playerDetector.DepthImage;
smoothedDepth.CopyTo(prevSmoothedDepth);
// Median smoothing cannot be in place.
CvInvoke.cvSmooth(depthImage.Ptr, smoothedDepth.Ptr, SMOOTH_TYPE.CV_MEDIAN, 5, 5,
0, 0);
if (t > 1) {
CvInvoke.cvAbsDiff(smoothedDepth.Ptr, prevSmoothedDepth.Ptr, Diff0.Ptr);
//CvInvoke.cvErode(Diff0.Ptr, Diff0.Ptr, StructuringElement.Ptr, 1);
DiffMask0.CopyTo(DiffMask1);
CvInvoke.cvThreshold(Diff0.Ptr, DiffMask0.Ptr, 2, 255, THRESH.CV_THRESH_BINARY);
if (t > 2) {
// Makes diffMask1 the motion mask at t - 1.
CvInvoke.cvAnd(DiffMask0.Ptr, DiffMask1.Ptr, DiffMask1.Ptr, IntPtr.Zero);
if (bufferSize <= 1) {
// Makes diffMask1 the motion mask at t - 0.
CvInvoke.cvXor(DiffMask0.Ptr, DiffMask1.Ptr, DiffMask1.Ptr, IntPtr.Zero);
}
CvInvoke.cvMorphologyEx(DiffMask1.Ptr, DiffMask1.Ptr, IntPtr.Zero, IntPtr.Zero,
CV_MORPH_OP.CV_MOP_OPEN, 1);
ComputeCumulativeDist(Diff0, diffCumulativeDist);
ComputeCumulativeDist(TrackedDepthFrame, depthCumulativeDist);
CvInvoke.cvZero(SaliencyProb);
var diffMaskData = DiffMask1.Data;
var diffData = Diff0.Data;
var depthData = TrackedDepthFrame.Data;
var probData = SaliencyProb.Data;
for (int i = 0; i < DiffMask1.Height; i++)
for (int j = 0; j < DiffMask1.Width; j++) {
if (diffMaskData[i, j, 0] > 0) {
var diffBin = diffData[i, j, 0];
var depthBin = depthData[i, j, 0];
probData[i, j, 0] = diffCumulativeDist[diffBin] * depthCumulativeDist[depthBin];
}
}
PrevBoundingBoxes = FindBestBoundingBox(depthFrame, skeleton);
if (PrevBoundingBoxes.LastOrDefault().Width > 0) {
var handSkeletonPoint = SkeletonUtil.DepthToSkeleton(PrevBoundingBoxes.Last(),
TrackedDepthFrame.Data, width, height, mapper);
relPos = new Some<Vector3D>(SkeletonUtil.RelativePosToShoulder(handSkeletonPoint,
skeleton));
angle = new Some<Vector3D>(SkeletonUtil.PointDirection(handSkeletonPoint,
SkeletonUtil.GetJoint(skeleton, JointType.ElbowRight).Position));
} }
}
List<Rectangle> colorBBs = new List<Rectangle>();
foreach (var bb in PrevBoundingBoxes) {
var colorBox = mapper.MapDepthRectToColorRect(bb, depthFrame, width, height);
playerDetector.SmoothSkin(colorBox);
colorBBs.Add(colorBox);
}
return new TrackingResult(relPos, angle, TrackedDepthFrame, PrevBoundingBoxes,
playerDetector.SkinImage, colorBBs);
}
/// <summary> /// Reads the configuration setting fro App.config /// If the setting is 'null' then the result will be None otherwise it /// will be Some(the config value). /// </summary> /// <param name="key"></param> /// <returns></returns> public static Option<string> GetValue(Some<string> key) => AppSettings[key];
public Tuple<AST.Env, AST.ExprType, Option<AST.Initr>, String> GetInitDeclr(AST.Env env, AST.ExprType type) {
String name;
Option<AST.Initr> initr_opt;
// Get the initializer list.
Option<Tuple<AST.Env, AST.Initr>> r_initr = this.initr.Map(_ => _.GetInitr(env));
if (r_initr.IsSome) {
env = r_initr.Value.Item1;
initr_opt = new Some<AST.Initr>(r_initr.Value.Item2);
} else {
initr_opt = new None<AST.Initr>();
}
// Get the declarator.
Tuple<String, AST.ExprType> r_declr = declr.GetNameAndType(env, type);
name = r_declr.Item1;
type = r_declr.Item2;
// Implicit cast the initializer.
initr_opt = initr_opt.Map(_ => _.ConformType(type));
// If the object is an incomplete list, we must determine the length based on the initializer.
if (type.kind == AST.ExprType.Kind.INCOMPLETE_ARRAY) {
if (initr_opt.IsNone) {
throw new InvalidOperationException("Cannot determine the length of the array.");
}
// Now we need to determine the length.
// Find the last element in the init list.
Int32 last_offset = -1;
initr_opt.Value.Iterate(type, (offset, _) => { last_offset = offset; });
if (last_offset == -1) {
throw new InvalidOperationException("Cannot determine the length of the array based on an empty initializer list.");
}
AST.ExprType elem_type = ((AST.TIncompleteArray)type).elem_type;
Int32 num_elems = 1 + last_offset / ((AST.TIncompleteArray)type).elem_type.SizeOf;
type = new AST.TArray(elem_type, num_elems, type.is_const, type.is_volatile);
}
return new Tuple<AST.Env, AST.ExprType, Option<AST.Initr>, String>(env, type, initr_opt, name);
}
/// <summary>
/// array_modifier
/// : '[' [constant_expression]? ']'
/// </summary>
public static Int32 ParseArrayModifier(List<Token> src, Int32 begin, out ArrayModifier modifier)
{
// match '['
if (!Parser.EatOperator(src, ref begin, OperatorVal.LBRACKET)) {
modifier = null;
return -1;
}
// match constant_expression, if fail, just put null
Expr num_elems;
Option<Expr> num_elems_opt;
Int32 saved = begin;
if ((begin = _constant_expression.Parse(src, begin, out num_elems)) == -1) {
num_elems_opt = new None<Expr>();
begin = saved;
} else {
num_elems_opt = new Some<Expr>(num_elems);
}
// match ']'
if (!Parser.EatOperator(src, ref begin, OperatorVal.RBRACKET)) {
modifier = null;
return -1;
}
modifier = new ArrayModifier(num_elems_opt);
return begin;
}
