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