//--------------------------------------------------------------------- public static string Filter(string Content, StringFilters Filters) { string value = ""; foreach (char ch in Content) { bool keep_char = false; if (Char.IsControl(ch)) { keep_char = ((Filters & StringFilters.Control) == StringFilters.Control); } else if (Char.IsLetter(ch)) { keep_char = ((Filters & StringFilters.Letter) == StringFilters.Letter); } else if (Char.IsNumber(ch)) { keep_char = ((Filters & StringFilters.Number) == StringFilters.Number); } else if (Char.IsPunctuation(ch)) { keep_char = ((Filters & StringFilters.Punctuation) == StringFilters.Punctuation); } else if (Char.IsWhiteSpace(ch)) { keep_char = ((Filters & StringFilters.WhiteSpace) == StringFilters.WhiteSpace); } if (keep_char) { value += ch; } } return(value); }
public void Truncate(string input, int size, string output) { var source = new StringValue(input); var arguments = new FilterArguments().Add(new NumberValue(size)); var context = new TemplateContext(); var result = StringFilters.Truncate(source, arguments, context); Assert.Equal(output, result.ToStringValue()); }
public void RemovesReturnsInputWhenArgumentIsEmpty() { var input = new StringValue("abcabc"); var arguments = FilterArguments.Empty; var context = new TemplateContext(); var result = StringFilters.Remove(input, arguments, context); }
public void SliceOutsideBounds(object input, object[] arguments, string expected) { var filterInput = FluidValue.Create(input, TemplateOptions.Default); var filterArguments = new FilterArguments(arguments.Select(x => FluidValue.Create(x, TemplateOptions.Default)).ToArray()); var context = new TemplateContext(); var result = StringFilters.Slice(filterInput, filterArguments, context); Assert.Equal(expected, result.Result.ToStringValue()); }
public void Slice(object input, object[] arguments, string expected) { var filterInput = FluidValue.Create(input); var filterArguments = new FilterArguments(arguments); var context = new TemplateContext(); var result = StringFilters.Slice(filterInput, filterArguments, context); Assert.Equal(expected, result.ToStringValue()); }
public void TruncateWords() { var input = new StringValue("This is a nice story with a bad end."); var arguments = new FilterArguments().Add(new NumberValue(5)).Add(new StringValue("...")); var context = new TemplateContext(); var result = StringFilters.TruncateWords(input, arguments, context); Assert.Equal("This is a nice story...", result.ToStringValue()); }
public void TruncateNullString() { var input = new StringValue(null); var arguments = new FilterArguments().Add(new NumberValue(5)).Add(new StringValue("...")); var context = new TemplateContext(); var result = StringFilters.Truncate(input, arguments, context); Assert.Null(result.ToStringValue()); }
public void TruncateShortString() { var input = new StringValue("Hello"); var arguments = new FilterArguments().Add(new NumberValue(5)).Add(new StringValue("...")); var context = new TemplateContext(); var result = StringFilters.Truncate(input, arguments, context); Assert.Equal("Hello", result.ToStringValue()); }
public void Replace() { var input = new StringValue("abcabc"); var arguments = new FilterArguments().Add(new StringValue("b")).Add(new StringValue("B")); var context = new TemplateContext(); var result = StringFilters.Replace(input, arguments, context); Assert.Equal("aBcaBc", result.ToStringValue()); }
public void Slice() { var input = new StringValue("hello"); var arguments = new FilterArguments().Add(new NumberValue(-3)).Add(new NumberValue(3)); var context = new TemplateContext(); var result = StringFilters.Slice(input, arguments, context); Assert.Equal("llo", result.ToStringValue()); }
public void Strip() { var input = new StringValue(" Hello World "); var arguments = new FilterArguments(); var context = new TemplateContext(); var result = StringFilters.Strip(input, arguments, context); Assert.Equal("Hello World", result.ToStringValue()); }
public void NewLineToBr() { var input = new StringValue("Hello\nWorld"); var arguments = new FilterArguments(); var context = new TemplateContext(); var result = StringFilters.NewLineToBr(input, arguments, context); Assert.Equal("Hello<br />World", result.ToStringValue()); }
public AutoFilterEmulators(List <Emulator> _sourceCollection, string _title) { title = _title; sourceCollection = _sourceCollection; StringFilters.Add(PlatformFilter = new StringFilter("Platform", () => Update(), Settings.EmulatorFilterPlatform)); BoolFilters.Add(IncludedFilter = new BoolFilter("Included", () => Update(), Settings.EmulatorFilterIncluded)); BoolFilters.Add(CrapFilter = new BoolFilter("Crap", () => Update(), Settings.EmulatorFilterIsCrap)); Update(); }
public AutoFilterReleases(List <Release> _sourceCollection, string _title) { title = _title; sourceCollection = _sourceCollection.OrderBy(x => x.Platform.ID).ThenBy(x => x.Title).ToList();; StringFilters.Add(PublisherFilter = new StringFilter("Publisher", () => Update(), Settings.ReleaseFilterPublisher)); StringFilters.Add(GenreFilter = new StringFilter("Genre", () => Update(), Settings.ReleaseFilterGenre)); StringFilters.Add(PlayersFilter = new StringFilter("Players", () => Update(), Settings.ReleaseFilterPlayers)); StringFilters.Add(PlatformFilter = new StringFilter("Platform", () => Update(), Settings.ReleaseFilterPlatform)); StringFilters.Add(RegionsFilter = new StringFilter("Regions", () => Update(), Settings.ReleaseFilterRegions)); StringFilters.Add(YearFilter = new StringFilter("Year", () => Update(), Settings.ReleaseFilterYear)); BoolFilters.Add(UnlicensedFilter = new BoolFilter("Unlicensed", () => Update(), Settings.ReleaseFilterUnlicensed)); BoolFilters.Add(BeatenFilter = new BoolFilter("Beaten", () => Update(), Settings.ReleaseFilterIsBeaten)); if (Settings.DisplayCrap) { BoolFilters.Add(CrapFilter = new BoolFilter("Crap", () => Update(), Settings.ReleaseFilterIsCrap)); } else { sourceCollection = sourceCollection.Where(x => !x.IsCrap).ToList(); } if (Settings.DisplayNotIncluded) { BoolFilters.Add(IncludedFilter = new BoolFilter("Playable", () => Update(), Settings.ReleaseFilterIncluded)); } else { sourceCollection = sourceCollection.Where(x => x.Included).ToList(); } if (Settings.DisplayNonGames) { BoolFilters.Add(IsGameFilter = new BoolFilter("Is Game", () => Update(), Settings.ReleaseFilterIsGame)); } else { sourceCollection = sourceCollection.Where(x => x.IsGame).ToList(); } if (Settings.DisplayAdult) { BoolFilters.Add(AdultFilter = new BoolFilter("Adult", () => Update(), Settings.ReleaseFilterAdult)); } else { sourceCollection = sourceCollection.Where(x => !x.IsAdult).ToList(); } Update(); }
public static async Task <FluidValue> RelativeUrl(FluidValue input, FilterArguments arguments, TemplateContext context) { var site = context.GetValue("site"); //var config = await site.GetValueAsync("configuration", context); var baseUrl = await site.GetValueAsync("baseUrl", context); if (baseUrl.IsNil()) { return(input); } return(StringFilters.Prepend(input, new FilterArguments(new StringValue(baseUrl.ToStringValue())), context)); }
public void TruncateWordsWithCustomEllipsis(string input, int size, string ellispsis, string output) { var source = new StringValue(input); var arguments = new FilterArguments() .Add(NumberValue.Create(size)) .Add(new StringValue(ellispsis)); var context = new TemplateContext(); var result = StringFilters.TruncateWords(source, arguments, context); Assert.Equal(output, result.Result.ToStringValue()); }
public void Split() { var input = new StringValue("a.b.c"); var arguments = new FilterArguments().Add(new StringValue(".")); var context = new TemplateContext(); var result = StringFilters.Split(input, arguments, context); Assert.Equal(3, result.Enumerate().Count()); Assert.Equal(new StringValue("a"), result.Enumerate().ElementAt(0)); Assert.Equal(new StringValue("b"), result.Enumerate().ElementAt(1)); Assert.Equal(new StringValue("c"), result.Enumerate().ElementAt(2)); }
public AutoFilterPlatforms(List <Platform> _sourceCollection, string _title) { title = _title; sourceCollection = _sourceCollection; StringFilters.Add(TypeFilter = new StringFilter("Type", () => Update(), Settings.PlatformFilterType)); StringFilters.Add(GenerationFilter = new StringFilter("Generation", () => Update(), Settings.PlatformFilterGeneration)); StringFilters.Add(DeveloperFilter = new StringFilter("Developer", () => Update(), Settings.PlatformFilterDeveloper)); StringFilters.Add(ManufacturerFilter = new StringFilter("Manufacturer", () => Update(), Settings.PlatformFilterManufacturer)); StringFilters.Add(MediaFilter = new StringFilter("Media", () => Update(), Settings.PlatformFilterMedia)); BoolFilters.Add(IncludedFilter = new BoolFilter("Playable", () => Update(), Settings.PlatformFilterIncluded)); BoolFilters.Add(PreferreddFilter = new BoolFilter("Preferred", () => Update(), Settings.PlatformFilterPreferred)); Update(); }
public void TestSliceOnArrays(string expected, params object[] arguments) { var foobar = new object [] { 'f', 'o', 'o', 'b', 'a', 'r' }; var result = StringFilters.Slice(FluidValue.Create(foobar), new FilterArguments(arguments), new TemplateContext()); Assert.IsType <ArrayValue>(result); string resultString = ""; foreach (var c in result.ToObjectValue() as object[]) { resultString += c.ToString(); } Assert.Equal(expected, resultString); }
public void TestUpcase(string expected, object input) { Assert.Equal(expected, StringFilters.Upcase(FluidValue.Create(input), FilterArguments.Empty, new TemplateContext()).ToObjectValue()); }
public void TestSlice(string expected, object input, params object[] arguments) { Assert.Equal(expected, StringFilters.Slice(FluidValue.Create(input, TemplateOptions.Default), new FilterArguments(arguments.Select(x => FluidValue.Create(x, TemplateOptions.Default)).ToArray()), new TemplateContext()).Result.ToObjectValue()); }
public void TestSliceArgument(object input, params object[] arguments) { Assert.Throws <ArgumentException>(() => StringFilters.Slice(FluidValue.Create(input, TemplateOptions.Default), new FilterArguments(arguments.Select(x => FluidValue.Create(x, TemplateOptions.Default)).ToArray()), new TemplateContext()).Result.ToObjectValue()); }
public void TestTruncate(string expected, object input, object length = null, object truncate = null) { Assert.Equal(expected, StringFilters.Truncate(FluidValue.Create(input, TemplateOptions.Default), new FilterArguments(FluidValue.Create(length, TemplateOptions.Default), FluidValue.Create(truncate, TemplateOptions.Default)), new TemplateContext()).Result.ToObjectValue()); }
public void TestTruncate(string expected, object input, object length = null, object truncate = null) { Assert.Equal(expected, StringFilters.Truncate(FluidValue.Create(input), new FilterArguments(length, truncate), new TemplateContext()).ToObjectValue()); }
public void TestDowncase(string expected, object input) { Assert.Equal(expected, StringFilters.Downcase(FluidValue.Create(input, TemplateOptions.Default), FilterArguments.Empty, new TemplateContext()).Result.ToObjectValue()); }
/// <summary> /// Maps result types from TRX into instance of drop models with configuration /// </summary> /// <param name="source">Instance of test results from deserialised TRX input</param> /// <param name="destination">Instance to map and merge results into</param> /// <param name="inputConfiguration">User configured input for current source</param> public static void Map(TestRunType source, TestRunDrop destination, ReportInput inputConfiguration = null) { var times = source.Times.FirstOrDefault(); var started = DateTimeOffset.Parse(times.Start); var finished = DateTimeOffset.Parse(times.Finish); if (destination.Started is null || destination.Started > started) { destination.Started = started; } if (destination.Finished is null || destination.Finished < finished) { destination.Finished = finished; } var definitions = source.TestDefinitions.SelectMany(x => x.UnitTest).ToDictionary(k => k.Id, v => v); var unitTestResultsGroup = source.Results .SelectMany(r => r.UnitTestResult) .Select(r => (result: r, definition: definitions[r.TestId])) .GroupBy(t => inputConfiguration?.GroupTitle ?? StringFilters.PathSplit(t.definition.TestMethod.CodeBase).Last()) // Group by codebase if no title is provided .ToList(); foreach (var resultGroup in unitTestResultsGroup) { TestResultSetDrop drop; if (destination.ResultSets.TryGetValue(resultGroup.Key, out var existingDrop)) { drop = existingDrop; } else { drop = new TestResultSetDrop { Source = resultGroup.Key, Results = new List <TestResultDrop>(), }; destination.ResultSets.Add(drop); } foreach (var(result, definition) in resultGroup) { foreach (var unitTestResults in ExtractTestResults(result)) { var testCase = new TestCaseDrop { Source = definition.TestMethod.CodeBase, DisplayName = string.IsNullOrEmpty(inputConfiguration?.TestSuffix) ? unitTestResults.TestName : $"{unitTestResults.TestName}{inputConfiguration.TestSuffix}", FullyQualifiedName = $"{definition.TestMethod.ClassName}.{definition.TestMethod.Name}", Id = Guid.Parse(definition.Id), ExecutorUri = definition.TestMethod.AdapterTypeName, }; var startTime = DateTimeOffset.Parse(unitTestResults.StartTime); var endTime = DateTimeOffset.Parse(unitTestResults.EndTime); var duration = (endTime - startTime); var outcome = MapOutcome(unitTestResults.Outcome, drop, destination.TestRunStatistics); var resultDrop = new TestResultDrop { StartTime = startTime, EndTime = endTime, Duration = duration, Outcome = outcome, TestCase = testCase, ComputerName = unitTestResults.ComputerName, AttachmentSets = new List <AttachmentSetDrop>(unitTestResults.CollectorDataEntries.Select(rf => new AttachmentSetDrop { Attachments = new List <AttachmentDrop>(rf.Collector.Select(c => new AttachmentDrop { Description = c.CollectorDisplayName, Uri = c.Uri })) })), DisplayName = definition.TestMethod.Name }; MapOutputToResult(unitTestResults.Output, resultDrop); destination.TestRunStatistics.ExecutedTestsCount++; destination.ElapsedTimeInRunningTests += duration; drop.Duration += duration; drop.ExecutedTestsCount++; drop.Results.Add(resultDrop); } } } }
public void TestSliceArgument(object input, params object[] arguments) { Assert.Throws <ArgumentException>(() => StringFilters.Slice(FluidValue.Create(input), new FilterArguments(arguments), new TemplateContext()).ToObjectValue()); }
public void TestSlice(string expected, object input, params object[] arguments) { Assert.Equal(expected, StringFilters.Slice(FluidValue.Create(input), new FilterArguments(arguments), new TemplateContext()).ToObjectValue()); }