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; }