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