using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.Runtime.InteropServices;

using CSharp;

using NUnit.Framework;

public unsafe class CSharpTests

public class ExtendsWrapper : TestOverrideFromSecondaryBase

}

[Test]

public void TestUncompilableCode()

}

private class OverriddenInManaged : Baz

{

public override int Type => 10;

}

[Test]

public void TestDer()

}

[Test]

[Ignore("https://github.com/mono/CppSharp/issues/1518")]

public void TestReturnCharPointer()

}

[Test]

public void TestTakeCharPointer()

}

[Test]

public void TestIndexer()

}

[Test]

public void TestReturnSmallPOD()

}

[Test]

public void TestPropertyAccessModifier()

}

[Test]

public void TestMultipleInheritance()

}

[Test]

public void TestProperties()

}

[Test]

public void TestAttributes()

}

[Test]

public void TestDestructors()

}

[Test]

public unsafe void TestArrayOfPointersToPrimitives()

{

using (var bar = new Bar())

{

var array = new IntPtr[1];

int i = 5;

array[0] = new IntPtr(&i);

bar.ArrayOfPrimitivePointers = array;

Assert.That(i, Is.EqualTo(*(int*)bar.ArrayOfPrimitivePointers[0]));

}

}

[Test]

public void TestCopyConstructorValue()

{

var testCopyConstructorVal = new TestCopyConstructorVal { A = 10, B = 5 };

var copyBar = new TestCopyConstructorVal(testCopyConstructorVal);

Assert.That(testCopyConstructorVal.A, Is.EqualTo(copyBar.A));

Assert.That(testCopyConstructorVal.B, Is.EqualTo(copyBar.B));

}

[Test]

public void TestPropertiesConflictingWithMethod()

{

using (var p = new P((IQux)new Qux()) { Test = true })

{

Assert.That(p.Test, Is.True);

p.GetTest();

}

}

[Test]

public void TestDefaultArguments()

