public static IEnumerable<string> GetHelp(ScriptSession session, string command) { Collection<PSParseError> errors; var tokens = PSParser.Tokenize(command, out errors); var lastPsToken = tokens.LastOrDefault(t => t.Type == PSTokenType.Command); if (lastPsToken != null) { session.Output.Clear(); var lastToken = lastPsToken.Content; session.SetVariable("helpFor", lastToken); var platformmodule = ModuleManager.GetModule("Platform"); var scriptItem = Database.GetDatabase(platformmodule.Database) .GetItem(platformmodule.Path + "/Internal/Context Help/Command Help"); if (scriptItem == null) { scriptItem = Factory.GetDatabase(ApplicationSettings.ScriptLibraryDb) .GetItem(ApplicationSettings.ScriptLibraryPath + "Internal/Context Help/Command Help"); } session.ExecuteScriptPart(scriptItem[ScriptItemFieldNames.Script], true, true); var sb = new StringBuilder("<div id=\"HelpClose\">X</div>"); if (session.Output.Count == 0 || session.Output[0].LineType == OutputLineType.Error) { return new[] { "<div class='ps-help-command-name'> </div><div class='ps-help-header' align='center'>No Command in line or help information found</div><div class='ps-help-parameter' align='center'>Cannot provide help in this context.</div>" }; } session.Output.ForEach(l => sb.Append(l.Text)); session.Output.Clear(); var result = new[] {sb.ToString()}; return result; } return new[] {"No Command in line found - cannot provide help in this context."}; }
public ActionResult Search(string query) { ViewData["Message"] = "query : " + query; var searcher = new IndexSearcher( new Lucene.Net.Store.SimpleFSDirectory(new DirectoryInfo(Configuration.IndexDirectory)), readOnly: true); var fieldsToSearchIn = new[] {Configuration.Fields.Name, Configuration.Fields.Description}; var queryanalizer = new MultiFieldQueryParser(Version.LUCENE_CURRENT, fieldsToSearchIn, new BrazilianAnalyzer()); var numberOfResults = 10; var top10Results = searcher.Search(queryanalizer.Parse(query), numberOfResults); var docs = new List<DocumentViewModel>(); foreach (var scoreDoc in top10Results.scoreDocs) { var document = searcher.Doc(scoreDoc.doc); var name = document.GetField(Configuration.Fields.Name).StringValue(); var description = document.GetField(Configuration.Fields.Description).StringValue(); var link = document.GetField(Configuration.Fields.Link).StringValue(); docs.Add(new DocumentViewModel(name, description, link)); } return View(new SearchViewModel(docs)); }
public ActionResult Index() { var themes = new List<dynamic>(); var dirbase = new DirectoryInfo(HttpContext.Server.MapPath(string.Format("~/Content/js/easyui/{0}/themes", AppSettings.EasyuiVersion))); DirectoryInfo[] dirs = dirbase.GetDirectories(); foreach (var dir in dirs) if (dir.Name != "icons") themes.Add(new {text=dir.Name,value=dir.Name }); var navigations = new List<dynamic>(); navigations.Add(new { text = "手风琴-2级(默认)", value = "accordion" }); //navigations.Add(new { text = "手风琴大图标-2级", value = "accordionbigicon" }); navigations.Add(new { text = "手风琴树", value = "accordiontree" }); navigations.Add(new { text = "横向菜单", value = "menubutton" }); navigations.Add(new { text = "树形结构", value = "tree" }); var model = new { dataSource = new{ themes=themes, navigations=navigations }, form= new sys_userService().GetCurrentUserSettings() }; return View(model); }
public void FiltersForLineItemType() { // Arrange var sw = new StringWriter(); using (var csv = new CsvWriter(sw)) { var lineItems = new[] { new LineItem {RecordType = "Dummy"}, new LineItem {RecordType = "LineItem", RecordId = "Hoojey"} }; csv.WriteHeader<LineItem>(); csv.WriteRecords(lineItems); } // Act List<LineItem> parsedItems; using (var reader = new StringReader(sw.ToString())) { using (var parser = new LineItemCsvParser(reader)) { parsedItems = parser.GetLineItems().ToList(); } } // Assert parsedItems.Count.Should().Be(1); parsedItems[0].RecordId.Should().Be("Hoojey"); }
public void TestIncomingMessageQueue() { var processed = new List<MessageSet>(); var testQueue = new IncomingMessageQueue(processed.Add); var testSets = new[] { new MessageSet {Number = 2}, new MessageSet {Number = 1}, new MessageSet {Number = 3}, new MessageSet {Number = 4}, new MessageSet {Number = 5}, new MessageSet {Number = 7}, new MessageSet {Number = 8}, new MessageSet {Number = 6}, new MessageSet {Number = 9}, new MessageSet {Number = 10} }; foreach (var messageSet in testSets) testQueue.ProcessMessageSet(messageSet); Assert.AreEqual(processed.Count, 10); int numberTest = 1; foreach (var eventSet in processed) Assert.AreEqual(eventSet.Number, numberTest++); Assert.AreEqual(testQueue.NextMessageSetNumber, 11); }
public void StdDevTest() { // TODO: write a mock for benchmark reports var report = new BenchmarkReport( new Benchmark( new BenchmarkTarget(null, null), new BenchmarkTask(1, new BenchmarkConfiguration( BenchmarkMode.SingleRun, BenchmarkPlatform.AnyCpu, BenchmarkJitVersion.HostJit, BenchmarkFramework.HostFramework, BenchmarkToolchain.Classic, BenchmarkRuntime.Clr, 1, 1))), new List<BenchmarkRunReport> { new BenchmarkRunReport(1, 10), new BenchmarkRunReport(1, 50), new BenchmarkRunReport(1, 100) }); var reports = new[] { report }; var warnings = new BenchmarkStdDevAnalyser().Analyze(reports).ToList(); Assert.Equal(1, warnings.Count); foreach (var warning in warnings) output.WriteLine($"[{warning.Kind}] {warning.Message}"); }
public void Should_return_the_file_names_that_are_in_the_array_of_arguments() { string[] args = new[] { "/Assembly:MyAssembly", "file1", "file2", "*.xlsx" }; List<string> files = args.GetFiles(); Assert.IsTrue(files.Count == 3); Assert.IsFalse(files.Exists(x => x.Equals("/Assembly:MyAssembly"))); }
public async Task GetUserClaimTest() { var db = UnitTestHelper.CreateDefaultDb(); var manager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db)); var user = new IdentityUser("u1"); var result = await manager.CreateAsync(user); UnitTestHelper.IsSuccess(result); Assert.NotNull(user); var claims = new[] { new Claim("c1", "v1"), new Claim("c2", "v2"), new Claim("c3", "v3") }; foreach (Claim c in claims) { UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c)); } var userClaims = new List<Claim>(await manager.GetClaimsAsync(user.Id)); Assert.Equal(3, userClaims.Count); foreach (Claim c in claims) { Assert.True(userClaims.Exists(u => u.Type == c.Type && u.Value == c.Value)); } }
public object GetConfiguration(string type, int id) { var objectType = Mappings.TreeNodeObjectTypes[new TreeNodeType("settings", type)]; var contentTypes = ContentTypeService.GetAllContentTypes().ToList(); var mediaTypes = ApplicationContext.Services.ContentTypeService.GetAllMediaTypes().ToList(); var types = new[] { (objectType == UmbracoObjectTypes.DocumentType ? UmbracoObjectTypes.Document : UmbracoObjectTypes.Media).GetGuid(), }; var relationTypes = ApplicationContext.Services.RelationService.GetAllRelationTypes() .Where(rt => types.Contains(rt.ParentObjectType)) ; var contentType = objectType == UmbracoObjectTypes.DocumentType ? (IContentTypeBase)contentTypes.Single(ct => ct.Id == id) : mediaTypes.Single(ct => ct.Id == id); var contentObjectType = objectType == UmbracoObjectTypes.DocumentType ? UmbracoObjectTypes.Document : UmbracoObjectTypes.Media; return new { contentTypes, mediaTypes, relationTypes, configuration = RelationEditor.Configuration.Get(contentObjectType, contentType.Alias) }; }
public void SortArrayOfInts() { var unsorted = new[] {5, 2, 3, -1, 8}; var sorted = new[] {-1, 2, 3, 5, 8}; Assert.That(InsertionSortArray(unsorted), Is.EqualTo(sorted)); }
public ActionResult GetLogGridItems(GridSettings gridSettings) { var logGridItems = _logRepository.GetLogItems(gridSettings); var totalLogGridItems = _logRepository.CountLogItems(gridSettings); var pageIndex = gridSettings.PageIndex; var pageSize = gridSettings.PageSize; var jsonData = new { total = (totalLogGridItems / pageSize) + ((totalLogGridItems % pageSize > 0) ? 1 : 0), page = pageIndex, records = totalLogGridItems, rows = (from logItem in logGridItems select new Dictionary<string, string> { { "Id", logItem.Id.ToString() }, { "Created", logItem.Created.ToString() }, { "Level", logItem.Level }, { "Username", logItem.Username }, { "Message", logItem.Message} }).ToArray() }; return Json(jsonData, JsonRequestBehavior.AllowGet); }
internal static async Task TestNotReusedOnAssemblyDiffersAsync(string projectLanguage) { var metadataSources = new[] { @"[assembly: System.Reflection.AssemblyVersion(""1.0.0.0"")] public class D {}", @"[assembly: System.Reflection.AssemblyVersion(""2.0.0.0"")] public class D {}" }; using (var context = await TestContext.CreateAsync(projectLanguage)) { var projectId = ProjectId.CreateNewId(); var metadataProject = context.CurrentSolution .AddProject(projectId, "Metadata", "Metadata", LanguageNames.CSharp).GetProject(projectId) .AddMetadataReference(TestReferences.NetFx.v4_0_30319.mscorlib) .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release)); var references = new List<MetadataReference>(); foreach (var source in metadataSources) { var newDoc = metadataProject.AddDocument("MetadataSource", source); metadataProject = newDoc.Project; references.Add(MetadataReference.CreateFromImage((await metadataProject.GetCompilationAsync()).EmitToArray())); metadataProject = metadataProject.RemoveDocument(newDoc.Id); } var project = context.DefaultProject.AddMetadataReference(references[0]); var a = await context.GenerateSourceAsync("D", project); project = project.RemoveMetadataReference(references[0]).AddMetadataReference(references[1]); var b = await context.GenerateSourceAsync("D", project); context.VerifyDocumentNotReused(a, b); } }
public void CombineWith() { // Arrange List<string> log = new List<string>(); ModelValidationNode[] allChildNodes = new[] { new ModelValidationNode(GetModelMetadata(), "key1"), new ModelValidationNode(GetModelMetadata(), "key2"), new ModelValidationNode(GetModelMetadata(), "key3"), }; ModelValidationNode parentNode1 = new ModelValidationNode(GetModelMetadata(), "parent1"); parentNode1.ChildNodes.Add(allChildNodes[0]); parentNode1.Validating += (sender, e) => log.Add("Validating parent1."); parentNode1.Validated += (sender, e) => log.Add("Validated parent1."); ModelValidationNode parentNode2 = new ModelValidationNode(GetModelMetadata(), "parent2"); parentNode2.ChildNodes.Add(allChildNodes[1]); parentNode2.ChildNodes.Add(allChildNodes[2]); parentNode2.Validating += (sender, e) => log.Add("Validating parent2."); parentNode2.Validated += (sender, e) => log.Add("Validated parent2."); // Act parentNode1.CombineWith(parentNode2); parentNode1.Validate(ContextUtil.CreateActionContext()); // Assert Assert.Equal(new[] { "Validating parent1.", "Validating parent2.", "Validated parent1.", "Validated parent2." }, log.ToArray()); Assert.Equal(allChildNodes, parentNode1.ChildNodes.ToArray()); }
public void HashCodeBasedOnEquality() { string[] names = new[] {"foo", "bar", "baz", "quux", "quuux"}; for (int i = 0; i <= names.Length; ++i) { for (int j = 0; j != 3; ++j) { for (int x = 0; x <= names.Length; ++x) { for (int y = 0; y != 3; ++y) { var info0 = new CallInfo(i + j, names.Take(i)); var info1 = new CallInfo(x + y, names.Take(x)); if (info0.Equals(info1)) { Assert.Equal(info0.GetHashCode(), info1.GetHashCode()); } else { // Failure at this point is not definitely a bug, // but should be considered a concern unless it can be // convincingly ruled a fluke. Assert.NotEqual(info0.GetHashCode(), info1.GetHashCode()); } } } } } }
protected override void Prepare() { base.Prepare(); _defaultScreen = new LocalMediaNavigationScreenData(_genericPlayableItemCreatorDelegate); // Dynamic screens remain null - browse media states don't provide dynamic filters _availableScreens = null; _defaultSorting = new BrowseDefaultSorting(); _availableSortings = new List<Sorting.Sorting> { _defaultSorting, new SortByTitle(), new SortByDate(), // We could offer sortings here which are specific for one media item type but which will cope with all three item types (and sort items of the three types in a defined order) }; var optionalMias = new[] { AudioAspect.ASPECT_ID, VideoAspect.ASPECT_ID, ImageAspect.ASPECT_ID }.Union(MediaNavigationModel.GetMediaSkinOptionalMIATypes(MediaNavigationMode)); _customRootViewSpecification = new AddedRemovableMediaViewSpecificationFacade( new LocalMediaRootProxyViewSpecification(_viewName, _necessaryMias, optionalMias)); }
private void WriteNodes(XElement nodes) { foreach (NodeInfo nodeInfo in _snapshot.Nodes) { var labelComponents = new[] {nodeInfo.NodeType.ToString(), nodeInfo.Details} .Union(nodeInfo.Conditions) .Union(nodeInfo.Expressions) .Where(x => !string.IsNullOrEmpty(x)); string label = string.Join("\n", labelComponents); var node = new XElement(Name("Node"), new XAttribute("Id", Id(nodeInfo)), new XAttribute("Category", nodeInfo.NodeType), new XAttribute("Label", label)); if (nodeInfo.Items.Length > 0) { node.Add(new XAttribute("Group", "Collapsed")); } nodes.Add(node); for (int i = 0; i < nodeInfo.Items.Length; i++) { var itemNode = new XElement(Name("Node"), new XAttribute("Id", SubNodeId(nodeInfo, i)), new XAttribute("Label", nodeInfo.Items[i]), new XAttribute("Style", "Plain")); nodes.Add(itemNode); } } }
public void ParseCommandLineArguments_ShouldUseBaseParserToParseArgs() { var args = new[] { "foo", "bar" }; parser.ParseCommandLineArguments(args); baseParser.Received().ParseCommandLineArguments(args); }
public void SetUp() { var list1 = new[] { 1, 2, 3, 5 }; var list2 = new[] { 1, 2, 3, 4, 5 }; this.result = list1.Consolidate(list2); }
public async Task TestLowerCaseComlicatedNamespaceAsync() { var testCode = @"namespace test.foo.bar { }"; var fixedCode = @"namespace Test.Foo.Bar { }"; DiagnosticResult[] expected = new[] { this.CSharpDiagnostic().WithArguments("test").WithLocation(1, 11), this.CSharpDiagnostic().WithArguments("test").WithLocation(1, 11), this.CSharpDiagnostic().WithArguments("test").WithLocation(1, 11), this.CSharpDiagnostic().WithArguments("foo").WithLocation(1, 16), this.CSharpDiagnostic().WithArguments("foo").WithLocation(1, 16), this.CSharpDiagnostic().WithArguments("foo").WithLocation(1, 16), this.CSharpDiagnostic().WithArguments("bar").WithLocation(1, 20), this.CSharpDiagnostic().WithArguments("bar").WithLocation(1, 20), this.CSharpDiagnostic().WithArguments("bar").WithLocation(1, 20) }; await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false); await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false); await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false); }
public static Edge[] GetEdgesOfTile(GameObject tile) { //1.构造出4个边 Vector2 center = tile.transform.position; Sprite sprite = tile.GetComponent<SpriteRenderer>().sprite; float extendX = sprite.bounds.extents.x; float extendY = sprite.bounds.extents.y; //顺序:左下、左上、右上、右下 Vector2[] vertices = new[] { new Vector2(center.x - extendX, center.y - extendY), new Vector2(center.x - extendX, center.y + extendY), new Vector2(center.x + extendX, center.y + extendY), new Vector2(center.x + extendX, center.y - extendY), }; return new[] { new Edge(vertices[0], vertices[1], center, Direction.Left), new Edge(vertices[1], vertices[2], center, Direction.Top), new Edge(vertices[2], vertices[3], center, Direction.Right), new Edge(vertices[3], vertices[0], center, Direction.Bottom), }; }
public void SortListOfInts() { var unsorted = new[] { 5, 2, 3, -1, 8 }; var sorted = new[] { -1, 2, 3, 5, 8 }; Assert.That(InsertionSortIEnumerable(unsorted), Is.EqualTo(sorted)); }
public override IEnumerable<OperatorElement> FindPath(Element target) { var pathHere = new[] {this}; if (ReferenceEquals(Elements.Lhs, target) || ReferenceEquals(Elements.Rhs, target)) return pathHere; var pathFromHere = Elements.Lhs.FindPath(target) ?? Elements.Rhs.FindPath(target); return pathFromHere != null ? pathHere.Concat(pathFromHere) : null; }
public void Can_translate_generic_lists() { var values = new[] { "A", "B", "C" }; var testA = new TestClassA { FromStringList = new ArrayOfString(values), ToStringList = new List<string>(values), FromUserFileTypes = new List<UserFileType> { UserFileType.DefaultProfile, UserFileType.OriginalProfile }, }; var fromTestA = testA.TranslateTo<TestClassB>(); AssertAreEqual(testA, fromTestA); var userFileTypeValues = testA.FromUserFileTypes.ConvertAll(x => x.ToString()); var testB = new TestClassB { FromStringList = new List<string>(values), ToStringList = new ArrayOfString(values), FromUserFileTypes = new ArrayOfString(userFileTypeValues), }; var fromTestB = testB.TranslateTo<TestClassA>(); AssertAreEqual(fromTestB, testB); }
public async Task TestCtor() { var blocks = new[] { new TransformBlock<int, string>(i => i.ToString()), new TransformBlock<int, string>(i => i.ToString(), new ExecutionDataflowBlockOptions { MaxMessagesPerTask = 1 }), new TransformBlock<int, string>(i => Task.Run(() => i.ToString()), new ExecutionDataflowBlockOptions { MaxMessagesPerTask = 1 }) }; foreach (var block in blocks) { Assert.Equal(expected: 0, actual: block.InputCount); Assert.Equal(expected: 0, actual: block.OutputCount); Assert.False(block.Completion.IsCompleted); } blocks = new[] { new TransformBlock<int, string>(i => i.ToString(), new ExecutionDataflowBlockOptions { CancellationToken = new CancellationToken(true) }), new TransformBlock<int, string>(i => Task.Run(() => i.ToString()), new ExecutionDataflowBlockOptions { CancellationToken = new CancellationToken(true) }) }; foreach (var block in blocks) { Assert.Equal(expected: 0, actual: block.InputCount); Assert.Equal(expected: 0, actual: block.OutputCount); await Assert.ThrowsAnyAsync<OperationCanceledException>(() => block.Completion); } }
public void MapToTokenModelTest() { const string email = "*****@*****.**"; const int id = 1; const string hash = "HashToken"; IEnumerable<string> roles = new[] {"Admin", "Student", "Teacher"}; Mock<ITokenValidation> token = new Mock<ITokenValidation>(); UserToTokenMapper mapper = new UserToTokenMapper(token.Object); var initial = new UserWithPasswordModel() { Email = email, Id = id, HashToken = hash, Roles = roles }; var expected = new TokenModel() { EmailAndIdToken = email, RolesToken = roles.ToString(), HashToken = hash }; token.Setup(x => x.EncodeEmailAndIdToken(id.ToString() + ' ' + email.ToLower())) .Returns(email); token.Setup(x => x.EncodeRoleToken(roles)) .Returns(roles.ToString); var action = mapper.MapToTokenModel(initial); Assert.IsNotNull(action); Assert.AreEqual(action.EmailAndIdToken, expected.EmailAndIdToken); Assert.AreEqual(action.HashToken, expected.HashToken); Assert.AreEqual(action.RolesToken, expected.RolesToken); }
private static string[] GetLibrariesScript() { string[] libraries = new[] { "~/Scripts/jquery-1.9.1.js", "~/Scripts/jquery.address.js", "~/Scripts/jquery-ui.js", "~/Scripts/jquery-timePicker/jquery.timepicker.js", "~/Scripts/shortcut.js", "~/Scripts/colorbox/jquery.colorbox.js", "~/Scripts/jqueryNumber/jquery.number.js", "~/Scripts/date.js", "~/Scripts/chartjs/Chart.min.js", "~/Scripts/chartjs/legend.js", "~/Scripts/notify-combined.min.js", "~/Scripts/semantic-ui/semantic.js", "~/Scripts/jquery.signalR.js", "~/Scripts/vakata-jstree/dist/jstree.min.js", "~/Scripts/momentjs/moment-with-locales.js", "~/Scripts/underscore/underscore-min.js", "~/Scripts/angular/angular.min.js", "~/Scripts/linq.js/linq.js" }; libraries = libraries.Concat(GetMixERPCoreScript()).ToArray(); return libraries; }
public void SearchUsesServiceMethodIfServerSupportsIt() { // Arrange var client = new Mock<IHttpClient>(); var context = new Mock<IDataServiceContext>(); var repository = new Mock<DataServicePackageRepository>(client.Object) { CallBase = true }; var packages = new[] { PackageUtility.CreatePackage("A", description:"New and aweseome"), PackageUtility.CreatePackage("B", description:"old and bad"), PackageUtility.CreatePackage("C", description:"rich") }; repository.Setup(m => m.GetPackages()).Returns(packages.AsQueryable()); repository.Object.Context = context.Object; context.Setup(m => m.SupportsServiceMethod("Search")).Returns(true); context.Setup(m => m.CreateQuery<DataServicePackage>(It.IsAny<string>(), It.IsAny<IDictionary<string, object>>())) .Callback<string, IDictionary<string, object>>((entitySet, parameters) => { // Assert Assert.Equal("Search", entitySet); Assert.Equal(2, parameters.Count); Assert.Equal("'old'", parameters["searchTerm"]); Assert.Equal("''", parameters["targetFramework"]); }) .Returns(new Mock<IDataServiceQuery<DataServicePackage>>().Object); // Act repository.Object.Search("old", allowPrereleaseVersions: false); }
public void ByViewAndVectorAnalysisData_ValidArgs() { var samplePoints = new[] { Point.ByCoordinates(0, 2, 4), Point.ByCoordinates(0, 7, 4), Point.ByCoordinates(0, 19, 4) }; var sampleValues = new[] { Vector.ByCoordinates(0, 2, 4), Vector.ByCoordinates(0, 7, 4), Vector.ByCoordinates(0, 19, 4) }; var data = VectorAnalysisData.ByPointsAndResults( samplePoints, new List<string>() { "Test vector data." }, new List<IList<Vector>>() { sampleValues }); var doc = Document.Current; var grid = VectorAnalysisDisplay.ByViewAndVectorAnalysisData(doc.ActiveView, new []{data}); Assert.NotNull(grid); }
private static void AssertInequalities(string[] subject) { var reference = new[] { "foo", "bar", "baz" }; IComparer<IEnumerable<string>> comparer = new EnumerableComparer<string>(); Assert.AreEqual(-1, comparer.Compare(reference, subject)); Assert.AreEqual(1, comparer.Compare(subject, reference)); }
public void Sink_ShouldContainTestForAllSupportedTypeOfSources() { var sources = new[] { "ListContentSupport" + BoostTestDiscoverer.ExeExtension, "DllProject1" + BoostTestDiscoverer.DllExtension, "DllProject2" + BoostTestDiscoverer.DllExtension, }; var context = new DefaultTestContext(); var logger = new ConsoleMessageLogger(); var sink = new DefaultTestCaseDiscoverySink(); context.RegisterSettingProvider(BoostTestAdapterSettings.XmlRootName, new BoostTestAdapterSettingsProvider()); context.LoadEmbeddedSettings("BoostTestAdapterNunit.Resources.Settings.externalTestRunner.runsettings"); var boostTestDiscovererFactory = new StubBoostTestDiscovererFactory(); var boostTestDiscoverer = new BoostTestDiscoverer(boostTestDiscovererFactory); boostTestDiscoverer.DiscoverTests(sources, context, logger, sink); Assert.That(sink.Tests, Is.Not.Empty); // tests are found in the using the fake debughelper Assert.That(sink.Tests.Count(x => x.Source == "ListContentSupport" + BoostTestDiscoverer.ExeExtension), Is.EqualTo(8)); // the external runner does NOT support the two dll projects Assert.That(sink.Tests.Any(x => x.Source == "DllProject1" + BoostTestDiscoverer.DllExtension), Is.False); Assert.That(sink.Tests.Any(x => x.Source == "DllProject2" + BoostTestDiscoverer.DllExtension), Is.False); }
public bool Find(ref K item) { SCG.KeyValuePair <K, V> p = new SCG.KeyValuePair <K, V>(item, default); bool retval = sortedpairs.Find(ref p); item = p.Key; return(retval); }
/// <summary> /// /// </summary> /// <param name="bot"></param> /// <returns></returns> public IDirectedEnumerable <SCG.KeyValuePair <K, V> > RangeFrom(K bot) { return(sortedpairs.RangeFrom(new SCG.KeyValuePair <K, V>(bot, default))); }
/// <summary> /// /// </summary> /// <param name="top"></param> /// <returns></returns> public IDirectedEnumerable <SCG.KeyValuePair <K, V> > RangeTo(K top) { return(sortedpairs.RangeTo(new SCG.KeyValuePair <K, V>(top, default))); }
/// <summary> /// Get the entry in the dictionary whose key is the /// predecessor of the specified key. /// </summary> /// <exception cref="NoSuchItemException"></exception> /// <param name="key">The key</param> /// <returns>The entry</returns> public SCG.KeyValuePair <K, V> Predecessor(K key) { return(sortedpairs.Predecessor(new SCG.KeyValuePair <K, V>(key, default))); }
/// <summary> /// Find the entry in the dictionary whose key is the /// weak successor of the specified key. /// </summary> /// <param name="key">The key</param> /// <param name="res">The weak successor, if any</param> /// <returns>True if the key has a weak successor</returns> public bool TryWeakSuccessor(K key, out SCG.KeyValuePair <K, V> res) { return(sortedpairs.TryWeakSuccessor(new SCG.KeyValuePair <K, V>(key, default), out res)); }
/// <summary> /// Get the entry in the dictionary whose key is the /// weak successor of the specified key. /// </summary> /// <exception cref="NoSuchItemException"></exception> /// <param name="key">The key</param> /// <returns>The entry</returns> public SCG.KeyValuePair <K, V> WeakSuccessor(K key) { return(sortedpairs.WeakSuccessor(new SCG.KeyValuePair <K, V>(key, default))); }
/// <summary> /// /// </summary> /// <param name="highKey"></param> public void RemoveRangeTo(K highKey) { sortedpairs.RemoveRangeTo(new SCG.KeyValuePair <K, V>(highKey, default)); }
/// <summary> /// Remove all items *not* in a supplied collection from this bag, /// counting multiplicities. /// </summary> /// <param name="items">The items to retain</param> public virtual void RetainAll(SCG.IEnumerable <T> items) { UpdateCheck(); HashBag <T> res = new HashBag <T>(itemequalityComparer); foreach (T item in items) { SCG.KeyValuePair <T, int> p = new SCG.KeyValuePair <T, int>(item, default); if (dict.Find(ref p)) { SCG.KeyValuePair <T, int> q = p; if (res.dict.Find(ref q)) { if (q.Value < p.Value) { q = new SCG.KeyValuePair <T, int>(q.Key, q.Value + 1); res.dict.Update(q); res.size++; } } else { q = new SCG.KeyValuePair <T, int>(q.Key, 1); res.dict.Add(q); res.size++; } } } if (size == res.size) { return; } CircularQueue <T> wasRemoved = null; if ((ActiveEvents & EventType.Removed) != 0) { wasRemoved = new CircularQueue <T>(); foreach (SCG.KeyValuePair <T, int> p in dict) { int removed = p.Value - res.ContainsCount(p.Key); if (removed > 0) { #warning We could send bag events here easily using a CircularQueue of (should?) for (int i = 0; i < removed; i++) { wasRemoved.Enqueue(p.Key); } } } } dict = res.dict; size = res.size; if ((ActiveEvents & EventType.Removed) != 0) { RaiseForRemoveAll(wasRemoved); } else if ((ActiveEvents & EventType.Changed) != 0) { RaiseCollectionChanged(); } }
/// <summary> /// /// </summary> /// <param name="lowKey"></param> /// <param name="highKey"></param> public void RemoveRangeFromTo(K lowKey, K highKey) { sortedpairs.RemoveRangeFromTo(new SCG.KeyValuePair <K, V>(lowKey, default), new SCG.KeyValuePair <K, V>(highKey, default)); }