private static void TestNullableU() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableU(true, 1u)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableUOut(true, 1u, out uint?value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddNullableU(default, default));
private static void TestVector256U() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector256U(1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u)); Vector256 <uint> value2; GenericsNative.GetVector256UOut(1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u, &value2); Assert.AreEqual(value2.GetElement(0), 1u); Assert.AreEqual(value2.GetElement(1), 2u); Assert.AreEqual(value2.GetElement(2), 3u); Assert.AreEqual(value2.GetElement(3), 4u); Assert.AreEqual(value2.GetElement(4), 5u); Assert.AreEqual(value2.GetElement(5), 6u); Assert.AreEqual(value2.GetElement(6), 7u); Assert.AreEqual(value2.GetElement(7), 8u); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector256UOut(1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u, out Vector256 <uint> value3)); Vector256 <uint> *value4 = GenericsNative.GetVector256UPtr(1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u); Assert.AreEqual(value4->GetElement(0), 1u); Assert.AreEqual(value4->GetElement(1), 2u); Assert.AreEqual(value4->GetElement(2), 3u); Assert.AreEqual(value4->GetElement(3), 4u); Assert.AreEqual(value4->GetElement(4), 5u); Assert.AreEqual(value4->GetElement(5), 6u); Assert.AreEqual(value4->GetElement(6), 7u); Assert.AreEqual(value4->GetElement(7), 8u); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector256URef(1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddVector256U(default, default));
private static void TestNullableF() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableF(true, 1.0f)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableFOut(true, 1.0f, out float?value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddNullableF(default, default));
private static void TestPoint4L() { GenericsNative.Point4 <long> value = GenericsNative.GetPoint4L(1L, 2L, 3L, 4L); Assert.AreEqual(value.e00, 1L); Assert.AreEqual(value.e01, 2L); Assert.AreEqual(value.e02, 3L); Assert.AreEqual(value.e03, 4L); GenericsNative.Point4 <long> value2; GenericsNative.GetPoint4LOut(1L, 2L, 3L, 4L, &value2); Assert.AreEqual(value2.e00, 1L); Assert.AreEqual(value2.e01, 2L); Assert.AreEqual(value2.e02, 3L); Assert.AreEqual(value2.e03, 4L); GenericsNative.GetPoint4LOut(1L, 2L, 3L, 4L, out GenericsNative.Point4 <long> value3); Assert.AreEqual(value3.e00, 1L); Assert.AreEqual(value3.e01, 2L); Assert.AreEqual(value3.e02, 3L); Assert.AreEqual(value3.e03, 4L); GenericsNative.Point4 <long> *value4 = GenericsNative.GetPoint4LPtr(1L, 2L, 3L, 4L); Assert.AreEqual(value4->e00, 1L); Assert.AreEqual(value4->e01, 2L); Assert.AreEqual(value4->e02, 3L); Assert.AreEqual(value4->e03, 4L); ref readonly GenericsNative.Point4 <long> value5 = ref GenericsNative.GetPoint4LRef(1L, 2L, 3L, 4L);
private static void TestPoint4D() { GenericsNative.Point4 <double> value = GenericsNative.GetPoint4D(1.0, 2.0, 3.0, 4.0); Assert.AreEqual(value.e00, 1.0); Assert.AreEqual(value.e01, 2.0); Assert.AreEqual(value.e02, 3.0); Assert.AreEqual(value.e03, 4.0); GenericsNative.Point4 <double> value2; GenericsNative.GetPoint4DOut(1.0, 2.0, 3.0, 4.0, &value2); Assert.AreEqual(value2.e00, 1.0); Assert.AreEqual(value2.e01, 2.0); Assert.AreEqual(value2.e02, 3.0); Assert.AreEqual(value2.e03, 4.0); GenericsNative.GetPoint4DOut(1.0, 2.0, 3.0, 4.0, out GenericsNative.Point4 <double> value3); Assert.AreEqual(value3.e00, 1.0); Assert.AreEqual(value3.e01, 2.0); Assert.AreEqual(value3.e02, 3.0); Assert.AreEqual(value3.e03, 4.0); GenericsNative.Point4 <double> *value4 = GenericsNative.GetPoint4DPtr(1.0, 2.0, 3.0, 4.0); Assert.AreEqual(value4->e00, 1.0); Assert.AreEqual(value4->e01, 2.0); Assert.AreEqual(value4->e02, 3.0); Assert.AreEqual(value4->e03, 4.0); ref readonly GenericsNative.Point4 <double> value5 = ref GenericsNative.GetPoint4DRef(1.0, 2.0, 3.0, 4.0);
private static void TestPoint4F() { GenericsNative.Point4 <float> value = GenericsNative.GetPoint4F(1.0f, 2.0f, 3.0f, 4.0f); Assert.AreEqual(value.e00, 1.0f); Assert.AreEqual(value.e01, 2.0f); Assert.AreEqual(value.e02, 3.0f); Assert.AreEqual(value.e03, 4.0f); GenericsNative.Point4 <float> value2; GenericsNative.GetPoint4FOut(1.0f, 2.0f, 3.0f, 4.0f, &value2); Assert.AreEqual(value2.e00, 1.0f); Assert.AreEqual(value2.e01, 2.0f); Assert.AreEqual(value2.e02, 3.0f); Assert.AreEqual(value2.e03, 4.0f); GenericsNative.GetPoint4FOut(1.0f, 2.0f, 3.0f, 4.0f, out GenericsNative.Point4 <float> value3); Assert.AreEqual(value3.e00, 1.0f); Assert.AreEqual(value3.e01, 2.0f); Assert.AreEqual(value3.e02, 3.0f); Assert.AreEqual(value3.e03, 4.0f); GenericsNative.Point4 <float> *value4 = GenericsNative.GetPoint4FPtr(1.0f, 2.0f, 3.0f, 4.0f); Assert.AreEqual(value4->e00, 1.0f); Assert.AreEqual(value4->e01, 2.0f); Assert.AreEqual(value4->e02, 3.0f); Assert.AreEqual(value4->e03, 4.0f); ref readonly GenericsNative.Point4 <float> value5 = ref GenericsNative.GetPoint4FRef(1.0f, 2.0f, 3.0f, 4.0f);
private static void TestVector64C() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector64C('0', '1', '2', '3')); Vector64 <char> value2; GenericsNative.GetVector64COut('0', '1', '2', '3', &value2); Vector64 <short> tValue2 = *(Vector64 <short> *) & value2; Assert.AreEqual(tValue2.GetElement(0), (short)'0'); Assert.AreEqual(tValue2.GetElement(1), (short)'1'); Assert.AreEqual(tValue2.GetElement(2), (short)'2'); Assert.AreEqual(tValue2.GetElement(3), (short)'3'); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector64COut('0', '1', '2', '3', out Vector64 <char> value3)); Vector64 <char> * value4 = GenericsNative.GetVector64CPtr('0', '1', '2', '3'); Vector64 <short> *tValue4 = (Vector64 <short> *)value4; Assert.AreEqual(tValue4->GetElement(0), (short)'0'); Assert.AreEqual(tValue4->GetElement(1), (short)'1'); Assert.AreEqual(tValue4->GetElement(2), (short)'2'); Assert.AreEqual(tValue4->GetElement(3), (short)'3'); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector64CRef('0', '1', '2', '3')); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddVector64C(default, default));
private static void TestVector64B() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector64B(true, false, true, false, true, false, true, false)); Vector64 <bool> value2; GenericsNative.GetVector64BOut(true, false, true, false, true, false, true, false, &value2); Vector64 <byte> tValue2 = *(Vector64 <byte> *) & value2; Assert.AreEqual(tValue2.GetElement(0), 1); Assert.AreEqual(tValue2.GetElement(1), 0); Assert.AreEqual(tValue2.GetElement(2), 1); Assert.AreEqual(tValue2.GetElement(3), 0); Assert.AreEqual(tValue2.GetElement(4), 1); Assert.AreEqual(tValue2.GetElement(5), 0); Assert.AreEqual(tValue2.GetElement(6), 1); Assert.AreEqual(tValue2.GetElement(7), 0); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector64BOut(true, false, true, false, true, false, true, false, out Vector64 <bool> value3)); Vector64 <bool> *value4 = GenericsNative.GetVector64BPtr(true, false, true, false, true, false, true, false); Vector64 <byte> *tValue4 = (Vector64 <byte> *)value4; Assert.AreEqual(tValue4->GetElement(0), 1); Assert.AreEqual(tValue4->GetElement(1), 0); Assert.AreEqual(tValue4->GetElement(2), 1); Assert.AreEqual(tValue4->GetElement(3), 0); Assert.AreEqual(tValue4->GetElement(4), 1); Assert.AreEqual(tValue4->GetElement(5), 0); Assert.AreEqual(tValue4->GetElement(6), 1); Assert.AreEqual(tValue4->GetElement(7), 0); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector64BRef(true, false, true, false, true, false, true, false)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddVector64B(default, default));
private static void TestNullableL() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableL(true, 1L)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableLOut(true, 1L, out long?value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddNullableL(default, default));
private static void TestNullableB() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableB(true, false)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableBOut(true, false, out bool?value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddNullableB(default, default));
private static void TestPoint4U() { GenericsNative.Point4 <uint> value = GenericsNative.GetPoint4U(1u, 2u, 3u, 4u); Assert.AreEqual(value.e00, 1u); Assert.AreEqual(value.e01, 2u); Assert.AreEqual(value.e02, 3u); Assert.AreEqual(value.e03, 4u); GenericsNative.Point4 <uint> value2; GenericsNative.GetPoint4UOut(1u, 2u, 3u, 4u, &value2); Assert.AreEqual(value2.e00, 1u); Assert.AreEqual(value2.e01, 2u); Assert.AreEqual(value2.e02, 3u); Assert.AreEqual(value2.e03, 4u); GenericsNative.GetPoint4UOut(1u, 2u, 3u, 4u, out GenericsNative.Point4 <uint> value3); Assert.AreEqual(value3.e00, 1u); Assert.AreEqual(value3.e01, 2u); Assert.AreEqual(value3.e02, 3u); Assert.AreEqual(value3.e03, 4u); GenericsNative.Point4 <uint> *value4 = GenericsNative.GetPoint4UPtr(1u, 2u, 3u, 4u); Assert.AreEqual(value4->e00, 1u); Assert.AreEqual(value4->e01, 2u); Assert.AreEqual(value4->e02, 3u); Assert.AreEqual(value4->e03, 4u); ref readonly GenericsNative.Point4 <uint> value5 = ref GenericsNative.GetPoint4URef(1u, 2u, 3u, 4u);
private static void TestVector128C() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector128C('0', '1', '2', '3', '4', '5', '6', '7')); Vector128 <char> value2; GenericsNative.GetVector128COut('0', '1', '2', '3', '4', '5', '6', '7', &value2); Vector128 <short> tValue2 = *(Vector128 <short> *) & value2; Assert.Equal(tValue2.GetElement(0), (short)'0'); Assert.Equal(tValue2.GetElement(1), (short)'1'); Assert.Equal(tValue2.GetElement(2), (short)'2'); Assert.Equal(tValue2.GetElement(3), (short)'3'); Assert.Equal(tValue2.GetElement(4), (short)'4'); Assert.Equal(tValue2.GetElement(5), (short)'5'); Assert.Equal(tValue2.GetElement(6), (short)'6'); Assert.Equal(tValue2.GetElement(7), (short)'7'); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector128COut('0', '1', '2', '3', '4', '5', '6', '7', out Vector128 <char> value3)); Vector128 <char> * value4 = GenericsNative.GetVector128CPtr('0', '1', '2', '3', '4', '5', '6', '7'); Vector128 <short> *tValue4 = (Vector128 <short> *)value4; Assert.Equal(tValue4->GetElement(0), (short)'0'); Assert.Equal(tValue4->GetElement(1), (short)'1'); Assert.Equal(tValue4->GetElement(2), (short)'2'); Assert.Equal(tValue4->GetElement(3), (short)'3'); Assert.Equal(tValue4->GetElement(4), (short)'4'); Assert.Equal(tValue4->GetElement(5), (short)'5'); Assert.Equal(tValue4->GetElement(6), (short)'6'); Assert.Equal(tValue4->GetElement(7), (short)'7'); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector128CRef('0', '1', '2', '3', '4', '5', '6', '7')); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddVector128C(default, default));
private static void TestVectorC128() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVectorC128('0', '1', '2', '3', '4', '5', '6', '7')); Vector <char> value2; GenericsNative.GetVectorC128Out('0', '1', '2', '3', '4', '5', '6', '7', &value2); Vector <short> tValue2 = *(Vector <short> *) & value2; Assert.AreEqual(tValue2[0], (short)'0'); Assert.AreEqual(tValue2[1], (short)'1'); Assert.AreEqual(tValue2[2], (short)'2'); Assert.AreEqual(tValue2[3], (short)'3'); Assert.AreEqual(tValue2[4], (short)'4'); Assert.AreEqual(tValue2[5], (short)'5'); Assert.AreEqual(tValue2[6], (short)'6'); Assert.AreEqual(tValue2[7], (short)'7'); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVectorC128Out('0', '1', '2', '3', '4', '5', '6', '7', out Vector <char> value3)); Vector <char> * value4 = GenericsNative.GetVectorC128Ptr('0', '1', '2', '3', '4', '5', '6', '7'); Vector <short> *tValue4 = (Vector <short> *)value4; Assert.AreEqual((*tValue4)[0], (short)'0'); Assert.AreEqual((*tValue4)[1], (short)'1'); Assert.AreEqual((*tValue4)[2], (short)'2'); Assert.AreEqual((*tValue4)[3], (short)'3'); Assert.AreEqual((*tValue4)[4], (short)'4'); Assert.AreEqual((*tValue4)[5], (short)'5'); Assert.AreEqual((*tValue4)[6], (short)'6'); Assert.AreEqual((*tValue4)[7], (short)'7'); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVectorC128Ref('0', '1', '2', '3', '4', '5', '6', '7')); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddVectorC128(default, default));
private static void TestNullableC() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableC(true, '1')); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableCOut(true, '1', out char?value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddNullableC(default, default));
private static void TestNullableD() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableD(true, 1.0)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetNullableDOut(true, 1.0, out double?value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddNullableD(default, default));
private static void TestVector256F() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector256F(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f)); Vector256 <float> value2; GenericsNative.GetVector256FOut(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, &value2); Assert.AreEqual(value2.GetElement(0), 1.0f); Assert.AreEqual(value2.GetElement(1), 2.0f); Assert.AreEqual(value2.GetElement(2), 3.0f); Assert.AreEqual(value2.GetElement(3), 4.0f); Assert.AreEqual(value2.GetElement(4), 5.0f); Assert.AreEqual(value2.GetElement(5), 6.0f); Assert.AreEqual(value2.GetElement(6), 7.0f); Assert.AreEqual(value2.GetElement(7), 8.0f); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector256FOut(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, out Vector256 <float> value3)); Vector256 <float> *value4 = GenericsNative.GetVector256FPtr(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f); Assert.AreEqual(value4->GetElement(0), 1.0f); Assert.AreEqual(value4->GetElement(1), 2.0f); Assert.AreEqual(value4->GetElement(2), 3.0f); Assert.AreEqual(value4->GetElement(3), 4.0f); Assert.AreEqual(value4->GetElement(4), 5.0f); Assert.AreEqual(value4->GetElement(5), 6.0f); Assert.AreEqual(value4->GetElement(6), 7.0f); Assert.AreEqual(value4->GetElement(7), 8.0f); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetVector256FRef(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddVector256F(default, default));
private static void TestSpanF() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSpanF(1.0f)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSpanFOut(1.0f, out Span <float> value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSpanFRef(1.0f)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddSpanF(default, default));
private static void TestReadOnlySpanC() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetReadOnlySpanC('1')); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetReadOnlySpanCOut('1', out ReadOnlySpan <char> value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetReadOnlySpanCRef('1')); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddReadOnlySpanC(default, default));
private static void TestSequentialClassD() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassD(1.0)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassDOut(1.0, out GenericsNative.SequentialClass <double> value2)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassDRef(1.0)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddSequentialClassD(default, default));
private static void TestPoint3C() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetPoint3C('1', '2', '3')); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetPoint3COut('1', '2', '3', out GenericsNative.Point3 <char> value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetPoint3CRef('1', '2', '3')); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddPoint3C(default, default));
private static void TestPoint1B() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetPoint1B(true)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetPoint1BOut(true, out GenericsNative.Point1 <bool> value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetPoint1BRef(true)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddPoint1B(default, default));
private static void TestSequentialClassL() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassL(1L)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassLOut(1L, out GenericsNative.SequentialClass <long> value2)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassLRef(1L)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddSequentialClassL(default, default));
private static void TestReadOnlySpanD() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetReadOnlySpanD(1.0)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetReadOnlySpanDOut(1.0, out ReadOnlySpan <double> value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetReadOnlySpanDRef(1.0)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddReadOnlySpanD(default, default));
private static void TestSequentialClassU() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassU(1u)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassUOut(1u, out GenericsNative.SequentialClass <uint> value2)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassURef(1u)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddSequentialClassU(default, default));
private static void TestSpanB() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSpanB(true)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSpanBOut(true, out Span <bool> value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSpanBRef(true)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddSpanB(default, default));
private static void TestReadOnlySpanU() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetReadOnlySpanU(1u)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetReadOnlySpanUOut(1u, out ReadOnlySpan <uint> value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetReadOnlySpanURef(1u)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddReadOnlySpanU(default, default));
private static void TestSpanL() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSpanL(1L)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSpanLOut(1L, out Span <long> value3)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSpanLRef(1L)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddSpanL(default, default));
private static void TestSequentialClassC() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassC('1')); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassCOut('1', out GenericsNative.SequentialClass <char> value2)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassCRef('1')); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddSequentialClassC(default, default));
private static void TestSequentialClassF() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassF(1.0f)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassFOut(1.0f, out GenericsNative.SequentialClass <float> value2)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassFRef(1.0f)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddSequentialClassF(default, default));
private static void TestSequentialClassB() { Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassB(true)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassBOut(true, out GenericsNative.SequentialClass <bool> value2)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.GetSequentialClassBRef(true)); Assert.Throws <MarshalDirectiveException>(() => GenericsNative.AddSequentialClassB(default, default));