{

using (var methodsWithDefaultValues = new MethodsWithDefaultValues())

{

methodsWithDefaultValues.DefaultPointer();

methodsWithDefaultValues.DefaultVoidStar();

methodsWithDefaultValues.DefaultFunctionPointer();

methodsWithDefaultValues.DefaultValueType();

methodsWithDefaultValues.DefaultChar();

methodsWithDefaultValues.DefaultEmptyChar();

methodsWithDefaultValues.DefaultEmptyEnum();

methodsWithDefaultValues.DefaultRefTypeBeforeOthers();

methodsWithDefaultValues.DefaultRefTypeAfterOthers();

methodsWithDefaultValues.DefaultRefTypeBeforeAndAfterOthers();

methodsWithDefaultValues.DefaultIntAssignedAnEnum();

methodsWithDefaultValues.defaultRefAssignedValue();

methodsWithDefaultValues.DefaultRefAssignedValue();

methodsWithDefaultValues.DefaultEnumAssignedBitwiseOr();

methodsWithDefaultValues.DefaultEnumAssignedBitwiseOrShort();

methodsWithDefaultValues.DefaultNonEmptyCtor();

methodsWithDefaultValues.DefaultNonEmptyCtorWithNullPtr();

Assert.That(methodsWithDefaultValues.DefaultMappedToEnum(), Is.EqualTo(Flags.Flag3));

methodsWithDefaultValues.DefaultMappedToZeroEnum();

methodsWithDefaultValues.DefaultMappedToEnumAssignedWithCtor();

methodsWithDefaultValues.DefaultTypedefMappedToEnumRefAssignedWithCtor();

methodsWithDefaultValues.DefaultZeroMappedToEnumAssignedWithCtor();

Assert.That(methodsWithDefaultValues.DefaultImplicitCtorInt().Priv, Is.EqualTo(0));

methodsWithDefaultValues.DefaultImplicitCtorChar();

methodsWithDefaultValues.DefaultImplicitCtorFoo();

methodsWithDefaultValues.DefaultImplicitCtorEnum();

methodsWithDefaultValues.DefaultIntWithLongExpression();

methodsWithDefaultValues.DefaultRefTypeEnumImplicitCtor();

methodsWithDefaultValues.Rotate4x4Matrix(0, 0, 0);

methodsWithDefaultValues.DefaultPointerToValueType();

methodsWithDefaultValues.DefaultDoubleWithoutF();

methodsWithDefaultValues.DefaultIntExpressionWithEnum();

methodsWithDefaultValues.DefaultCtorWithMoreThanOneArg();

methodsWithDefaultValues.DefaultEmptyBraces();

methodsWithDefaultValues.DefaultWithRefManagedLong();

methodsWithDefaultValues.DefaultWithFunctionCall();

methodsWithDefaultValues.DefaultWithPropertyCall();

methodsWithDefaultValues.DefaultWithGetPropertyCall();

methodsWithDefaultValues.DefaultWithIndirectStringConstant();

methodsWithDefaultValues.DefaultWithDirectIntConstant();

methodsWithDefaultValues.DefaultWithEnumInLowerCasedNameSpace();

methodsWithDefaultValues.DefaultWithCharFromInt();

methodsWithDefaultValues.DefaultWithFreeConstantInNameSpace();

methodsWithDefaultValues.DefaultWithStdNumericLimits(10, 5);

methodsWithDefaultValues.DefaultWithSpecialization();

methodsWithDefaultValues.DefaultOverloadedImplicitCtor();

methodsWithDefaultValues.DefaultWithParamNamedSameAsMethod(5);

Assert.That(methodsWithDefaultValues.DefaultIntAssignedAnEnumWithBinaryOperatorAndFlags(), Is.EqualTo((int)(Bar.Items.Item1 | Bar.Items.Item2)));

Assert.That(methodsWithDefaultValues.DefaultWithConstantFlags(), Is.EqualTo(CSharp.CSharpCool.ConstFlag1 | CSharp.CSharpCool.ConstFlag2 | CSharp.CSharpCool.ConstFlag3));

Assert.IsTrue(methodsWithDefaultValues.DefaultWithPointerToEnum());

Assert.AreEqual(CSharp.CSharpCool.DefaultSmallPODInstance.__Instance, methodsWithDefaultValues.DefaultWithNonPrimitiveType().__Instance);

}

}

[Test]

public void TestGenerationOfAnotherUnitInSameFile()

{

AnotherUnitCool.FunctionInAnotherUnit();

}

[Test]

public void TestPrivateOverride()

{

using (var hasOverridesWithChangedAccess = new HasOverridesWithChangedAccess())

hasOverridesWithChangedAccess.PrivateOverride();

using (var hasOverridesWithIncreasedAccess = new HasOverridesWithIncreasedAccess())

hasOverridesWithIncreasedAccess.PrivateOverride();

}

[Test]

public void TestQFlags()

{

Assert.AreEqual(TestFlag.Flag2, new ComplexType().ReturnsQFlags);

}

[Test]

public void TestCopyCtor()

{

using (Qux q1 = new Qux())

{

for (int i = 0; i < q1.Array.Length; i++)

{

q1.Array[i] = i;

}

using (Qux q2 = new Qux(q1))

{

for (int i = 0; i < q2.Array.Length; i++)

{

Assert.AreEqual(q1.Array[i], q2.Array[i]);

}

}

}

}

[Test]

public void TestBooleanArray()

{

using (Foo foo = new Foo { A = 10 })

{

var new_values = new bool[5];

for (int i = 0; i < new_values.Length; ++i)

{

new_values[i] = i % 2 == 0;

}

foo.Btest = new_values;

Assert.AreEqual(true, foo.Btest[0]);

Assert.AreEqual(false, foo.Btest[1]);

Assert.AreEqual(true, foo.Btest[2]);

Assert.AreEqual(false, foo.Btest[3]);

Assert.AreEqual(true, foo.Btest[4]);

}

}

