public void SerializeStack()
{
ImmutableStack <string> l = ImmutableStack.CreateRange(new List <string>
{
"One",
"II",
"3"
});
string json = JsonConvert.SerializeObject(l, Formatting.Indented);
Assert.AreEqual(@"[
""3"",
""II"",
""One""
]", json);
}
public async Task WritePrimitiveIImmutableStackT()
{
IImmutableStack <int> input = ImmutableStack.CreateRange(new List <int> {
1, 2
});
string json = await Serializer.SerializeWrapper(input);
Assert.Equal("[2,1]", json);
StringIImmutableStackWrapper input2 = new StringIImmutableStackWrapper(new List <string> {
"1", "2"
});
json = await Serializer.SerializeWrapper(input2);
Assert.Equal(@"[""2"",""1""]", json);
}
private static GameEvent ExchangeDeadCard(GameState state, int playerIdx, Card deadCard)
{
if (playerIdx == -1)
{
throw new ExchangeDeadCardFailedException(ExchangeDeadCardError.PlayerIsNotInGame);
}
var playerId = state.PlayerIdByIdx[playerIdx];
if (!playerId.Equals(state.CurrentPlayerId))
{
throw new ExchangeDeadCardFailedException(ExchangeDeadCardError.PlayerIsNotCurrentPlayer);
}
if (!state.PlayerHandByIdx[playerIdx].Contains(deadCard))
{
throw new ExchangeDeadCardFailedException(ExchangeDeadCardError.PlayerDoesNotHaveCard);
}
if (!state.DeadCards.Contains(deadCard))
{
throw new ExchangeDeadCardFailedException(ExchangeDeadCardError.CardIsNotDead);
}
if (state.HasExchangedDeadCard)
{
throw new ExchangeDeadCardFailedException(ExchangeDeadCardError.PlayerHasAlreadyExchangedDeadCard);
}
var deck = ImmutableStack.CreateRange(state.Deck);
return(new GameEvent
{
ByPlayerId = playerId,
CardDrawn = deck.Peek(),
CardUsed = deadCard,
Coord = new Coord(-1, -1),
Index = state.Version + 1,
NextPlayerId = playerId,
Sequences = Array.Empty <Seq>(),
});
}
public void CanSerializeImmutableCollectionsReferencedThroughInterfaceInFields()
{
var expected = new TestClass(
dictionary: ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <int, int>(2, 1),
new KeyValuePair <int, int>(3, 2),
}),
list: ImmutableList.CreateRange(new[] { "c", "d" }),
queue: ImmutableQueue.CreateRange(new[] { "e", "f" }),
sortedSet: ImmutableSortedSet.CreateRange(new[] { "g", "h" }),
hashSet: ImmutableHashSet.CreateRange(new[] { "i", "j" }),
stack: ImmutableStack.CreateRange(new[] { "k", "l" }));
Serialize(expected);
Reset();
var actual = Deserialize <TestClass>();
Assert.Equal(expected, actual);
}
public async Task InvokeAsync(IMiddlewareContext context)
{
DelegateDirective?delegateDirective = context.Field
.Directives[DirectiveNames.Delegate]
.FirstOrDefault()?.ToObject <DelegateDirective>();
if (delegateDirective != null)
{
IImmutableStack <SelectionPathComponent> path;
IImmutableStack <SelectionPathComponent> reversePath;
if (delegateDirective.Path is null)
{
path = ImmutableStack <SelectionPathComponent> .Empty;
reversePath = ImmutableStack <SelectionPathComponent> .Empty;
}
else
{
path = SelectionPathParser.Parse(delegateDirective.Path);
reversePath = ImmutableStack.CreateRange(path);
}
IReadOnlyQueryRequest request =
CreateQuery(context, delegateDirective.Schema, path, reversePath);
IReadOnlyQueryResult result = await ExecuteQueryAsync(
context, request, delegateDirective.Schema)
.ConfigureAwait(false);
UpdateContextData(context, result, delegateDirective);
object?value = ExtractData(result.Data, reversePath, context.ResponseName);
context.Result = new SerializedData(value);
if (result.Errors is not null)
{
ReportErrors(delegateDirective.Schema, context, result.Errors);
}
}
await _next.Invoke(context).ConfigureAwait(false);
}
public void Create()
{
ImmutableStack <int> queue = ImmutableStack.Create <int>();
Assert.True(queue.IsEmpty);
queue = ImmutableStack.Create(1);
Assert.False(queue.IsEmpty);
Assert.Equal(new[] { 1 }, queue);
queue = ImmutableStack.Create(1, 2);
Assert.False(queue.IsEmpty);
Assert.Equal(new[] { 2, 1 }, queue);
queue = ImmutableStack.CreateRange((IEnumerable <int>) new[] { 1, 2 });
Assert.False(queue.IsEmpty);
Assert.Equal(new[] { 2, 1 }, queue);
Assert.Throws <ArgumentNullException>(() => ImmutableStack.CreateRange((IEnumerable <int>)null));
Assert.Throws <ArgumentNullException>(() => ImmutableStack.Create((int[])null));
}
public void Create()
{
ImmutableStack <int> stack = ImmutableStack.Create <int>();
Assert.True(stack.IsEmpty);
stack = ImmutableStack.Create(1);
Assert.False(stack.IsEmpty);
Assert.Equal(new[] { 1 }, stack);
stack = ImmutableStack.Create(1, 2);
Assert.False(stack.IsEmpty);
Assert.Equal(new[] { 2, 1 }, stack);
stack = ImmutableStack.CreateRange((IEnumerable <int>) new[] { 1, 2 });
Assert.False(stack.IsEmpty);
Assert.Equal(new[] { 2, 1 }, stack);
Assert.Throws <ArgumentNullException>("items", () => ImmutableStack.CreateRange((IEnumerable <int>)null));
Assert.Throws <ArgumentNullException>("items", () => ImmutableStack.Create((int[])null));
}
private static object GetPopulatedCollection <TElement>(Type type, int stringLength)
{
if (type == typeof(TElement[]))
{
return(GetArr_TypedElements <TElement>(stringLength));
}
else if (type == typeof(ImmutableList <TElement>))
{
return(ImmutableList.CreateRange(GetArr_TypedElements <TElement>(stringLength)));
}
else if (type == typeof(ImmutableStack <TElement>))
{
return(ImmutableStack.CreateRange(GetArr_TypedElements <TElement>(stringLength)));
}
else if (type == typeof(ImmutableDictionary <string, TElement>))
{
return(ImmutableDictionary.CreateRange(GetDict_TypedElements <TElement>(stringLength)));
}
else if (type == typeof(KeyValuePair <TElement, TElement>))
{
TElement item = GetCollectionElement <TElement>(stringLength);
return(new KeyValuePair <TElement, TElement>(item, item));
}
else if (
typeof(IDictionary <string, TElement>).IsAssignableFrom(type) ||
typeof(IReadOnlyDictionary <string, TElement>).IsAssignableFrom(type) ||
typeof(IDictionary).IsAssignableFrom(type))
{
return(Activator.CreateInstance(type, new object[] { GetDict_TypedElements <TElement>(stringLength) }));
}
else if (typeof(IEnumerable <TElement>).IsAssignableFrom(type))
{
return(Activator.CreateInstance(type, new object[] { GetArr_TypedElements <TElement>(stringLength) }));
}
else
{
return(Activator.CreateInstance(type, new object[] { GetArr_BoxedElements <TElement>(stringLength) }));
}
}
private static object GetEmptyCollection <TElement>(Type type)
{
if (type == typeof(TElement[]))
{
return(Array.Empty <TElement>());
}
else if (type == typeof(ImmutableList <TElement>))
{
return(ImmutableList.CreateRange(Array.Empty <TElement>()));
}
else if (type == typeof(ImmutableStack <TElement>))
{
return(ImmutableStack.CreateRange(Array.Empty <TElement>()));
}
else if (type == typeof(ImmutableDictionary <string, TElement>))
{
return(ImmutableDictionary.CreateRange(new Dictionary <string, TElement>()));
}
else
{
return(Activator.CreateInstance(type));
}
}
public void CanSerializeImmutableStack()
{
var expected = ImmutableStack.CreateRange(new[]
{
new Something
{
BoolProp = true,
Else = new Else
{
Name = "Yoho"
},
Int32Prop = 999,
StringProp = "Yesbox!"
},
new Something(),
new Something()
});
Serialize(expected);
Reset();
var actual = Deserialize <ImmutableStack <Something> >();
Assert.Equal(expected.ToList(), actual.ToList());
}
public StringIImmutableStackWrapper(List <string> items)
{
_stack = ImmutableStack.CreateRange(items);
}
public static CompositionConfiguration Create(ComposableCatalog catalog)
{
Requires.NotNull(catalog, nameof(catalog));
// We consider all the parts in the catalog, plus the specially synthesized ones
// that should always be applied.
var customizedCatalog = catalog.AddParts(AlwaysBundledParts);
// Construct our part builders, initialized with all their imports satisfied.
// We explicitly use reference equality because ComposablePartDefinition.Equals is too slow, and unnecessary for this.
var partBuilders = new Dictionary <ComposablePartDefinition, PartBuilder>(ReferenceEquality <ComposablePartDefinition> .Default);
foreach (ComposablePartDefinition partDefinition in customizedCatalog.Parts)
{
var satisfyingImports = partDefinition.Imports.ToImmutableDictionary(i => i, i => customizedCatalog.GetExports(i.ImportDefinition));
partBuilders.Add(partDefinition, new PartBuilder(partDefinition, satisfyingImports));
}
// Create a lookup table that gets all immediate importers for each part.
foreach (PartBuilder partBuilder in partBuilders.Values)
{
// We want to understand who imports each part so we can properly propagate sharing boundaries
// for MEFv1 attributed parts. ExportFactory's that create sharing boundaries are an exception
// because if a part has a factory that creates new sharing boundaries, the requirement for
// that sharing boundary of the child scope shouldn't be interpreted as a requirement for that
// same boundary by the parent part.
// However, if the ExportFactory does not create sharing boundaries, it does in fact need all
// the same sharing boundaries as the parts it constructs.
var importedPartsExcludingFactoriesWithSharingBoundaries =
(from entry in partBuilder.SatisfyingExports
where !entry.Key.IsExportFactory || entry.Key.ImportDefinition.ExportFactorySharingBoundaries.Count == 0
from export in entry.Value
select export.PartDefinition).Distinct(ReferenceEquality <ComposablePartDefinition> .Default);
foreach (var importedPartDefinition in importedPartsExcludingFactoriesWithSharingBoundaries)
{
var importedPartBuilder = partBuilders[importedPartDefinition];
importedPartBuilder.ReportImportingPart(partBuilder);
}
}
// Propagate sharing boundaries defined on parts to all importers (transitive closure).
foreach (PartBuilder partBuilder in partBuilders.Values)
{
partBuilder.ApplySharingBoundary();
}
var sharingBoundaryOverrides = ComputeInferredSharingBoundaries(partBuilders.Values);
// Build up our set of composed parts.
var partsBuilder = ImmutableHashSet.CreateBuilder <ComposedPart>();
foreach (var partBuilder in partBuilders.Values)
{
var composedPart = new ComposedPart(partBuilder.PartDefinition, partBuilder.SatisfyingExports, partBuilder.RequiredSharingBoundaries.ToImmutableHashSet());
partsBuilder.Add(composedPart);
}
var parts = partsBuilder.ToImmutable();
// Determine which metadata views to use for each applicable import.
var metadataViewsAndProviders = GetMetadataViewProvidersMap(customizedCatalog);
// Validate configuration.
var errors = new List <ComposedPartDiagnostic>();
foreach (var part in parts)
{
errors.AddRange(part.Validate(metadataViewsAndProviders));
}
// Detect loops of all non-shared parts.
errors.AddRange(FindLoops(parts));
// If errors are found, re-validate the salvaged parts in case there are parts whose dependencies are affected by the initial errors
if (errors.Count > 0)
{
// Set salvaged parts to current catalog in case there are no errors
var salvagedParts = parts;
var salvagedPartDefinitions = catalog.Parts;
List <ComposedPartDiagnostic> previousErrors = errors;
Stack <IReadOnlyCollection <ComposedPartDiagnostic> > stackedErrors = new Stack <IReadOnlyCollection <ComposedPartDiagnostic> >();
// While we still find errors we validate the exports so that we remove all dependency failures
while (previousErrors.Count > 0)
{
stackedErrors.Push(previousErrors);
// Get the salvaged parts
var invalidParts = previousErrors.SelectMany(error => error.Parts).ToList();
if (invalidParts.Count == 0)
{
// If we can't identify the faulty parts but we still have errors, we have to just throw.
throw new CompositionFailedException(Strings.FailStableComposition, ImmutableStack.Create <IReadOnlyCollection <ComposedPartDiagnostic> >(errors));
}
salvagedParts = salvagedParts.Except(invalidParts);
var invalidPartDefinitionsSet = new HashSet <ComposablePartDefinition>(invalidParts.Select(p => p.Definition));
salvagedPartDefinitions = salvagedPartDefinitions.Except(invalidPartDefinitionsSet);
// Empty the list so that we create a new one only with the new set of errors
previousErrors = new List <ComposedPartDiagnostic>();
foreach (var part in salvagedParts)
{
previousErrors.AddRange(part.RemoveSatisfyingExports(invalidPartDefinitionsSet));
}
}
var finalCatalog = ComposableCatalog.Create(catalog.Resolver).AddParts(salvagedPartDefinitions);
// We want the first found errors to come out of the stack first, so we need to invert the current stack.
var compositionErrors = ImmutableStack.CreateRange(stackedErrors);
var configuration = new CompositionConfiguration(
finalCatalog,
salvagedParts,
metadataViewsAndProviders,
compositionErrors,
sharingBoundaryOverrides);
return(configuration);
}
return(new CompositionConfiguration(
catalog,
parts,
metadataViewsAndProviders,
ImmutableStack <IReadOnlyCollection <ComposedPartDiagnostic> > .Empty,
sharingBoundaryOverrides));
}
public override void Initialize()
{
base.Initialize();
MyInt16Array = new short[] { 1 };
MyInt32Array = new int[] { 2 };
MyInt64Array = new long[] { 3 };
MyUInt16Array = new ushort[] { 4 };
MyUInt32Array = new uint[] { 5 };
MyUInt64Array = new ulong[] { 6 };
MyByteArray = new byte[] { 7 };
MySByteArray = new sbyte[] { 8 };
MyCharArray = new char[] { 'a' };
MyStringArray = new string[] { "Hello" };
MyBooleanTrueArray = new bool[] { true };
MyBooleanFalseArray = new bool[] { false };
MySingleArray = new float[] { 1.1f };
MyDoubleArray = new double[] { 2.2d };
MyDecimalArray = new decimal[] { 3.3m };
MyDateTimeArray = new DateTime[] { new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc) };
MyEnumArray = new SampleEnum[] { SampleEnum.Two };
MyStringList = new List <string>()
{
"Hello"
};
MyStringIEnumerableT = new string[] { "Hello" };
MyStringIListT = new string[] { "Hello" };
MyStringICollectionT = new string[] { "Hello" };
MyStringIReadOnlyCollectionT = new string[] { "Hello" };
MyStringIReadOnlyListT = new string[] { "Hello" };
MyStringToStringDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringIDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringIReadOnlyDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringImmutableDict = ImmutableDictionary.CreateRange((Dictionary <string, string>)MyStringToStringDict);
MyStringToStringIImmutableDict = ImmutableDictionary.CreateRange((Dictionary <string, string>)MyStringToStringDict);
MyStringToStringImmutableSortedDict = ImmutableSortedDictionary.CreateRange((Dictionary <string, string>)MyStringToStringDict);
MyStringStackT = new Stack <string>(new List <string>()
{
"Hello", "World"
});
MyStringQueueT = new Queue <string>(new List <string>()
{
"Hello", "World"
});
MyStringHashSetT = new HashSet <string>(new List <string>()
{
"Hello"
});
MyStringLinkedListT = new LinkedList <string>(new List <string>()
{
"Hello"
});
MyStringSortedSetT = new SortedSet <string>(new List <string>()
{
"Hello"
});
MyStringIImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableHashSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello"
});
MyStringImmutablQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableSortedSetT = ImmutableSortedSet.CreateRange(new List <string> {
"Hello"
});
}
public static void ArrayAsRootObject()
{
const string ExpectedJson = @"[1,true,{""City"":""MyCity""},null,""foo""]";
const string ReversedExpectedJson = @"[""foo"",null,{""City"":""MyCity""},true,1]";
string[] expectedObjects = { @"""foo""", @"null", @"{""City"":""MyCity""}", @"true", @"1" };
var address = new Address();
address.Initialize();
var array = new object[] { 1, true, address, null, "foo" };
string json = JsonSerializer.Serialize(array);
Assert.Equal(ExpectedJson, json);
var dictionary = new Dictionary <string, string> {
{ "City", "MyCity" }
};
var arrayWithDictionary = new object[] { 1, true, dictionary, null, "foo" };
json = JsonSerializer.Serialize(arrayWithDictionary);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(array);
Assert.Equal(ExpectedJson, json);
List <object> list = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(list);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(list);
Assert.Equal(ExpectedJson, json);
IEnumerable ienumerable = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(ienumerable);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(ienumerable);
Assert.Equal(ExpectedJson, json);
IList ilist = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(ilist);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(ilist);
Assert.Equal(ExpectedJson, json);
ICollection icollection = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(icollection);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(icollection);
Assert.Equal(ExpectedJson, json);
IEnumerable <object> genericIEnumerable = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(genericIEnumerable);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(genericIEnumerable);
Assert.Equal(ExpectedJson, json);
IList <object> genericIList = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(genericIList);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(genericIList);
Assert.Equal(ExpectedJson, json);
ICollection <object> genericICollection = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(genericICollection);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(genericICollection);
Assert.Equal(ExpectedJson, json);
IReadOnlyCollection <object> genericIReadOnlyCollection = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(genericIReadOnlyCollection);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(genericIReadOnlyCollection);
Assert.Equal(ExpectedJson, json);
IReadOnlyList <object> genericIReadonlyList = new List <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(genericIReadonlyList);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(genericIReadonlyList);
Assert.Equal(ExpectedJson, json);
ISet <object> iset = new HashSet <object> {
1, true, address, null, "foo"
};
json = JsonSerializer.Serialize(iset);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(iset);
Assert.Equal(ExpectedJson, json);
Stack <object> stack = new Stack <object>(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(stack);
Assert.Equal(ReversedExpectedJson, json);
json = JsonSerializer.Serialize <object>(stack);
Assert.Equal(ReversedExpectedJson, json);
Queue <object> queue = new Queue <object>(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(queue);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(queue);
Assert.Equal(ExpectedJson, json);
HashSet <object> hashset = new HashSet <object>(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(hashset);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(hashset);
Assert.Equal(ExpectedJson, json);
LinkedList <object> linkedlist = new LinkedList <object>(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(linkedlist);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(linkedlist);
Assert.Equal(ExpectedJson, json);
ImmutableArray <object> immutablearray = ImmutableArray.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(immutablearray);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(immutablearray);
Assert.Equal(ExpectedJson, json);
IImmutableList <object> iimmutablelist = ImmutableList.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(iimmutablelist);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(iimmutablelist);
Assert.Equal(ExpectedJson, json);
IImmutableStack <object> iimmutablestack = ImmutableStack.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(iimmutablestack);
Assert.Equal(ReversedExpectedJson, json);
json = JsonSerializer.Serialize <object>(iimmutablestack);
Assert.Equal(ReversedExpectedJson, json);
IImmutableQueue <object> iimmutablequeue = ImmutableQueue.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(iimmutablequeue);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(iimmutablequeue);
Assert.Equal(ExpectedJson, json);
IImmutableSet <object> iimmutableset = ImmutableHashSet.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(iimmutableset);
foreach (string obj in expectedObjects)
{
Assert.Contains(obj, json);
}
json = JsonSerializer.Serialize <object>(iimmutableset);
foreach (string obj in expectedObjects)
{
Assert.Contains(obj, json);
}
ImmutableHashSet <object> immutablehashset = ImmutableHashSet.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(immutablehashset);
foreach (string obj in expectedObjects)
{
Assert.Contains(obj, json);
}
json = JsonSerializer.Serialize <object>(immutablehashset);
foreach (string obj in expectedObjects)
{
Assert.Contains(obj, json);
}
ImmutableList <object> immutablelist = ImmutableList.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(immutablelist);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(immutablelist);
Assert.Equal(ExpectedJson, json);
ImmutableStack <object> immutablestack = ImmutableStack.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(immutablestack);
Assert.Equal(ReversedExpectedJson, json);
json = JsonSerializer.Serialize <object>(immutablestack);
Assert.Equal(ReversedExpectedJson, json);
ImmutableQueue <object> immutablequeue = ImmutableQueue.CreateRange(new List <object> {
1, true, address, null, "foo"
});
json = JsonSerializer.Serialize(immutablequeue);
Assert.Equal(ExpectedJson, json);
json = JsonSerializer.Serialize <object>(immutablequeue);
Assert.Equal(ExpectedJson, json);
}
protected override IImmutableStack <T> Complete(T[] intermediateCollection)
{
return(ImmutableStack.CreateRange(intermediateCollection));
}
public void Initialize()
{
{
SimpleTestClass obj1 = new SimpleTestClass();
obj1.Initialize();
SimpleTestClass obj2 = new SimpleTestClass();
obj2.Initialize();
MyIImmutableList = ImmutableList.CreateRange(new List <SimpleTestClass> {
obj1, obj2
});
}
{
SimpleTestClass obj1 = new SimpleTestClass();
obj1.Initialize();
SimpleTestClass obj2 = new SimpleTestClass();
obj2.Initialize();
MyIImmutableStack = ImmutableStack.CreateRange(new List <SimpleTestClass> {
obj1, obj2
});
}
{
SimpleTestClass obj1 = new SimpleTestClass();
obj1.Initialize();
SimpleTestClass obj2 = new SimpleTestClass();
obj2.Initialize();
MyIImmutableQueue = ImmutableQueue.CreateRange(new List <SimpleTestClass> {
obj1, obj2
});
}
{
SimpleTestClass obj1 = new SimpleTestClass();
obj1.Initialize();
SimpleTestClass obj2 = new SimpleTestClass();
obj2.Initialize();
MyIImmutableSet = ImmutableHashSet.CreateRange(new List <SimpleTestClass> {
obj1, obj2
});
}
{
SimpleTestClass obj1 = new SimpleTestClass();
obj1.Initialize();
SimpleTestClass obj2 = new SimpleTestClass();
obj2.Initialize();
MyImmutableHashSet = ImmutableHashSet.CreateRange(new List <SimpleTestClass> {
obj1, obj2
});
}
{
SimpleTestClass obj1 = new SimpleTestClass();
obj1.Initialize();
SimpleTestClass obj2 = new SimpleTestClass();
obj2.Initialize();
MyImmutableList = ImmutableList.CreateRange(new List <SimpleTestClass> {
obj1, obj2
});
}
{
SimpleTestClass obj1 = new SimpleTestClass();
obj1.Initialize();
SimpleTestClass obj2 = new SimpleTestClass();
obj2.Initialize();
MyImmutableStack = ImmutableStack.CreateRange(new List <SimpleTestClass> {
obj1, obj2
});
}
{
SimpleTestClass obj1 = new SimpleTestClass();
obj1.Initialize();
SimpleTestClass obj2 = new SimpleTestClass();
obj2.Initialize();
MyImmutableQueue = ImmutableQueue.CreateRange(new List <SimpleTestClass> {
obj1, obj2
});
}
}
public ObjectWithObjectProperties()
{
Address = new Address();
((Address)Address).Initialize();
List = new List <string> {
"Hello", "World"
};
Array = new string[] { "Hello", "Again" };
IEnumerable = new List <string> {
"Hello", "World"
};
IList = new List <string> {
"Hello", "World"
};
ICollection = new List <string> {
"Hello", "World"
};
IEnumerableT = new List <string> {
"Hello", "World"
};
IListT = new List <string> {
"Hello", "World"
};
ICollectionT = new List <string> {
"Hello", "World"
};
IReadOnlyCollectionT = new List <string> {
"Hello", "World"
};
IReadOnlyListT = new List <string> {
"Hello", "World"
};
ISetT = new HashSet <string> {
"Hello", "World"
};
StackT = new Stack <string>(new List <string> {
"Hello", "World"
});
QueueT = new Queue <string>(new List <string> {
"Hello", "World"
});
HashSetT = new HashSet <string>(new List <string> {
"Hello", "World"
});
LinkedListT = new LinkedList <string>(new List <string> {
"Hello", "World"
});
SortedSetT = new SortedSet <string>(new List <string> {
"Hello", "World"
});
ImmutableArrayT = ImmutableArray.CreateRange(new List <string> {
"Hello", "World"
});
IImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello", "World"
});
IImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello", "World"
});
IImmutableQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello", "World"
});
IImmutableSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello", "World"
});
ImmutableHashSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello", "World"
});
ImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello", "World"
});
ImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello", "World"
});
ImmutableQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello", "World"
});
ImmutableSortedSetT = ImmutableSortedSet.CreateRange(new List <string> {
"Hello", "World"
});
NullableInt = new int?(42);
Object = new object();
NullableIntArray = new int?[] { null, 42, null };
}
public void Initialize()
{
MyInt16 = 1;
MyInt32 = 2;
MyInt64 = 3;
MyUInt16 = 4;
MyUInt32 = 5;
MyUInt64 = 6;
MyByte = 7;
MySByte = 8;
MyChar = 'a';
MyString = "Hello";
MyBooleanTrue = true;
MyBooleanFalse = false;
MySingle = 1.1f;
MyDouble = 2.2d;
MyDecimal = 3.3m;
MyDateTime = new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc);
MyDateTimeOffset = new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0));
MyEnum = SampleEnum.Two;
MyInt16Array = new short[] { 1 };
MyInt32Array = new int[] { 2 };
MyInt64Array = new long[] { 3 };
MyUInt16Array = new ushort[] { 4 };
MyUInt32Array = new uint[] { 5 };
MyUInt64Array = new ulong[] { 6 };
MyByteArray = new byte[] { 7 };
MySByteArray = new sbyte[] { 8 };
MyCharArray = new char[] { 'a' };
MyStringArray = new string[] { "Hello" };
MyBooleanTrueArray = new bool[] { true };
MyBooleanFalseArray = new bool[] { false };
MySingleArray = new float[] { 1.1f };
MyDoubleArray = new double[] { 2.2d };
MyDecimalArray = new decimal[] { 3.3m };
MyDateTimeArray = new DateTime[] { new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc) };
MyDateTimeOffsetArray = new DateTimeOffset[] { new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0)) };
MyEnumArray = new SampleEnum[] { SampleEnum.Two };
MyStringList = new List <string>()
{
"Hello"
};
MyStringIEnumerableT = new string[] { "Hello" };
MyStringIListT = new string[] { "Hello" };
MyStringICollectionT = new string[] { "Hello" };
MyStringIReadOnlyCollectionT = new string[] { "Hello" };
MyStringIReadOnlyListT = new string[] { "Hello" };
MyStringToStringDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringIDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringIReadOnlyDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringStackT = new Stack <string>(new List <string>()
{
"Hello", "World"
});
MyStringQueueT = new Queue <string>(new List <string>()
{
"Hello", "World"
});
MyStringHashSetT = new HashSet <string>(new List <string>()
{
"Hello"
});
MyStringLinkedListT = new LinkedList <string>(new List <string>()
{
"Hello"
});
MyStringSortedSetT = new SortedSet <string>(new List <string>()
{
"Hello"
});
MyStringIImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableHashSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello"
});
MyStringImmutablQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableSortedSetT = ImmutableSortedSet.CreateRange(new List <string> {
"Hello"
});
MyListOfNullString = new List <string> {
null
};
}
public void Deserialize(byte[] buffer, ref int offset, ref ImmutableStack <TItem> value)
{
TItem[] array = null;
_itemsFormatter.Deserialize(buffer, ref offset, ref array);
value = ImmutableStack.CreateRange(array.Reverse());
}
public void Replace(params T[] stack)
{
_stack.OnNext(ImmutableStack.CreateRange(stack));
}
/// <summary> /// Create an immutable stack /// </summary> public static IImmutableStack <T> toStack <T>(IEnumerable <T> items) => ImmutableStack.CreateRange <T>(items);
public static ImmutableStack <T> ImmutableStackFrom <T>(T first, T second, T third, params T[] values)
{
return(ImmutableStack.CreateRange(EnumerableUtils.GetEnumerableFrom(first, second, third, values)));
}
public void Initialize()
{
MyInt16 = 1;
MyInt32 = 2;
MyInt64 = 3;
MyUInt16 = 4;
MyUInt32 = 5;
MyUInt64 = 6;
MyByte = 7;
MySByte = 8;
MyChar = 'a';
MyString = "Hello";
MyBooleanTrue = true;
MyBooleanFalse = false;
MySingle = 1.1f;
MyDouble = 2.2d;
MyDecimal = 3.3m;
MyDateTime = new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc);
MyDateTimeOffset = new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0));
MyEnum = SampleEnum.Two;
MyInt16Array = new short[] { 1 };
MyInt32Array = new int[] { 2 };
MyInt64Array = new long[] { 3 };
MyUInt16Array = new ushort[] { 4 };
MyUInt32Array = new uint[] { 5 };
MyUInt64Array = new ulong[] { 6 };
MyByteArray = new byte[] { 7 };
MySByteArray = new sbyte[] { 8 };
MyCharArray = new char[] { 'a' };
MyStringArray = new string[] { "Hello" };
MyBooleanTrueArray = new bool[] { true };
MyBooleanFalseArray = new bool[] { false };
MySingleArray = new float[] { 1.1f };
MyDoubleArray = new double[] { 2.2d };
MyDecimalArray = new decimal[] { 3.3m };
MyDateTimeArray = new DateTime[] { new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc) };
MyDateTimeOffsetArray = new DateTimeOffset[] { new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0)) };
MyEnumArray = new SampleEnum[] { SampleEnum.Two };
MyInt16TwoDimensionArray = new int[2][];
MyInt16TwoDimensionArray[0] = new int[] { 10, 11 };
MyInt16TwoDimensionArray[1] = new int[] { 20, 21 };
MyInt16TwoDimensionList = new List <List <int> >();
MyInt16TwoDimensionList.Add(new List <int> {
10, 11
});
MyInt16TwoDimensionList.Add(new List <int> {
20, 21
});
MyInt16ThreeDimensionArray = new int[2][][];
MyInt16ThreeDimensionArray[0] = new int[2][];
MyInt16ThreeDimensionArray[1] = new int[2][];
MyInt16ThreeDimensionArray[0][0] = new int[] { 11, 12 };
MyInt16ThreeDimensionArray[0][1] = new int[] { 13, 14 };
MyInt16ThreeDimensionArray[1][0] = new int[] { 21, 22 };
MyInt16ThreeDimensionArray[1][1] = new int[] { 23, 24 };
MyInt16ThreeDimensionList = new List <List <List <int> > >();
var list1 = new List <List <int> >();
MyInt16ThreeDimensionList.Add(list1);
list1.Add(new List <int> {
11, 12
});
list1.Add(new List <int> {
13, 14
});
var list2 = new List <List <int> >();
MyInt16ThreeDimensionList.Add(list2);
list2.Add(new List <int> {
21, 22
});
list2.Add(new List <int> {
23, 24
});
MyStringList = new List <string>()
{
"Hello"
};
MyStringIEnumerable = new string[] { "Hello" };
MyStringIList = new string[] { "Hello" };
MyStringICollection = new string[] { "Hello" };
MyStringIEnumerableT = new string[] { "Hello" };
MyStringIListT = new string[] { "Hello" };
MyStringICollectionT = new string[] { "Hello" };
MyStringIReadOnlyCollectionT = new string[] { "Hello" };
MyStringIReadOnlyListT = new string[] { "Hello" };
MyStringISetT = new HashSet <string> {
"Hello"
};
MyStringToStringKeyValuePair = new KeyValuePair <string, string>("myKey", "myValue");
MyStringToStringIDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringGenericDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringGenericIDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringGenericIReadOnlyDict = new Dictionary <string, string> {
{ "key", "value" }
};
MyStringToStringImmutableDict = ImmutableDictionary.CreateRange(MyStringToStringGenericDict);
MyStringToStringIImmutableDict = ImmutableDictionary.CreateRange(MyStringToStringGenericDict);
MyStringToStringImmutableSortedDict = ImmutableSortedDictionary.CreateRange(MyStringToStringGenericDict);
MyStringStackT = new Stack <string>(new List <string>()
{
"Hello", "World"
});
MyStringQueueT = new Queue <string>(new List <string>()
{
"Hello", "World"
});
MyStringHashSetT = new HashSet <string>(new List <string>()
{
"Hello"
});
MyStringLinkedListT = new LinkedList <string>(new List <string>()
{
"Hello"
});
MyStringSortedSetT = new SortedSet <string>(new List <string>()
{
"Hello"
});
MyStringIImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello"
});
MyStringIImmutableSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableHashSetT = ImmutableHashSet.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableListT = ImmutableList.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableStackT = ImmutableStack.CreateRange(new List <string> {
"Hello"
});
MyStringImmutablQueueT = ImmutableQueue.CreateRange(new List <string> {
"Hello"
});
MyStringImmutableSortedSetT = ImmutableSortedSet.CreateRange(new List <string> {
"Hello"
});
MyListOfNullString = new List <string> {
null
};
}
private static GameEvent PlayCard(GameState state, int playerIdx, Card card, Coord coord)
{
if (playerIdx == -1)
{
throw new PlayCardFailedException(PlayCardError.PlayerIsNotInGame);
}
var playerId = state.PlayerIdByIdx[playerIdx];
if (!playerId.Equals(state.CurrentPlayerId))
{
throw new PlayCardFailedException(PlayCardError.PlayerIsNotCurrentPlayer);
}
if (!state.PlayerHandByIdx[playerIdx].Contains(card))
{
throw new PlayCardFailedException(PlayCardError.PlayerDoesNotHaveCard);
}
var chips = state.Chips;
var deck = ImmutableStack.CreateRange(state.Deck);
var team = state.PlayerTeamByIdx[playerIdx];
if (card.IsOneEyedJack())
{
if (!chips.ContainsKey(coord))
{
throw new PlayCardFailedException(PlayCardError.CoordIsEmpty);
}
if (chips.TryGetValue(coord, out var chip) && chip == team)
{
throw new PlayCardFailedException(PlayCardError.ChipBelongsToPlayerTeam);
}
if (state.CoordsInSequence.Contains(coord))
{
throw new PlayCardFailedException(PlayCardError.ChipIsPartOfSequence);
}
return(new GameEvent
{
ByPlayerId = playerId,
CardDrawn = deck.Peek(),
CardUsed = card,
Coord = coord,
Index = state.Version + 1,
NextPlayerId = state.PlayerIdByIdx[(playerIdx + 1) % state.NumberOfPlayers],
Sequences = Array.Empty <Seq>(),
});
}
else
{
if (chips.ContainsKey(coord))
{
throw new PlayCardFailedException(PlayCardError.CoordIsOccupied);
}
var board = state.BoardType.Board;
if (!board.Matches(coord, card))
{
throw new PlayCardFailedException(PlayCardError.CardDoesNotMatchCoord);
}
var sequences = board.GetSequences(
chips: chips.Add(coord, team),
state.CoordsInSequence,
coord, team);
Team?winnerTeam = null;
if (sequences.Count > 0)
{
// Test for win condition:
var numSequencesForTeam = state.Sequences
.AddRange(sequences)
.Count(seq => seq.Team == team);
if (numSequencesForTeam >= state.WinCondition)
{
winnerTeam = team;
}
}
var nextPlayerId = winnerTeam == null
? state.PlayerIdByIdx[(playerIdx + 1) % state.NumberOfPlayers]
: null;
return(new GameEvent
{
ByPlayerId = playerId,
CardDrawn = deck.Peek(),
CardUsed = card,
Chip = team,
Coord = coord,
Index = state.Version + 1,
NextPlayerId = nextPlayerId,
Sequences = sequences.ToArray(),
Winner = winnerTeam
});
}
}
public static ImmutableStack <T> ImmutableStackFrom <T>(T value, params T[] values)
{
return(ImmutableStack.CreateRange(EnumerableUtils.GetEnumerableFrom(value, values)));
}