From df933eda71af90eecf9e2cfd0ae0eeac6f4b7c9c Mon Sep 17 00:00:00 2001 From: Andy McFadden Date: Thu, 18 Jun 2009 14:15:23 -0700 Subject: [PATCH] Method override tests. Test various method overrides, especially those that the compiler doesn't allow (public vs. private, static vs. virtual). This doesn't succeed right now because of the way the verifier deals with static and virtual methods (internal bug 1752800). --- tests/077-method-override/expected.txt | 15 ++++++ tests/077-method-override/info.txt | 2 + tests/077-method-override/src/Base.java | 84 ++++++++++++++++++++++++++++++ tests/077-method-override/src/Derived.java | 60 +++++++++++++++++++++ tests/077-method-override/src/Main.java | 54 +++++++++++++++++++ tests/077-method-override/src2/Base.java | 83 +++++++++++++++++++++++++++++ 6 files changed, 298 insertions(+) create mode 100644 tests/077-method-override/expected.txt create mode 100644 tests/077-method-override/info.txt create mode 100644 tests/077-method-override/src/Base.java create mode 100644 tests/077-method-override/src/Derived.java create mode 100644 tests/077-method-override/src/Main.java create mode 100644 tests/077-method-override/src2/Base.java diff --git a/tests/077-method-override/expected.txt b/tests/077-method-override/expected.txt new file mode 100644 index 000000000..2e9bda33f --- /dev/null +++ b/tests/077-method-override/expected.txt @@ -0,0 +1,15 @@ +declaredInBase: Base +notDeclaredInBase: Derived +wasOverridden: Derived +overrideWithPublic: Derived +overrideProtectedWithPublic: Derived +overridePublicWithProtected: Derived +overridePublicWithPrivate: Base +overridePrivateWithPublic: Base +overridePrivateWithPublic: Derived +overrideVirtualWithStatic: Base +overrideVirtualWithStatic: Derived +overrideStaticWithVirtual: Base +overrideStaticWithVirtual: Derived +Got expected exception - ovws +Got expected exception - oswv diff --git a/tests/077-method-override/info.txt b/tests/077-method-override/info.txt new file mode 100644 index 000000000..914b4f253 --- /dev/null +++ b/tests/077-method-override/info.txt @@ -0,0 +1,2 @@ +Test various forms of method overrides, including some not allowed by the +compiler but possible with separate compilation. diff --git a/tests/077-method-override/src/Base.java b/tests/077-method-override/src/Base.java new file mode 100644 index 000000000..eed6f2258 --- /dev/null +++ b/tests/077-method-override/src/Base.java @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * 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. + */ + +public class Base { + public void declaredInBase() { + System.out.println("declaredInBase: Base"); + } + + public void overridden() { + System.out.println("overridden: Base"); + } + + /* src2: removed */ + public void wasOverridden() { + System.out.println("wasOverridden: Base"); + } + + public void callOverrideWithPublic() { + overrideWithPublic(); + } + public void overrideWithPublic() { + System.out.println("overrideWithPublic: Base"); + } + + public void callOverridePublicWithProtected() { + overridePublicWithProtected(); + } + /* src2: public */ + protected void overridePublicWithProtected() { + System.out.println("overridePublicWithProtected: Base"); + } + + public void callOverrideProtectedWithPublic() { + overrideProtectedWithPublic(); + } + protected void overrideProtectedWithPublic() { + System.out.println("overrideProtectedWithPublic: Base"); + } + + public void callOverridePublicWithPrivate() { + overridePublicWithPrivate(); + } + /* src2: public */ + private void overridePublicWithPrivate() { + System.out.println("overridePublicWithPrivate: Base"); + } + + public void callOverridePrivateWithPublic() { + overridePrivateWithPublic(); + } + private void overridePrivateWithPublic() { + System.out.println("overridePrivateWithPublic: Base"); + } + + public void callOverrideVirtualWithStatic() { + overrideVirtualWithStatic(); + } + /* src2: non-static */ + public static void overrideVirtualWithStatic() { + System.out.println("overrideVirtualWithStatic: Base"); + } + + public void callOverrideStaticWithVirtual() { + overrideStaticWithVirtual(); + } + /* src2: static */ + public void overrideStaticWithVirtual() { + System.out.println("overrideStaticWithVirtual: Base"); + } +} + diff --git a/tests/077-method-override/src/Derived.java b/tests/077-method-override/src/Derived.java new file mode 100644 index 000000000..09ffdf648 --- /dev/null +++ b/tests/077-method-override/src/Derived.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * 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. + */ + +public class Derived extends Base { + public static void notDeclaredInBase() { + System.out.println("notDeclaredInBase: Derived"); + } + + public void overridden() { + System.out.println("overridden: Derived"); + } + + public void wasOverridden() { + System.out.println("wasOverridden: Derived"); + } + + public void overrideWithPublic() { + System.out.println("overrideWithPublic: Derived"); + } + + protected void overridePublicWithProtected() { + System.out.println("overridePublicWithProtected: Derived"); + } + + public void overrideProtectedWithPublic() { + System.out.println("overrideProtectedWithPublic: Derived"); + } + + private void overridePublicWithPrivate() { + System.out.println("overridePublicWithPrivate: Derived"); + } + + public void overridePrivateWithPublic() { + System.out.println("overridePrivateWithPublic: Derived"); + } + + /* not really an "override"; just has same method signature */ + public static void overrideVirtualWithStatic() { + System.out.println("overrideVirtualWithStatic: Derived"); + } + + /* not really an "override"; just has same method signature */ + public void overrideStaticWithVirtual() { + System.out.println("overrideStaticWithVirtual: Derived"); + } +} + diff --git a/tests/077-method-override/src/Main.java b/tests/077-method-override/src/Main.java new file mode 100644 index 000000000..fa401cd26 --- /dev/null +++ b/tests/077-method-override/src/Main.java @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * 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. + */ + +public class Main { + public static void main(String args[]) { + Derived derived = new Derived(); + + derived.declaredInBase(); + derived.notDeclaredInBase(); + derived.wasOverridden(); + + derived.callOverrideWithPublic(); + derived.callOverrideProtectedWithPublic(); + derived.callOverridePublicWithProtected(); + derived.callOverridePublicWithPrivate(); + derived.callOverridePrivateWithPublic(); + derived.overridePrivateWithPublic(); + derived.callOverrideVirtualWithStatic(); + derived.overrideVirtualWithStatic(); + derived.callOverrideStaticWithVirtual(); + derived.overrideStaticWithVirtual(); + + try { + ((Base)derived).overrideVirtualWithStatic(); + } catch (NoSuchMethodError nsme) { + /* NSME is subclass of ICCE, so check it explicitly */ + System.err.println("Got NSME - ovws"); + } catch (IncompatibleClassChangeError icce) { + System.out.println("Got expected exception - ovws"); + } + + try { + ((Base)derived).overrideStaticWithVirtual(); + } catch (NoSuchMethodError nsme) { + System.err.println("Got NSME - ovws"); + } catch (IncompatibleClassChangeError icce) { + System.out.println("Got expected exception - oswv"); + } + } +} + diff --git a/tests/077-method-override/src2/Base.java b/tests/077-method-override/src2/Base.java new file mode 100644 index 000000000..8be42bc9a --- /dev/null +++ b/tests/077-method-override/src2/Base.java @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * 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. + */ + +public class Base { + public void declaredInBase() { + System.out.println("declaredInBase: Base"); + } + + public void overridden() { + System.out.println("overridden: Base"); + } + + /* src2: removed */ + //public void wasOverridden() { + // System.out.println("wasOverridden: Base"); + //} + + public void callOverrideWithPublic() { + overrideWithPublic(); + } + public void overrideWithPublic() { + System.out.println("overrideWithPublic: Base"); + } + + public void callOverridePublicWithProtected() { + overridePublicWithProtected(); + } + /* src2: public */ + public void overridePublicWithProtected() { + System.out.println("overridePublicWithProtected: Base"); + } + + public void callOverrideProtectedWithPublic() { + overrideProtectedWithPublic(); + } + protected void overrideProtectedWithPublic() { + System.out.println("overrideProtectedWithPublic: Base"); + } + + public void callOverridePublicWithPrivate() { + overridePublicWithPrivate(); + } + /* src2: public */ + public void overridePublicWithPrivate() { + System.out.println("overridePublicWithPrivate: Base"); + } + + public void callOverridePrivateWithPublic() { + overridePrivateWithPublic(); + } + private void overridePrivateWithPublic() { + System.out.println("overridePrivateWithPublic: Base"); + } + + public void callOverrideVirtualWithStatic() { + overrideVirtualWithStatic(); + } + /* src2: non-static */ + public void overrideVirtualWithStatic() { + System.out.println("overrideVirtualWithStatic: Base"); + } + + public void callOverrideStaticWithVirtual() { + overrideStaticWithVirtual(); + } + public static void overrideStaticWithVirtual() { + System.out.println("overrideStaticWithVirtual: Base"); + } +} + -- 2.11.0