public void KeyComparerCollisions()
{
// First check where collisions have matching values.
var builder = ImmutableSortedDictionary.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 = ImmutableSortedDictionary.Create <string, string>()
.Add("a", "1").Add("A", "2").Add("b", "3").ToBuilder();
Assert.Throws <ArgumentException>(() => builder.KeyComparer = StringComparer.OrdinalIgnoreCase);
// Force all values to be considered equal.
builder.ValueComparer = EverythingEqual <string> .Default;
Assert.Same(EverythingEqual <string> .Default, builder.ValueComparer);
builder.KeyComparer = StringComparer.OrdinalIgnoreCase; // should not throw because values will be seen as equal.
Assert.Equal(2, builder.Count);
Assert.True(builder.ContainsKey("a"));
Assert.True(builder.ContainsKey("b"));
}
public void WithComparersCollisions()
{
// First check where collisions have matching values.
var map = ImmutableSortedDictionary.Create <string, string>()
.Add("a", "1").Add("A", "1");
map = map.WithComparers(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 = ImmutableSortedDictionary.Create <string, string>()
.Add("a", "1").Add("A", "2").Add("b", "3");
Assert.Throws <ArgumentException>(() => map.WithComparers(StringComparer.OrdinalIgnoreCase));
// Force all values to be considered equal.
map = map.WithComparers(StringComparer.OrdinalIgnoreCase, EverythingEqual <string> .Default);
Assert.Same(StringComparer.OrdinalIgnoreCase, map.KeyComparer);
Assert.Same(EverythingEqual <string> .Default, map.ValueComparer);
Assert.Equal(2, map.Count);
Assert.True(map.ContainsKey("a"));
Assert.True(map.ContainsKey("b"));
}
public ProjectState RemoveAllDocuments()
{
return(this.With(
projectInfo: this.ProjectInfo.WithVersion(this.Version.GetNewerVersion()).WithDocuments(SpecializedCollections.EmptyEnumerable <DocumentInfo>()),
documentIds: ImmutableList <DocumentId> .Empty,
documentStates: ImmutableSortedDictionary.Create <DocumentId, DocumentState>(DocumentIdComparer.Instance)));
}
public void WithComparers()
{
var map = ImmutableSortedDictionary.Create <string, string>().Add("a", "1").Add("B", "1");
Assert.Same(Comparer <string> .Default, map.KeyComparer);
Assert.True(map.ContainsKey("a"));
Assert.False(map.ContainsKey("A"));
map = map.WithComparers(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"));
var cultureComparer = StringComparer.CurrentCulture;
map = map.WithComparers(StringComparer.OrdinalIgnoreCase, cultureComparer);
Assert.Same(StringComparer.OrdinalIgnoreCase, map.KeyComparer);
Assert.Same(cultureComparer, map.ValueComparer);
Assert.Equal(2, map.Count);
Assert.True(map.ContainsKey("a"));
Assert.True(map.ContainsKey("A"));
Assert.True(map.ContainsKey("b"));
}
public void EnumeratorRecyclingMisuse()
{
var collection = ImmutableSortedDictionary.Create <int, int>().Add(3, 5);
var enumerator = collection.GetEnumerator();
var enumeratorCopy = enumerator;
Assert.True(enumerator.MoveNext());
Assert.False(enumerator.MoveNext());
enumerator.Dispose();
Assert.Throws <ObjectDisposedException>(() => enumerator.MoveNext());
Assert.Throws <ObjectDisposedException>(() => enumerator.Reset());
Assert.Throws <ObjectDisposedException>(() => enumerator.Current);
Assert.Throws <ObjectDisposedException>(() => enumeratorCopy.MoveNext());
Assert.Throws <ObjectDisposedException>(() => enumeratorCopy.Reset());
Assert.Throws <ObjectDisposedException>(() => enumeratorCopy.Current);
enumerator.Dispose(); // double-disposal should not throw
enumeratorCopy.Dispose();
// We expect that acquiring a new enumerator will use the same underlying Stack<T> object,
// but that it will not throw exceptions for the new enumerator.
enumerator = collection.GetEnumerator();
Assert.True(enumerator.MoveNext());
Assert.False(enumerator.MoveNext());
Assert.Throws <InvalidOperationException>(() => enumerator.Current);
enumerator.Dispose();
}
public static void TestDebuggerAttributes_Null()
{
Type proxyType = DebuggerAttributes.GetProxyType(ImmutableSortedDictionary.Create <int, int>());
TargetInvocationException tie = Assert.Throws <TargetInvocationException>(() => Activator.CreateInstance(proxyType, (object)null));
Assert.IsType <ArgumentNullException>(tie.InnerException);
}
public void WithComparersEmptyCollection()
{
var map = ImmutableSortedDictionary.Create <string, string>();
Assert.Same(Comparer <string> .Default, map.KeyComparer);
map = map.WithComparers(StringComparer.OrdinalIgnoreCase);
Assert.Same(StringComparer.OrdinalIgnoreCase, map.KeyComparer);
}
public Builder()
{
Pizzas = ImmutableSortedDictionary.Create <int, Pizza>();
Sizes = ImmutableSortedDictionary.Create <int, Size>();
Toppings = ImmutableSortedDictionary.Create <int, Topping>();
Orders = ImmutableSortedDictionary.Create <int, Order>();
OrderDetails = ImmutableSortedDictionary.Create <int, OrderDetail>();
}
public void ContainsValue()
{
var map = ImmutableSortedDictionary.Create <string, int>().Add("five", 5);
var builder = map.ToBuilder();
Assert.True(builder.ContainsValue(5));
Assert.False(builder.ContainsValue(4));
}
public void CollisionExceptionMessageContainsKey()
{
var map = ImmutableSortedDictionary.Create <string, string>()
.Add("firstKey", "1").Add("secondKey", "2");
var exception = Assert.Throws <ArgumentException>(null, () => map.Add("firstKey", "3"));
Assert.Contains("firstKey", exception.Message);
}
/// <summary>
/// Initializes a new instance of the <see cref="DbContextOptions" /> class. You normally override
/// <see cref="DbContext.OnConfiguring(DbContextOptionsBuilder)" /> or use a <see cref="DbContextOptionsBuilder" />
/// to create instances of this class and it is not designed to be directly constructed in your application code.
/// </summary>
/// <param name="extensions"> The extensions that store the configured options. </param>
protected DbContextOptions(
IReadOnlyDictionary <Type, IDbContextOptionsExtension> extensions)
{
Check.NotNull(extensions, nameof(extensions));
_extensionsMap = extensions as ImmutableSortedDictionary <Type, IDbContextOptionsExtension>
?? ImmutableSortedDictionary.Create <Type, IDbContextOptionsExtension>(TypeFullNameComparer.Instance)
.AddRange(extensions);
}
public void DebuggerAttributesValid()
{
DebuggerAttributes.ValidateDebuggerDisplayReferences(ImmutableSortedDictionary.Create <string, int>());
DebuggerAttributes.ValidateDebuggerTypeProxyProperties(ImmutableSortedDictionary.Create <int, int>());
object rootNode = DebuggerAttributes.GetFieldValue(ImmutableSortedDictionary.Create <string, string>(), "_root");
DebuggerAttributes.ValidateDebuggerDisplayReferences(rootNode);
}
public void Clear()
{
var builder = ImmutableSortedDictionary.Create <string, int>().ToBuilder();
builder.Add("five", 5);
Assert.Equal(1, builder.Count);
builder.Clear();
Assert.Equal(0, builder.Count);
}
public void GetValueOrDefaultOfConcreteType()
{
var empty = ImmutableSortedDictionary.Create <string, int>().ToBuilder();
var populated = ImmutableSortedDictionary.Create <string, int>().Add("a", 5).ToBuilder();
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 CollisionExceptionMessageContainsKey()
{
var map = ImmutableSortedDictionary.Create <string, string>()
.Add("firstKey", "1").Add("secondKey", "2");
var exception = AssertExtensions.Throws <ArgumentException>(null, () => map.Add("firstKey", "3"));
if (!PlatformDetection.IsNetNative) //.Net Native toolchain removes exception messages.
{
Assert.Contains("firstKey", exception.Message);
}
}
public void AddRange()
{
var builder = ImmutableSortedDictionary.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 static ImmutableSortedDictionary <T, T> SysColImmutableSortedDictionarySetup <T>(Dictionary <T, T> values)
{
var immutableMap = ImmutableSortedDictionary.Create <T, T>();
foreach (var kvp in values)
{
immutableMap = immutableMap.Add(kvp.Key, kvp.Value);
}
return(immutableMap);
}
public ImmutableSortedDictionary <T, T> SysColImmutableSortedDictionary()
{
var map = ImmutableSortedDictionary.Create <T, T>();
foreach (var kvp in values)
{
map = map.Add(kvp.Key, kvp.Value);
}
return(map);
}
public void KeyComparerEmptyCollection()
{
var builder = ImmutableSortedDictionary.Create <string, string>()
.Add("a", "1").Add("B", "1").ToBuilder();
Assert.Same(Comparer <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 RemoveRange()
{
var builder =
ImmutableSortedDictionary.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"]);
}
public void DebuggerAttributesValid()
{
DebuggerAttributes.ValidateDebuggerDisplayReferences(ImmutableSortedDictionary.Create <string, int>());
ImmutableSortedDictionary <int, int> dict = ImmutableSortedDictionary.Create <int, int>().Add(1, 2).Add(2, 3).Add(3, 4);
var info = DebuggerAttributes.ValidateDebuggerTypeProxyProperties(dict);
object rootNode = DebuggerAttributes.GetFieldValue(ImmutableSortedDictionary.Create <string, string>(), "_root");
DebuggerAttributes.ValidateDebuggerDisplayReferences(rootNode);
PropertyInfo itemProperty = info.Properties.Single(pr => pr.GetCustomAttribute <DebuggerBrowsableAttribute>().State == DebuggerBrowsableState.RootHidden);
KeyValuePair <int, int>[] items = itemProperty.GetValue(info.Instance) as KeyValuePair <int, int>[];
Assert.Equal(dict, items);
}
static void Main(string[] args)
{
ImmutableSortedDictionary <int, int> isd = ImmutableSortedDictionary.Create <int, int>();
isd = isd.Add(1, 1);
isd = isd.Add(2, 2);
isd = isd.Remove(2);
ImmutableSortedDictionary <int, int> .Builder isdBuilder = isd.ToBuilder();
isdBuilder.Add(10, 10); //adds to original SortedDictionary. returns void.
ImmutableSortedDictionary <int, int> .Builder builder = ImmutableSortedDictionary.CreateBuilder <int, int>();
builder.Add(3, 3);
isd = builder.ToImmutable();
}
public void ImmutableSortedDictionaryTest_0_Success()
{
var collection = ImmutableSortedDictionary.Create <int, int>();
var target = this.CreateTarget <ImmutableSortedDictionary <int, int> >();
using (var buffer = new MemoryStream())
{
target.Pack(buffer, collection);
buffer.Position = 0;
var unpacked = target.Unpack(buffer);
buffer.Position = 0;
Assert.That(unpacked.ToArray(), Is.EqualTo(collection.ToArray()));
}
}
private ImmutableSortedDictionary <Payload, Payload> creatASListWithNelement(int numberOfElements)
{
var treeBuilder = ImmutableSortedDictionary.Create <Payload, Payload>();
Payload firstElement = new Payload("Load 0");
treeBuilder = treeBuilder.Add(firstElement, firstElement);
for (int i = 1; i < numberOfElements; i++)
{
Payload objecttoAdd = new Payload("Load " + i);
treeBuilder = treeBuilder.Add(objecttoAdd, objecttoAdd);
}
return(treeBuilder.ToImmutableSortedDictionary <Payload, Payload>());
}
public void SerializeSortedDictionary()
{
ImmutableSortedDictionary <int, string> l = ImmutableSortedDictionary.Create(new SortedDictionary <int, string>
{
{ 1, "One" },
{ 2, "II" },
{ 3, "3" }
});
string json = JsonConvert.SerializeObject(l, Formatting.Indented);
Assert.AreEqual(@"{
""1"": ""One"",
""2"": ""II"",
""3"": ""3""
}", json);
}
public ProjectState(ProjectInfo projectInfo, HostLanguageServices languageServices, SolutionServices solutionServices)
{
Contract.ThrowIfNull(projectInfo);
Contract.ThrowIfNull(languageServices);
Contract.ThrowIfNull(solutionServices);
_languageServices = languageServices;
_solutionServices = solutionServices;
var projectInfoFixed = FixProjectInfo(projectInfo);
// We need to compute our AnalyerConfigDocumentStates first, since we use those to produce our DocumentStates
_analyzerConfigDocumentStates = ImmutableSortedDictionary.Create <DocumentId, AnalyzerConfigDocumentState>(DocumentIdComparer.Instance);
_lazyAnalyzerConfigSet = ComputeAnalyzerConfigSetValueSource(_analyzerConfigDocumentStates.Values);
_documentIds = projectInfoFixed.Documents.Select(d => d.Id).ToImmutableList();
_additionalDocumentIds = projectInfoFixed.AdditionalDocuments.Select(d => d.Id).ToImmutableList();
var parseOptions = projectInfoFixed.ParseOptions;
var docStates = ImmutableSortedDictionary.CreateRange(DocumentIdComparer.Instance,
projectInfoFixed.Documents.Select(d =>
new KeyValuePair <DocumentId, DocumentState>(d.Id,
CreateDocument(d, parseOptions))));
_documentStates = docStates;
var additionalDocStates = ImmutableSortedDictionary.CreateRange(DocumentIdComparer.Instance,
projectInfoFixed.AdditionalDocuments.Select(d =>
new KeyValuePair <DocumentId, TextDocumentState>(d.Id, new TextDocumentState(d, solutionServices))));
_additionalDocumentStates = additionalDocStates;
_lazyLatestDocumentVersion = new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentVersionAsync(docStates, additionalDocStates, c), cacheResult: true);
_lazyLatestDocumentTopLevelChangeVersion = new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentTopLevelChangeVersionAsync(docStates, additionalDocStates, c), cacheResult: true);
// ownership of information on document has moved to project state. clear out documentInfo the state is
// holding on. otherwise, these information will be held onto unnecesarily by projectInfo even after
// the info has changed by DocumentState.
// we hold onto the info so that we don't need to duplicate all information info already has in the state
_projectInfo = ClearAllDocumentsFromProjectInfo(projectInfoFixed);
_lazyChecksums = new AsyncLazy <ProjectStateChecksums>(ComputeChecksumsAsync, cacheResult: true);
}
public void Always_ShouldCorrectlyUpdatePairSettings()
{
//arrange
var env = _testSuit.Build();
env.Setup(b => b.RegisterType <ExtPriceSettingsController>().AsSelf());
env.Setup(b => b.RegisterType <AssetPairsController>().AsSelf());
var container = env.CreateContainer();
var assetPairsController = container.Resolve <AssetPairsController>();
var extPriceSettingsController = container.Resolve <ExtPriceSettingsController>();
var model = new AssetPairExtPriceSettingsModel
{
AssetPairId = "pair",
Markups = new AssetPairMarkupsParamsModel {
Bid = 1, Ask = 2
},
MinOrderbooksSendingPeriod = TimeSpan.FromMinutes(3),
OutlierThreshold = 4,
PresetDefaultExchange = "ex",
RepeatedOutliers = new RepeatedOutliersParamsModel
{
MaxAvg = 5,
MaxAvgAge = TimeSpan.FromMinutes(6),
MaxSequenceLength = 7,
MaxSequenceAge = TimeSpan.FromMinutes(8),
},
Steps = ImmutableSortedDictionary.Create <OrderbookGeneratorStepEnum, bool>()
.Add(OrderbookGeneratorStepEnum.FindOutliers, false),
};
//act
assetPairsController.Add("pair", AssetPairQuotesSourceTypeDomainEnum.Disabled);
env.Sleep(new TimeSpan(1));
extPriceSettingsController.Update(model);
var extractedModel = extPriceSettingsController.Get("pair");
//assert
model.Steps = GetDefaultSteps().SetItems(model.Steps);
extractedModel.Should().BeEquivalentTo(model);
}
private static void TestSortedDictionaryImpl <T>(TypeModel model, string caption)
where T : class, IImmutableCollectionWrapper, new()
{
var dict = new Dictionary <int, string> {
{ 1, "a" },
{ 3, "c" },
{ 2, "b" }
};
var obj = new T {
SortedDictionary = ImmutableSortedDictionary.Create <int, string>().AddRange(dict)
};
using var ms = new MemoryStream();
try
{
model.Serialize(ms, obj);
}
catch (Exception ex)
{
throw new ProtoException(caption + ":serialize", ex);
}
ms.Position = 0;
T clone;
try
{
#pragma warning disable CS0618
clone = (T)model.Deserialize(ms, null, typeof(T));
#pragma warning restore CS0618
}
catch (Exception ex)
{
throw new ProtoException(caption + ":deserialize", ex);
}
Assert.Equal(3, clone.SortedDictionary.Count); //, caption);
Assert.Equal("a", clone.SortedDictionary[1]); //, caption);
Assert.Equal("b", clone.SortedDictionary[2]); //, caption);
Assert.Equal("c", clone.SortedDictionary[3]); //, caption);
AssertSequence(new[] { 1, 2, 3 }, clone.SortedDictionary.Keys, caption);
}
private static void TestSortedDictionaryImpl <T>(TypeModel model, string caption)
where T : class, IImmutableCollectionWrapper, new()
{
var dict = new Dictionary <int, string>
{
{ 1, "a" },
{ 3, "c" },
{ 2, "b" }
};
var obj = new T {
SortedDictionary = ImmutableSortedDictionary.Create <int, string>().AddRange(dict)
};
model.ForceSerializationDuringClone = true;
var clone = model.DeepClone(obj);
Assert.AreEqual(3, clone.SortedDictionary.Count, caption);
Assert.AreEqual("a", clone.SortedDictionary[1], caption);
Assert.AreEqual("b", clone.SortedDictionary[2], caption);
Assert.AreEqual("c", clone.SortedDictionary[3], caption);
AssertSequence(new[] { 1, 2, 3 }, clone.SortedDictionary.Keys, caption);
}
public void Create()
{
IEnumerable <KeyValuePair <string, string> > pairs = new Dictionary <string, string> {
{ "a", "b" }
};
var keyComparer = StringComparer.OrdinalIgnoreCase;
var valueComparer = StringComparer.CurrentCulture;
var dictionary = ImmutableSortedDictionary.Create <string, string>();
Assert.Equal(0, dictionary.Count);
Assert.Same(Comparer <string> .Default, dictionary.KeyComparer);
Assert.Same(EqualityComparer <string> .Default, dictionary.ValueComparer);
dictionary = ImmutableSortedDictionary.Create <string, string>(keyComparer);
Assert.Equal(0, dictionary.Count);
Assert.Same(keyComparer, dictionary.KeyComparer);
Assert.Same(EqualityComparer <string> .Default, dictionary.ValueComparer);
dictionary = ImmutableSortedDictionary.Create(keyComparer, valueComparer);
Assert.Equal(0, dictionary.Count);
Assert.Same(keyComparer, dictionary.KeyComparer);
Assert.Same(valueComparer, dictionary.ValueComparer);
dictionary = ImmutableSortedDictionary.CreateRange(pairs);
Assert.Equal(1, dictionary.Count);
Assert.Same(Comparer <string> .Default, dictionary.KeyComparer);
Assert.Same(EqualityComparer <string> .Default, dictionary.ValueComparer);
dictionary = ImmutableSortedDictionary.CreateRange(keyComparer, pairs);
Assert.Equal(1, dictionary.Count);
Assert.Same(keyComparer, dictionary.KeyComparer);
Assert.Same(EqualityComparer <string> .Default, dictionary.ValueComparer);
dictionary = ImmutableSortedDictionary.CreateRange(keyComparer, valueComparer, pairs);
Assert.Equal(1, dictionary.Count);
Assert.Same(keyComparer, dictionary.KeyComparer);
Assert.Same(valueComparer, dictionary.ValueComparer);
}