[Test]

public void TestImplicitCtor()

{

using (Foo foo = new Foo { A = 10 })

{

using (MethodsWithDefaultValues m = foo)

{

Assert.AreEqual(foo.A, m.A);

}

}

using (MethodsWithDefaultValues m1 = 5)

{

Assert.AreEqual(5, m1.A);

}

}

[Test]

public void TestStructWithPrivateFields()

{

var structWithPrivateFields = new StructWithPrivateFields(10, new Foo { A = 5 });

Assert.AreEqual(10, structWithPrivateFields.SimplePrivateField);

Assert.AreEqual(5, structWithPrivateFields.ComplexPrivateField.A);

}

[Test]

public void TestRenamingVariable()

{

Assert.AreEqual(5, Foo.Rename);

}

[Test]

public void TestPrimarySecondaryBase()

{

using (var a = new MI_A0())

{

Assert.That(a.Get(), Is.EqualTo(50));

}

using (var c = new MI_C())

{

Assert.That(c.Get(), Is.EqualTo(50));

}

using (var d = new MI_D())

{

Assert.That(d.Get(), Is.EqualTo(50));

}

}

[Test]

public void TestNativeToManagedMapWithForeignObjects()

{

IntPtr native1;

IntPtr native2;

var hasVirtualDtor1Map = (IDictionary<IntPtr, HasVirtualDtor1>)typeof(

HasVirtualDtor1).GetField("NativeToManagedMap",

BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);

var hasVirtualDtor2Map = (IDictionary<IntPtr, HasVirtualDtor2>)typeof(

HasVirtualDtor2).GetField("NativeToManagedMap",

BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);

using (var testNativeToManagedMap = new TestNativeToManagedMap())

{

var hasVirtualDtor2 = testNativeToManagedMap.HasVirtualDtor2;

native2 = hasVirtualDtor2.__Instance;

native1 = hasVirtualDtor2.HasVirtualDtor1.__Instance;

Assert.IsTrue(hasVirtualDtor1Map.ContainsKey(native1));

Assert.IsTrue(hasVirtualDtor2Map.ContainsKey(native2));

Assert.AreSame(hasVirtualDtor2, testNativeToManagedMap.HasVirtualDtor2);

}

Assert.IsFalse(hasVirtualDtor1Map.ContainsKey(native1));

Assert.IsFalse(hasVirtualDtor2Map.ContainsKey(native2));

}

[Test]

public void TestNativeToManagedMapWithOwnObjects()

{

using (var testNativeToManagedMap = new TestNativeToManagedMap())

{

var quxMap = (IDictionary<IntPtr, IQux>)typeof(

Qux).GetField("NativeToManagedMap",

BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);

var bar = new Bar();

testNativeToManagedMap.PropertyWithNoVirtualDtor = bar;

Assert.AreSame(bar, testNativeToManagedMap.PropertyWithNoVirtualDtor);

Assert.IsTrue(quxMap.ContainsKey(bar.__Instance));

bar.Dispose();

Assert.IsFalse(quxMap.ContainsKey(bar.__Instance));

}

}

[Test]

public void TestCallingVirtualDtor()

{

CallDtorVirtually.Destroyed = false;

using (var callDtorVirtually = new CallDtorVirtually())

{

var hasVirtualDtor1 = CallDtorVirtually.GetHasVirtualDtor1(callDtorVirtually);

hasVirtualDtor1.Dispose();

}

Assert.That(CallDtorVirtually.Destroyed, Is.True);

}

[Test]

public void TestNonOwning()

{

CallDtorVirtually.Destroyed = false;

var nonOwned = CallDtorVirtually.NonOwnedInstance;

nonOwned.Dispose();

Assert.That(CallDtorVirtually.Destroyed, Is.False);

}

// Verify that the finalizer gets called if an instance is not disposed. Note that

// we've arranged to have the generator turn on finalizers for (just) the

// TestFinalizer class.

[Test]

