static void Main(string[] args)
{
var myObject = new MyObject(
100,
SingleCaseUnion.NewSingleCaseUnion(12345),
DiscriminatedUnion.NewCase1DU(111, "aaa"),
ListModule.OfSeq(new[] { 0, 1, 2, 3, 4, 5 }),
MapModule.OfSeq(new[] { Tuple.Create("One", 1), Tuple.Create("Two", 2) }),
Tuple.Create("Hello", "F# fans"),
FSharpOption <string> .Some("Option1")
);
//var converters = new JsonConverter[0];
var converters = new JsonConverter[] { new UnionConverter() };
// Test a single serialize and deserialize
var json = JsonConvert.SerializeObject(myObject, converters);
var myNewObject = JsonConvert.DeserializeObject <MyObject>(json, converters);
Console.WriteLine("Writing {0}", json);
//Console.WriteLine("Objects are the same {0}", (myObject == myNewObject));
var count = 10000;
Duration(() => SerializeLoad(false, count, myObject, converters), count, "Serialize Default");
Duration(() => DeserializeLoad(false, count, myObject, converters), count, "Deserialize Default");
Duration(() => SerializeLoad(true, count, myObject, converters), count, "Serialize Custom");
Duration(() => DeserializeLoad(true, count, myObject, converters), count, "Deserialize Custom");
}
internal static DataStoreEventArgs CreateDataStoreEventArgs <T>(ushort startAddress, ModbusDataType modbusDataType, IEnumerable <T> data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (!(typeof(T) == typeof(bool) || typeof(T) == typeof(ushort)))
{
throw new ArgumentException("Generic type T should be of type bool or ushort");
}
var eventArgs = new DataStoreEventArgs(startAddress, modbusDataType);
if (typeof(T) == typeof(bool))
{
eventArgs.Data = DiscriminatedUnion <ReadOnlyCollection <bool>, ReadOnlyCollection <ushort> > .CreateA(data.Cast <bool>().ToReadOnly());
}
else
{
eventArgs.Data = DiscriminatedUnion <ReadOnlyCollection <bool>, ReadOnlyCollection <ushort> > .CreateB(data.Cast <ushort>().ToReadOnly());
}
return(eventArgs);
}
public void DiscriminatedUnion_AllowNulls()
{
var du = DiscriminatedUnion <object, object> .CreateB(null);
Assert.Equal(DiscriminatedUnionOption.B, du.Option);
Assert.Equal(null, du.B);
}
public void DiscriminatedUnion_CreateB()
{
DiscriminatedUnion <string, string>?du = DiscriminatedUnion <string, string> .CreateB("foo");
Assert.Equal(DiscriminatedUnionOption.B, du.Option);
Assert.Equal("foo", du.B);
}
public void DiscriminatedUnion_CreateA()
{
var du = DiscriminatedUnion <string, string> .CreateA("foo");
Assert.Equal(DiscriminatedUnionOption.A, du.Option);
Assert.Equal("foo", du.A);
}
internal static DataStoreEventArgs CreateDataStoreEventArgs <T>(ushort startAddress, ModbusDataType modbusDataType, IEnumerable <T> data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
DataStoreEventArgs eventArgs;
if (typeof(T) == typeof(bool))
{
ReadOnlyCollection <bool>?a = new(data.Cast <bool>().ToArray());
eventArgs = new DataStoreEventArgs(startAddress, modbusDataType)
{
Data = DiscriminatedUnion <ReadOnlyCollection <bool>, ReadOnlyCollection <ushort> > .CreateA(a)
};
}
else if (typeof(T) == typeof(ushort))
{
ReadOnlyCollection <ushort>?b = new(data.Cast <ushort>().ToArray());
eventArgs = new DataStoreEventArgs(startAddress, modbusDataType)
{
Data = DiscriminatedUnion <ReadOnlyCollection <bool>, ReadOnlyCollection <ushort> > .CreateB(b)
};
}
else
{
throw new ArgumentException("Generic type T should be of type bool or ushort");
}
return(eventArgs);
}
public void Match2CasesTest()
{
var union = new DiscriminatedUnion <string, bool>("ok");
Assert.True(union.Match(
s => true,
b => false
));
}
public void DiscriminatedUnion_TwoTypes_ThrowsIfTypeNotAllowed()
{
// Arrange
var union = new DiscriminatedUnion <int, string>();
// Act/Assert
var ex = Assert.Throws <InvalidOperationException>(() => union.Value = 'C');
Assert.Equal("Type 'Char' is not a valid type for this value. Valid values are: 'Int32', 'String'.", ex.Message);
}
public void Write_DiscriminatedUnionAsString_WritesValueAsJson()
{
// Arrange
DiscriminatedUnion <int, string> union = "Hello, World!";
// Act
var result = JsonSerializer.Serialize(union, _serializerOptions);
// Assert
Assert.Equal(@"""Hello, World!""", result);
}
public void Write_DiscriminatedUnionAsBool_WritesValueAsJson()
{
// Arrange
DiscriminatedUnion <int, bool> union = true;
// Act
var result = JsonSerializer.Serialize(union, _serializerOptions);
// Assert
Assert.Equal("true", result);
}
public void Write_DiscriminatedUnionAsInteger_WritesValueAsJson()
{
// Arrange
DiscriminatedUnion <int, IEnumerable <int> > union = 1;
// Act
var result = JsonSerializer.Serialize(union, _serializerOptions);
// Assert
Assert.Equal("1", result);
}
public void CreateOptionType()
{
var typeName = "Option";
var du = new DiscriminatedUnion(
typeName,
new SimpleDiscriminatedUnionCase("None", typeName),
new ParameterisedDiscriminatedUnionCase("Some", typeName, "object"));
var typeDefinition = du.ToString();
WriteToFile(typeName, typeDefinition);
}
public void DiscriminatedUnion_TwoTypes_SetsValueIfAllowed()
{
// Arrange
var union = new DiscriminatedUnion <int, string>();
// Act/Assert
union.Value = 1;
Assert.IsType <int>(union.Value);
Assert.Equal(1, union.Value);
union.Value = "Hello, World!";
Assert.IsType <string>(union.Value);
Assert.Equal("Hello, World!", union.Value);
}
public void Match3CasesTest()
{
var union = new DiscriminatedUnion <string, bool, int>(true);
var fail = true;
var r = union.Match(
s => fail = true,
b => fail = false,
i => fail = true
);
Assert.False(fail);
Assert.False(r);
}
public void DeepCopyTests_FSharp_Types()
{
// discriminated union case with an array field
{
var original = DiscriminatedUnion.nonEmptyArray();
var copy = (DiscriminatedUnion)this.fixture.SerializationManager.DeepCopy(original);
Assert.Equal(original, copy);
}
{
var original = DiscriminatedUnion.emptyArray();
var copy = (DiscriminatedUnion)this.fixture.SerializationManager.DeepCopy(original);
Assert.Equal(original, copy);
}
// discriminated union case with an F# list field
{
var original = DiscriminatedUnion.emptyList();
var copy = (DiscriminatedUnion)this.fixture.SerializationManager.DeepCopy(original);
Assert.Equal(original, copy);
}
{
var original = DiscriminatedUnion.nonEmptyList();
var copy = (DiscriminatedUnion)this.fixture.SerializationManager.DeepCopy(original);
Assert.Equal(original, copy);
}
// discriminated union case with an F# set field
{
var original = DiscriminatedUnion.emptySet();
var copy = (DiscriminatedUnion)this.fixture.SerializationManager.DeepCopy(original);
Assert.Equal(original, copy);
}
{
var original = DiscriminatedUnion.nonEmptySet();
var copy = (DiscriminatedUnion)this.fixture.SerializationManager.DeepCopy(original);
Assert.Equal(original, copy);
}
// discriminated union case with an F# map field
{
var original = DiscriminatedUnion.emptyMap();
var copy = (DiscriminatedUnion)this.fixture.SerializationManager.DeepCopy(original);
Assert.Equal(original, copy);
}
{
var original = DiscriminatedUnion.nonEmptyMap();
var copy = (DiscriminatedUnion)this.fixture.SerializationManager.DeepCopy(original);
Assert.Equal(original, copy);
}
}
public void SerializationTests_FSharp_Discriminated_Union()
{
// discriminated union case with an array field
RoundtripSerializationTest(DiscriminatedUnion.emptyArray());
RoundtripSerializationTest(DiscriminatedUnion.nonEmptyArray());
// discriminated union case with an F# list field
RoundtripSerializationTest(DiscriminatedUnion.emptyList());
RoundtripSerializationTest(DiscriminatedUnion.nonEmptyList());
// discriminated union case with an F# set field
RoundtripSerializationTest(DiscriminatedUnion.emptySet());
RoundtripSerializationTest(DiscriminatedUnion.nonEmptySet());
// discriminated union case with an F# map field
RoundtripSerializationTest(DiscriminatedUnion.emptyMap());
RoundtripSerializationTest(DiscriminatedUnion.nonEmptyMap());
}
public void Match4CasesTest()
{
var union = new DiscriminatedUnion <string, bool, int, long>(8L);
Assert.Throws <Exception>(() =>
{
union.Match(
s => true,
b => false
);
});
Assert.True(union.Match(
s => false,
b => false,
i => false,
l => true
));
}
public void DiscriminatedUnion_FourTypes_SetsValueIfAllowed()
{
// Arrange
var union = new DiscriminatedUnion <int, string, long, decimal>();
// Act/Assert
union.Value = 1;
Assert.IsType <int>(union.Value);
Assert.Equal(1, union.Value);
union.Value = "Hello, World!";
Assert.IsType <string>(union.Value);
Assert.Equal("Hello, World!", union.Value);
union.Value = long.MaxValue;
Assert.IsType <long>(union.Value);
Assert.Equal(long.MaxValue, union.Value);
union.Value = 1.2M;
Assert.IsType <decimal>(union.Value);
Assert.Equal(1.2M, union.Value);
}
public void CreateShapeType()
{
var typeName = "Shape";
var du = new DiscriminatedUnion(
typeName,
new SimpleDiscriminatedUnionCase("Point", typeName),
new ParameterisedDiscriminatedUnionCase("Line", typeName, "int"),
new ParameterisedDiscriminatedUnionCase(
"Square",
typeName,
Tuple.Create("Width", "int"),
Tuple.Create("Height", "int")),
new ParameterisedDiscriminatedUnionCase(
"Cube",
typeName,
Tuple.Create("Width", "int"),
Tuple.Create("Height", "int"),
Tuple.Create("Depth", "int")));
var typeDefinition = du.ToString();
WriteToFile(typeName, typeDefinition);
}
public void AccessInvalidOption_B()
{
var du = DiscriminatedUnion <string, string> .CreateA("foo");
du.B.ToString();
}
public void DiscriminatedUnion_ToString()
{
var du = DiscriminatedUnion <string, string> .CreateA("foo");
Assert.Equal(du.ToString(), "foo");
}
public void AccessInvalidOption_B()
{
var du = DiscriminatedUnion <string, string> .CreateA("foo");
Assert.Throws <InvalidOperationException>(() => du.B.ToString());
}
