public void WriteSealedOverriddenDefaultMethod() { // Create an interface with a default method var iface = SupportTypeBuilder.CreateEmptyInterface("java.code.IMyInterface"); iface.Methods.Add(new TestMethod(iface, "DoSomething").SetDefaultInterfaceMethod()); options.SymbolTable.AddType(iface); // Create a type that inherits the interface, overriding the method as final var klass = new TestClass("java.code.IMyInterface", "java.code.MyClass"); klass.AddImplementedInterface("java.code.IMyInterface"); klass.Methods.Add(new TestMethod(iface, "DoSomething").SetFinal()); iface.Validate(options, new GenericParameterDefinitionList(), generator.Context); klass.Validate(options, new GenericParameterDefinitionList(), generator.Context); klass.FixupMethodOverrides(options); generator.Context.ContextTypes.Push(klass); generator.WriteClass(klass, string.Empty, new GenerationInfo(string.Empty, string.Empty, "MyAssembly")); generator.Context.ContextTypes.Pop(); // The method should not be marked as 'virtual sealed' Assert.False(writer.ToString().Contains("virtual sealed")); }
public void WriteConstSugarInterfaceFields() { // Need a JLO class "FromXml" to trigger ConstSugar logic. (ie: this is "building" Mono.Android.dll) var klass = new TestClass("java.lang.Object", "java.lang.Object") { FromXml = true, }; options.SymbolTable.AddType(klass); // This is an interface that only has fields (IsConstSugar) // We treat a little differenly because they don't need to interop with Java var iface = SupportTypeBuilder.CreateEmptyInterface("java.code.IMyInterface"); // These interface fields are supported and should be in the output iface.Fields.Add(new TestField("int", "MyConstantField").SetConstant().SetValue("7")); iface.Fields.Add(new TestField("java.lang.String", "MyConstantStringField").SetConstant().SetValue("\"hello\"")); iface.Fields.Add(new TestField("int", "MyDeprecatedField").SetConstant().SetValue("7").SetDeprecated()); // These interface fields are not supported and should be ignored iface.Fields.Add(new TestField("int", "MyDeprecatedEnumField").SetConstant().SetValue("MyEnumValue").SetDeprecated("This constant will be removed in the future version.")); iface.Fields.Add(new TestField("int", "MyStaticField").SetStatic().SetValue("7")); iface.Validate(options, new GenericParameterDefinitionList(), new CodeGeneratorContext()); generator.Context.ContextTypes.Push(iface); generator.WriteInterfaceDeclaration(iface, string.Empty, new GenerationInfo(null, null, null)); generator.Context.ContextTypes.Pop(); Assert.AreEqual(GetTargetedExpected(nameof(WriteConstSugarInterfaceFields)), writer.ToString().NormalizeLineEndings()); }
public void WriteInterfaceDefaultMethod() { // Create an interface with a default method var iface = SupportTypeBuilder.CreateEmptyInterface("java.code.IMyInterface"); iface.Methods.Add(new TestMethod(iface, "DoSomething").SetDefaultInterfaceMethod()); iface.Validate(options, new GenericParameterDefinitionList(), new CodeGeneratorContext()); generator.WriteInterfaceDeclaration(iface, string.Empty); Assert.AreEqual(GetTargetedExpected(nameof(WriteInterfaceDefaultMethod)), writer.ToString().NormalizeLineEndings()); }
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 WriteInterfaceFields() { // This is an interface that has both fields and method declarations var iface = SupportTypeBuilder.CreateEmptyInterface("java.code.IMyInterface"); iface.Fields.Add(new TestField("int", "MyConstantField").SetConstant().SetValue("7")); iface.Methods.Add(new TestMethod(iface, "DoSomething").SetAbstract()); iface.Validate(options, new GenericParameterDefinitionList(), new CodeGeneratorContext()); generator.Context.ContextTypes.Push(iface); generator.WriteInterfaceDeclaration(iface, string.Empty); generator.Context.ContextTypes.Pop(); Assert.AreEqual(GetTargetedExpected(nameof(WriteInterfaceFields)), writer.ToString().NormalizeLineEndings()); }
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 WriteInterfaceDefaultPropertyGetterOnly() { // Create an interface with a default method var iface = SupportTypeBuilder.CreateEmptyInterface("java.code.IMyInterface"); var prop = SupportTypeBuilder.CreateProperty(iface, "Value", "int", options); prop.Getter.IsInterfaceDefaultMethod = true; prop.Setter = null; iface.Properties.Add(prop); iface.Validate(options, new GenericParameterDefinitionList(), new CodeGeneratorContext()); generator.WriteInterfaceDeclaration(iface, string.Empty); Assert.AreEqual(GetTargetedExpected(nameof(WriteInterfaceDefaultPropertyGetterOnly)), writer.ToString().NormalizeLineEndings()); }
public void WriteStaticInterfaceProperty() { // Create an interface with a static property var iface = SupportTypeBuilder.CreateEmptyInterface("java.code.IMyInterface"); var prop = SupportTypeBuilder.CreateProperty(iface, "Value", "int", options); prop.Getter.IsStatic = true; prop.Getter.IsVirtual = false; prop.Setter.IsStatic = true; prop.Setter.IsVirtual = false; iface.Properties.Add(prop); iface.Validate(options, new GenericParameterDefinitionList(), new CodeGeneratorContext()); generator.WriteInterfaceDeclaration(iface, string.Empty, new GenerationInfo(null, null, null)); Assert.AreEqual(GetTargetedExpected(nameof(WriteStaticInterfaceProperty)), writer.ToString().NormalizeLineEndings()); }
public void WriteInterfaceRedeclaredDefaultMethod() { // Create an interface with a default method var iface = SupportTypeBuilder.CreateEmptyInterface("java.code.IMyInterface"); iface.Methods.Add(new TestMethod(iface, "DoSomething").SetDefaultInterfaceMethod()); options.SymbolTable.AddType(iface); // Create a second interface that inherits the first, declaring the method as not default var iface2 = SupportTypeBuilder.CreateEmptyInterface("java.code.IMyInterface2"); iface2.AddImplementedInterface("java.code.IMyInterface"); iface2.Methods.Add(new TestMethod(iface, "DoSomething")); iface.Validate(options, new GenericParameterDefinitionList(), new CodeGeneratorContext()); iface2.Validate(options, new GenericParameterDefinitionList(), new CodeGeneratorContext()); generator.WriteInterfaceDeclaration(iface2, string.Empty); // IMyInterface2 should generate the method as abstract, not a default method Assert.AreEqual(GetExpected(nameof(WriteInterfaceRedeclaredDefaultMethod)), writer.ToString().NormalizeLineEndings()); }