| /* |
| * Copyright 2015 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.gwt.dev.jjs.impl; |
| |
| import com.google.gwt.core.ext.TreeLogger; |
| import com.google.gwt.dev.MinimalRebuildCache; |
| import com.google.gwt.dev.javac.testing.impl.MockJavaResource; |
| import com.google.gwt.dev.jjs.ast.JMethod; |
| import com.google.gwt.dev.jjs.ast.JProgram; |
| import com.google.gwt.dev.util.arg.SourceLevel; |
| import com.google.gwt.thirdparty.guava.common.collect.Lists; |
| |
| import java.util.Arrays; |
| import java.util.List; |
| |
| /** |
| * Tests for the JsInteropRestrictionChecker. |
| */ |
| public class JsInteropRestrictionCheckerTest extends OptimizerTestBase { |
| @Override |
| public void setUp() { |
| sourceLevel = SourceLevel.JAVA8; |
| } |
| |
| // TODO: eventually test this for default methods in Java 8. |
| public void testCollidingAccidentalOverrideConcreteMethodFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface Foo {", |
| " void doIt(Foo foo);", |
| "}", |
| "@JsType", |
| "public static interface Bar {", |
| " void doIt(Bar bar);", |
| "}", |
| "public static class ParentBuggy {", |
| " public void doIt(Foo foo) {}", |
| " public void doIt(Bar bar) {}", |
| "}", |
| "public static class Buggy extends ParentBuggy implements Foo, Bar {", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 14: 'void EntryPoint.ParentBuggy.doIt(EntryPoint.Bar)' " |
| + "(exposed by 'EntryPoint.Buggy') and " |
| + "'void EntryPoint.ParentBuggy.doIt(EntryPoint.Foo)' (exposed by 'EntryPoint.Buggy') " |
| + "cannot both use the same JavaScript name 'doIt'."); |
| } |
| |
| public void testCollidingAccidentalOverrideAbstractMethodFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface Foo {", |
| " void doIt(Foo foo);", |
| "}", |
| "@JsType", |
| "public static interface Bar {", |
| " void doIt(Bar bar);", |
| "}", |
| "public static abstract class Baz implements Foo, Bar {", |
| " public abstract void doIt(Foo foo);", |
| " public abstract void doIt(Bar bar);", |
| "}", |
| "public static class Buggy {} // Unrelated class"); |
| |
| assertBuggyFails( |
| "Line 14: 'void EntryPoint.Baz.doIt(EntryPoint.Bar)' and " |
| + "'void EntryPoint.Baz.doIt(EntryPoint.Foo)' cannot both use the same " |
| + "JavaScript name 'doIt'."); |
| } |
| |
| public void testCollidingAccidentalOverrideHalfAndHalfFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public static interface Foo {", |
| " void doIt(Foo foo);", |
| "}", |
| "@JsType", |
| "public static interface Bar {", |
| " void doIt(Bar bar);", |
| "}", |
| "public static class ParentParent {", |
| " public void doIt(Bar x) {}", |
| "}", |
| "@JsType", |
| "public static class Parent extends ParentParent {", |
| " public void doIt(Foo x) {}", |
| "}", |
| "public static class Buggy extends Parent implements Bar {}"); |
| |
| assertBuggyFails( |
| "Line 12: 'void EntryPoint.ParentParent.doIt(EntryPoint.Bar)' " |
| + "(exposed by 'EntryPoint.Buggy') and 'void EntryPoint.Parent.doIt(EntryPoint.Foo)' " |
| + "cannot both use the same JavaScript name 'doIt'."); |
| } |
| |
| public void testCollidingFieldExportsFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "public static class Buggy {", |
| " @JsProperty", |
| " public static final int show = 0;", |
| " @JsProperty(name = \"show\")", |
| " public static final int display = 0;", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 8: 'int EntryPoint.Buggy.display' cannot be exported because the global " |
| + "name 'test.EntryPoint.Buggy.show' is already taken by " |
| + "'int EntryPoint.Buggy.show'."); |
| } |
| |
| public void testJsPropertyNonGetterStyleSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public interface Buggy {", |
| " @JsProperty(name = \"x\") int x();", |
| " @JsProperty(name = \"x\") void x(int x);", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsPropertyGetterStyleSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public interface Buggy {", |
| " @JsProperty static int getStaticX(){ return 0;}", |
| " @JsProperty static void setStaticX(int x){}", |
| " @JsProperty int getX();", |
| " @JsProperty void setX(int x);", |
| " @JsProperty boolean isY();", |
| " @JsProperty void setY(boolean y);", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsPropertyIncorrectGetterStyleFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public interface Buggy {", |
| " @JsProperty int isX();", |
| " @JsProperty int getY(int x);", |
| " @JsProperty void getZ();", |
| " @JsProperty void setX(int x, int y);", |
| " @JsProperty void setY();", |
| " @JsProperty int setZ(int z);", |
| " @JsProperty static void setStatic(){}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 7: JsProperty 'int EntryPoint.Buggy.isX()' cannot have a non-boolean return.", |
| "Line 8: JsProperty 'int EntryPoint.Buggy.getY(int)' should have a correct setter " |
| + "or getter signature.", |
| "Line 9: JsProperty 'void EntryPoint.Buggy.getZ()' should have a correct setter " |
| + "or getter signature.", |
| "Line 10: JsProperty 'void EntryPoint.Buggy.setX(int, int)' should have a correct setter " |
| + "or getter signature.", |
| "Line 11: JsProperty 'void EntryPoint.Buggy.setY()' should have a correct setter " |
| + "or getter signature.", |
| "Line 12: JsProperty 'int EntryPoint.Buggy.setZ(int)' should have a correct setter " |
| + "or getter signature.", |
| "Line 13: JsProperty 'void EntryPoint.Buggy.setStatic()' should have a correct setter " |
| + "or getter signature."); |
| } |
| |
| public void testJsPropertyNonGetterStyleFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public interface Buggy {", |
| " @JsProperty boolean hasX();", |
| " @JsProperty int x();", |
| " @JsProperty void x(int x);", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 7: JsProperty 'boolean EntryPoint.Buggy.hasX()' should either follow Java Bean " |
| + "naming conventions or provide a name.", |
| "Line 8: JsProperty 'int EntryPoint.Buggy.x()' should either follow Java Bean " |
| + "naming conventions or provide a name.", |
| "Line 9: JsProperty 'void EntryPoint.Buggy.x(int)' should either follow Java Bean " |
| + "naming conventions or provide a name."); |
| } |
| |
| public void testCollidingJsPropertiesTwoGettersFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface Buggy {", |
| " @JsProperty", |
| " boolean isX();", |
| " @JsProperty", |
| " boolean getX();", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 10: 'boolean EntryPoint.Buggy.getX()' and 'boolean EntryPoint.Buggy.isX()' " |
| + "cannot both use the same JavaScript name 'x'."); |
| } |
| |
| public void testCollidingJsPropertiesTwoSettersFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface Buggy {", |
| " @JsProperty", |
| " void setX(boolean x);", |
| " @JsProperty", |
| " void setX(int x);", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 10: 'void EntryPoint.Buggy.setX(int)' and 'void EntryPoint.Buggy.setX(boolean)' " |
| + "cannot both use the same JavaScript name 'x'."); |
| } |
| |
| public void testCollidingJsTypeAndJsPropertyGetterFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface IBuggy {", |
| " boolean x(boolean foo);", |
| " @JsProperty", |
| " int getX();", |
| "}", |
| "public static class Buggy implements IBuggy {", |
| " public boolean x(boolean foo) {return false;}", |
| " public int getX() {return 0;}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 9: 'int EntryPoint.IBuggy.getX()' and 'boolean EntryPoint.IBuggy.x(boolean)' " |
| + "cannot both use the same JavaScript name 'x'.", |
| "Line 13: 'int EntryPoint.Buggy.getX()' and 'boolean EntryPoint.Buggy.x(boolean)' " |
| + "cannot both use the same JavaScript name 'x'."); |
| } |
| |
| public void testCollidingJsTypeAndJsPropertySetterFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface IBuggy {", |
| " boolean x(boolean foo);", |
| " @JsProperty", |
| " void setX(int a);", |
| "}", |
| "public static class Buggy implements IBuggy {", |
| " public boolean x(boolean foo) {return false;}", |
| " public void setX(int a) {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 9: 'void EntryPoint.IBuggy.setX(int)' and 'boolean EntryPoint.IBuggy.x(boolean)' " |
| + "cannot both use the same JavaScript name 'x'.", |
| "Line 13: 'void EntryPoint.Buggy.setX(int)' and 'boolean EntryPoint.Buggy.x(boolean)' " |
| + "cannot both use the same JavaScript name 'x'."); |
| } |
| |
| public void testCollidingPropertyAccessorExportsFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "public static class Buggy {", |
| " @JsProperty", |
| " public static void setDisplay(int x) {}", |
| " @JsProperty(name = \"display\")", |
| " public static void setDisplay2(int x) {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 8: 'void EntryPoint.Buggy.setDisplay2(int)' cannot be exported because the global " |
| + "name 'test.EntryPoint.Buggy.display' is already taken " |
| + "by 'void EntryPoint.Buggy.setDisplay(int)'."); |
| } |
| |
| public void testCollidingMethodExportsFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetClassDecl( |
| "public static class Buggy {", |
| " @JsMethod", |
| " public static void show() {}", |
| " @JsMethod(name = \"show\")", |
| " public static void display() {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 8: 'void EntryPoint.Buggy.display()' cannot be exported because the global name " |
| + "'test.EntryPoint.Buggy.show' is already taken " |
| + "by 'void EntryPoint.Buggy.show()'."); |
| } |
| |
| public void testCollidingMethodToPropertyAccessorExportsFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "public static class Buggy {", |
| " @JsProperty", |
| " public static void setShow(int x) {}", |
| " @JsMethod", |
| " public static void show() {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 9: 'void EntryPoint.Buggy.show()' cannot be exported because the global name " |
| + "'test.EntryPoint.Buggy.show' is already taken by " |
| + "'void EntryPoint.Buggy.setShow(int)'."); |
| } |
| |
| public void testCollidingMethodToFieldExportsFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "public static class Buggy {", |
| " @JsMethod", |
| " public static void show() {}", |
| " @JsProperty", |
| " public static final int show = 0;", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 7: 'void EntryPoint.Buggy.show()' cannot be exported because the global name " |
| + "'test.EntryPoint.Buggy.show' is already taken by " |
| + "'int EntryPoint.Buggy.show'."); |
| } |
| |
| public void testCollidingMethodToFieldJsTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class Buggy {", |
| " public void show() {}", |
| " public final int show = 0;", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: 'void EntryPoint.Buggy.show()' and 'int EntryPoint.Buggy.show' cannot both use " |
| + "the same JavaScript name 'show'."); |
| } |
| |
| public void testCollidingMethodToMethodJsTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class Buggy {", |
| " public void show(int x) {}", |
| " public void show() {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 7: 'void EntryPoint.Buggy.show()' and 'void EntryPoint.Buggy.show(int)' cannot both " |
| + "use the same JavaScript name 'show'."); |
| } |
| |
| public void testCollidingSubclassExportedFieldToFieldJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class ParentBuggy {", |
| " public int foo = 55;", |
| "}", |
| "public static class Buggy extends ParentBuggy {", |
| " public int foo = 110;", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testCollidingSubclassExportedFieldToMethodJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class ParentBuggy {", |
| " public int foo = 55;", |
| "}", |
| "public static class Buggy extends ParentBuggy {", |
| " public void foo(int a) {}", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testCollidingSubclassExportedMethodToMethodJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class ParentBuggy {", |
| " public void foo() {}", |
| "}", |
| "public static class Buggy extends ParentBuggy {", |
| " public void foo(int a) {}", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testCollidingSubclassFieldToExportedFieldJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public static class ParentBuggy {", |
| " public int foo = 55;", |
| "}", |
| "@JsType", |
| "public static class Buggy extends ParentBuggy {", |
| " public int foo = 110;", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testCollidingSubclassFieldToExportedMethodJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public static class ParentBuggy {", |
| " public int foo = 55;", |
| "}", |
| "@JsType", |
| "public static class Buggy extends ParentBuggy {", |
| " public void foo(int a) {}", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testCollidingSubclassFieldToFieldJsTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class ParentBuggy {", |
| " public int foo = 55;", |
| "}", |
| "@JsType", |
| "public static class Buggy extends ParentBuggy {", |
| " public int foo = 110;", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 10: 'int EntryPoint.Buggy.foo' and 'int EntryPoint.ParentBuggy.foo' cannot both use " |
| + "the same JavaScript name 'foo'."); |
| } |
| |
| public void testCollidingSubclassFieldToMethodJsTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class ParentBuggy {", |
| " public int foo = 55;", |
| "}", |
| "@JsType", |
| "public static class Buggy extends ParentBuggy {", |
| " public void foo(int a) {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 10: 'void EntryPoint.Buggy.foo(int)' and 'int EntryPoint.ParentBuggy.foo' cannot " |
| + "both use the same JavaScript name 'foo'."); |
| } |
| |
| public void testCollidingSubclassMethodToExportedMethodJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public static class ParentBuggy {", |
| " public void foo() {}", |
| "}", |
| "@JsType", |
| "public static class Buggy extends ParentBuggy {", |
| " public void foo(int a) {}", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testCollidingSubclassMethodToMethodInterfaceJsTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public interface IBuggy1 {", |
| " void show();", |
| "}", |
| "@JsType", |
| "public interface IBuggy2 {", |
| " void show(boolean b);", |
| "}", |
| "public static class Buggy implements IBuggy1 {", |
| " public void show() {}", |
| "}", |
| "public static class Buggy2 extends Buggy implements IBuggy2 {", |
| " public void show(boolean b) {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 16: 'void EntryPoint.Buggy2.show(boolean)' and 'void EntryPoint.Buggy.show()' cannot " |
| + "both use the same JavaScript name 'show'."); |
| } |
| |
| public void testCollidingSubclassMethodToMethodJsTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class ParentBuggy {", |
| " public void foo() {}", |
| "}", |
| "@JsType", |
| "public static class Buggy extends ParentBuggy {", |
| " public void foo(int a) {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 10: 'void EntryPoint.Buggy.foo(int)' and 'void EntryPoint.ParentBuggy.foo()' " |
| + "cannot both use the same JavaScript name 'foo'."); |
| } |
| |
| public void testCollidingSubclassMethodToMethodTwoLayerInterfaceJsTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public interface IParentBuggy1 {", |
| " void show();", |
| "}", |
| "public interface IBuggy1 extends IParentBuggy1 {", |
| "}", |
| "@JsType", |
| "public interface IParentBuggy2 {", |
| " void show(boolean b);", |
| "}", |
| "public interface IBuggy2 extends IParentBuggy2 {", |
| "}", |
| "public static class Buggy implements IBuggy1 {", |
| " public void show() {}", |
| "}", |
| "public static class Buggy2 extends Buggy implements IBuggy2 {", |
| " public void show(boolean b) {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 20: 'void EntryPoint.Buggy2.show(boolean)' and 'void EntryPoint.Buggy.show()' " |
| + "cannot both use the same JavaScript name 'show'."); |
| } |
| |
| public void testNonCollidingSyntheticBridgeMethodSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "public static interface Comparable<T> {", |
| " int compareTo(T other);", |
| "}", |
| "@JsType", |
| "public static class Enum<E extends Enum<E>> implements Comparable<E> {", |
| " public int compareTo(E other) {return 0;}", |
| "}", |
| "public static class Buggy {}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testCollidingSyntheticBridgeMethodSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface Comparable<T> {", |
| " int compareTo(T other);", |
| "}", |
| "@JsType", |
| "public static class Enum<E extends Enum<E>> implements Comparable<E> {", |
| " public int compareTo(E other) {return 0;}", |
| "}", |
| "public static class Buggy {}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testSpecializeReturnTypeInImplementorSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "interface I {", |
| " I m();", |
| "}", |
| "@JsType", |
| "public static class Buggy implements I {", |
| " public Buggy m() { return null; } ", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testSpecializeReturnTypeInSubclassSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class S {", |
| " public S m() { return null; }", |
| "}", |
| "@JsType", |
| "public static class Buggy extends S {", |
| " public Buggy m() { return null; } ", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testCollidingTwoLayerSubclassFieldToFieldJsTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class ParentParentBuggy {", |
| " public int foo = 55;", |
| "}", |
| "public static class ParentBuggy extends ParentParentBuggy {", |
| " public int foo = 55;", |
| "}", |
| "@JsType", |
| "public static class Buggy extends ParentBuggy {", |
| " public int foo = 110;", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 13: 'int EntryPoint.Buggy.foo' and 'int EntryPoint.ParentParentBuggy.foo' cannot " |
| + "both use the same JavaScript name 'foo'."); |
| } |
| |
| public void testRenamedSuperclassJsMethodFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class ParentBuggy {", |
| " public void foo() {}", |
| "}", |
| "public static class Buggy extends ParentBuggy {", |
| " @JsMethod(name = \"bar\") public void foo() {}", |
| "}"); |
| |
| assertBuggyFails("Line 10: 'void EntryPoint.Buggy.foo()' cannot be assigned a different " |
| + "JavaScript name than the method it overrides."); |
| } |
| |
| public void testRenamedSuperInterfaceJsMethodFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public interface ParentBuggy {", |
| " void foo();;", |
| "}", |
| "public interface Buggy extends ParentBuggy {", |
| " @JsMethod(name = \"bar\") void foo();", |
| "}"); |
| |
| assertBuggyFails("Line 10: 'void EntryPoint.Buggy.foo()' cannot be assigned a different " |
| + "JavaScript name than the method it overrides."); |
| } |
| |
| public void testAccidentallyRenamedSuperInterfaceJsMethodFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public interface IBuggy {", |
| " void foo();", |
| "}", |
| "@JsType", |
| "public static class ParentBuggy {", |
| " @JsMethod(name = \"bar\") public void foo() {}", |
| "}", |
| "public static class Buggy extends ParentBuggy implements IBuggy {", |
| "}"); |
| |
| assertBuggyFails("Line 11: 'void EntryPoint.ParentBuggy.foo()' (exposed by 'EntryPoint.Buggy') " |
| + "cannot be assigned a different JavaScript name than the method it overrides."); |
| } |
| |
| // TODO(goktug): enable once the property names are handled. |
| public void __disabled__testRenamedSuperclassJsPropertyFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class ParentBuggy {", |
| " @JsProperty public int getFoo() { return 0; }", |
| "}", |
| "public static class Buggy extends ParentBuggy {", |
| " @JsProperty(name = \"bar\") public int getFoo() { return 0;}", |
| "}"); |
| |
| assertBuggyFails("'EntryPoint.Buggy.getFoo()I' cannot be exported because the method " |
| + "overrides a method with different name."); |
| } |
| |
| public void testJsPropertyDifferentFlavourInSubclassFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class ParentBuggy {", |
| " @JsProperty public boolean isFoo() { return false; }", |
| "}", |
| "public static class Buggy extends ParentBuggy {", |
| " @JsProperty public boolean getFoo() { return false;}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 10: 'boolean EntryPoint.Buggy.getFoo()' and 'boolean EntryPoint.ParentBuggy.isFoo()' " |
| + "cannot both use the same JavaScript name 'foo'."); |
| } |
| |
| public void testConsistentPropertyTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface IBuggy {", |
| " @JsProperty", |
| " public int getFoo();", |
| " @JsProperty", |
| " public void setFoo(int value);", |
| "}", |
| "public static class Buggy implements IBuggy {", |
| " public int getFoo() {return 0;}", |
| " public void setFoo(int value) {}", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testInconsistentGetSetPropertyTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface IBuggy {", |
| " @JsProperty", |
| " public int getFoo();", |
| " @JsProperty", |
| " public void setFoo(Integer value);", |
| "}", |
| "public static class Buggy implements IBuggy {", |
| " public int getFoo() {return 0;}", |
| " public void setFoo(Integer value) {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 10: JsProperty setter 'void EntryPoint.IBuggy.setFoo(Integer)' and " |
| + "getter 'int EntryPoint.IBuggy.getFoo()' cannot have inconsistent types.", |
| "Line 14: JsProperty setter 'void EntryPoint.Buggy.setFoo(Integer)' and " |
| + "getter 'int EntryPoint.Buggy.getFoo()' cannot have inconsistent types."); |
| } |
| |
| public void testInconsistentIsSetPropertyTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface IBuggy {", |
| " @JsProperty", |
| " public boolean isFoo();", |
| " @JsProperty", |
| " public void setFoo(Object value);", |
| "}", |
| "public static class Buggy implements IBuggy {", |
| " public boolean isFoo() {return false;}", |
| " public void setFoo(Object value) {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 10: JsProperty setter 'void EntryPoint.IBuggy.setFoo(Object)' and " |
| + "getter 'boolean EntryPoint.IBuggy.isFoo()' cannot have inconsistent types.", |
| "Line 14: JsProperty setter 'void EntryPoint.Buggy.setFoo(Object)' and " |
| + "getter 'boolean EntryPoint.Buggy.isFoo()' cannot have inconsistent types."); |
| } |
| |
| public void testJsPropertySuperCallFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType public static class Super {", |
| " @JsProperty public int getX() { return 5; }", |
| "}", |
| "@JsType public static class Buggy extends Super {", |
| " public int m() { return super.getX(); }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 9: Cannot call property accessor 'int EntryPoint.Super.getX()' via super."); |
| } |
| |
| public void testJsPropertyCallSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType public static class Super {", |
| " @JsProperty public int getX() { return 5; }", |
| "}", |
| "@JsType public static class Buggy extends Super {", |
| " public int m() { return getX(); }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsPropertyAccidentalSuperCallSucceeds() |
| throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType public static class Super {", |
| " @JsProperty public int getX() { return 5; }", |
| "}", |
| "@JsType public interface Interface {", |
| " @JsProperty int getX();", |
| "}", |
| |
| "@JsType public static class Buggy extends Super implements Interface {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsPropertyOverrideSucceeds() |
| throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType public static class Super {", |
| " @JsProperty public void setX(int x) { }", |
| " @JsProperty public int getX() { return 5; }", |
| "}", |
| |
| "@JsType public static class Buggy extends Super {", |
| " @JsProperty public void setX(int x) { }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testMultiplePrivateConstructorsExportSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class Buggy {", |
| " private Buggy() {}", |
| " private Buggy(int a) {}", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testMultiplePublicConstructorsAllDelegatesToJsConstructorSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsIgnore"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class Buggy {", |
| " public Buggy() {}", |
| " @JsIgnore", |
| " public Buggy(int a) {", |
| " this();", |
| " }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testMultipleConstructorsNotAllDelegatedToJsConstructorFails() |
| throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class Buggy {", |
| " public Buggy() {}", |
| " private Buggy(int a) {", |
| " new Buggy();", |
| " }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: Constructor 'EntryPoint.Buggy.EntryPoint$Buggy()' can be a JsConstructor only if " |
| + "all constructors in the class are delegating to it."); |
| } |
| |
| public void testMultiplePublicConstructorsExportFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class Buggy {", |
| " public Buggy() {}", |
| " public Buggy(int a) {", |
| " this();", |
| " }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 5: More than one JsConstructor exists for EntryPoint.Buggy.", |
| "Line 7: 'EntryPoint.Buggy.EntryPoint$Buggy(int)' cannot be exported because the global " |
| + "name 'test.EntryPoint.Buggy' is already taken by " |
| + "'EntryPoint.Buggy.EntryPoint$Buggy()'."); |
| } |
| |
| public void testNonCollidingAccidentalOverrideSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public interface Foo {", |
| " void doIt(Object foo);", |
| "}", |
| "public static class ParentParent {", |
| " public void doIt(String x) {}", |
| "}", |
| "@JsType", |
| "public static class Parent extends ParentParent {", |
| " public void doIt(Object x) {}", |
| "}", |
| "public static class Buggy extends Parent implements Foo {}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsNameInvalidNamesFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType(name = \"a.b.c\") public static class Buggy {", |
| " @JsMethod(name = \"34s\") public void m() {}", |
| " @JsProperty(name = \"s^\") public int m;", |
| " @JsProperty(name = \"\") public int n;", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: 'EntryPoint.Buggy' has invalid name 'a.b.c'.", |
| "Line 7: 'void EntryPoint.Buggy.m()' has invalid name '34s'.", |
| "Line 8: 'int EntryPoint.Buggy.m' has invalid name 's^'.", |
| "Line 9: 'int EntryPoint.Buggy.n' cannot have an empty name."); |
| } |
| |
| public void testJsNameInvalidNamespacesFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType(namespace = \"a.b.\") public static class Buggy {", |
| " @JsMethod(namespace = \"34s\") public static void m() {}", |
| " @JsProperty(namespace = \"s^\") public static int n;", |
| " @JsProperty(namespace = \"\") public int p;", |
| " @JsMethod(namespace = \"a\") public void q() {}", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: 'EntryPoint.Buggy' has invalid namespace 'a.b.'.", |
| "Line 7: 'void EntryPoint.Buggy.m()' has invalid namespace '34s'.", |
| "Line 8: 'int EntryPoint.Buggy.n' has invalid namespace 's^'.", |
| "Line 9: Instance member 'int EntryPoint.Buggy.p' cannot declare a namespace.", |
| "Line 10: Instance member 'void EntryPoint.Buggy.q()' cannot declare a namespace."); |
| } |
| |
| public void testJsNameEmptyNamespacesSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "@JsType(namespace = \"\") public static class Buggy {", |
| " @JsMethod(namespace = \"\") public static void m() {}", |
| " @JsProperty(namespace = \"\") public static int n;", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testSingleJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class Buggy {", |
| " public static void show1() {}", |
| " public void show2() {}", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsFunctionWithNoExtendsSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsFunction"); |
| addSnippetClassDecl( |
| "@JsFunction", |
| "public interface Buggy {", |
| " void foo();", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsFunctionExtendsInterfaceFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsFunction"); |
| addSnippetClassDecl( |
| "interface AnotherInterface {}", |
| "@JsFunction", |
| "public interface Buggy extends AnotherInterface {", |
| " void foo();", |
| "}"); |
| |
| assertBuggyFails("Line 6: JsFunction 'EntryPoint.Buggy' cannot extend other interfaces."); |
| } |
| |
| public void testJsFunctionExtendedByInterfaceFails() throws Exception { |
| addAll(jsFunctionInterface); |
| |
| addSnippetClassDecl("public interface Buggy extends MyJsFunctionInterface {}"); |
| |
| assertBuggyFails( |
| "Line 3: 'EntryPoint.Buggy' cannot extend JsFunction 'MyJsFunctionInterface'."); |
| } |
| |
| public void testJsFunctionMarkedAsJsTypeFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsFunction"); |
| addSnippetClassDecl( |
| "@JsFunction @JsType", |
| "public interface Buggy {", |
| " void foo();", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: 'EntryPoint.Buggy' cannot be both a JsFunction and a JsType at the same time."); |
| } |
| |
| public void testJsFunctionImplementationWithSingleInterfaceSucceeds() throws Exception { |
| addAll(jsFunctionInterface); |
| addSnippetClassDecl( |
| "public static class Buggy implements MyJsFunctionInterface {", |
| " public int foo(int x) { return 0; }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsFunctionImplementationWithMultipleSuperInterfacesFails() throws Exception { |
| addAll(jsFunctionInterface); |
| addSnippetClassDecl( |
| "interface AnotherInterface {}", |
| "public static class Buggy implements MyJsFunctionInterface, AnotherInterface {", |
| " public int foo(int x) { return 0; }", |
| " public int bar(int x) { return 0; }", |
| "}"); |
| |
| assertBuggyFails("Line 4: JsFunction implementation 'EntryPoint.Buggy' cannot " |
| + "implement more than one interface."); |
| } |
| |
| public void testJsFunctionImplementationWithSuperClassFails() throws Exception { |
| addAll(jsFunctionInterface); |
| addSnippetClassDecl( |
| "public static class BaseClass {}", |
| "public static class Buggy extends BaseClass implements MyJsFunctionInterface {", |
| " public int foo(int x) { return 0; }", |
| "}"); |
| |
| assertBuggyFails("Line 4: JsFunction implementation 'EntryPoint.Buggy' cannot " |
| + "extend a class."); |
| } |
| |
| public void testJsFunctionImplementationWithSubclassesFails() throws Exception { |
| addAll(jsFunctionInterface); |
| addSnippetClassDecl( |
| "public static class BaseClass implements MyJsFunctionInterface {", |
| " public int foo(int x) { return 0; }", |
| "}", |
| "public static class Buggy extends BaseClass {", |
| "}"); |
| |
| assertBuggyFails("Line 6: 'EntryPoint.Buggy' cannot extend " |
| + "JsFunction implementation 'EntryPoint.BaseClass'."); |
| } |
| |
| public void testJsFunctionImplementationMarkedAsJsTypeFails() throws Exception { |
| addAll(jsFunctionInterface); |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class Buggy implements MyJsFunctionInterface {", |
| " public int foo(int x) { return 0; }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 5: 'EntryPoint.Buggy' cannot be both a JsFunction implementation and a JsType " |
| + "at the same time."); |
| } |
| |
| public void testJsFunctionStaticInitializerFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsFunction"); |
| addSnippetClassDecl( |
| "public static String someString() { return \"hello\"; }", |
| "@JsFunction public interface Buggy {", |
| " static String s = someString();", |
| " void m();", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: JsFunction 'EntryPoint.Buggy' cannot have static initializer."); |
| } |
| |
| public void testNativeJsTypeStaticInitializerFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Buggy {", |
| " static { int x = 1; }", |
| "}", |
| "@JsType(isNative=true) public static class Buggy2 {", |
| " static { Object.class.getName(); }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 4: Native JsType 'EntryPoint.Buggy' cannot have static initializer.", |
| "Line 7: Native JsType 'EntryPoint.Buggy2' cannot have static initializer."); |
| } |
| |
| public void testNativeJsTypeInstanceInitializerFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Buggy {", |
| " { Object.class.getName(); }", |
| "}", |
| "@JsType(isNative=true) public static class Buggy2 {", |
| " { int x = 1; }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 4: Native JsType 'EntryPoint.Buggy' cannot have initializer.", |
| "Line 7: Native JsType 'EntryPoint.Buggy2' cannot have initializer."); |
| } |
| |
| public void testNativeJsTypeNonEmptyConstructorFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Buggy {", |
| " public Buggy(int n) {", |
| " n++;", |
| " }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 5: Native JsType constructor 'EntryPoint.Buggy.EntryPoint$Buggy(int)' cannot have " |
| + "non-empty method body."); |
| } |
| |
| public void testNativeJsTypeImplicitSuperSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Super {", |
| " public Super() {", |
| " }", |
| "}", |
| "@JsType(isNative=true) public static class Buggy extends Super {", |
| " public Buggy(int n) {", |
| " }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNativeJsTypeExplicitSuperSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Super {", |
| " public Super(int x) {", |
| " }", |
| "}", |
| "@JsType(isNative=true) public static class Buggy extends Super {", |
| " public Buggy(int n) {", |
| " super(n);", |
| " }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNativeJsTypeExplicitSuperWithEffectSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Super {", |
| " public Super(int x) {", |
| " }", |
| "}", |
| "@JsType(isNative=true) public static class Buggy extends Super {", |
| " public Buggy(int n) {", |
| " super(n++);", |
| " }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsTypeInterfaceInInstanceofFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public interface IBuggy {}", |
| "@JsType public static class Buggy {", |
| " public Buggy() { if (new Object() instanceof IBuggy) {} }", |
| "}"); |
| |
| assertBuggyFails("Line 6: Cannot do instanceof against native JsType interface " |
| + "'EntryPoint.IBuggy'."); |
| } |
| |
| public void testNativeJsTypeEnumFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public enum Buggy { A, B }"); |
| |
| assertBuggyFails( |
| "Line 4: Enum 'EntryPoint.Buggy' cannot be a native JsType."); |
| } |
| |
| public void testInnerNativeJsTypeFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public class Buggy { }"); |
| |
| assertBuggyFails( |
| "Line 4: Non static inner class 'EntryPoint.Buggy' cannot be a native JsType."); |
| } |
| |
| public void testInnerJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@SuppressWarnings(\"unusable-by-js\") @JsType public class Buggy { }"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testLocalJsTypeFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public class Buggy { void m() { @JsType class Local {} } }"); |
| |
| assertBuggyFails( |
| "Line 4: Local class 'EntryPoint.Buggy.1Local' cannot be a JsType."); |
| } |
| |
| public void testNativeJsTypeExtendsNativeJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Super {", |
| "}", |
| "@JsType(isNative=true) public static class Buggy extends Super {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNativeJsTypeImplementsNativeJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public interface Super {", |
| "}", |
| "@JsType(isNative=true) public static class Buggy implements Super {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNativeJsTypeInterfaceImplementsNativeJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public interface Super {", |
| "}", |
| "@JsType(isNative=true) public interface Buggy extends Super {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNativeJsTypeExtendsJsTypeFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType public static class Super {", |
| "}", |
| "@JsType(isNative=true) public static class Buggy extends Super {", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: Native JsType 'EntryPoint.Buggy' can only extend native JsType classes."); |
| } |
| |
| public void testNativeJsTypeImplementsJsTypeInterfaceFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType public interface Interface {", |
| "}", |
| "@JsType(isNative=true) public static class Buggy implements Interface {", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: Native JsType ''EntryPoint.Buggy'' can only implement native JsType interfaces."); |
| } |
| |
| public void testNativeJsTypeInterfaceExtendsJsTypeInterfaceFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType public interface Interface {", |
| "}", |
| "@JsType(isNative=true) public interface Buggy extends Interface {", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: Native JsType ''EntryPoint.Buggy'' can only extend native JsType interfaces."); |
| } |
| |
| public void testNativeJsTypeImplementsNonJsTypeFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public interface Super {", |
| "}", |
| "@JsType(isNative=true) public static class Buggy implements Super {", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: Native JsType ''EntryPoint.Buggy'' can only implement native JsType interfaces."); |
| } |
| |
| public void testNativeJsTypeInterfaceExtendsNonJsTypeFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public interface Super {", |
| "}", |
| "@JsType(isNative=true) public interface Buggy extends Super {", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: Native JsType ''EntryPoint.Buggy'' can only extend native JsType interfaces."); |
| } |
| |
| public void testJsOverlayOnNativeJsTypeMemberSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsOverlay"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Buggy {", |
| " @JsOverlay public static final int f = 2;", |
| " @JsOverlay public static void m() { }", |
| " @JsOverlay public static void m(int x) { }", |
| " @JsOverlay private static void m(boolean x) { }", |
| " @JsOverlay public final void n() { }", |
| " @JsOverlay public final void n(int x) { }", |
| " @JsOverlay private final void n(boolean x) { }", |
| " @JsOverlay final void o() { }", |
| " @JsOverlay protected final void p() { }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsOverlayImplementingInterfaceMethodFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsOverlay"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public interface IBuggy {", |
| " void m();", |
| "}", |
| "@JsType(isNative=true) public static class Buggy implements IBuggy {", |
| " @JsOverlay public void m() { }", |
| "}"); |
| |
| assertBuggyFails("Line 9: JsOverlay method 'void EntryPoint.Buggy.m()' cannot override a " |
| + "supertype method."); |
| } |
| |
| public void testJsOverlayOverridingSuperclassMethodFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsOverlay"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Super {", |
| " public native void m();", |
| "}", |
| "@JsType(isNative=true) public static class Buggy extends Super {", |
| " @JsOverlay public void m() { }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 9: JsOverlay method 'void EntryPoint.Buggy.m()' cannot override a supertype method."); |
| } |
| |
| public void testJsOverlayOnNonFinalMethodAndNonCompileTimeConstantFieldFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsOverlay"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Buggy {", |
| " @JsOverlay public static int f1 = 2;", |
| " @JsOverlay public final int f2 = 2;", |
| " @JsOverlay public void m() { }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 5: Native JsType 'EntryPoint.Buggy' cannot have initializer.", |
| "Line 6: JsOverlay field 'int EntryPoint.Buggy.f1' can only be a compile time constant.", |
| "Line 7: JsOverlay field 'int EntryPoint.Buggy.f2' can only be a compile time constant.", |
| "Line 8: JsOverlay method 'void EntryPoint.Buggy.m()' cannot be non-final nor native."); |
| } |
| |
| public void testJsOverlayOnNativeMethodFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsOverlay"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Buggy {", |
| " @JsOverlay public static final native void m1();", |
| " @JsOverlay public static final native void m2()/*-{}-*/;", |
| " @JsOverlay public final native void m3();", |
| " @JsOverlay public final native void m4()/*-{}-*/;", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: JsOverlay method 'void EntryPoint.Buggy.m1()' cannot be non-final nor native.", |
| "Line 7: JSNI method 'void EntryPoint.Buggy.m2()' is not allowed in a native JsType.", |
| "Line 8: JsOverlay method 'void EntryPoint.Buggy.m3()' cannot be non-final nor native.", |
| "Line 9: JSNI method 'void EntryPoint.Buggy.m4()' is not allowed in a native JsType."); |
| } |
| |
| public void testJsOverlayOnJsoMethodSucceeds() throws Exception { |
| addSnippetImport("com.google.gwt.core.client.JavaScriptObject"); |
| addSnippetImport("jsinterop.annotations.JsOverlay"); |
| addSnippetClassDecl( |
| "public static class Buggy extends JavaScriptObject {", |
| " protected Buggy() { }", |
| " @JsOverlay public final void m() { }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testImplicitJsOverlayOnJsoMethodSucceeds() throws Exception { |
| addSnippetImport("com.google.gwt.core.client.JavaScriptObject"); |
| addSnippetImport("jsinterop.annotations.JsOverlay"); |
| addSnippetClassDecl( |
| "public static class Buggy extends JavaScriptObject {", |
| " protected Buggy() { }", |
| " public final void m() { }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsOverlayOnNonNativeJsTypeFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsOverlay"); |
| addSnippetClassDecl( |
| "@JsType public static class Buggy {", |
| " @JsOverlay public static final int f = 2;", |
| " @JsOverlay public final void m() { };", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: JsOverlay 'int EntryPoint.Buggy.f' can only be declared in a native type.", |
| "Line 7: JsOverlay 'void EntryPoint.Buggy.m()' can only be declared in a native type."); |
| } |
| |
| public void testJsTypeExtendsNativeJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Super {", |
| "}", |
| "@JsType public static class Buggy extends Super {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsTypeExtendsNonJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public static class Super {", |
| "}", |
| "@JsType public static class Buggy extends Super {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsTypeImplementsNativeJsTypeInterfaceSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public interface Interface {", |
| "}", |
| "@JsType public static class Buggy implements Interface {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsTypeImplementsNonJsTypeInterfaceSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public interface Interface {", |
| "}", |
| "@JsType public static class Buggy implements Interface {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsTypeIntefaceExtendsNativeJsTypeInterfaceSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public interface Interface {", |
| "}", |
| "@JsType public interface Buggy extends Interface {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testJsTypeInterfaceExtendsNonJsTypeInterfaceSucceeds() |
| throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public interface Interface {", |
| "}", |
| "@JsType public interface Buggy extends Interface {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNativeJsTypeExtendsNaiveJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Super {", |
| "}", |
| "@JsType(isNative=true) public static class Buggy extends Super {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNativeJsTypeBadMembersFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsIgnore"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) static class Buggy {", |
| " public static final int s = 42;", |
| " public int f = 42;", |
| " @JsIgnore public Buggy() { }", |
| " @JsIgnore public int x;", |
| " @JsIgnore public native void n();", |
| " public void o() {}", |
| " public native void p() /*-{}-*/;", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 5: Native JsType 'EntryPoint.Buggy' cannot have initializer.", |
| "Line 6: Native JsType field 'int EntryPoint.Buggy.s' cannot have initializer.", |
| "Line 7: Native JsType field 'int EntryPoint.Buggy.f' cannot have initializer.", |
| "Line 8: Native JsType member 'EntryPoint.Buggy.EntryPoint$Buggy()' cannot have @JsIgnore.", |
| "Line 9: Native JsType member 'int EntryPoint.Buggy.x' cannot have @JsIgnore.", |
| "Line 10: Native JsType member 'void EntryPoint.Buggy.n()' cannot have @JsIgnore.", |
| "Line 11: Native JsType method 'void EntryPoint.Buggy.o()' should be native or abstract.", |
| "Line 12: JSNI method 'void EntryPoint.Buggy.p()' is not allowed in a native JsType."); |
| } |
| |
| public void testNativeMethodOnJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetClassDecl( |
| "public static class Buggy {", |
| " @JsMethod public native void m();", |
| " @JsMethod public native void n() /*-{}-*/;", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNativeJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) abstract static class Buggy {", |
| " public static native void m();", |
| " protected static native void m(Object o);", |
| " private static native void m(String o);", |
| " public Buggy() { }", |
| " protected Buggy(Object o) { }", |
| " private Buggy(String o) { }", |
| " public native void n();", |
| " protected native void n(Object o);", |
| " private native void n(String o);", |
| " public abstract void o();", |
| " protected abstract void o(Object o);", |
| " abstract void o(String o);", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNativeJsTypeFieldsSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) static class Buggy {", |
| " public static int f1;", |
| " protected static int f2;", |
| " private static int f3;", |
| " public int f4;", |
| " protected int f5;", |
| " private int f6;", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNativeJsTypeDefaultConstructorSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) static class Buggy {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNonJsTypeExtendingNativeJsTypeWithInstanceMethodSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@SuppressWarnings(\"unusable-by-js\")", |
| "@JsType(isNative=true) public static class Super {", |
| " public native void m(Object o);", |
| " public native void m(Object[] o);", |
| "}", |
| "@JsType public static class Buggy extends Super {", |
| " public void n(Object o) { }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNonJsTypeExtendingNativeJsTypeWithInstanceMethodOverloadsFails() { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Super {", |
| " public native void m(Object o);", |
| " public native void m(int o);", |
| "}", |
| "public static class Buggy extends Super {", |
| " public void m(Object o) { }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 9: 'void EntryPoint.Buggy.m(Object)' and 'void EntryPoint.Super.m(int)' " |
| + "cannot both use the same JavaScript name 'm'."); |
| } |
| |
| public void testNonJsTypeWithNativeStaticMethodOverloadsSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetClassDecl( |
| "public static class Buggy {", |
| " @JsMethod public static native void m(Object o);", |
| " @JsMethod public static native void m(int o);", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNonJsTypeWithNativeInstanceMethodOverloadsFails() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetClassDecl( |
| "public static class Buggy {", |
| " @JsMethod public native void m(Object o);", |
| " @JsMethod public void m(int o) { }", |
| "}"); |
| |
| assertBuggyFails( |
| "Line 6: 'void EntryPoint.Buggy.m(int)' and 'void EntryPoint.Buggy.m(Object)' " |
| + "cannot both use the same JavaScript name 'm'."); |
| } |
| |
| public void testNonJsTypeExtendsJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType public static class Super {", |
| "}", |
| "public static class Buggy extends Super {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNonJsTypeImplementsJsTypeInterfaceSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType public interface Interface {", |
| "}", |
| "public static class Buggy implements Interface {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNonJsTypeInterfaceExtendsJsTypeInterfaceSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType public interface Interface {", |
| "}", |
| "public interface Buggy extends Interface {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNonJsTypeExtendsNativeJsTypeSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public static class Super {", |
| " public native void m();", |
| "}", |
| "public static class Buggy extends Super {", |
| " public void m() { }", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNonJsTypeImplementsNativeJsTypeInterfaceSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public interface Interface {", |
| "}", |
| "public static class Buggy implements Interface {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testNonJsTypeInterfaceExtendsNativeJsTypeInterfaceSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType(isNative=true) public interface Interface {", |
| "}", |
| "public interface Buggy extends Interface {", |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testUnusableByJsSuppressionSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl("public static class A {}"); |
| addSnippetClassDecl( |
| "@JsType @SuppressWarnings(\"unusable-by-js\")", // SuppressWarnings on the class. |
| "public static class B {", |
| " public A field;", |
| " public A t0(A a, A b) { return null; }", |
| "}"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static class Buggy {", |
| " @SuppressWarnings(\"unusable-by-js\") public A field;", // add SuppressWarnings to field. |
| " @SuppressWarnings({\"unusable-by-js\", \"unused\"})", // test multiple warnings. |
| " public A t0(A a, A b) { return null; }", // add SuppressWarnings to the method. |
| " public void t1(", |
| " @SuppressWarnings(\"unusable-by-js\")A a,", |
| " @SuppressWarnings(\"unusable-by-js\")A b", |
| " ) {}", // add SuppressWarnings to parameters. |
| "}"); |
| |
| assertBuggySucceeds(); |
| } |
| |
| public void testUsableByJsTypesSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsExport"); |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsFunction"); |
| addSnippetImport("com.google.gwt.core.client.JavaScriptObject"); |
| addSnippetClassDecl( |
| "@JsType public static class A {}", |
| "@JsType public static interface I {}", |
| "@JsFunction public static interface FI {void foo();}", |
| "public static class C extends JavaScriptObject {protected C(){}}", |
| "@JsType public static class Buggy {", |
| " public void f1(boolean a, int b, double c) {}", // primitive types work fine. |
| " public void f2(Boolean a, Double b, String c) {}", // unboxed types work fine. |
| " public void f3(A a) {}", // JsType works fine. |
| " public void f4(I a) {}", // JsFunction works fine. |
| " public void f5(FI a) {}", // JsFunction works fine. |
| " public void f6(C a) {}", // JavaScriptObject works fine. |
| " public void f7(Object a) {}", // Java Object works fine. |
| " public void f8(boolean[] a) {}", // array of primitive types work fine. |
| " public void f9(Boolean[] a, Double[] b, String[] c) {}", // array of unboxed types. |
| " public void f10(A[] a) {}", // array of JsType works fine. |
| " public void f11(FI[] a) {}", // array of JsFunction works fine. |
| " public void f12(C[][] a) {}", // array of JavaScriptObject works fine. |
| "}"); |
| assertBuggySucceeds(); |
| } |
| |
| public void testUnusableByJsNotExportedMembersSucceeds() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "public static class A {}", |
| "@JsType public static class Buggy {", |
| " private A field;", // private field. |
| " private A f1(A a) { return null; }", // private method. |
| "}"); |
| assertBuggySucceeds(); |
| } |
| |
| public void testUnusuableByJsWarns() throws Exception { |
| addSnippetImport("jsinterop.annotations.JsFunction"); |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetImport("jsinterop.annotations.JsMethod"); |
| addSnippetImport("jsinterop.annotations.JsProperty"); |
| addSnippetClassDecl( |
| "public static class A {}", |
| "@JsType public static interface I {}", |
| "public static class B implements I {}", |
| "public static class C {", // non-jstype class with JsMethod |
| " @JsMethod", |
| " public static void fc1(A a) {}", // JsMethod |
| "}", |
| "public static class D {", // non-jstype class with JsProperty |
| " @JsProperty", |
| " public static A a;", // JsProperty |
| "}", |
| "@JsFunction public static interface FI { void f(A a); }", // JsFunction method is checked. |
| "@JsType public static class Buggy {", |
| " public A f;", // exported field |
| " public A f1(A a) { return null; }", // regular class fails. |
| " public A[] f2(A[] a) { return null; }", // array of regular class fails. |
| " public long f3(long a) { return 1l; }", // long fails. |
| // non-JsType class that implements a JsType interface fails. |
| " public B f4(B a) { return null; }", |
| " public void f5(Object[][] a) {}", // Object[][] fails. |
| " public void f6(Object[] a) {}", // Object[] also fails. |
| "}"); |
| |
| assertBuggySucceeds( |
| "Line 12: [unusable-by-js] Type of parameter 'a' in " |
| + "'void EntryPoint.C.fc1(EntryPoint.A)' is not usable by but exposed to JavaScript.", |
| "Line 16: [unusable-by-js] Type of 'EntryPoint.A EntryPoint.D.a' is not usable by but " |
| + "exposed to JavaScript.", |
| "Line 18: [unusable-by-js] Type of parameter 'a' in " |
| + "'void EntryPoint.FI.f(EntryPoint.A)' is not usable by but exposed to JavaScript.", |
| "Line 20: [unusable-by-js] Type of 'EntryPoint.A EntryPoint.Buggy.f' is not usable by but " |
| + "exposed to JavaScript.", |
| "Line 21: [unusable-by-js] Return type of 'EntryPoint.A EntryPoint.Buggy.f1(EntryPoint.A)' " |
| + "is not usable by but exposed to JavaScript.", |
| "Line 21: [unusable-by-js] Type of parameter 'a' in " |
| + "'EntryPoint.A EntryPoint.Buggy.f1(EntryPoint.A)' is not usable by but " |
| + "exposed to JavaScript.", |
| "Line 22: [unusable-by-js] Return type of " |
| + "'EntryPoint.A[] EntryPoint.Buggy.f2(EntryPoint.A[])' is not usable by but " |
| + "exposed to JavaScript.", |
| "Line 22: [unusable-by-js] Type of parameter 'a' in " |
| + "'EntryPoint.A[] EntryPoint.Buggy.f2(EntryPoint.A[])' is not usable by but " |
| + "exposed to JavaScript.", |
| "Line 23: [unusable-by-js] Return type of 'long EntryPoint.Buggy.f3(long)' is not " |
| + "usable by but exposed to JavaScript.", |
| "Line 23: [unusable-by-js] Type of parameter 'a' in " |
| + "'long EntryPoint.Buggy.f3(long)' is not usable by but exposed to JavaScript.", |
| "Line 24: [unusable-by-js] Return type of 'EntryPoint.B EntryPoint.Buggy.f4(EntryPoint.B)' " |
| + "is not usable by but exposed to JavaScript.", |
| "Line 24: [unusable-by-js] Type of parameter 'a' in " |
| + "'EntryPoint.B EntryPoint.Buggy.f4(EntryPoint.B)' is not usable by but " |
| + "exposed to JavaScript.", |
| "Line 25: [unusable-by-js] Type of parameter 'a' in " |
| + "'void EntryPoint.Buggy.f5(Object[][])' is not usable by but exposed to JavaScript.", |
| "Line 26: [unusable-by-js] Type of parameter 'a' in " |
| + "'void EntryPoint.Buggy.f6(Object[])' is not usable by but exposed to JavaScript."); |
| } |
| |
| public void testUnusableByJsAccidentalOverrideSuppressionWarns() |
| throws Exception { |
| addSnippetImport("jsinterop.annotations.JsType"); |
| addSnippetClassDecl( |
| "@JsType", |
| "public static interface Foo {", |
| " @SuppressWarnings(\"unusable-by-js\") ", |
| " void doIt(Class foo);", |
| "}", |
| "public static class Parent {", |
| " public void doIt(Class x) {}", |
| "}", |
| "public static class Buggy extends Parent implements Foo {}"); |
| |
| assertBuggySucceeds( |
| "Line 10: [unusable-by-js] Type of parameter 'x' in " |
| + "'void EntryPoint.Parent.doIt(Class)' (exposed by 'EntryPoint.Buggy') is not usable " |
| + "by but exposed to JavaScript."); |
| } |
| |
| private static final MockJavaResource jsFunctionInterface = new MockJavaResource( |
| "test.MyJsFunctionInterface") { |
| @Override |
| public CharSequence getContent() { |
| StringBuilder code = new StringBuilder(); |
| code.append("package test;\n"); |
| code.append("import jsinterop.annotations.JsFunction;\n"); |
| code.append("@JsFunction public interface MyJsFunctionInterface {\n"); |
| code.append("int foo(int x);\n"); |
| code.append("}\n"); |
| return code; |
| } |
| }; |
| |
| public final void assertBuggySucceeds(String... expectedWarnings) |
| throws Exception { |
| List<String> allWarnings = Lists.newArrayList(); |
| if (expectedWarnings.length > 0) { |
| allWarnings.add("Warnings in test/EntryPoint.java"); |
| allWarnings.addAll(Arrays.asList(expectedWarnings)); |
| } |
| Result result = assertCompileSucceeds("Buggy buggy = null;", |
| allWarnings.toArray(new String[0])); |
| assertNotNull(result.findClass("test.EntryPoint$Buggy")); |
| } |
| |
| public final void assertBuggyFails(String... expectedErrors) { |
| assertTrue(expectedErrors.length > 0); |
| |
| List<String> allErrors = Lists.newArrayList(); |
| allErrors.add("Errors in test/EntryPoint.java"); |
| allErrors.addAll(Arrays.asList(expectedErrors)); |
| assertCompileFails("Buggy buggy = null;", allErrors.toArray(new String[0])); |
| } |
| |
| @Override |
| protected boolean doOptimizeMethod(TreeLogger logger, JProgram program, JMethod method) { |
| try { |
| JsInteropRestrictionChecker.exec(logger, program, new MinimalRebuildCache()); |
| } catch (Exception e) { |
| throw new RuntimeException(e); |
| } |
| return false; |
| } |
| } |
