public async Task CollectionActorRemove_ExpectsNewStateWithoutRemovedItems() { var stateManager = new Mock <IActorStateManager>(); var list = new List <string> { Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString() }; var state = new HashSet <string>(list); stateManager.Setup(manager => manager.GetStateAsync <HashSet <string> >(_stateName, It.IsAny <CancellationToken>())) .Returns(Task.FromResult(state)) .Verifiable(); stateManager.Setup(manager => manager.SetStateAsync(_stateName, state, It.IsAny <CancellationToken>())) .Verifiable(); CollectionActor testDemoActor = await CreateActor(stateManager.Object, "Test Collection"); await testDemoActor.Remove(list[2]); await testDemoActor.Remove(list[0]); list.Remove(list[2]); list.Remove(list[0]); state.Should().HaveCount(3); state.Should().Contain(list); stateManager.VerifyAll(); }
public void TestAddRangeAddsElements() { var elementsToBeAdded = new List <int> { 1, 3, 5 }; HashSet <int> hash = new HashSet <int>(); hash.AddRange(elementsToBeAdded); foreach (int elementToBeAdded in elementsToBeAdded) { hash.Should().Contain(elementToBeAdded); } var moreElementsToBeAdded = new List <int> { 5, 7, 9 }; hash.AddRange(moreElementsToBeAdded); foreach (int elementToBeAdded in moreElementsToBeAdded) { hash.Should().Contain(elementToBeAdded); } hash.Count.Should().Be(5); }
public void CreateNew_ShouldReturnNewGuid_WithoutCollisions_WhenTypeIsBinaryEnd() { // Arrange const int numberOfChars = SequentialGuidFactory.NumberOfSequentialBytes * 2; // 2 chars per byte var uniqueResults = new HashSet <Guid>(); var sequentialData = new string[TestIterations]; var subject = new SequentialGuidFactory(SequentialGuidType.BinaryEnd); for (var i = 0; i < TestIterations; i++) { // Act var result = subject.CreateNew(); // Assert uniqueResults.Add(result).Should().BeTrue(); var guidString = result.ToString(); sequentialData[i] = guidString.Substring(guidString.Length - numberOfChars, numberOfChars); } uniqueResults.Should().HaveCount(TestIterations); uniqueResults.Should().NotContain(Guid.Empty); sequentialData.Should().BeInAscendingOrder(); }
public async Task CollectionActorAdd_ExpectsNewStateWithNewItems() { var stateManager = new Mock <IActorStateManager>(); var state1 = new HashSet <string> { Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString() }; var state2 = new List <string> { Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString() }; stateManager.Setup(manager => manager.GetStateAsync <HashSet <string> >(_stateName, It.IsAny <CancellationToken>())) .Returns(Task.FromResult(state1)) .Verifiable(); stateManager.Setup(manager => manager.SetStateAsync(_stateName, state1, It.IsAny <CancellationToken>())) .Verifiable(); CollectionActor testDemoActor = await CreateActor(stateManager.Object, "Test Collection"); await testDemoActor.Add(state2[0]); await testDemoActor.Add(state2[1]); await testDemoActor.Add(state2[2]); state1.Should().HaveCount(8); state1.Should().Contain(state2); stateManager.VerifyAll(); }
public void BigTest_WithLimitedDepth(int depth, double ans, int evaluationsCount) { var root = GetTreeFromWikipediaSample(); alphaBeta.Search(root, depth).Score .Should().Be(ans); evaluations.Should().HaveCount(evaluationsCount); }
public void Clean_EmptyRootFolder_EmptyFileRegistry() { _folderNamesGenerator = path => Enumerable.Empty <string>(); _fileNamesGenerator = path => Enumerable.Empty <string>(); _cleaner.Clean("root"); _uniqueNames.Should().BeEmpty(); _backedUpNames.Should().BeEmpty(); }
public void GetNeighbours_Coordinates_For_TopRight_Cell() { var cell = new NotAliveCell(new Coordinate(x: 99, y: 1)); var neighbours = new HashSet <Coordinate>(cell.GetNeighbours()); neighbours.Count.Should().Be(3); neighbours.Should().Contain(new Coordinate(98, 1)); neighbours.Should().Contain(new Coordinate(98, 2)); neighbours.Should().Contain(new Coordinate(99, 2)); }
public void GetNeighbours_Coordinates_For_BottomLeft_Cell() { var cell = new NotAliveCell(new Coordinate(x: 1, y: 99)); var neighbours = new HashSet <Coordinate>(cell.GetNeighbours()); neighbours.Count.Should().Be(3); neighbours.Should().Contain(new Coordinate(1, 98)); neighbours.Should().Contain(new Coordinate(2, 98)); neighbours.Should().Contain(new Coordinate(2, 99)); }
public void GetNeighbours_Coordinates_For_LeftSide_Cell() { var cell = new NotAliveCell(new Coordinate(x: 1, y: 2)); var neighbours = new HashSet <Coordinate>(cell.GetNeighbours()); neighbours.Count.Should().Be(5); neighbours.Should().Contain(new Coordinate(1, 1)); neighbours.Should().Contain(new Coordinate(2, 1)); neighbours.Should().Contain(new Coordinate(2, 2)); neighbours.Should().Contain(new Coordinate(1, 3)); neighbours.Should().Contain(new Coordinate(2, 3)); }
public void CheckLoadOfSuppressionFile(string fileName) { const int expectedCount = 3629; var messagesToCheck = GetSuppressionMessagesToCheck(); string suppressionFilePath = GetFileFullPath(fileName); HashSet <SuppressMessage> messages = SuppressionFile.LoadMessages(_fileService, suppressionFilePath); messages.Should().NotBeNull(); messages.Should().HaveCount(expectedCount); messages.Should().ContainInOrder(messagesToCheck); }
public void Visit_EventDelegateTypesInluded() { //-- arrange var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne"); var type2 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS2", MemberVisibility.Public, TypeMemberKind.Class, "ClassTwo"); type1.Members.Add(new EventMember( MemberVisibility.Public, MemberModifier.None, typeof(Action <DateTime>), "E1")); type1.Members.Add(new EventMember( MemberVisibility.Public, MemberModifier.Static, ((TypeMember)typeof(Action <>)).MakeGenericType(type2), "E2")); var foundTypes = new HashSet <TypeMember>(); var visitorUnderTest = new TypeReferenceMemberVisitor(foundTypes); //-- act type1.AcceptVisitor(visitorUnderTest); //-- assert foundTypes.Should().BeEquivalentTo(new TypeMember[] { type1, typeof(Action <>), typeof(DateTime), type2 }); }
public void Visit_GenericTypeDefinitionsAndArgumentsIncluded() { //-- arrange var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne"); var type2 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS2", MemberVisibility.Public, TypeMemberKind.Class, "ClassTwo"); var type3 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS3", MemberVisibility.Public, TypeMemberKind.Class, "ClassThree"); type1.Members.Add(new PropertyMember( type1, MemberVisibility.Public, MemberModifier.None, ((TypeMember)typeof(IList <>)).MakeGenericType(type2), "Twos")); type1.Members.Add(new PropertyMember( type1, MemberVisibility.Public, MemberModifier.Static, ((TypeMember)typeof(IDictionary <,>)).MakeGenericType(type2, type3), "ThreeByTwo")); var foundTypes = new HashSet <TypeMember>(); var visitorUnderTest = new TypeReferenceMemberVisitor(foundTypes); //-- act type1.AcceptVisitor(visitorUnderTest); //-- assert foundTypes.Should().BeEquivalentTo(new TypeMember[] { type1, typeof(IList <>), typeof(IDictionary <,>), type2, type3 }); }
public void MergePrioritized_must_stream_data_from_all_sources() { var source1 = Source.From(Enumerable.Range(1, 3)); var source2 = Source.From(Enumerable.Range(4, 3)); var source3 = Source.From(Enumerable.Range(7, 3)); var priorities = new List <int> { 6, 3, 1 }; var probe = this.CreateManualSubscriberProbe <int>(); ThreeSourceMerge(source1, source2, source3, priorities, probe).Run(Materializer); var subscription = probe.ExpectSubscription(); var collected = new HashSet <int>(); for (int i = 1; i <= 9; i++) { subscription.Request(1); collected.Add(probe.ExpectNext()); } collected.Should().BeEquivalentTo(new HashSet <int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 }); probe.ExpectComplete(); }
public void Visit_MethodSignatureTypesIncluded() { //-- arrange var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne"); type1.Members.Add(new MethodMember(MemberVisibility.Public, MemberModifier.None, "M1", new MethodSignature( new[] { new MethodParameter("x", 1, typeof(int)), new MethodParameter("y", 2, typeof(string)) }, returnValue: null, isAsync: false ))); type1.Members.Add(new MethodMember(MemberVisibility.Public, MemberModifier.Static, "M2", new MethodSignature( new MethodParameter[0], returnValue: new MethodParameter(null, -1, typeof(TimeSpan)), isAsync: false ))); var foundTypes = new HashSet <TypeMember>(); var visitorUnderTest = new TypeReferenceMemberVisitor(foundTypes); //-- act type1.AcceptVisitor(visitorUnderTest); //-- assert foundTypes.Should().BeEquivalentTo(new TypeMember[] { type1, typeof(int), typeof(string), typeof(TimeSpan) }); }
public void BuildExpressionTree_Should_Create_ExpressionTree_From_PrefixExpression(List <int> minterms) { GC.Collect(); Stopwatch s2 = Stopwatch.StartNew(); var externalLibraryResult = QuineMcCluskeySolver.QMC_Solve(minterms, new int[] { }); s2.Stop(); TruthTable table = TruthTableHelpers.GenerateTruthTable(minterms); Stopwatch s1 = Stopwatch.StartNew(); var customLibraryResult = logic.ExpressionService.Common.QMC.QuineMcCluskey.SimplifyTable(table.Value); s1.Stop(); TestContext.Out.WriteLine(s1.ElapsedTicks); TestContext.Out.WriteLine(s2.ElapsedTicks); var helperSet = new HashSet <string>(); foreach (var pr in customLibraryResult) { helperSet.Add(pr.RowData); } foreach (var item in externalLibraryResult) { helperSet.Should().Contain(item.ToString()); } }
public void ShouldReportEventsWhenStateIsModified() { var expected = new HashSet <string>() { "resized", "deactivated", "activated", "closed", "disposed" }; var actual = new HashSet <string>(); app.Window.Show(); app.Window.Raise(); Window.OverrideCurrentWith(app.Window); app.IsActive.Should().BeTrue(); // it gets called when the initial size of window is set too app.Resized += (s, e) => actual.Add("resized"); app.Deactivated += (s, e) => actual.Add("deactivated"); app.Activated += (s, e) => actual.Add("activated"); app.Exiting += (s, e) => { actual.Add("closed"); e.Cancel = true; }; app.Disposed += (s, e) => actual.Add("disposed"); app.Window.Hide(); app.Tick(); app.Window.Raise(); app.Tick(); app.RequestExit(); app.Tick(); Window.OverrideCurrentWith(app.Window); app.Dispose(); actual.Should().BeEquivalentTo(expected); }
public void Group_Send_AllClientsShouldBeReceiveEvent() { var group = new FlowGroup(server); group.Add(destinationClients[0]); group.Add(destinationClients[2]); var transferString = "Hello client under index 0 & 2"; var expected = new HashSet <int> { 0, 2 }; var receivedOn = new HashSet <int>(); for (var i = 0; i < clients.Length; i++) { var index = i; clients[i].Bind <string>(1, value => { receivedOn.Add(index); }); } group.Send(1, transferString); Thread.Sleep(MillisecondsToWaitForTransfer); receivedOn.Should().BeEquivalentTo(expected); }
public void DocumentMappableTestDiscoversAllTypes() { //Arrange var assemblies = new HashSet <Assembly> { this.GetType().Assembly }; var seenTypes = new HashSet <Type>(); var expectedTypes = new HashSet <Type> { typeof(Guid), typeof(string), typeof(ClassWithDifferentMappableName), typeof(ChildClassWithDifferentMappableName), typeof(List <ChildClassWithDifferentMappableName>), typeof(IReadOnlyList <ChildClassWithDifferentMappableName>), typeof(IChildClassWithDifferentMappableName), typeof(List <IChildClassWithDifferentMappableName>), typeof(ChildClassWithDifferentMappableNameBase), typeof(IList <ChildClassWithDifferentMappableNameBase>), typeof(IReadOnlyDictionary <string, ChildClassWithDifferentMappableNameBase>), typeof(ChildClassWithDifferentMappableNameBase[]) }; //Act CheckForDocumentMappableAttribute(typeof(ClassWithDifferentMappableName), assemblies, seenTypes); //Assert seenTypes.Should().BeEquivalentTo(expectedTypes); }
public void ExplodedGraph_BothBranchesVisited_NonCondition() { var testInput = "var str = this?.ToString();"; var method = ControlFlowGraphTest.CompileWithMethodBody(string.Format(TestInput, testInput), "Bar", out var semanticModel); var methodSymbol = semanticModel.GetDeclaredSymbol(method); var cfg = CSharpControlFlowGraph.Create(method.Body, semanticModel); var lva = CSharpLiveVariableAnalysis.Analyze(cfg, methodSymbol, semanticModel); var explodedGraph = new CSharpExplodedGraph(cfg, methodSymbol, semanticModel, lva); var explorationEnded = false; explodedGraph.ExplorationEnded += (sender, args) => { explorationEnded = true; }; var countConditionEvaluated = 0; explodedGraph.ConditionEvaluated += (sender, args) => { countConditionEvaluated++; }; var visitedBlocks = new HashSet <Block>(); explodedGraph.InstructionProcessed += (sender, args) => { visitedBlocks.Add(args.ProgramPoint.Block); }; explodedGraph.Walk(); explorationEnded.Should().BeTrue(); visitedBlocks.Should().HaveCount(cfg.Blocks.Count() - 1 /* Exit block */); countConditionEvaluated.Should().Be(0); }
public void Visit_ConstructorBodyStatementsIncluded() { //-- arrange var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne"); var constructor1 = new ConstructorMember(MemberVisibility.Public, MemberModifier.None, "ClassOne", new MethodSignature()); var variable1 = new LocalVariable { Name = "x", Type = typeof(TimeSpan) }; constructor1.Body = new BlockStatement( new VariableDeclarationStatement { Variable = variable1 } ); type1.Members.Add(constructor1); var foundTypes = new HashSet <TypeMember>(); var visitorUnderTest = new TypeReferenceMemberVisitor(foundTypes); //-- act type1.AcceptVisitor(visitorUnderTest); //-- assert foundTypes.Should().BeEquivalentTo(new TypeMember[] { type1, typeof(TimeSpan) }); }
public void ItComputesExcludeFromPublishList() { LockFile lockFile = TestLockFiles.GetLockFile("dependencies.withgraphs"); ProjectContext projectContext = lockFile.CreateProjectContext( FrameworkConstants.CommonFrameworks.NetStandard16, runtime: null, Constants.DefaultPlatformLibrary, runtimeFrameworks: null, isSelfContained: false); IEnumerable <string> excludeFromPublishPackageIds = new[] { "Microsoft.Extensions.Logging.Abstractions" }; IDictionary <string, LockFileTargetLibrary> libraryLookup = projectContext .LockFileTarget .Libraries .ToDictionary(e => e.Name, StringComparer.OrdinalIgnoreCase); HashSet <string> exclusionList = projectContext.GetExcludeFromPublishList(excludeFromPublishPackageIds, libraryLookup); HashSet <string> expectedExclusions = new HashSet <string>() { "Microsoft.Extensions.Logging.Abstractions", "System.Collections.Concurrent", "System.Diagnostics.Tracing", }; exclusionList.Should().BeEquivalentTo(expectedExclusions); }
private void ExecuteRandomDurationsTest(int nrOfTests, int maxRandomDuration, int nrOfThreads) { IDictionary <Model.TestCase, int> durations = CreateRandomTestResults(nrOfTests, maxRandomDuration); MockOptions.Setup(o => o.MaxNrOfThreads).Returns(nrOfThreads); ITestsSplitter splitter = new DurationBasedTestsSplitter(durations, TestEnvironment.Options); List <List <Model.TestCase> > result = splitter.SplitTestcases(); result.Should().HaveCount(nrOfThreads); result.Select(l => l.Count).Sum().Should().Be(nrOfTests); int sumOfAllDurations = durations.Select(kvp => kvp.Value).Sum(); int maxDuration = durations.Select(kvp => kvp.Value).Max(); int targetDuration = sumOfAllDurations / nrOfThreads; HashSet <Model.TestCase> foundTestcases = new HashSet <Model.TestCase>(); foreach (List <Model.TestCase> testcases in result) { int sum = testcases.Select(tc => durations[tc]).Sum(); sum.Should().BeLessThan(targetDuration + maxDuration / 2); sum.Should().BeGreaterThan(targetDuration - maxDuration / 2); foundTestcases.UnionWith(testcases); } foundTestcases.Should().HaveCount(nrOfTests); }
public void DiagnosticBuilder_CodesAreUnique() { var diagnosticMethods = typeof(DiagnosticBuilder.DiagnosticBuilderInternal) .GetMethods(BindingFlags.Instance | BindingFlags.Public) .Where(m => typeof(Diagnostic).IsAssignableFrom(m.ReturnType)); // verify the above Linq is actually working diagnosticMethods.Should().HaveCountGreaterThan(40); var builder = DiagnosticBuilder.ForPosition(new TextSpan(0, 10)); var definedCodes = new HashSet <string>(StringComparer.OrdinalIgnoreCase); foreach (var diagnosticMethod in diagnosticMethods) { var mockParams = diagnosticMethod.GetParameters().Select(CreateMockParameter); var diagnostic = diagnosticMethod.Invoke(builder, mockParams.ToArray()) as Diagnostic; if (mockParams.Any()) { // verify that all the params are actually being written in the message diagnostic !.Message.Should().ContainAll(CollectExpectedStrings(mockParams), $"method {diagnosticMethod.Name} should use all of its parameters in the format string."); } // verify that the Code is unique definedCodes.Should().NotContain(diagnostic !.Code, $"Method {diagnosticMethod.Name} should be assigned a unique error code."); definedCodes.Add(diagnostic !.Code); } }
public async Task SubscribeAndUnsubcribe_MultipleSubscription() { var customResizeOptioons = new ResizeOptions(); var feedbackCallerCount = 0; Action <ListenForResizeCallbackInfo> feedbackCaller = (x) => { if (x.ListenerId == default) { throw new ArgumentException(); } feedbackCallerCount++; }; SetupJsMockForSubscription(customResizeOptioons, true, feedbackCaller); HashSet <Guid> subscriptionIds = new HashSet <Guid>(); for (int i = 0; i < 10; i++) { var subscritionResult = await _service.Subscribe((Breakpoint size) => { }); subscriptionIds.Add(subscritionResult.SubscriptionId); } feedbackCallerCount.Should().Be(1); subscriptionIds.Should().HaveCount(10); _jsruntimeMock.Verify(); _browserWindowSizeProvider.Verify(x => x.GetBrowserWindowSize(), Times.Once()); }
public void VisitBlockStatement_TypeofConstantsIncluded() { //-- arrange var block = new BlockStatement( new ReturnStatement { Expression = new ConstantExpression { Value = typeof(IDisposable) } }, new ReturnStatement { Expression = new ConstantExpression { Value = (TypeMember)typeof(IFormattable) } } ); var foundTypes = new HashSet <TypeMember>(); var visitor = new TypeReferenceStatementVisitor(foundTypes); //-- act block.AcceptVisitor(visitor); //-- assert foundTypes.Should().BeEquivalentTo(new TypeMember[] { typeof(IDisposable), typeof(IFormattable) }); }
public void ThenTheFollowingTimeseriesWillBeNonPrioritized(Table timeseries) { foreach (var row in timeseries.Rows) { _nonPrioritizedTimeseries.Should().Contain(Guid.Parse(row["timeseries"])); } }
public void ExplodedGraph_BothBranchesVisited() { const string testInput = "var a = false; bool b; if (inParameter) { b = inParameter; } else { b = !inParameter; } a = b;"; var context = new ExplodedGraphContext(testInput); var aSymbol = context.GetSymbol("a"); var bSymbol = context.GetSymbol("b"); var parameters = context.MainMethod.DescendantNodes().OfType <ParameterSyntax>(); var inParameterSymbol = context.SemanticModel.GetDeclaredSymbol(parameters.First(d => d.Identifier.ToString() == "inParameter")); var numberOfLastInstructionVisits = 0; var visitedBlocks = new HashSet <Block>(); var branchesVisited = 0; context.ExplodedGraph.InstructionProcessed += (sender, args) => { visitedBlocks.Add(args.ProgramPoint.Block); if (args.Instruction.ToString() == "a = false") { branchesVisited++; args.ProgramState.GetSymbolValue(aSymbol).Should().Be(SymbolicValue.False); } if (args.Instruction.ToString() == "b = inParameter") { branchesVisited++; bSymbol.HasConstraint(BoolConstraint.True, args.ProgramState).Should().BeTrue(); inParameterSymbol.HasConstraint(BoolConstraint.True, args.ProgramState).Should().BeTrue(); } if (args.Instruction.ToString() == "b = !inParameter") { branchesVisited++; // b has value, but not true or false args.ProgramState.GetSymbolValue(bSymbol).Should().NotBeNull(); bSymbol.HasConstraint(BoolConstraint.False, args.ProgramState).Should().BeFalse(); bSymbol.HasConstraint(BoolConstraint.True, args.ProgramState).Should().BeFalse(); inParameterSymbol.HasConstraint(BoolConstraint.False, args.ProgramState).Should().BeTrue(); } if (args.Instruction.ToString() == "a = b") { branchesVisited++; args.ProgramState.GetSymbolValue(inParameterSymbol).Should().BeNull(); // not out/ref parameter and LVA says dead numberOfLastInstructionVisits++; } }; // Number of ExitBlocks is still 1 in this case: // All variables are dead at the ExitBlock, so whenever we get there, // the ExplodedGraph nodes should be the same, and thus should be processed only once. context.WalkWithInstructions(13); branchesVisited.Should().Be(4 + 1); numberOfLastInstructionVisits.Should().Be(2); visitedBlocks.Should().HaveCount(context.ControlFlowGraph.Blocks.Count() - 1 /* Exit block*/); }
public void EqualityComparer_List_VB() { var comparer = new VisualBasicSyntaxNodeEqualityComparer <VisualBasic.StatementSyntax>(); var result = comparer.Equals(vbMethods.Method1, vbMethods.Method2); result.Should().BeTrue(); result = comparer.Equals(vbMethods.Method1, vbMethods.Method3); result.Should().BeFalse(); var hashSet = new HashSet <SyntaxList <VisualBasic.StatementSyntax> >(new[] { vbMethods.Method1, vbMethods.Method2, vbMethods.Method3 }, comparer); hashSet.Should().HaveCount(2); hashSet.Should().Contain(vbMethods.Method1); hashSet.Should().NotContain(vbMethods.Method4); }
public void EqualityComparer_Node_VB() { var comparer = new VisualBasicSyntaxNodeEqualityComparer <VisualBasic.StatementSyntax>(); var result = comparer.Equals(vbMethods.Method1.First(), vbMethods.Method2.First()); result.Should().BeTrue(); result = comparer.Equals(vbMethods.Method1.First(), vbMethods.Method3.First()); result.Should().BeFalse(); var hashSet = new HashSet <VisualBasic.StatementSyntax>(new[] { vbMethods.Method1.First(), vbMethods.Method2.First(), vbMethods.Method3.First() }, comparer); hashSet.Should().HaveCount(2); hashSet.Should().Contain(vbMethods.Method1.First()); hashSet.Should().NotContain(vbMethods.Method4.First()); }
public static void RandomSelect_SelectsAllElementsEventually() { var outputValues = new HashSet <string>(); for (int numberOfSelections = 0; numberOfSelections < 1000; numberOfSelections++) { var selector = new Selector <string>(); selector.TryAddItem("jen").Should().BeTrue(); selector.TryAddItem("michael").Should().BeTrue(); selector.TryAddItem("staci").Should().BeTrue(); outputValues.Add(selector.RandomSelect(1).First().Value); } outputValues.Should().Contain("jen"); outputValues.Should().Contain("michael"); outputValues.Should().Contain("staci"); }
public void When_getting_a_new_identifier_multiple_times_they_should_all_be_unique() { var generator = new BasicGuidGenerator(); var identifiers = new HashSet<Guid>(); for (int i = 0; i < 500; i++) { var newId = generator.GenerateNewId(); identifiers.Should().NotContain(newId); identifiers.Add(newId); } }
/** * Request and Response class names should be one to one in *most* cases. * e.g. ValidateRequest => ValidateResponse, and not ValidateQueryRequest => ValidateResponse */ //[U] public void ParityBetweenRequestsAndResponses() { var types = Assembly.Load("Nest").GetTypes(); var requests = new HashSet<string>(types .Where(t => t.IsClass && !t.IsAbstract && typeof(IRequest).IsAssignableFrom(t) && !(t.Name.EndsWith("Descriptor"))) .Select(t => t.Name.Split('`')[0].Replace("Request", "")) ); var responses = types .Where(t => t.IsClass && !t.IsAbstract && typeof(IResponse).IsAssignableFrom(t)) .Select(t => t.Name.Split('`')[0].Replace("Response", "")); // Add any exceptions to the rule here var exceptions = new string[] { "Cat" }; responses = responses.Where(r => !exceptions.Contains(r)).ToList(); foreach (var response in responses) requests.Should().Contain(response); }
public void PartialDelete() { using (var tmp = new TempDirectory()) { var dir = new LocalFileSystemDirectory(tmp); Directory.CreateDirectory(Path.Combine(tmp, "dir1")); Directory.CreateDirectory(Path.Combine(tmp, "dir1", "dir2")); using (var f = File.CreateText(Path.Combine(tmp, "dir1", "file.delete"))) f.WriteLine("test"); using (var f = File.CreateText(Path.Combine(tmp, "dir1", "file.keep"))) f.WriteLine("test"); using (var f = File.CreateText(Path.Combine(tmp, "dir1", "dir2", "file.delete"))) f.WriteLine("test"); var paths = new HashSet<string>(); dir.Delete(p => { paths.Add(p); return false; }); paths.Should().HaveCount(3); paths.Should().Contain(Path.Combine("dir1", "file.delete")); paths.Should().Contain(Path.Combine("dir1", "file.keep")); paths.Should().Contain(Path.Combine("dir1", "dir2", "file.delete")); Directory.Exists(tmp).Should().BeTrue(); Directory.Exists(Path.Combine(tmp, "dir1")).Should().BeTrue(); Directory.Exists(Path.Combine(tmp, "dir1", "dir2")).Should().BeTrue(); File.Exists(Path.Combine(tmp, "dir1", "file.delete")).Should().BeTrue(); File.Exists(Path.Combine(tmp, "dir1", "file.keep")).Should().BeTrue(); File.Exists(Path.Combine(tmp, "dir1", "dir2", "file.delete")).Should().BeTrue(); paths.Clear(); dir.Delete(p => { paths.Add(p); return !p.EndsWith(".keep", System.StringComparison.InvariantCulture); }); paths.Should().HaveCount(4); paths.Should().Contain(Path.Combine("dir1", "file.delete")); paths.Should().Contain(Path.Combine("dir1", "file.keep")); paths.Should().Contain(Path.Combine("dir1", "dir2")); paths.Should().Contain(Path.Combine("dir1", "dir2", "file.delete")); Directory.Exists(tmp).Should().BeTrue(); Directory.Exists(Path.Combine(tmp, "dir1")).Should().BeTrue(); Directory.Exists(Path.Combine(tmp, "dir1", "dir2")).Should().BeFalse(); File.Exists(Path.Combine(tmp, "dir1", "file.delete")).Should().BeFalse(); File.Exists(Path.Combine(tmp, "dir1", "file.keep")).Should().BeTrue(); File.Exists(Path.Combine(tmp, "dir1", "dir2", "file.delete")).Should().BeFalse(); paths.Clear(); dir.Delete(p => { paths.Add(p); return true; }); paths.Should().HaveCount(3); paths.Should().Contain(Path.Combine("dir1", "file.keep")); paths.Should().Contain("dir1"); paths.Should().Contain(""); Directory.Exists(tmp).Should().BeFalse(); } }
public void GetCommandLines_ManyTestsWithSuites_BreaksUpLongCommandLinesCorrectly() { List<string> allTests = new List<string>(); List<string> testsToExecute = new List<string>(); for (int i = 0; i < 1000; i++) { allTests.Add("MyTestSuite" + i + ".MyTest"); testsToExecute.Add("MyTestSuite" + i + ".MyTest"); allTests.Add("MyTestSuite" + i + ".MyTest2"); } testsToExecute.Add("MyTestSuite1.MyTest2"); testsToExecute.Add("MyTestSuite5.MyTest2"); IEnumerable<Model.TestCase> allTestCases = allTests.Select(TestDataCreator.ToTestCase).ToList(); IEnumerable<Model.TestCase> testCases = testsToExecute.Select(TestDataCreator.ToTestCase).ToList(); List<CommandLineGenerator.Args> commands = new CommandLineGenerator(allTestCases, testCases, TestDataCreator.DummyExecutable.Length, "", "", TestEnvironment) .GetCommandLines().ToList(); commands.Count.Should().Be(3); int lengthOfLongestTestname = allTests.Max(s => s.Length); int maxLength = CommandLineGenerator.MaxCommandLength - TestDataCreator.DummyExecutable.Length; int minLength = CommandLineGenerator.MaxCommandLength - lengthOfLongestTestname - TestDataCreator.DummyExecutable.Length - 1; string commandLine = commands[0].CommandLine; commandLine.Length.Should().BeLessThan(maxLength); commandLine.Length.Should().BeGreaterOrEqualTo(minLength); commandLine.Should().StartWith($@"--gtest_output=""xml:""{DefaultArgs} --gtest_filter=MyTestSuite1.*:MyTestSuite5.*:MyTestSuite0.MyTest:"); commandLine = commands[1].CommandLine; commandLine.Length.Should().BeLessThan(maxLength); commandLine.Length.Should().BeGreaterOrEqualTo(minLength); commandLine.Should().NotStartWith(@"--gtest_output=""xml:"" --gtest_filter=MyTestSuite1.*:MyTestSuite5.*:"); commandLine.Should().StartWith($@"--gtest_output=""xml:""{DefaultArgs} --gtest_filter="); commandLine = commands[2].CommandLine; commandLine.Length.Should().BeLessThan(maxLength); commandLine.Should() .NotStartWith($@"--gtest_output=""xml:""{DefaultArgs} --gtest_filter=MyTestSuite1.*:MyTestSuite5.*:"); commandLine.Should().StartWith($@"--gtest_output=""xml:""{DefaultArgs} --gtest_filter="); HashSet<Model.TestCase> testsAsSet = new HashSet<Model.TestCase>(testCases); HashSet<Model.TestCase> splittedTestsAsSet = new HashSet<Model.TestCase>(commands[0].TestCases.Union(commands[1].TestCases).Union(commands[2].TestCases)); splittedTestsAsSet.Should().BeEquivalentTo(testsAsSet); }
public void RemoteRouter_must_deploy_its_children_on_remote_host_driven_by_configuration() { var probe = CreateTestProbe(masterSystem); var router = masterSystem.ActorOf(new RoundRobinPool(2).Props(EchoActorProps), "blub"); var replies = CollectRouteePaths(probe, router, 5); var childred = new HashSet<ActorPath>(replies); childred.Should().HaveCount(2); childred.Select(x => x.Parent).Distinct().Should().HaveCount(1); childred.ForEach(x => x.Address.Should().Be(intendedRemoteAddress)); masterSystem.Stop(router); }
public void RemoteRouter_must_deploy_its_children_on_remote_host_driven_by_programmatic_definition() { var probe = CreateTestProbe(masterSystem); var router = masterSystem.ActorOf(new RemoteRouterConfig( new RoundRobinPool(2), new[] { new Address("akka.tcp", sysName, "127.0.0.1", port) }) .Props(EchoActorProps), "blub2"); var replies = CollectRouteePaths(probe, router, 5); var childred = new HashSet<ActorPath>(replies); childred.Should().HaveCount(2); childred.Select(x => x.Parent).Distinct().Should().HaveCount(1); childred.ForEach(x => x.Address.Should().Be(intendedRemoteAddress)); masterSystem.Stop(router); }
public void RemoteRouter_must_deploy_dynamic_resizable_number_of_children_on_remote_host_driven_by_configuration() { var probe = CreateTestProbe(masterSystem); var router = masterSystem.ActorOf(FromConfig.Instance.Props(EchoActorProps), "elastic-blub"); var replies = CollectRouteePaths(probe, router, 5); var childred = new HashSet<ActorPath>(replies); childred.Should().HaveCount(2); childred.Select(x => x.Parent).Distinct().Should().HaveCount(1); childred.ForEach(x => x.Address.Should().Be(intendedRemoteAddress)); masterSystem.Stop(router); }
public void RemoteRouter_must_deploy_remote_routers_based_on_configuration() { var probe = CreateTestProbe(masterSystem); var router = masterSystem.ActorOf(FromConfig.Instance.Props(EchoActorProps), "remote-blub"); router.Path.Address.Should().Be(intendedRemoteAddress); var replies = CollectRouteePaths(probe, router, 5); var childred = new HashSet<ActorPath>(replies); childred.Should().HaveCount(2); var parents = childred.Select(x => x.Parent).Distinct().ToList(); parents.Should().HaveCount(1); parents.Head().Should().Be(router.Path); childred.ForEach(x => x.Address.Should().Be(intendedRemoteAddress)); masterSystem.Stop(router); }
public void RemoteRouter_must_let_remote_deployment_be_overridden_by_local_configuration() { var probe = CreateTestProbe(masterSystem); var router = masterSystem.ActorOf( new RoundRobinPool(2) .Props(EchoActorProps) .WithDeploy(new Deploy(new RemoteScope(intendedRemoteAddress))), "local-blub"); router.Path.Address.ToString().Should().Be(string.Format("akka://{0}", masterSystem.Name)); var replies = CollectRouteePaths(probe, router, 5); var childred = new HashSet<ActorPath>(replies); childred.Should().HaveCount(2); var parents = childred.Select(x => x.Parent).Distinct().ToList(); parents.Should().HaveCount(1); parents.Head().Address.Should().Be(new Address("akka.tcp", sysName, "127.0.0.1", port)); childred.ForEach(x => x.Address.Should().Be(intendedRemoteAddress)); masterSystem.Stop(router); }
public void RemoteRouter_must_let_remote_deployment_be_overridden_by_remote_configuration() { var probe = CreateTestProbe(masterSystem); var router = masterSystem.ActorOf( new RoundRobinPool(2) .Props(EchoActorProps) .WithDeploy(new Deploy(new RemoteScope(intendedRemoteAddress))), "remote-override"); router.Path.Address.Should().Be(intendedRemoteAddress); var replies = CollectRouteePaths(probe, router, 5); var childred = new HashSet<ActorPath>(replies); childred.Should().HaveCount(4); var parents = childred.Select(x => x.Parent).Distinct().ToList(); parents.Should().HaveCount(1); parents.Head().Address.Should().Be(router.Path.Address); childred.ForEach(x => x.Address.Should().Be(intendedRemoteAddress)); masterSystem.Stop(router); }
public void RemoteRouter_must_load_settings_from_config_for_local_router() { var probe = CreateTestProbe(masterSystem); var router = masterSystem.ActorOf(FromConfig.Instance.Props(EchoActorProps), "round"); var replies = CollectRouteePaths(probe, router, 10); var childred = new HashSet<ActorPath>(replies); childred.Should().HaveCount(5); masterSystem.Stop(router); }
public void RemoteRouter_must_load_settings_from_config_for_local_child_router_of_system_actor() { // we don't really support deployment configuration of system actors, but // it's used for the pool of the SimpleDnsManager "/IO-DNS/inet-address" var probe = CreateTestProbe(masterSystem); var parent = ((ExtendedActorSystem)masterSystem).SystemActorOf(FromConfig.Instance.Props(Props.Create<Parent>()), "sys-parent"); parent.Tell(Tuple.Create(FromConfig.Instance.Props(EchoActorProps), "round"), probe); var router = probe.ExpectMsg<IActorRef>(); var replies = CollectRouteePaths(probe, router, 10); var childred = new HashSet<ActorPath>(replies); childred.Should().HaveCount(6); masterSystem.Stop(router); }