public void GetEnumerator_UsesOverrides()
{
var parent = new Dictionary <string, object>
{
["first"] = 1,
["second"] = 2
};
var dict = new FallbackDictionary <string, object>(parent)
{
["second"] = "two",
["third"] = 3
};
var list = new List <KeyValuePair <string, object> >();
foreach (var kvp in dict)
{
list.Add(kvp);
}
Assert.Equal(3, list.Count);
Assert.Contains(1, list.Select(k => k.Value));
Assert.Contains("two", list.Select(k => k.Value));
Assert.Contains(3, list.Select(k => k.Value));
}
public void Add_LocalContainsKey()
{
var dict = new FallbackDictionary <string, object>();
dict.Add("key", true);
Assert.Throws <ArgumentException>(() => dict.Add("key", false));
}
public void Count_LocalOnly()
{
var dict = new FallbackDictionary <string, object>();
dict.Add("first", 1);
dict.Add("second", 2);
Assert.Equal(2, dict.Count);
}
public void Contains_LocalOnly()
{
var dict = new FallbackDictionary <string, object>();
dict.Add("first", 1);
dict.Add("second", 2);
Assert.Contains(new KeyValuePair <string, object>("first", 1), dict);
Assert.Contains(new KeyValuePair <string, object>("second", 2), dict);
}
public void Add_ParentContainsKey()
{
var parent = new Dictionary <string, object>();
parent["key"] = true;
var dict = new FallbackDictionary <string, object>(parent);
Assert.Throws <ArgumentException>(() => dict.Add("key", false));
}
public void Count_LocalOnly()
{
var dict = new FallbackDictionary <string, object>
{
{ "first", 1 },
{ "second", 2 }
};
Assert.Equal(2, dict.Count);
}
public void Count_ParentOnly()
{
var parent = new Dictionary <string, object>();
parent.Add("first", 1);
parent.Add("second", 2);
var dict = new FallbackDictionary <string, object>(parent);
Assert.Equal(2, dict.Count);
}
public void Contains_ParentOnly()
{
var parent = new Dictionary <string, object>();
parent.Add("first", 1);
parent.Add("second", 2);
var dict = new FallbackDictionary <string, object>(parent);
Assert.True(dict.Contains(new KeyValuePair <string, object>("first", 1)));
Assert.True(dict.Contains(new KeyValuePair <string, object>("second", 2)));
}
public void Values_LocalOnly()
{
var dict = new FallbackDictionary <string, object>
{
{ "first", 1 },
{ "second", 2 }
};
Assert.Equal(2, dict.Values.Count);
Assert.Contains(1, dict.Values);
Assert.Contains(2, dict.Values);
}
public void Count_ParentOnly()
{
var parent = new Dictionary <string, object>
{
{ "first", 1 },
{ "second", 2 }
};
var dict = new FallbackDictionary <string, object>(parent);
Assert.Equal(2, dict.Count);
}
public void Contains_ParentOnly()
{
var parent = new Dictionary <string, object>
{
{ "first", 1 },
{ "second", 2 }
};
var dict = new FallbackDictionary <string, object>(parent);
Assert.Contains(new KeyValuePair <string, object>("first", 1), dict);
Assert.Contains(new KeyValuePair <string, object>("second", 2), dict);
}
public void Count_LocalAndParent()
{
var parent = new Dictionary <string, object>();
parent.Add("first", 1);
parent.Add("second", 2);
var dict = new FallbackDictionary <string, object>(parent);
dict.Add("third", 3);
Assert.Equal(3, dict.Count);
}
public void Count_IgnoresOverrides()
{
var parent = new Dictionary <string, object>();
parent["first"] = 1;
parent["second"] = 2;
var dict = new FallbackDictionary <string, object>(parent);
dict["second"] = "two";
dict["third"] = 3;
Assert.Equal(3, dict.Count);
}
public void Count_LocalAndParent()
{
var parent = new Dictionary <string, object>
{
{ "first", 1 },
{ "second", 2 }
};
var dict = new FallbackDictionary <string, object>(parent)
{
{ "third", 3 }
};
Assert.Equal(3, dict.Count);
}
public void Contains_LocalAndParent()
{
var parent = new Dictionary <string, object>();
parent.Add("first", 1);
parent.Add("second", 2);
var dict = new FallbackDictionary <string, object>(parent);
dict.Add("third", 3);
Assert.Contains(new KeyValuePair <string, object>("first", 1), dict);
Assert.Contains(new KeyValuePair <string, object>("second", 2), dict);
Assert.Contains(new KeyValuePair <string, object>("third", 3), dict);
}
public void Values_UsesOverrides()
{
var parent = new Dictionary <string, object>();
parent["first"] = 1;
parent["second"] = 2;
var dict = new FallbackDictionary <string, object>(parent);
dict["second"] = "two";
dict["third"] = 3;
Assert.Equal(3, dict.Values.Count);
Assert.Contains(1, dict.Values);
Assert.Contains("two", dict.Values);
Assert.Contains(3, dict.Values);
}
public void Keys_IgnoresDuplicatesInOverrides()
{
var parent = new Dictionary <string, object>();
parent["first"] = 1;
parent["second"] = 2;
var dict = new FallbackDictionary <string, object>(parent);
dict["second"] = "two";
dict["third"] = 3;
Assert.Equal(3, dict.Keys.Count);
Assert.Contains("first", dict.Keys);
Assert.Contains("second", dict.Keys);
Assert.Contains("third", dict.Keys);
}
public void Contains_UsesOverrides()
{
var parent = new Dictionary <string, object>();
parent["first"] = 1;
parent["second"] = 2;
var dict = new FallbackDictionary <string, object>(parent);
dict["second"] = "two";
dict["third"] = 3;
Assert.Contains(new KeyValuePair <string, object>("first", 1), dict);
Assert.DoesNotContain(new KeyValuePair <string, object>("second", 2), dict);
Assert.Contains(new KeyValuePair <string, object>("second", "two"), dict);
Assert.Contains(new KeyValuePair <string, object>("third", 3), dict);
}
/// <summary>
/// Creates and setup the registry for a child scope.
/// </summary>
/// <param name="tag">The tag applied to the <see cref="ILifetimeScope"/>.</param>
/// <param name="configurationAction">Action on a <see cref="ContainerBuilder"/>
/// that adds component registrations visible only in the child scope.</param>
/// <returns>Registry to use for a child scope.</returns>
/// <remarks>It is the responsibility of the caller to make sure that the registry is properly
/// disposed of. This is generally done by adding the registry to the <see cref="Disposer"/>
/// property of the child scope.</remarks>
private IComponentRegistryBuilder CreateScopeRestrictedRegistry(object tag, Action <ContainerBuilder> configurationAction)
{
var restrictedRootScopeLifetime = new MatchingScopeLifetime(tag);
var tracker = new ScopeRestrictedRegisteredServicesTracker(restrictedRootScopeLifetime);
var fallbackProperties = new FallbackDictionary <string, object?>(ComponentRegistry.Properties);
var registryBuilder = new ComponentRegistryBuilder(tracker, fallbackProperties);
var builder = new ContainerBuilder(fallbackProperties, registryBuilder);
foreach (var source in ComponentRegistry.Sources)
{
if (source.IsAdapterForIndividualComponents)
{
builder.RegisterSource(source);
}
}
// Issue #272: Only the most nested parent registry with HasLocalComponents is registered as an external source
// It provides all non-adapting registrations from itself and from it's parent registries
ISharingLifetimeScope?parent = this;
while (parent != null)
{
if (parent.ComponentRegistry.HasLocalComponents)
{
var externalSource = new ExternalRegistrySource(parent.ComponentRegistry);
builder.RegisterSource(externalSource);
break;
}
parent = parent.ParentLifetimeScope;
}
configurationAction(builder);
builder.UpdateRegistry(registryBuilder);
return(registryBuilder);
}
public void Keys_Values_SameOrder()
{
var parent = new Dictionary <string, object>();
parent["first"] = 1;
parent["second"] = 2;
var dict = new FallbackDictionary <string, object>(parent);
dict["second"] = "two";
dict["third"] = 3;
var keys = dict.Keys.ToArray();
var values = dict.Values.ToArray();
Assert.Equal(3, keys.Length);
Assert.Equal(3, values.Length);
Assert.Equal(values[0], dict[keys[0]]);
Assert.Equal(values[1], dict[keys[1]]);
Assert.Equal(values[2], dict[keys[2]]);
}
public CopyOnWriteRegistry(IComponentRegistry readRegistry, Func <IComponentRegistry> createWriteRegistry)
{
_readRegistry = readRegistry ?? throw new ArgumentNullException(nameof(readRegistry));
_createWriteRegistry = createWriteRegistry ?? throw new ArgumentNullException(nameof(createWriteRegistry));
Properties = new FallbackDictionary <string, object>(readRegistry.Properties);
}
public void Keys_Empty()
{
var dict = new FallbackDictionary <string, object>();
Assert.Equal(0, dict.Keys.Count);
}
public void Count_Empty()
{
var dict = new FallbackDictionary <string, object>();
Assert.Empty(dict);
}
public void Ctor_Default()
{
var dict = new FallbackDictionary <string, object>();
Assert.IsAssignableFrom <IDictionary <string, object> >(dict.Parent);
}
