private ClassGen CreateSealedClass()
{
var klass = SupportTypeBuilder.CreateClass("my.example.class", options);
klass.IsFinal = true;
return(klass);
}
public void WriteClassInternalBase()
{
// Tests the case where a class inherits from Java.Lang.Object and is in the same assembly.
// Specifically, the internal class_ref field does need the new modifier.
// - This prevents a CS0108 warning from being generated.
options.SymbolTable.AddType(new TestClass(null, "Java.Lang.Object"));
var @class = SupportTypeBuilder.CreateClass("java.code.MyClass", options, "Java.Lang.Object");
@class.Validate(options, new GenericParameterDefinitionList(), generator.Context);
// FromXml is set to true when a class is set to true when the api.xml contains an entry for the class.
// Therefore, if a class's base has FromXml set to true, the class and its base will be in the same C# assembly.
@class.BaseGen.FromXml = true;
generator.Context.ContextTypes.Push(@class);
generator.WriteClass(@class, string.Empty, new GenerationInfo("", "", "MyAssembly"));
generator.Context.ContextTypes.Pop();
var result = writer.ToString().NormalizeLineEndings();
Assert.True(result.Contains("internal static new IntPtr class_ref"));
Assert.False(result.Contains("internal static IntPtr class_ref"));
}
public void WriteClassProperties()
{
var @class = SupportTypeBuilder.CreateClass("java.code.MyClass", options);
generator.Context.ContextTypes.Push(@class);
generator.WriteImplementedProperties(@class.Properties, string.Empty, @class.IsFinal, @class);
generator.Context.ContextTypes.Pop();
Assert.AreEqual(GetTargetedExpected(nameof(WriteClassProperties)), writer.ToString().NormalizeLineEndings());
}
public void WriteClassInvoker()
{
var @class = SupportTypeBuilder.CreateClass("java.code.MyClass", options);
generator.Context.ContextTypes.Push(@class);
generator.WriteClassInvoker(@class, string.Empty);
generator.Context.ContextTypes.Pop();
Assert.AreEqual(GetTargetedExpected(nameof(WriteClassInvoker)), writer.ToString().NormalizeLineEndings());
}
public void WriteClassPropertyInvokersWithSkips()
{
// This test should skip the first Property because members contains the Property
var @class = SupportTypeBuilder.CreateClass("java.code.MyClass", options);
var members = new HashSet <string> (new [] { @class.Properties [0].Name });
generator.Context.ContextTypes.Push(@class);
generator.WriteClassPropertyInvokers(@class, @class.Properties, string.Empty, members);
generator.Context.ContextTypes.Pop();
Assert.AreEqual(GetTargetedExpected(nameof(WriteClassPropertyInvokersWithSkips)), writer.ToString().NormalizeLineEndings());
}
public void WriteClassPropertyInvokers()
{
// This test should generate all the properties (members is empty)
var @class = SupportTypeBuilder.CreateClass("java.code.MyClass", options);
var members = new HashSet <string> ();
generator.Context.ContextTypes.Push(@class);
generator.WriteClassPropertyInvokers(@class, @class.Properties, string.Empty, members);
generator.Context.ContextTypes.Pop();
Assert.AreEqual(GetTargetedExpected(nameof(WriteClassPropertyInvokers)), writer.ToString().NormalizeLineEndings());
}
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 FixProtectedType()
{
var klass = CreateSealedClass();
var type = SupportTypeBuilder.CreateClass("my.example.class.inner", options);
type.Visibility = "protected";
klass.NestedTypes.Add(type);
SealedProtectedFixups.Fixup(new [] { (GenBase)klass }.ToList());
Assert.AreEqual("private", type.Visibility);
}
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 WriteClassExternalBase()
{
// Tests the case where a class inherits from a class that is not in the same assembly.
// Specifically, the internal class_ref field does NOT need the new modifier.
// - This prevents a CS0109 warning from being generated.
options.SymbolTable.AddType(new TestClass(null, "Java.Lang.Object"));
var @class = SupportTypeBuilder.CreateClass("java.code.MyClass", options, "Java.Lang.Object");
@class.Validate(options, new GenericParameterDefinitionList(), generator.Context);
generator.Context.ContextTypes.Push(@class);
generator.WriteClass(@class, string.Empty, new GenerationInfo("", "", "MyAssembly"));
generator.Context.ContextTypes.Pop();
var result = writer.ToString().NormalizeLineEndings();
Assert.True(result.Contains("internal static IntPtr class_ref"));
Assert.False(result.Contains("internal static new IntPtr class_ref"));
}
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));
}
