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