public void GetContextTypeMember()
{
var klass = new TestClass("Object", "java.code.MyClass");
klass.AddMethod(SupportTypeBuilder.CreateMethod(klass, "Echo", new CodeGenerationOptions(), "uint", false, false, new Parameter("value", "uint", "uint", false)));
klass.AddField(new TestField("string", "Foo"));
var context = new CodeGeneratorContext();
context.ContextTypes.Push(klass);
Assert.AreEqual("java.code.MyClass", context.GetContextTypeMember());
context.ContextMethod = klass.Methods.Single();
Assert.AreEqual("java.code.MyClass.Echo (uint)", context.GetContextTypeMember());
context.ContextMethod = null;
context.ContextField = klass.Fields.Single();
Assert.AreEqual("java.code.MyClass.Foo", context.GetContextTypeMember());
context.ContextMethod = klass.Methods.Single();
context.ContextField = null;
context.ContextTypes.Clear();
Assert.AreEqual("Echo (uint)", context.GetContextTypeMember());
}
void TestParameterlessMethods(string name)
{
var c = SupportTypeBuilder.CreateClass("java.myClass", options);
var m = SupportTypeBuilder.CreateMethod(c, name, options);
// Yes
Assert.True(c.RequiresNew(m.Name, m));
// No because > 0 parameters
m.Parameters.Add(new Parameter("value", "int", "int", false));
Assert.False(c.RequiresNew(m.Name, m));
}
public void HandleAlwaysRequiresNew()
{
// The same name as a property always requires new, no matter the parameters
var c = SupportTypeBuilder.CreateClass("java.myClass", options);
var m = SupportTypeBuilder.CreateMethod(c, "Handle", options);
// Yes
Assert.True(c.RequiresNew(m.Name, m));
// Yes, even with parameters
m.Parameters.Add(new Parameter("value", "int", "int", false));
Assert.True(c.RequiresNew(m.Name, m));
}
public void ValidateInterfaceMethods()
{
var options = new CodeGenerationOptions {
SupportDefaultInterfaceMethods = true
};
var iface = SupportTypeBuilder.CreateEmptyInterface("My.Test.Interface");
iface.Methods.Add(SupportTypeBuilder.CreateMethod(iface, "DoAbstractThing", options));
iface.Methods.Add(SupportTypeBuilder.CreateMethod(iface, "DoDefaultThing", options).SetDefaultInterfaceMethod());
// The interface should be valid
Assert.True(iface.Validate(options, new GenericParameterDefinitionList(), new CodeGeneratorContext()));
Assert.AreEqual(2, iface.Methods.Count);
}
public void FixProtectedMethod()
{
var klass = CreateSealedClass();
var method = SupportTypeBuilder.CreateMethod(klass, "ToString", options);
klass.Methods.Add(method);
method.Visibility = "protected";
method.IsOverride = false;
SealedProtectedFixups.Fixup(new [] { (GenBase)klass }.ToList());
Assert.AreEqual("private", method.Visibility);
}
public void ValidateInvalidAbstractInterfaceMethods()
{
var options = new CodeGenerationOptions {
SupportDefaultInterfaceMethods = true
};
var iface = SupportTypeBuilder.CreateEmptyInterface("My.Test.Interface");
iface.Methods.Add(SupportTypeBuilder.CreateMethod(iface, "DoAbstractThing", options, "potato"));
iface.Methods.Add(SupportTypeBuilder.CreateMethod(iface, "DoDefaultThing", options).SetDefaultInterfaceMethod());
// The interface should be invalid because an abstract method is invalid
Assert.False(iface.Validate(options, new GenericParameterDefinitionList(), new CodeGeneratorContext()));
// The invalid abstract method should be removed, leaving just the valid default method
Assert.AreEqual(1, iface.Methods.Count);
}
public void WriteKotlinUnsignedArrayTypeMethodsClass()
{
var @class = new TestClass("Object", "java.code.MyClass");
@class.AddMethod(SupportTypeBuilder.CreateMethod(@class, "Echo", options, "uint[]", false, false, new Parameter("value", "uint[]", "uint[]", false)));
@class.AddMethod(SupportTypeBuilder.CreateMethod(@class, "Echo", options, "ushort[]", false, false, new Parameter("value", "ushort[]", "ushort[]", false)));
@class.AddMethod(SupportTypeBuilder.CreateMethod(@class, "Echo", options, "ulong[]", false, false, new Parameter("value", "ulong[]", "ulong[]", false)));
@class.AddMethod(SupportTypeBuilder.CreateMethod(@class, "Echo", options, "ubyte[]", false, false, new Parameter("value", "ubyte[]", "byte[]", false)));
// Kotlin methods with unsigned types are name-mangled and don't support virtual
foreach (var m in @class.Methods)
{
m.IsVirtual = false;
}
generator.Context.ContextTypes.Push(@class);
generator.WriteClass(@class, string.Empty, new GenerationInfo("", "", "MyAssembly"));
generator.Context.ContextTypes.Pop();
Assert.AreEqual(GetTargetedExpected(nameof(WriteKotlinUnsignedArrayTypeMethodsClass)), writer.ToString().NormalizeLineEndings());
}
public void TestEqualsMethodsWithOneParameter()
{
var c = SupportTypeBuilder.CreateClass("java.myClass", options);
var m = SupportTypeBuilder.CreateMethod(c, "Equals", options, "void", false, false);
// No because 0 parameters
Assert.False(c.RequiresNew(m.Name, m));
var p0 = new Parameter("p0", "object", "object", false);
m.Parameters.Add(p0);
// Yes
Assert.True(c.RequiresNew(m.Name, m));
// No because parameter is wrong type
var p1 = new Parameter("p1", "string", "string", false);
m = SupportTypeBuilder.CreateMethod(c, "Equals", options, "void", true, false, p1);
Assert.False(c.RequiresNew(m.Name, m));
}
void TestStaticMethodsWithTwoParameters(string name)
{
var c = SupportTypeBuilder.CreateClass("java.myClass", options);
var p0 = new Parameter("p0", "object", "object", false);
var p1 = new Parameter("p1", "object", "object", false);
var m = SupportTypeBuilder.CreateMethod(c, name, options, "void", true, false, p0, p1);
// Yes
Assert.True(c.RequiresNew(m.Name, m));
// No because != 2 parameters
m.Parameters.Add(new Parameter("value", "int", "int", false));
Assert.False(c.RequiresNew(m.Name, m));
// No because parameter is wrong type
var p2 = new Parameter("p1", "string", "string", false);
m = SupportTypeBuilder.CreateMethod(c, name, options, "void", true, false, p0, p2);
Assert.False(c.RequiresNew(m.Name, m));
}
