protected override IImmutableDictionary <TKey, TValue> GetEmptyImmutableDictionary < TKey, TValue >() { return(ImmutableSegmentedDictionary.Create <TKey, TValue>()); }
public void ToImmutableDictionary() { ImmutableSegmentedDictionary <int, int> .Builder builder = ImmutableSegmentedDictionary.CreateBuilder <int, int>(); builder.Add(0, 0); builder.Add(1, 1); builder.Add(2, 2); var dictionary = builder.ToImmutableSegmentedDictionary(); Assert.Equal(0, dictionary[0]); Assert.Equal(1, dictionary[1]); Assert.Equal(2, dictionary[2]); builder[1] = 5; Assert.Equal(5, builder[1]); Assert.Equal(1, dictionary[1]); builder.Clear(); Assert.True(builder.ToImmutableSegmentedDictionary().IsEmpty); Assert.False(dictionary.IsEmpty); ImmutableSegmentedDictionary <int, int> .Builder?nullBuilder = null; Assert.Throws <ArgumentNullException>( "builder", () => nullBuilder !.ToImmutableSegmentedDictionary() ); }
public void DebuggerAttributesValid() { DebuggerAttributes.ValidateDebuggerDisplayReferences( ImmutableSegmentedDictionary.Create <int, int>() ); ImmutableSegmentedDictionary <string, int> dict = ImmutableSegmentedDictionary .Create <string, int>() .Add("One", 1) .Add("Two", 2); DebuggerAttributeInfo info = DebuggerAttributes.ValidateDebuggerTypeProxyProperties( dict ); object rootNode = DebuggerAttributes.GetFieldValue( ImmutableSegmentedDictionary.Create <string, string>(), "_root" ) ?? throw new InvalidOperationException(); DebuggerAttributes.ValidateDebuggerDisplayReferences(rootNode); PropertyInfo itemProperty = info.Properties.Single( pr => pr.GetCustomAttribute <DebuggerBrowsableAttribute>() !.State == DebuggerBrowsableState.RootHidden ); KeyValuePair <string, int>[]? items = itemProperty.GetValue(info.Instance) as KeyValuePair <string, int>[]; Assert.Equal(dict, items); }
public void KeyComparer() { var builder = ImmutableSegmentedDictionary .Create <string, string>() .Add("a", "1") .Add("B", "1") .ToBuilder(); Assert.Same(EqualityComparer <string> .Default, builder.KeyComparer); Assert.True(builder.ContainsKey("a")); Assert.False(builder.ContainsKey("A")); builder.KeyComparer = StringComparer.OrdinalIgnoreCase; Assert.Same(StringComparer.OrdinalIgnoreCase, builder.KeyComparer); Assert.Equal(2, builder.Count); Assert.True(builder.ContainsKey("a")); Assert.True(builder.ContainsKey("A")); Assert.True(builder.ContainsKey("b")); var set = builder.ToImmutable(); Assert.Same(StringComparer.OrdinalIgnoreCase, set.KeyComparer); Assert.True(set.ContainsKey("a")); Assert.True(set.ContainsKey("A")); Assert.True(set.ContainsKey("b")); }
public void Create() { IEnumerable <KeyValuePair <string, string> > pairs = new Dictionary <string, string> { { "a", "b" } }; var keyComparer = StringComparer.OrdinalIgnoreCase; var dictionary = ImmutableSegmentedDictionary.Create <string, string>(); Assert.Equal(0, dictionary.Count); Assert.Same(EqualityComparer <string> .Default, dictionary.KeyComparer); dictionary = ImmutableSegmentedDictionary.Create <string, string>(keyComparer); Assert.Equal(0, dictionary.Count); Assert.Same(keyComparer, dictionary.KeyComparer); dictionary = ImmutableSegmentedDictionary.CreateRange(pairs); Assert.Equal(1, dictionary.Count); Assert.Same(EqualityComparer <string> .Default, dictionary.KeyComparer); dictionary = ImmutableSegmentedDictionary.CreateRange(keyComparer, pairs); Assert.Equal(1, dictionary.Count); Assert.Same(keyComparer, dictionary.KeyComparer); }
public static void TestDebuggerAttributes_Null() { Type proxyType = DebuggerAttributes.GetProxyType(ImmutableSegmentedDictionary.Create <string, int>()); TargetInvocationException tie = Assert.Throws <TargetInvocationException>(() => Activator.CreateInstance(proxyType, (object?)null)); Assert.IsType <ArgumentNullException>(tie.InnerException); }
public void WithComparerCollisions() { // First check where collisions have matching values. var map = ImmutableSegmentedDictionary .Create <string, string>() .Add("a", "1") .Add("A", "1"); map = map.WithComparer(StringComparer.OrdinalIgnoreCase); Assert.Same(StringComparer.OrdinalIgnoreCase, map.KeyComparer); Assert.Equal(1, map.Count); Assert.True(map.ContainsKey("a")); Assert.Equal("1", map["a"]); // Now check where collisions have conflicting values. map = ImmutableSegmentedDictionary .Create <string, string>() .Add("a", "1") .Add("A", "2") .Add("b", "3"); Assert.Throws <ArgumentException>( null, () => map.WithComparer(StringComparer.OrdinalIgnoreCase) ); }
public void KeyComparerCollisions() { // First check where collisions have matching values. var builder = ImmutableSegmentedDictionary .Create <string, string>() .Add("a", "1") .Add("A", "1") .ToBuilder(); builder.KeyComparer = StringComparer.OrdinalIgnoreCase; Assert.Equal(1, builder.Count); Assert.True(builder.ContainsKey("a")); var set = builder.ToImmutable(); Assert.Same(StringComparer.OrdinalIgnoreCase, set.KeyComparer); Assert.Equal(1, set.Count); Assert.True(set.ContainsKey("a")); // Now check where collisions have conflicting values. builder = ImmutableSegmentedDictionary .Create <string, string>() .Add("a", "1") .Add("A", "2") .Add("b", "3") .ToBuilder(); Assert.Throws <ArgumentException>( null, () => builder.KeyComparer = StringComparer.OrdinalIgnoreCase ); }
public void Indexer_KeyNotFoundException_ContainsKeyInMessage() { var map = ImmutableSegmentedDictionary.Create <string, string>() .Add("a", "1").Add("b", "2"); var exception = Assert.Throws <KeyNotFoundException>(() => map["c"]); Assert.Contains("'c'", exception.Message); }
public void ContainsValue() { var map = ImmutableSegmentedDictionary.Create <string, int>().Add("five", 5); var builder = map.ToBuilder(); Assert.True(builder.ContainsValue(5)); Assert.False(builder.ContainsValue(4)); }
public void WithComparerEmptyCollection() { var map = ImmutableSegmentedDictionary.Create <string, string>(); Assert.Same(EqualityComparer <string> .Default, map.KeyComparer); map = map.WithComparer(StringComparer.OrdinalIgnoreCase); Assert.Same(StringComparer.OrdinalIgnoreCase, map.KeyComparer); }
public void CollisionExceptionMessageContainsKey() { var map = ImmutableSegmentedDictionary.Create <string, string>() .Add("firstKey", "1").Add("secondKey", "2"); var exception = Assert.Throws <ArgumentException>(null, () => map.Add("firstKey", "3")); Assert.Contains("firstKey", exception.Message); }
private protected static void ContainsValueTestHelper <TKey, TValue>( ImmutableSegmentedDictionary <TKey, TValue> map, TKey key, TValue value ) where TKey : notnull { Assert.False(map.ContainsValue(value)); Assert.True(map.Add(key, value).ContainsValue(value)); }
public void CreateBuilder() { var builder = ImmutableSegmentedDictionary.CreateBuilder <string, string>(); Assert.Same(EqualityComparer <string> .Default, builder.KeyComparer); builder = ImmutableSegmentedDictionary.CreateBuilder <string, string>(StringComparer.Ordinal); Assert.Same(StringComparer.Ordinal, builder.KeyComparer); }
public void Clear() { var builder = ImmutableSegmentedDictionary.Create <string, int>().ToBuilder(); builder.Add("five", 5); Assert.Equal(1, builder.Count); builder.Clear(); Assert.Equal(0, builder.Count); }
public void Indexer_KeyNotFoundException_ContainsKeyInMessage() { var map = ImmutableSegmentedDictionary.Create <string, string>() .Add("a", "1").Add("b", "2"); var missingKey = "__ThisKeyDoesNotExist__"; var exception = Assert.Throws <KeyNotFoundException>(() => map[missingKey]); Assert.Contains(missingKey, exception.Message); }
public void GetValueOrDefaultOfConcreteType() { var empty = ImmutableSegmentedDictionary.Create <string, int>(); var populated = ImmutableSegmentedDictionary.Create <string, int>().Add("a", 5); Assert.Equal(0, empty.GetValueOrDefault("a")); Assert.Equal(1, empty.GetValueOrDefault("a", 1)); Assert.Equal(5, populated.GetValueOrDefault("a")); Assert.Equal(5, populated.GetValueOrDefault("a", 1)); }
public void GetValueOrDefaultOfIImmutableDictionary() { IImmutableDictionary <string, int> empty = ImmutableSegmentedDictionary.Create <string, int>(); IImmutableDictionary <string, int> populated = ImmutableSegmentedDictionary.Create <string, int>().Add("a", 5); Assert.Equal(0, empty.GetValueOrDefault("a")); Assert.Equal(1, empty.GetValueOrDefault("a", 1)); Assert.Equal(5, populated.GetValueOrDefault("a")); Assert.Equal(5, populated.GetValueOrDefault("a", 1)); }
internal static IDictionary <TKey, TValue> ToBuilder <TKey, TValue>(this IImmutableDictionary <TKey, TValue> dictionary) where TKey : notnull { return(dictionary switch { ImmutableDictionary <TKey, TValue> d => d.ToBuilder(), ImmutableSortedDictionary <TKey, TValue> d => d.ToBuilder(), ImmutableSegmentedDictionary <TKey, TValue> d => d.ToBuilder(), null => throw new ArgumentNullException(nameof(dictionary)), _ => throw ExceptionUtilities.UnexpectedValue(dictionary), });
public void AddRange() { var builder = ImmutableSegmentedDictionary.Create <string, int>().ToBuilder(); builder.AddRange(new Dictionary <string, int> { { "a", 1 }, { "b", 2 } }); Assert.Equal(2, builder.Count); Assert.Equal(1, builder["a"]); Assert.Equal(2, builder["b"]); }
public void ToImmutableDictionaryOptimized() { var dictionary = ImmutableSegmentedDictionary.Create <string, string>(); var result = dictionary.ToImmutableSegmentedDictionary(); Assert.True(IsSame(dictionary, result)); var cultureComparer = StringComparer.CurrentCulture; result = dictionary.WithComparer(cultureComparer); Assert.Same(cultureComparer, result.KeyComparer); }
public void KeyComparerEmptyCollection() { var builder = ImmutableSegmentedDictionary.Create <string, string>() .Add("a", "1").Add("B", "1").ToBuilder(); Assert.Same(EqualityComparer <string> .Default, builder.KeyComparer); builder.KeyComparer = StringComparer.OrdinalIgnoreCase; Assert.Same(StringComparer.OrdinalIgnoreCase, builder.KeyComparer); var set = builder.ToImmutable(); Assert.Same(StringComparer.OrdinalIgnoreCase, set.KeyComparer); }
public void DebuggerAttributesValid() { DebuggerAttributes.ValidateDebuggerDisplayReferences(ImmutableSegmentedDictionary.CreateBuilder <string, int>()); ImmutableSegmentedDictionary <int, string> .Builder builder = ImmutableSegmentedDictionary.CreateBuilder <int, string>(); builder.Add(1, "One"); builder.Add(2, "Two"); DebuggerAttributeInfo info = DebuggerAttributes.ValidateDebuggerTypeProxyProperties(builder); PropertyInfo itemProperty = info.Properties.Single(pr => pr.GetCustomAttribute <DebuggerBrowsableAttribute>() !.State == DebuggerBrowsableState.RootHidden); KeyValuePair <int, string>[]? items = itemProperty.GetValue(info.Instance) as KeyValuePair <int, string>[]; Assert.Equal(builder, items); }
public void RemoveRange() { var builder = ImmutableSegmentedDictionary.Create <string, int>() .AddRange(new Dictionary <string, int> { { "a", 1 }, { "b", 2 }, { "c", 3 } }) .ToBuilder(); Assert.Equal(3, builder.Count); builder.RemoveRange(new[] { "a", "b" }); Assert.Equal(1, builder.Count); Assert.Equal(3, builder["c"]); }
private static SingleNamespaceOrTypeDeclaration CreateImplicitClass(ImmutableSegmentedDictionary <string, VoidResult> memberNames, SyntaxReference container, SingleTypeDeclaration.TypeDeclarationFlags declFlags) { return(new SingleTypeDeclaration( kind: DeclarationKind.ImplicitClass, name: TypeSymbol.ImplicitTypeName, arity: 0, modifiers: DeclarationModifiers.Internal | DeclarationModifiers.Partial | DeclarationModifiers.Sealed, declFlags: declFlags, syntaxReference: container, nameLocation: new SourceLocation(container), memberNames: memberNames, children: ImmutableArray <SingleTypeDeclaration> .Empty, diagnostics: ImmutableArray <Diagnostic> .Empty)); }
public void ToImmutableDictionary() { IEnumerable <KeyValuePair <string, string> > pairs = new Dictionary <string, string> { { "a", "B" } }; var keyComparer = StringComparer.OrdinalIgnoreCase; ImmutableSegmentedDictionary <string, string> dictionary = pairs.ToImmutableSegmentedDictionary(); Assert.Equal(1, dictionary.Count); Assert.Same(EqualityComparer <string> .Default, dictionary.KeyComparer); dictionary = pairs.ToImmutableSegmentedDictionary(keyComparer); Assert.Equal(1, dictionary.Count); Assert.Same(keyComparer, dictionary.KeyComparer); dictionary = pairs.ToImmutableSegmentedDictionary(p => p.Key.ToUpperInvariant(), p => p.Value.ToLowerInvariant()); Assert.Equal(1, dictionary.Count); Assert.Equal("A", dictionary.Keys.Single()); Assert.Equal("b", dictionary.Values.Single()); Assert.Same(EqualityComparer <string> .Default, dictionary.KeyComparer); dictionary = pairs.ToImmutableSegmentedDictionary(p => p.Key.ToUpperInvariant(), p => p.Value.ToLowerInvariant(), keyComparer); Assert.Equal(1, dictionary.Count); Assert.Equal("A", dictionary.Keys.Single()); Assert.Equal("b", dictionary.Values.Single()); Assert.Same(keyComparer, dictionary.KeyComparer); var list = new int[] { 1, 2 }; var intDictionary = list.ToImmutableSegmentedDictionary(n => (double)n); Assert.Equal(1, intDictionary[1.0]); Assert.Equal(2, intDictionary[2.0]); Assert.Equal(2, intDictionary.Count); var stringIntDictionary = list.ToImmutableSegmentedDictionary(n => n.ToString(), StringComparer.OrdinalIgnoreCase); Assert.Same(StringComparer.OrdinalIgnoreCase, stringIntDictionary.KeyComparer); Assert.Equal(1, stringIntDictionary["1"]); Assert.Equal(2, stringIntDictionary["2"]); Assert.Equal(2, intDictionary.Count); Assert.Throws <ArgumentNullException>("keySelector", () => list.ToImmutableSegmentedDictionary <int, int>(null !)); Assert.Throws <ArgumentNullException>("keySelector", () => list.ToImmutableSegmentedDictionary <int, int, int>(null !, v => v)); Assert.Throws <ArgumentNullException>("elementSelector", () => list.ToImmutableSegmentedDictionary <int, int, int>(k => k, null !)); list.ToDictionary(k => k, v => v, null); // verifies BCL behavior is to not throw. list.ToImmutableSegmentedDictionary(k => k, v => v, null); }
public void Clear_HasComparer_ReturnsEmptyWithOriginalComparer() { ImmutableSegmentedDictionary <string, int> dictionary = new Dictionary <string, int> { { "a", 1 } }.ToImmutableSegmentedDictionary(StringComparer.OrdinalIgnoreCase); ImmutableSegmentedDictionary <string, int> clearedDictionary = dictionary.Clear(); Assert.False(IsSame(ImmutableSegmentedDictionary <string, int> .Empty, clearedDictionary.Clear())); Assert.NotEmpty(dictionary); clearedDictionary = clearedDictionary.Add("a", 1); Assert.True(clearedDictionary.ContainsKey("A")); }
public void WithComparer() { var map = ImmutableSegmentedDictionary.Create <string, string>().Add("a", "1").Add("B", "1"); Assert.Same(EqualityComparer <string> .Default, map.KeyComparer); Assert.True(map.ContainsKey("a")); Assert.False(map.ContainsKey("A")); map = map.WithComparer(StringComparer.OrdinalIgnoreCase); Assert.Same(StringComparer.OrdinalIgnoreCase, map.KeyComparer); Assert.Equal(2, map.Count); Assert.True(map.ContainsKey("a")); Assert.True(map.ContainsKey("A")); Assert.True(map.ContainsKey("b")); }
private SingleNamespaceOrTypeDeclaration CreateScriptClass( CompilationUnitSyntax parent, ImmutableArray <SingleTypeDeclaration> children, ImmutableSegmentedDictionary <string, VoidResult> memberNames, SingleTypeDeclaration.TypeDeclarationFlags declFlags) { Debug.Assert(parent.Kind() == SyntaxKind.CompilationUnit && _syntaxTree.Options.Kind != SourceCodeKind.Regular); // script type is represented by the parent node: var parentReference = _syntaxTree.GetReference(parent); var fullName = _scriptClassName.Split('.'); // Note: The symbol representing the merged declarations uses parentReference to enumerate non-type members. SingleNamespaceOrTypeDeclaration decl = new SingleTypeDeclaration( kind: _isSubmission ? DeclarationKind.Submission : DeclarationKind.Script, name: fullName.Last(), arity: 0, modifiers: DeclarationModifiers.Internal | DeclarationModifiers.Partial | DeclarationModifiers.Sealed, declFlags: declFlags, syntaxReference: parentReference, nameLocation: new SourceLocation(parentReference), memberNames: memberNames, children: children, diagnostics: ImmutableArray <Diagnostic> .Empty, quickAttributes: QuickAttributes.None); for (int i = fullName.Length - 2; i >= 0; i--) { decl = SingleNamespaceDeclaration.Create( name: fullName[i], hasUsings: false, hasExternAliases: false, syntaxReference: parentReference, nameLocation: new SourceLocation(parentReference), children: ImmutableArray.Create(decl), diagnostics: ImmutableArray <Diagnostic> .Empty); } return(decl); }
internal SingleTypeDeclaration( DeclarationKind kind, string name, int arity, DeclarationModifiers modifiers, TypeDeclarationFlags declFlags, SyntaxReference syntaxReference, SourceLocation nameLocation, ImmutableSegmentedDictionary <string, VoidResult> memberNames, ImmutableArray <SingleTypeDeclaration> children, ImmutableArray <Diagnostic> diagnostics) : base(name, syntaxReference, nameLocation, diagnostics) { Debug.Assert(kind != DeclarationKind.Namespace); _kind = kind; _arity = (ushort)arity; _modifiers = modifiers; MemberNames = memberNames; _children = children; _flags = declFlags; }