public void TestFinalizerGetsCalledWhenNotDisposed()

{

using var callbackRegistration = new TestFinalizerDisposeCallbackRegistration();

var nativeAddr = CreateAndReleaseTestFinalizerInstance(false);

GC.Collect();

GC.WaitForPendingFinalizers();

Assert.That(callbackRegistration.NativeAddr, Is.EqualTo(nativeAddr));

Assert.That(callbackRegistration.IsDisposing, Is.False);

}

// Verify that the finalizer is not called if an instance is disposed. Note that we've

// arranged to have the generator turn on finalizers for (just) the TestFinalizer

// class.

[Test]

public void TestFinalizerNotCalledWhenDisposed()

{

using var callbackRegistration = new TestFinalizerDisposeCallbackRegistration();

var nativeAddr = CreateAndReleaseTestFinalizerInstance(true);

GC.Collect();

GC.WaitForPendingFinalizers();

Assert.That(callbackRegistration.NativeAddr, Is.EqualTo(nativeAddr));

Assert.That(callbackRegistration.IsDisposing, Is.True);

}

// Empirically, the finalizer won't release a reference until the stack frame in which

// the reference was created has been released. Use this method to create/release the

// instance.

private Int64 CreateAndReleaseTestFinalizerInstance(bool dispose)

{

var instance = new TestFinalizer();

Assert.That(instance.__Instance, !Is.EqualTo(IntPtr.Zero));

var nativeAddr = instance.__Instance.ToInt64();

if (dispose) instance.Dispose();

return nativeAddr;

}

class TestFinalizerDisposeCallbackRegistration : IDisposable

{

public bool? IsDisposing = null;

public long? NativeAddr = null;

public TestFinalizerDisposeCallbackRegistration()

{

TestFinalizer.DisposeCallback = (isDisposing, intPtr) =>

{

IsDisposing = isDisposing;

NativeAddr = intPtr.ToInt64();

};

}

public void Dispose() => TestFinalizer.DisposeCallback = null;

}

[Test]

public void TestParamTypeToInterfacePass()

{

var baseClass = new TestParamToInterfacePassBaseTwo();

baseClass++;

Assert.AreEqual(baseClass.M, 1);

ITestParamToInterfacePassBaseTwo baseInterface = new TestParamToInterfacePassBaseTwo();

var dervClass = new TestParamToInterfacePass();

dervClass.AddM(baseClass);

Assert.AreEqual(dervClass.M, 1);

dervClass = new TestParamToInterfacePass(dervClass + baseClass);

Assert.AreEqual(dervClass.M, 2);

dervClass = new TestParamToInterfacePass(dervClass + baseInterface);

Assert.AreEqual(dervClass.M, 2);

baseClass.Dispose();

}

[Test]

public unsafe void TestMultiOverLoadPtrToRef()

{

var r = 0;

MultiOverloadPtrToRef m = &r;

m.Dispose();

using (var obj = new MultiOverloadPtrToRef(ref r))

{

var p = obj.ReturnPrimTypePtr();

Assert.AreEqual(0, p[0]);

Assert.AreEqual(0, p[1]);

Assert.AreEqual(0, p[2]);

obj.TakePrimTypePtr(ref *p);

Assert.AreEqual(100, p[0]);

Assert.AreEqual(200, p[1]);

Assert.AreEqual(300, p[2]);

int[] array = { 1, 2, 3 };

fixed (int* p1 = array)

{

obj.TakePrimTypePtr(ref *p1);

Assert.AreEqual(100, p1[0]);

Assert.AreEqual(200, p1[1]);

Assert.AreEqual(300, p1[2]);

}

Assert.AreEqual(100, array[0]);

Assert.AreEqual(200, array[1]);

Assert.AreEqual(300, array[2]);

float pThree = 0;

var refInt = 0;

obj.FuncPrimitivePtrToRef(ref refInt, null, ref pThree);

obj.FuncPrimitivePtrToRefWithDefVal(ref refInt, null, null, ref refInt);

obj.FuncPrimitivePtrToRefWithMultiOverload(ref refInt, null, null, ref refInt);

}

}

