From 1a5e3c2d64be1c05a422fd78b23a31de155eca64 Mon Sep 17 00:00:00 2001 From: "alexanders@b2ef00c0-3703-41da-baef-cfe82387ac0c" Date: Wed, 3 Feb 2010 00:48:31 +0000 Subject: removed duplicate trunk directory --HG-- extra : convert_revision : svn%3Ab2ef00c0-3703-41da-baef-cfe82387ac0c/trunk%404 --- .../mozilla/javascript/tests/Bug409702Test.java | 49 +++++++++++ .../javascript/tests/JavaAcessibilityTest.java | 99 ++++++++++++++++++++++ .../javascript/tests/PrivateAccessClass.java | 89 +++++++++++++++++++ 3 files changed, 237 insertions(+) create mode 100644 trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/Bug409702Test.java create mode 100644 trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/JavaAcessibilityTest.java create mode 100644 trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/PrivateAccessClass.java (limited to 'trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests') diff --git a/trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/Bug409702Test.java b/trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/Bug409702Test.java new file mode 100644 index 0000000..e9793cb --- /dev/null +++ b/trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/Bug409702Test.java @@ -0,0 +1,49 @@ +/** + * + */ +package org.mozilla.javascript.tests; + +import junit.framework.TestCase; + +import org.mozilla.javascript.*; + +/** + * See https://bugzilla.mozilla.org/show_bug.cgi?id=409702 + * @author Norris Boyd + */ +public class Bug409702Test extends TestCase { + + public static abstract class Test { + public Test() { + } + + public abstract void a(); + + public abstract int b(); + + public static abstract class Subclass extends Test { + + @Override + public final void a() { + } + } + } + + public void testAdapter() { + final int value = 12; + String source = + "var instance = " + + " new JavaAdapter(" + getClass().getName() + ".Test.Subclass," + + "{ b: function () { return " + value + "; } });" + + "instance.b();"; + + Context cx = ContextFactory.getGlobal().enterContext(); + try { + Scriptable scope = cx.initStandardObjects(); + Object result = cx.evaluateString(scope, source, "source", 1, null); + assertEquals(new Integer(value), result); + } finally { + Context.exit(); + } + } +} diff --git a/trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/JavaAcessibilityTest.java b/trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/JavaAcessibilityTest.java new file mode 100644 index 0000000..b6cf3ca --- /dev/null +++ b/trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/JavaAcessibilityTest.java @@ -0,0 +1,99 @@ +/** + * + */ +package org.mozilla.javascript.tests; + +import junit.framework.TestCase; + +import org.mozilla.javascript.Context; +import org.mozilla.javascript.ContextAction; +import org.mozilla.javascript.ContextFactory; +import org.mozilla.javascript.NativeJavaObject; +import org.mozilla.javascript.Script; +import org.mozilla.javascript.tools.shell.Global; +import org.mozilla.javascript.tools.shell.ShellContextFactory; + +/** + * @author donnamalayeri + */ +public class JavaAcessibilityTest extends TestCase { + + protected final Global global = new Global(); + String importClass = "importClass(Packages.org.mozilla.javascript.tests.PrivateAccessClass)\n"; + + public JavaAcessibilityTest() { + global.init(contextFactory); + } + + private ContextFactory contextFactory = new ShellContextFactory() { + protected boolean hasFeature(Context cx, int featureIndex) { + if (featureIndex == Context.FEATURE_ENHANCED_JAVA_ACCESS) + return true; + return super.hasFeature(cx, featureIndex); + } + }; + + public void testAccessingFields() { + Object result = runScript(importClass + "PrivateAccessClass.staticPackagePrivateInt"); + assertEquals(new Integer(0), result); + + result = runScript(importClass + "PrivateAccessClass.staticPrivateInt"); + assertEquals(new Integer(1), result); + + result = runScript(importClass + "PrivateAccessClass.staticProtectedInt"); + assertEquals(new Integer(2), result); + + result = runScript(importClass + "new PrivateAccessClass().packagePrivateString"); + assertEquals("package private", ((NativeJavaObject) result).unwrap()); + + result = runScript(importClass + "new PrivateAccessClass().privateString"); + assertEquals("private", ((NativeJavaObject) result).unwrap()); + + result = runScript(importClass + "new PrivateAccessClass().protectedString"); + assertEquals("protected", ((NativeJavaObject) result).unwrap()); + + result = runScript(importClass + "new PrivateAccessClass.PrivateNestedClass().packagePrivateInt"); + assertEquals(new Integer(0), result); + + result = runScript(importClass + "new PrivateAccessClass.PrivateNestedClass().privateInt"); + assertEquals(new Integer(1), result); + + result = runScript(importClass + "new PrivateAccessClass.PrivateNestedClass().protectedInt"); + assertEquals(new Integer(2), result); + } + + public void testAccessingMethods() { + Object result = runScript(importClass + "PrivateAccessClass.staticPackagePrivateMethod()"); + assertEquals(new Integer(0), result); + + result = runScript(importClass + "PrivateAccessClass.staticPrivateMethod()"); + assertEquals(new Integer(1), result); + + result = runScript(importClass + "PrivateAccessClass.staticProtectedMethod()"); + assertEquals(new Integer(2), result); + + result = runScript(importClass + "new PrivateAccessClass().packagePrivateMethod()"); + assertEquals(new Integer(3), result); + + result = runScript(importClass + "new PrivateAccessClass().privateMethod()"); + assertEquals(new Integer(4), result); + + result = runScript(importClass + "new PrivateAccessClass().protectedMethod()"); + assertEquals(new Integer(5), result); + } + + public void testAccessingConstructors() { + runScript(importClass + "new PrivateAccessClass(\"foo\")"); + runScript(importClass + "new PrivateAccessClass(5)"); + runScript(importClass + "new PrivateAccessClass(5, \"foo\")"); + } + + private Object runScript(final String scriptSourceText) { + return this.contextFactory.call(new ContextAction() { + public Object run(Context context) { + Script script = context.compileString(scriptSourceText, "", 1, null); + return script.exec(context, global); + } + }); + } +} diff --git a/trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/PrivateAccessClass.java b/trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/PrivateAccessClass.java new file mode 100644 index 0000000..08f95a3 --- /dev/null +++ b/trunk/infrastructure/rhino1_7R1/testsrc/org/mozilla/javascript/tests/PrivateAccessClass.java @@ -0,0 +1,89 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (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.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Attila Szegedi + * David P. Caldwell + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.tests; + +/** + * A class with private/protected/package private members, to test the Rhino + * feature Context.FEATURE_ENHANCED_JAVA_ACCESS, that allows bypassing Java + * member access restrictions. + * @author Donna Malayeri + */ + +public class PrivateAccessClass +{ + private PrivateAccessClass() { } + PrivateAccessClass(String s) { } + private PrivateAccessClass(int x) { } + protected PrivateAccessClass(int x, String s) { } + + private static class PrivateNestedClass + { + private PrivateNestedClass() { } + + int packagePrivateInt = 0; + private int privateInt = 1; + protected int protectedInt = 2; + } + + static int staticPackagePrivateInt = 0; + private static int staticPrivateInt = 1; + protected static int staticProtectedInt = 2; + + String packagePrivateString = "package private"; + private String privateString = "private"; + protected String protectedString = "protected"; + + static int staticPackagePrivateMethod() { return 0; } + static private int staticPrivateMethod() { return 1; } + static protected int staticProtectedMethod() { return 2; } + + int packagePrivateMethod() { return 3; } + private int privateMethod() { return 4; } + protected int protectedMethod() { return 5; } + + /* + * Suppress warnings about unused private members. + */ + public int referenceToPrivateMembers() { + PrivateAccessClass pac = new PrivateAccessClass(); + PrivateAccessClass pac2 = new PrivateAccessClass(2); + PrivateNestedClass pnc = new PrivateNestedClass(); + System.out.println(privateString); + return pnc.privateInt + staticPrivateInt + staticPrivateMethod() + + pac.privateMethod(); + } +} -- cgit v1.2.3