public static bool Test0(TestStruct
s)
{
bool
res
=
s.A
==
42
&&
Math.Abs
(s.B
-
3.1415)
<
0.001;
s.A
=
12;
s.B
=
13;
return
res;
}
public void CanCopyByteArrayToStructArray()
{
// Arrange.
var structArray = new[]
{
new TestStruct
{
A = 2,
B = 3.0f
},
new TestStruct
{
A = 4,
B = 5.5f
}
};
var byteArray = new byte[2 * Utilities.SizeOf<TestStruct>()];
Utilities.ToByteArray(structArray, byteArray, 0);
// Act.
var result = new TestStruct[2];
Utilities.FromByteArray(result, 0, byteArray, 0, byteArray.Length);
// Assert.
Assert.That(result, Is.EqualTo(structArray));
}
public MFTestResults SystemReflectionType_ObjectGetType_Test0()
{
bool fRes = true;
///
/// Test object.GetType method for various types (including
/// reflection types and arrays of reflection types).
///
object o = (object)1;
fRes &= (o.GetType() == typeof(int));
o = (object)typeof(Type);
fRes &= o.GetType() == typeof(Type).GetType();
o = AppDomain.CurrentDomain.GetAssemblies();
fRes &= o.GetType() == typeof(Assembly[]);
o = new TestClass();
fRes &= o.GetType() == typeof(TestClass);
o = new TestStruct();
fRes &= o.GetType() == typeof(TestStruct);
o = new MyDelegate(MyDelegateImpl);
fRes &= o.GetType() == typeof(MyDelegate);
o = (new MyDelegate(MyDelegateImpl)).Method;
Debug.Print("object (MethodInfo) GetType: " + o.GetType().ToString());
MethodInfo mi = typeof(SystemReflectionTypeTests).GetMethod("MyDelegateImpl", BindingFlags.Static | BindingFlags.NonPublic);
fRes &= o.GetType() == mi.GetType();
return fRes ? MFTestResults.Pass : MFTestResults.Fail;
}
public void ShouldThrowExceptionIfNotEnum()
{
var testStruct = new TestStruct();
var testStruct2 = new TestStruct();
Assert.Throws<ArgumentException>(() => testStruct.IsFlagSet(testStruct2));
}
static void Main()
{
TestStruct ts = new TestStruct();
Console.WriteLine("Test");
Console.WriteLine("number = " + ts.number);
Console.WriteLine("string = " + ts.str);
}
public static void Main () {
var ip = new IntPtr(32);
var a = new TestStruct { I = ip, F = 2.5f };
var b = ReturnStructArgument(a);
Console.WriteLine("ip.ToInt32() = {0}", b.I.ToInt32());
}
public static TestStruct[] InitSomeStructs (int count) {
var result = PackedArray.New<TestStruct>(count);
for (var i = 0; i < count; i++)
result[i] = new TestStruct(i);
return result;
}
public SpecialTestCase(string stringArg, int intArg, bool boolArg, TestEnum enumArg, TestStruct structArg)
{
StringInput = stringArg;
IntInput = intArg;
BoolInput = boolArg;
EnumInput = enumArg;
StructInput = structArg;
}
public void StructAllocation([Values(0, 1)] Int32 a, [Values(2, 3)] Single b) {
TestStruct writeStruct = new TestStruct();
writeStruct.a = a;
writeStruct.b = b;
IntPtr structPtr = StructAllocator.AllocateStruct(ref writeStruct);
TestStruct readStruct = (TestStruct)Marshal.PtrToStructure(structPtr, typeof(TestStruct));
Assert.That(writeStruct, Is.EqualTo(readStruct));
}
public void Sr_ReadLeUInt16_Field()
{
var rdr = new LeImageReader(new byte[] { 0x34, 0x12 }, 0);
var test = new TestStruct();
var sr = new StructureReader(test);
sr.Read(rdr);
Assert.AreEqual((ushort) 0x1234, test.usField);
}
public static void Main (string[] args) {
var a = new TestStruct();
a.Value = 1;
var b = a;
b.Value = 0;
Console.WriteLine("a = {0}", a.Value);
}
public void Should_Bind_CustomStruct()
{
var dateTimeTest = new TestStruct();
_matcher.MatchStruct<TestStruct>(ref dateTimeTest);
/* Assert that we populated all of the fields of the DateTime object */
Assert.IsNotNull(((TestStruct)dateTimeTest).Name);
}
public void BindToStructProperty()
{
var ts = new TestStruct();
try {
var structProp = new BoundMember<int>(ts, ts.GetType().GetProperty("Property"));
Assert.Fail("Did not throw InvalidOperationException");
} catch (InvalidOperationException) {
}
}
public void GetDescription_TypeIsNotAnEnum_ThrowsException()
{
//C# won't allow generic parameters to be constrainted to enums
//so we have to allow structs. We don't have to be happy about it
//though so we'll throw an exception if the supplied type is not
//an enum.
TestStruct value = new TestStruct();
string description = DescriptionResolver.GetDescription(value);
}
public static void Main () {
var a = new TestStruct { I = 1, F = 2.5f };
try {
var b = RetrurnStructArgument(a);
} catch (Exception exc) {
Console.WriteLine(exc.GetType().Name);
Console.WriteLine(exc.Message);
}
}
public static TestStruct RecursiveMethod_Inline(TestStruct teststruct, int c)
{
if (0 != c)
{
--c;
teststruct.icount = c;
return RecursiveMethod_Inline(teststruct, c);
}
return teststruct;
}
public static void Test1(ref
TestStruct
s)
{
s.A
=
42;
s.B
=
3.1415;
}
public static void Main () {
{
Console.WriteLine(CallBinaryOperator(Multiply, 5, 3));
}
{
var a = new TestStruct { I = 1, F = 2.5f };
var b = CallReturnStructArgument(IncrementFields, a);
Console.WriteLine("i={0} f={1:F4}", b.I, b.F);
}
}
public void WriteStructTest ()
{
TestStruct stct = new TestStruct ();
stct.bleh = 5;
stct.bloup = 3;
stct.blop = 5.5f;
writer.WriteStructure<TestStruct> (stct);
byte[] result = writer.ToArray ();
Assert.AreEqual (5, BitConverter.ToInt32 (result, 0));
Assert.AreEqual ((uint)3, BitConverter.ToUInt32 (result, 4));
Assert.AreEqual (5.5f, BitConverter.ToSingle (result, 8));
}
//Test 1
// check whether GetHashCode returns the same value
// check to see if we can use ArgIterators on any class
// check ArgIterators on Arrays
// test arg iterators with instance methods on normal classes
public TestStruct argit1( Object[] objExpectedArr, __arglist )
{
ArgIterator args = new ArgIterator( __arglist );
int hashcode = args.GetHashCode();
int iCount = args.GetRemainingCount();
Console.WriteLine( "Found "+ iCount +" arguments. " );
Object[] objArr = new Object[iCount];
for ( int i = 0; i < iCount; i++ ){
objArr[i] = TypedReference.ToObject(args.GetNextArg());
Console.WriteLine( "Object " + i + ": " + objArr[i] + " Expected: " + objExpectedArr[i] );
if ( objExpectedArr[i] == null ){
if ( objArr[i] != null ){
throw new Exception( "argit1 - 1, __arglist[i] was null but it did not equal to objExpectedArr[i]" );
}
}
else if ( ! objArr[i].Equals( objExpectedArr[i] ) ) {
throw new Exception( "argit1 - 2, __arglist[i] was null but it did not equal to objExpectedArr[i]" );
}
}
//repeating the code above __arglist should be valid in method scope
ArgIterator args2 = new ArgIterator( __arglist );
int iCount2 = args2.GetRemainingCount();
Object[] objArr2 = new Object[iCount];
for ( int i = 0; i < iCount2; i++ ){
objArr2[i] = TypedReference.ToObject(args2.GetNextArg());
Console.WriteLine( "Object " + i + ": " + objArr2[i] + " Expected: " + objExpectedArr[i] );
if ( objExpectedArr[i] == null ){
if ( objArr2[i] != null ){
throw new Exception( "argit1 - 3, __arglist[i] was null but it did not equal to objExpectedArr[i]" );
}
}
else if ( ! objArr2[i].Equals( objExpectedArr[i] ) ) {
throw new Exception( "argit1 - 4, __arglist[i] was null but it did not equal to objExpectedArr[i]" );
}
}
int hashcodecompare= args.GetHashCode();
if (! hashcode.Equals(hashcodecompare))
{
throw new Exception( "argit1 - 5, hashcode changed" );
}
TestStruct Bar = new TestStruct();
Bar.foo1 = 1;
Bar.foo2 = 2;
return Bar;
}
public static bool TryParse(string toBeParsed, out TestStruct parsedValue)
{
if (string.IsNullOrEmpty(toBeParsed))
{
parsedValue = new TestStruct() { ParsedSucceeded = false };
return false;
}
else
{
parsedValue = new TestStruct() { ParsedSucceeded = true };
return true;
}
}
public static unsafe void TestGetObjectValue()
{
// Object RuntimeHelpers.GetObjectValue(Object)
TestStruct t = new TestStruct() { i1 = 2, i2 = 4 };
object tOV = RuntimeHelpers.GetObjectValue(t);
Assert.Equal(t, (TestStruct)tOV);
Object o = new object();
object oOV = RuntimeHelpers.GetObjectValue(o);
Assert.Equal(o, oOV);
int i = 3;
object iOV = RuntimeHelpers.GetObjectValue(i);
Assert.Equal(i, (int)iOV);
}
public void AllJoynStructs()
{
TestStruct testStruct = new TestStruct();
testStruct.a = 42;
testStruct.b = "Hello";
testStruct.c = "World";
testStruct.d = 88;
AllJoyn.MsgArg arg = new AllJoyn.MsgArg();
object[] mystruct = new object[4];
mystruct[0] = testStruct.a;
mystruct[1] = testStruct.b;
mystruct[2] = testStruct.c;
mystruct[3] = testStruct.d;
AllJoyn.QStatus status = arg.Set("(issi)", mystruct);
Assert.Equal(AllJoyn.QStatus.OK, status);
object outstruct;
status = arg.Get("(issi)", out outstruct);
Assert.Equal(AllJoyn.QStatus.OK, status);
object[] outstructa = (object[])outstruct;
Assert.Equal(4, outstructa.Length);
Assert.Equal(testStruct.a, (int)outstructa[0]);
Assert.Equal(testStruct.b, (string)outstructa[1]);
Assert.Equal(testStruct.c, (string)outstructa[2]);
Assert.Equal(testStruct.d, (int)outstructa[3]);
arg.Dispose();
arg = new AllJoyn.MsgArg();
//struct within a struct
object[] mystruct2 = new object[2];
mystruct2[0] = "bob";
mystruct2[1] = mystruct;
status = arg.Set("(s(issi))", mystruct2);
Assert.Equal(AllJoyn.QStatus.OK, status);
status = arg.Get("(s(issi))", out outstruct);
object[] outstruct1 = (object[])outstruct;
Assert.Equal(2, outstruct1.Length);
object[] outstruct2 = (object[])outstruct1[1];
Assert.Equal(4, outstruct2.Length);
Assert.Equal("bob", (string)outstruct1[0]);
Assert.Equal(testStruct.a, (int)outstruct2[0]);
Assert.Equal(testStruct.b, (string)outstruct2[1]);
Assert.Equal(testStruct.c, (string)outstruct2[2]);
Assert.Equal(testStruct.d, (int)outstruct2[3]);
}
public void NoDups()
{
var sut = new DailyList<TestStruct>();
sut.AllocateMemory(new DateTime(2015, 12, 1));
var s1 = new TestStruct(1, 2, 3, 4);
var s2 = new TestStruct(1, 2, 3, 4);
Assert.Null(sut[2015, 12, 1]);
sut[2015, 12, 1] = new HashSet<TestStruct>();
sut[2015, 12, 1].Add(s1).MustBe(true);
sut[2015, 12, 1].Add(s2).MustBe(false);
sut[2015, 12, 1].Count.MustBe(1);
}
public static TestStruct Test2()
{
TestStruct
s
=
new
TestStruct
();
s.A
=
42;
s.B
=
3.1415;
return
s;
}
public void DataReaderReadStruct()
{
var d = new TestStruct[] { new TestStruct (1, new DateTime (1997, 7, 1), 7.1f), new TestStruct (3, new DateTime (2046, 10, 1), null) };
using (var r = new EnumerableDataReader<TestStruct> (d)) {
var xi = r.GetOrdinal ("X");
var yi = r.GetOrdinal ("Y");
var zi = r.GetOrdinal ("Z");
Assert.AreEqual (true, r.Read ());
Assert.AreEqual (1, r.GetInt32 (xi));
Assert.AreEqual (new DateTime (1997, 7, 1), r.GetDateTime (yi));
Assert.AreEqual (7.1f, r.GetFloat (zi));
Assert.AreEqual (true, r.Read ());
Assert.AreEqual (3, r.GetInt32 (xi));
Assert.AreEqual (new DateTime (2046, 10, 1), r.GetDateTime (yi));
Assert.IsNull (r.GetValue (zi));
}
}
public void OrderByNaturalTest()
{
var Items = new TestStruct[] {
new TestStruct(Index: 2, Title: "Test 3"),
new TestStruct(Index: 3, Title: "Test 10"),
new TestStruct(Index: 0, Title: "Test 1"),
new TestStruct(Index: 4, Title: "Test 11"),
new TestStruct(Index: 1, Title: "Test 2"),
new TestStruct(Index: 5, Title: "Test 21"),
};
var OrderedItems = Items.OrderByNatural(Item => Item.Title).ToArray();
CollectionAssert.AreEqual(
new int[] { 0, 1, 2, 3, 4, 5 },
OrderedItems.Select(Item => Item.Index).ToArray()
);
}
public static void Main () {
var a = new TestStruct { I = 1, F = 2.5f };
try {
var b = ReturnStructArgument(a);
Console.WriteLine("Lookup ignored DLL name");
} catch (Exception exc) {
Console.WriteLine(exc.GetType().Name);
// HACK: JS exception won't have hresult
var msg = exc.Message;
var parenPosition = msg.IndexOf("(");
if (parenPosition >= 0)
msg = msg.Substring(0, parenPosition - 1).Trim();
Console.WriteLine(msg);
}
}
public static void Main () {
{
var d = new TBinaryOperator(Multiply);
var fp = Marshal.GetFunctionPointerForDelegate(d);
Console.WriteLine(CallBinaryOperator(fp, 5, 3));
}
{
var d = new TReturnStructArgument(IncrementFields);
var fp = Marshal.GetFunctionPointerForDelegate(d);
var a = new TestStruct { I = 1, F = 2.5f };
var b = CallReturnStructArgument(fp, a);
Console.WriteLine("i={0} f={1:F4}", b.I, b.F);
}
}
public void DumpEmptyStruct()
{
var testStruct = new TestStruct();
var dumper = new Dumper();
var dump = dumper.Dump(testStruct);
Assert.NotNull(dump, "Dump shall return a DumpLevel instance.");
Assert.AreEqual(null, dump.Value, "Dump value shall be null.");
Assert.AreEqual(typeof(TestStruct), dump.Type, "Dump type shall be a TestStruct type.");
Assert.AreEqual(1, dump.Count(), "Dump children count shall be 1.");
Assert.AreEqual(0, dump.Level, "Dump level count shall be 0.");
var children = new List<DumpLevel>(dump);
Assert.AreEqual(1, children.Count, "Dump IEnumerable copy shall be count 1 item.");
Assert.AreEqual("Property", children[0].Header, "First children header shall be 'Property'.");
Assert.AreEqual(typeof(string), children[0].Type, "First children type shall be a string.");
Assert.AreEqual(null, children[0].Value, "First children value shall be null.");
Assert.AreEqual(1, children[0].Level, "First children level shall be 1.");
}
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++)
{
_data1[i] = TestLibrary.Generator.GetDouble();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Double>, byte>(ref testStruct._fld1), ref Unsafe.As <Double, byte>(ref _data1[0]), (uint)Unsafe.SizeOf <Vector128 <Double> >());
for (var i = 0; i < Op2ElementCount; i++)
{
_data2[i] = TestLibrary.Generator.GetDouble();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Double>, byte>(ref testStruct._fld2), ref Unsafe.As <Double, byte>(ref _data2[0]), (uint)Unsafe.SizeOf <Vector128 <Double> >());
for (var i = 0; i < Op3ElementCount; i++)
{
_data3[i] = TestLibrary.Generator.GetDouble();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Double>, byte>(ref testStruct._fld3), ref Unsafe.As <Double, byte>(ref _data3[0]), (uint)Unsafe.SizeOf <Vector128 <Double> >());
return(testStruct);
}
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op0ElementCount; i++)
{
_data0[i] = TestLibrary.Generator.GetInt16();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Int32>, byte>(ref testStruct._fld0), ref Unsafe.As <Int32, byte>(ref _data0[0]), (uint)Unsafe.SizeOf <Vector128 <Int32> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data1[i] = TestLibrary.Generator.GetByte();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Int16>, byte>(ref testStruct._fld1), ref Unsafe.As <Int16, byte>(ref _data1[0]), (uint)Unsafe.SizeOf <Vector128 <Int16> >());
for (var i = 0; i < Op2ElementCount; i++)
{
_data2[i] = (sbyte)TestLibrary.Generator.GetInt16();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Int16>, byte>(ref testStruct._fld2), ref Unsafe.As <Int16, byte>(ref _data2[0]), (uint)Unsafe.SizeOf <Vector128 <Int16> >());
return(testStruct);
}
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++)
{
_data1[i] = TestLibrary.Generator.GetInt64();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Int64>, byte>(ref testStruct._fld1), ref Unsafe.As <Int64, byte>(ref _data1[0]), (uint)Unsafe.SizeOf <Vector128 <Int64> >());
for (var i = 0; i < Op2ElementCount; i++)
{
_data2[i] = TestLibrary.Generator.GetInt64();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Int64>, byte>(ref testStruct._fld2), ref Unsafe.As <Int64, byte>(ref _data2[0]), (uint)Unsafe.SizeOf <Vector128 <Int64> >());
for (var i = 0; i < Op3ElementCount; i++)
{
_data3[i] = (((i % 2) == 0) ? Convert.ToInt64("0xFFFFFFFFFFFFFFFF", 16) : (long)0);
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Int64>, byte>(ref _clsVar3), ref Unsafe.As <Int64, byte>(ref _data3[0]), (uint)Unsafe.SizeOf <Vector128 <Int64> >());
return(testStruct);
}
public static TestStruct Create()
{
var testStruct = new TestStruct();
for (var i = 0; i < Op1ElementCount; i++)
{
_data1[i] = TestLibrary.Generator.GetSByte();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <SByte>, byte>(ref testStruct._fld1), ref Unsafe.As <SByte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf <Vector256 <SByte> >());
for (var i = 0; i < Op2ElementCount; i++)
{
_data2[i] = TestLibrary.Generator.GetSByte();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <SByte>, byte>(ref testStruct._fld2), ref Unsafe.As <SByte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf <Vector256 <SByte> >());
for (var i = 0; i < Op3ElementCount; i++)
{
_data3[i] = (sbyte)(((i % 2) == 0) ? -128 : 1);
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <SByte>, byte>(ref _clsVar3), ref Unsafe.As <SByte, byte>(ref _data3[0]), (uint)Unsafe.SizeOf <Vector256 <SByte> >());
return(testStruct);
}
public static TestStruct Create()
{
var testStruct = new TestStruct();
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data1[i] = (byte)(random.Next(0, byte.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Byte>, byte>(ref testStruct._fld1), ref Unsafe.As <Byte, byte>(ref _data1[0]), (uint)Unsafe.SizeOf <Vector128 <Byte> >());
for (var i = 0; i < Op2ElementCount; i++)
{
_data2[i] = (byte)(random.Next(0, byte.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Byte>, byte>(ref testStruct._fld2), ref Unsafe.As <Byte, byte>(ref _data2[0]), (uint)Unsafe.SizeOf <Vector128 <Byte> >());
for (var i = 0; i < Op3ElementCount; i++)
{
_data3[i] = (byte)(((i % 2) == 0) ? 128 : 1);
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Byte>, byte>(ref _clsVar3), ref Unsafe.As <Byte, byte>(ref _data3[0]), (uint)Unsafe.SizeOf <Vector128 <Byte> >());
return(testStruct);
}
public void T05_ReadAndWriteStruct()
{
Assert.IsTrue(plc.IsConnected, "Before executing this test, the plc must be connected. Check constructor.");
TestStruct tc = new TestStruct();
tc.BitVariable00 = true;
tc.BitVariable10 = true;
tc.DIntVariable = -100000;
tc.IntVariable = -15000;
tc.RealVariable = -154.789;
tc.DWordVariable = 850;
plc.WriteStruct(tc, DB2);
// Values that are read from a struct are stored in a new struct, returned by the funcion ReadStruct
TestStruct tc2 = (TestStruct)plc.ReadStruct(typeof(TestStruct), DB2);
Assert.AreEqual(tc.BitVariable00, tc2.BitVariable00);
Assert.AreEqual(tc.BitVariable10, tc2.BitVariable10);
Assert.AreEqual(tc.DIntVariable, tc2.DIntVariable);
Assert.AreEqual(tc.IntVariable, tc2.IntVariable);
Assert.AreEqual(tc.RealVariable, Math.Round(tc2.RealVariable, 3));
Assert.AreEqual(tc.DWordVariable, tc2.DWordVariable);
}
public static int test_0_generic_get_value_optimization_vtype () {
TestStruct[] arr = new TestStruct[] { new TestStruct (100, 200), new TestStruct (300, 400) };
IEnumerator<TestStruct> enumerator = GenericClass<TestStruct>.Y (arr);
TestStruct s;
int sum = 0;
while (enumerator.MoveNext ()) {
s = enumerator.Current;
sum += s.i + s.j;
}
if (sum != 1000)
return 1;
s = GenericClass<TestStruct>.Z (arr, 0);
if (s.i != 100 || s.j != 200)
return 2;
s = GenericClass<TestStruct>.Z (arr, 1);
if (s.i != 300 || s.j != 400)
return 3;
return 0;
}
public void Test()
{
Test123();
float abc = float.NegativeInfinity;
GenericClass <Test1> .InnerGenericClass <Test2> t = new GenericClass <Test1> .InnerGenericClass <Test2>(new Test1(), new Test2());
t.Test(123);
t.Test2 <int>(new Test1(), new Test2());
int v;
int vv = TestLocal(out v);
TestStruct ts = new TestStruct();
ts.A = 1;
ts.B = 2;
ts.C = 3;
TestStruct ts2 = ts;
TestStruct ts3;
ts3 = ts;
TestValueArg(ts);
if (OnSimple != null)
{
OnSimple();
}
var f = OnSimple;
if (null != f)
{
f();
}
}
public void SpanWriteAndReadLittleEndianHeterogeneousStruct()
{
Span <byte> spanLE = new byte[Unsafe.SizeOf <TestStruct>()];
WriteInt16LittleEndian(spanLE, s_testStruct.S0);
WriteInt32LittleEndian(spanLE.Slice(2), s_testStruct.I0);
WriteInt64LittleEndian(spanLE.Slice(6), s_testStruct.L0);
WriteUInt16LittleEndian(spanLE.Slice(14), s_testStruct.US0);
WriteUInt32LittleEndian(spanLE.Slice(16), s_testStruct.UI0);
WriteUInt64LittleEndian(spanLE.Slice(20), s_testStruct.UL0);
WriteSingleLittleEndian(spanLE.Slice(28), s_testStruct.F0);
WriteDoubleLittleEndian(spanLE.Slice(32), s_testStruct.D0);
WriteInt16LittleEndian(spanLE.Slice(40), s_testStruct.S1);
WriteInt32LittleEndian(spanLE.Slice(42), s_testStruct.I1);
WriteInt64LittleEndian(spanLE.Slice(46), s_testStruct.L1);
WriteUInt16LittleEndian(spanLE.Slice(54), s_testStruct.US1);
WriteUInt32LittleEndian(spanLE.Slice(56), s_testStruct.UI1);
WriteUInt64LittleEndian(spanLE.Slice(60), s_testStruct.UL1);
WriteSingleLittleEndian(spanLE.Slice(68), s_testStruct.F1);
WriteDoubleLittleEndian(spanLE.Slice(72), s_testStruct.D1);
WriteHalfLittleEndian(spanLE.Slice(80), s_testStruct.H0);
WriteHalfLittleEndian(spanLE.Slice(82), s_testStruct.H1);
ReadOnlySpan <byte> readOnlySpanLE = new ReadOnlySpan <byte>(spanLE.ToArray());
var readStruct = new TestStruct
{
S0 = ReadInt16LittleEndian(spanLE),
I0 = ReadInt32LittleEndian(spanLE.Slice(2)),
L0 = ReadInt64LittleEndian(spanLE.Slice(6)),
US0 = ReadUInt16LittleEndian(spanLE.Slice(14)),
UI0 = ReadUInt32LittleEndian(spanLE.Slice(16)),
UL0 = ReadUInt64LittleEndian(spanLE.Slice(20)),
F0 = ReadSingleLittleEndian(spanLE.Slice(28)),
D0 = ReadDoubleLittleEndian(spanLE.Slice(32)),
S1 = ReadInt16LittleEndian(spanLE.Slice(40)),
I1 = ReadInt32LittleEndian(spanLE.Slice(42)),
L1 = ReadInt64LittleEndian(spanLE.Slice(46)),
US1 = ReadUInt16LittleEndian(spanLE.Slice(54)),
UI1 = ReadUInt32LittleEndian(spanLE.Slice(56)),
UL1 = ReadUInt64LittleEndian(spanLE.Slice(60)),
F1 = ReadSingleLittleEndian(spanLE.Slice(68)),
D1 = ReadDoubleLittleEndian(spanLE.Slice(72)),
H0 = ReadHalfLittleEndian(spanLE.Slice(80)),
H1 = ReadHalfLittleEndian(spanLE.Slice(82))
};
var readStructFromReadOnlySpan = new TestStruct
{
S0 = ReadInt16LittleEndian(readOnlySpanLE),
I0 = ReadInt32LittleEndian(readOnlySpanLE.Slice(2)),
L0 = ReadInt64LittleEndian(readOnlySpanLE.Slice(6)),
US0 = ReadUInt16LittleEndian(readOnlySpanLE.Slice(14)),
UI0 = ReadUInt32LittleEndian(readOnlySpanLE.Slice(16)),
UL0 = ReadUInt64LittleEndian(readOnlySpanLE.Slice(20)),
F0 = ReadSingleLittleEndian(readOnlySpanLE.Slice(28)),
D0 = ReadDoubleLittleEndian(readOnlySpanLE.Slice(32)),
S1 = ReadInt16LittleEndian(readOnlySpanLE.Slice(40)),
I1 = ReadInt32LittleEndian(readOnlySpanLE.Slice(42)),
L1 = ReadInt64LittleEndian(readOnlySpanLE.Slice(46)),
US1 = ReadUInt16LittleEndian(readOnlySpanLE.Slice(54)),
UI1 = ReadUInt32LittleEndian(readOnlySpanLE.Slice(56)),
UL1 = ReadUInt64LittleEndian(readOnlySpanLE.Slice(60)),
F1 = ReadSingleLittleEndian(readOnlySpanLE.Slice(68)),
D1 = ReadDoubleLittleEndian(readOnlySpanLE.Slice(72)),
H0 = ReadHalfLittleEndian(readOnlySpanLE.Slice(80)),
H1 = ReadHalfLittleEndian(readOnlySpanLE.Slice(82))
};
Assert.Equal(s_testStruct, readStruct);
Assert.Equal(s_testStruct, readStructFromReadOnlySpan);
}
public string Send(TestStruct strct)
{
return((string)Invoke("Send", new object[] { strct }));
}
static bool IsEnabledWithMultipleRefParams(int p1, ref int p2, ref TestStruct p3, string p4)
{
p2 = 0;
return(_isEnabledWithMultipleRefParamsField);
}
static void Main(string[] args)
{
TestSubs.Test();
SeqPerf.Broken1();
return;
HashMapPerf.Run();
SeqPerf.Run();
Test533();
IEnumerableOptionBindT_NotEnumerabled_NotEvaluated();
var xs = (new[] { 1, 2, 3 }).ConcatFast(new[] { 4, 5, 6 });
var ys = (new int [0]).ConcatFast(new[] { 4, 5, 6 });
var zs = (new[] { 1, 2, 3 }).ConcatFast(new int[0]);
var nxs = ((IEnumerable <int>)null).ConcatFast(new[] { 4, 5, 6 });
var nzs = (new[] { 1, 2, 3 }).ConcatFast(((IEnumerable <int>)null));
var bxs = new[] { 1, 2, 3 }.Bind(va => new[] { 1 * va, 2 * va, 3 * va });
var xyz = new TestWith("Paul", "Louth");
var xyz2 = new TestWith2("Paul", "Louth");
var xyz3 = new TestWith3 <string>("Test", "Paul", "Louth");
var xyz4 = new TestWith4("", "", "", "");
//[email protected]
xyz3 = xyz3.With(Value: "Another");
xyz2 = xyz2.With();
xyz2 = xyz2.With(Name: Some("P"));
xyz2 = xyz2.With(Surname: Some("L"));
xyz2 = xyz2.With(Name: None, Surname: None);
xyz = xyz.With(Name: "Test1");
xyz = TestWith.surname.Set("Test2", xyz);
var asq = typeof(LanguageExt.CodeGen.RecordWithAndLensGenerator).AssemblyQualifiedName;
var r = MonadicGetGenderByIdAsync(Guid.NewGuid()).Result;
WriterTest1();
WriterTest2();
WriterTest3();
Asm();
var x = new TestStruct(1, "Hello", Guid.Empty);
var y = new TestStruct(1, "Hello", Guid.Empty);
var z = new TestStruct(1, "Hello", Guid.NewGuid());
var a = x == y;
var b = x == z;
var c = x.Equals((object)y);
var d = x.Equals((object)z);
var e = x.Equals(y);
var f = x.Equals(z);
var g = JsonConvert.SerializeObject(x);
var h = JsonConvert.DeserializeObject <TestStruct>(g);
var i = x.ToString();
var j = x > y;
var k = x < z;
var l = x.GetHashCode();
var m = y.GetHashCode();
var n = z.GetHashCode();
Console.WriteLine("Coming soon");
}
public void GetDescription_GivenInvalidEnumType_ShouldThrowException()
{
TestStruct structTest = default(TestStruct);
Assert.Throws <ArgumentException>(() => structTest.GetDescription());
}
public static extern TestStruct CallReturnStructArgument(TReturnStructArgument rsa, TestStruct s);
public static TestStruct IncrementFields(TestStruct s)
{
s.I += 1;
s.F += 1.3f;
return(s);
}
public void UseStruct(TestStruct a)
{
Assert.AreEqual(1, a.I);
a.I = 2;
}
public void StructSetterTest()
{
var r = new TestStruct();
r.N = 1;
}
private int TestValueArg(TestStruct ts)
{
ts.A = 4;
ts.B = 5;
ts.C = 6;
}
public static TestStruct StructMethod(TestStruct s)
{
return(new TestStruct(s.Value + s.Value));
}
public static extern TestStruct RSA(TestStruct arg);
bool IsEnabledWithMultipleInParamsInstance(int p1, string p2, TestClass p3, TestStruct p4, TestEnum p5)
{
return(_isEnabledField);
}
public void InstanceStructTest()
{
TestStruct.Test();
}
public int CompareTo(TestStruct other) => RecordType <TestStruct> .Compare(this, other);
public static int test_1_isinst_nullable_vtype()
{
object o = new TestStruct(1, 2);
return((o is TestStruct?) ? 1 : 0);
}
public override void Test () {
for (int i = 0; i < TestAllocationCount; i++) {
_testStruct = new TestStruct(i);
}
}
public bool Equals(TestStruct other) => RecordType <TestStruct> .EqualityTyped(this, other);
public static int test_5_ldelem_stelem_generics () {
GenericClass<TestStruct> t = new GenericClass<TestStruct> ();
TestStruct s = new TestStruct (5, 5);
return t.ldelem_stelem (s).i;
}
public void RunStructFldScenario()
{
var test = TestStruct.Create();
test.RunStructFldScenario(this);
}
private static void TestMarshalByVal_Out()
{
Console.WriteLine("By value marshaling CLR array as c-style-array with OutAttribute applied");
int[] iArr = new int[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Int_Out(iArr, ARRAY_SIZE), "CStyle_Array_Int_Out");
Assert.IsTrue(Equals <int>(iArr, GetExpectedOutArray <int>(ARRAY_SIZE)), "CStyle_Array_Int_Out:Equals<int>");
int[] iArrNull = null;
Assert.IsTrue(CStyle_Array_Int_Out_Null(iArrNull), "CStyle_Array_Int_Out_Null");
Assert.IsNull(iArrNull, "CStyle_Array_Int_Out_Null:Equals<null>");
int[] iArrLength0 = new int[0];
Assert.IsTrue(CStyle_Array_Int_Out_ZeroLength(iArrLength0), "CStyle_Array_Int_Out_ZeroLength");
Assert.AreEqual(0, iArrLength0.Length, "CStyle_Array_Int_Out_ZeroLength:Length<!0>");
uint[] uiArr = new uint[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Uint_Out(uiArr, ARRAY_SIZE), "CStyle_Array_Uint_Out");
Assert.IsTrue(Equals <uint>(uiArr, GetExpectedOutArray <uint>(ARRAY_SIZE)), "CStyle_Array_Uint_Out:Equals<uint>");
short[] sArr = new short[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Short_Out(sArr, ARRAY_SIZE), "CStyle_Array_Short_Out");
Assert.IsTrue(Equals <short>(sArr, GetExpectedOutArray <short>(ARRAY_SIZE)), "CStyle_Array_Short_Out:Equals<short>");
ushort[] usArr = new ushort[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Word_Out(usArr, ARRAY_SIZE), "CStyle_Array_Word_Out");
Assert.IsTrue(Equals <ushort>(usArr, GetExpectedOutArray <ushort>(ARRAY_SIZE)), "CStyle_Array_Word_Out:Equals<ushort>");
long[] lArr = new long[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Long64_Out(lArr, ARRAY_SIZE), "CStyle_Array_Long64_Out");
Assert.IsTrue(Equals <long>(lArr, GetExpectedOutArray <long>(ARRAY_SIZE)), "CStyle_Array_Long64_Out:Equals<long>");
ulong[] ulArr = new ulong[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_ULong64_Out(ulArr, ARRAY_SIZE), "CStyle_Array_ULong64_Out");
Assert.IsTrue(Equals <ulong>(ulArr, GetExpectedOutArray <ulong>(ARRAY_SIZE)), "CStyle_Array_ULong64_Out:Equals<ulong>");
double[] dArr = new double[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Double_Out(dArr, ARRAY_SIZE), "CStyle_Array_Double_Out");
Assert.IsTrue(Equals <double>(dArr, GetExpectedOutArray <double>(ARRAY_SIZE)), "CStyle_Array_Double_Out:Equals<double>");
float[] fArr = new float[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Float_Out(fArr, ARRAY_SIZE), "CStyle_Array_Float_Out");
Assert.IsTrue(Equals <float>(fArr, GetExpectedOutArray <float>(ARRAY_SIZE)), "CStyle_Array_Float_Out:Equals<float>");
byte[] bArr = new byte[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Byte_Out(bArr, ARRAY_SIZE), "CStyle_Array_Byte_Out");
Assert.IsTrue(Equals <byte>(bArr, GetExpectedOutArray <byte>(ARRAY_SIZE)), "CStyle_Array_Byte_Out:Equals<byte>");
char[] cArr = new char[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Char_Out(cArr, ARRAY_SIZE), "CStyle_Array_Char_Out");
Assert.IsTrue(Equals <char>(cArr, GetExpectedOutArray <char>(ARRAY_SIZE)), "CStyle_Array_Char_Out:Equals<char>");
string[] strArr = new string[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_LPSTR_Out(strArr, ARRAY_SIZE), "CStyle_Array_LPSTR_Out");
string[] expectedArr = GetExpectedOutArray <string>(ARRAY_SIZE);
// Test nesting null value scenario
expectedArr[expectedArr.Length / 2 - 1] = null;
Assert.IsTrue(Equals <string>(strArr, expectedArr), "CStyle_Array_LPSTR_Out:Equals<string>");
TestStruct[] tsArr = new TestStruct[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Struct_Out(tsArr, ARRAY_SIZE), "CStyle_Array_Struct_Out");
Assert.IsTrue(Equals <TestStruct>(tsArr, GetExpectedOutStructArray(ARRAY_SIZE)), "CStyle_Array_Struct_Out:Equals<TestStruct>");
bool[] boolArr = new bool[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Bool_Out(boolArr, ARRAY_SIZE), "CStyle_Array_Bool_Out");
Assert.IsTrue(Equals <bool>(boolArr, GetExpectedOutBoolArray(ARRAY_SIZE)), "CStyle_Array_Bool_Out:Equals<bool>");
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
object[] oArr = new object[ARRAY_SIZE];
Assert.IsTrue(CStyle_Array_Object_Out(oArr, ARRAY_SIZE), "CStyle_Array_Object_Out");
object[] expectedOArr = GetExpectedOutArray <object>(ARRAY_SIZE);
// Test nesting null value scenario
expectedOArr[expectedOArr.Length / 2 - 1] = null;
Assert.IsTrue(Equals <object>(oArr, expectedOArr), "CStyle_Array_Object_Out:Equals<object>");
}
}