[Test]

public void TestFixedArrayRefType()

{

Foo[] foos = new Foo[4];

foos[0] = new Foo { A = 5 };

foos[1] = new Foo { A = 6 };

foos[2] = new Foo { A = 7 };

foos[3] = new Foo { A = 8 };

Bar bar = new Bar { Foos = foos };

Foo[] retFoos = bar.Foos;

Assert.AreEqual(5, retFoos[0].A);

Assert.AreEqual(6, retFoos[1].A);

Assert.AreEqual(7, retFoos[2].A);

Assert.AreEqual(8, retFoos[3].A);

foreach (Foo foo in foos)

{

foo.Dispose();

}

Foo[] foosMore = new Foo[2];

foosMore[0] = new Foo();

foosMore[1] = new Foo();

var ex = Assert.Throws<ArgumentOutOfRangeException>(() => bar.Foos = foosMore);

Assert.AreEqual("value", ex.ParamName);

string[] message = ex.Message.Split(

Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

Assert.AreEqual("The dimensions of the provided array don't match the required size. (Parameter 'value')", message[0]);

foreach (Foo foo in foosMore)

{

foo.Dispose();

}

}

[Test]

public void TestOutTypeInterfacePassTry()

{

using (var interfaceClassObj = new TestParamToInterfacePassBaseTwo())

{

ITestParamToInterfacePassBaseTwo interfaceType = interfaceClassObj;

using (var obj = new TestOutTypeInterfaces())

{

obj.FuncTryInterfaceTypeOut(out interfaceType);

ITestParamToInterfacePassBaseTwo interfaceTypePtr;

obj.FuncTryInterfaceTypePtrOut(out interfaceTypePtr);

}

}

}

[Test]

public void TestConversionForCtorWithDefaultParams()

{

using (Foo foo = 15)

{

Assert.That(foo.A, Is.EqualTo(15));

}

}

[Test]

public unsafe void TestSizeOfDerivesFromTemplateInstantiation()

{

Assert.That(sizeof(DerivesFromTemplateInstantiation.__Internal), Is.EqualTo(sizeof(int)));

}

[Test]

public void TestReferenceToArrayWithConstSize()

{

int[] incorrectlySizedArray = { 1 };

Assert.Catch<ArgumentOutOfRangeException>(() => CSharp.CSharpCool.PassConstantArrayRef(incorrectlySizedArray));

int[] array = { 1, 2 };

var result = CSharp.CSharpCool.PassConstantArrayRef(array);

Assert.That(result, Is.EqualTo(array[0]));

}

[Test]

public void TestComparison()

{

var testComparison1 = new TestComparison { A = 5, B = 5.5f };

var testComparison2 = new TestComparison { A = 5, B = 5.5f };

Assert.IsTrue(testComparison1 == testComparison2);

Assert.IsTrue(testComparison1.Equals(testComparison2));

var testHashes = new Dictionary<TestComparison, int>();

testHashes[testComparison1] = 1;

testHashes[testComparison2] = 2;

Assert.That(testHashes[testComparison1], Is.EqualTo(2));

}

[Test]

public void TestOverriddenPropertyFromIndirectBase()

{

using (var overridePropertyFromIndirectPrimaryBase = new OverridePropertyFromIndirectPrimaryBase())

{

Assert.That(overridePropertyFromIndirectPrimaryBase.Property, Is.EqualTo(5));

}

}

[Test]

public void TestCallingVirtualBeforeCtorFinished()

{

using (new QApplication())

{

using (new QWidget())

{

}

}

}

[Test]

public void TestMultipleInheritanceFieldOffsets()

{

using (var multipleInheritanceFieldOffsets = new MultipleInheritanceFieldOffsets())

{

Assert.That(multipleInheritanceFieldOffsets.Primary, Is.EqualTo(1));