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