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>"); } }