public void GetConfigValue_ConfigurationExtensions_ShouldBeOk(StringComparison stringComparison, string cultureName = "nb-NO")
{
var current = CultureInfo.CurrentCulture;
var currentIgnoreCaseStringComparison = StringExtensions.CurrentIgnoreCaseStringComparison;
try
{
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo(cultureName ?? "nb-NO");
StringExtensions.CurrentIgnoreCaseStringComparison = stringComparison;
var config = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>(StringComparer.FromComparison(stringComparison))
{
{ "database:paramKey", "val_" }
})
.AddInMemoryCollection(new Dictionary <string, string>(StringComparer.FromComparison(stringComparison))
{
{ "Database:ParamKey", "val__" }
})
.AddInMemoryCollection(new Dictionary <string, string>(StringComparer.FromComparison(stringComparison))
{
{ "DATABASE:PARAMKEY", "val" }
})
.Build();
config.GetConfigValue("database:paramKey").Should().Be("val");
}
finally
{
CultureInfo.CurrentCulture = current;
StringExtensions.CurrentIgnoreCaseStringComparison = currentIgnoreCaseStringComparison;
}
}
public static void FromComparisonInvalidTest()
{
StringComparison minInvalid = Enum.GetValues(typeof(StringComparison)).Cast <StringComparison>().Min() - 1;
StringComparison maxInvalid = Enum.GetValues(typeof(StringComparison)).Cast <StringComparison>().Max() + 1;
AssertExtensions.Throws <ArgumentException>("comparisonType", () => StringComparer.FromComparison(minInvalid));
AssertExtensions.Throws <ArgumentException>("comparisonType", () => StringComparer.FromComparison(maxInvalid));
}
public int CompareTo(Utf8Span other, StringComparison comparison)
{
// TODO_UTF8STRING: We can avoid the virtual dispatch by moving the switch into this method.
// TODO_UTF8STRING: To avoid allocations, use Utf8StringComparer instead of StringComparer once it's submitted.
return(StringComparer.FromComparison(comparison).Compare(this.ToString(), other.ToString()));
}
public static void GetHashCode_StringComparison(StringComparison comparisonType)
{
int hashCodeFromStringComparer = StringComparer.FromComparison(comparisonType).GetHashCode("abc");
int hashCodeFromStringGetHashCode = "abc".GetHashCode(comparisonType);
int hashCodeFromStringGetHashCodeOfSpan = string.GetHashCode("abc".AsSpan(), comparisonType);
Assert.Equal(hashCodeFromStringComparer, hashCodeFromStringGetHashCode);
Assert.Equal(hashCodeFromStringComparer, hashCodeFromStringGetHashCodeOfSpan);
}
protected TextMatchingApprovalAnalyzer(
IEnumerable <string> approvalStateOptions,
IEnumerable <string> noApprovalStateOptions,
IEnumerable <string> approvalTextFragments,
StringComparison comparison)
{
_comparison = comparison;
_approvalStates = approvalStateOptions?.ToHashSet(StringComparer.FromComparison(_comparison))
?? throw new ArgumentNullException(nameof(approvalStateOptions));
_nonApprovalStates = noApprovalStateOptions?.ToHashSet(StringComparer.FromComparison(_comparison))
?? throw new ArgumentNullException(nameof(noApprovalStateOptions));
_approvalTextFragments = approvalTextFragments?.ToHashSet(StringComparer.FromComparison(_comparison))
?? throw new ArgumentNullException(nameof(approvalTextFragments));
}
public WordList(
IEnumerable <string>?values,
IEnumerable <WordSequence>?sequences,
StringComparison?comparison = null)
{
Comparer = StringComparer.FromComparison(comparison ?? DefaultComparison);
Comparison = comparison ?? DefaultComparison;
Values = values?.ToImmutableHashSet(Comparer) ?? ImmutableHashSet <string> .Empty;
Sequences = sequences?
.GroupBy(f => f.First, Comparer)
.ToImmutableDictionary(f => f.Key, f => f.ToImmutableArray(), Comparer)
?? ImmutableDictionary <string, ImmutableArray <WordSequence> > .Empty;
}
public void Setup()
{
if (Comparison == (StringComparison)(-1))
{
_dict = new Dictionary <string, object>();
_set = new HashSet <string>();
}
else
{
_dict = new Dictionary <string, object>(StringComparer.FromComparison(Comparison));
_set = new HashSet <string>(StringComparer.FromComparison(Comparison));
}
_dict["Some-Sample-Key"] = null;
_set.Add("Some-Sample-Key");
}
public static int IndexOf(this List <string> text, List <string> pattern, StringComparison comparisonType)
{
if (text.Count < pattern.Count)
{
return(-1);
}
for (int i = 0; i < text.Count - pattern.Count + 1; i++)
{
if (text.Skip(i).Take(pattern.Count).SequenceEqual(pattern, StringComparer.FromComparison(comparisonType)))
{
return(i);
}
}
return(-1);
}
public AssemblyResourceProvider(
Assembly assembly,
string?rootNamespace,
StringComparison comparisonType = StringComparison.Ordinal)
{
Assembly = assembly ?? throw new ArgumentNullException(nameof(assembly));
RootNamespace = rootNamespace ?? "";
RootNamespace = RootNamespace.TrimEnd('.');
_resources = new Dictionary <string, string>(StringComparer.FromComparison(comparisonType));
foreach (var name in Assembly.GetManifestResourceNames())
{
if (name.StartsWith(RootNamespace, comparisonType))
{
int extraCutoff =
name.Length > RootNamespace.Length && name[RootNamespace.Length] == '.' ? 1 : 0;
string subName = name[(RootNamespace.Length + extraCutoff)..];
public void AccessTest(StringComparison?comparison)
{
const int count = 100_000;
StringComparer sc = null;
StringSegmentComparer ssc = null;
if (comparison != null)
{
#if NETFRAMEWORK || NETSTANDARD2_0
sc = comparison.Value switch
{
StringComparison.Ordinal => StringComparer.Ordinal,
StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase,
StringComparison.InvariantCulture => StringComparer.InvariantCulture,
StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase,
_ => throw new ArgumentOutOfRangeException(nameof(comparison))
};
#else
sc = StringComparer.FromComparison(comparison.Value);
#endif
ssc = StringSegmentComparer.FromComparison(comparison.Value);
}
Dictionary <string, int> dictionary = Enumerable.Range(0, count).ToDictionary(i => i.ToString(CultureInfo.InvariantCulture), sc);
var strDict = new StringKeyedDictionary <int>(dictionary, ssc);
new IteratorPerformanceTest <int> {
TestName = "Indexer access test", Iterations = count
}
.AddCase(i => dictionary[i.ToString(CultureInfo.InvariantCulture)], "Dictionary read")
.AddCase(i => strDict[i.ToString(CultureInfo.InvariantCulture)], "StringKeyedDictionary read (string)")
.AddCase(i => strDict[i.ToString(CultureInfo.InvariantCulture).AsSegment()], "StringKeyedDictionary read (StringSegment)")
#if !(NETFRAMEWORK || NETSTANDARD2_0 || NETCOREAPP2_0)
.AddCase(i => strDict[i.ToString(CultureInfo.InvariantCulture).AsSpan()], "StringKeyedDictionary read (ReadOnlySpan<char>)")
#endif
.DoTest()
.DumpResults(Console.Out);
}
/// <summary>
/// Initializes a new instance of the <see cref="LineEndingInvariantStringComparer"/> class.
/// </summary>
/// <param name="comparison">The string comparison method.</param>
public LineEndingInvariantStringComparer(StringComparison comparison)
{
_comparer = StringComparer.FromComparison(comparison);
}
public static void FromComparisonTest(StringComparison comparison, StringComparer comparer)
{
Assert.Equal(comparer, StringComparer.FromComparison(comparison));
}
public static StringComparer ToStringComparer(this StringComparison @this) => StringComparer.FromComparison(@this);
public static void GetHashCode_StringComparison(StringComparison comparisonType)
{
Assert.Equal(StringComparer.FromComparison(comparisonType).GetHashCode("abc"), "abc".GetHashCode(comparisonType));
}
/// <summary>
/// Creates a new instance of <see cref="ModuleCache" />
/// </summary>
public ModuleCache(IOptions <MariCommandsOptions> config)
{
_config = config.Value;
_commands = new ConcurrentDictionary <string, List <ICommand> >(StringComparer.FromComparison(_config.Comparison));
}
private StringSegmentComparer(StringComparison comparison)
{
_comparison = comparison;
_comparer = StringComparer.FromComparison(comparison);
}
public ArgumentManager(StringComparison nameComparison, params string[] stringArgs)
{
this.stringArgs = string.Join(' ', stringArgs);
arguments = new Dictionary <string, List <Argument> >(StringComparer.FromComparison(this.nameComparison = nameComparison));
ReadArguments();
}