4c0f24ef71
Reviewed-by: vromero
222 lines
8.7 KiB
Java
222 lines
8.7 KiB
Java
/*
|
|
* Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8064362
|
|
* @summary WriteableScope.dupUnshared not working properly for shared Scopes.
|
|
* @modules jdk.compiler/com.sun.tools.javac.code:+open
|
|
* jdk.compiler/com.sun.tools.javac.file
|
|
* jdk.compiler/com.sun.tools.javac.util
|
|
*/
|
|
|
|
import com.sun.tools.javac.util.*;
|
|
import com.sun.tools.javac.code.*;
|
|
import com.sun.tools.javac.code.Scope.*;
|
|
import com.sun.tools.javac.code.Symbol.*;
|
|
import com.sun.tools.javac.file.JavacFileManager;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.Method;
|
|
import java.util.Collections;
|
|
import java.util.IdentityHashMap;
|
|
import java.util.Objects;
|
|
import java.util.Set;
|
|
|
|
public class DupUnsharedTest {
|
|
public static void main(String... args) throws Exception {
|
|
new DupUnsharedTest().run();
|
|
}
|
|
|
|
Context context;
|
|
Names names;
|
|
Symtab symtab;
|
|
Name a;
|
|
Name b;
|
|
int errors;
|
|
|
|
public DupUnsharedTest() {
|
|
context = new Context();
|
|
JavacFileManager.preRegister(context); // required by ClassReader which is required by Symtab
|
|
names = Names.instance(context);
|
|
symtab = Symtab.instance(context);
|
|
a = names.fromString("a");
|
|
b = names.fromString("b");
|
|
}
|
|
|
|
void run() throws Exception {
|
|
runScopeContentTest();
|
|
runClashTest();
|
|
|
|
if (errors > 0)
|
|
throw new AssertionError("Errors detected (" + errors + ").");
|
|
}
|
|
|
|
void runScopeContentTest() throws Exception {
|
|
Set<Symbol> expected = Collections.newSetFromMap(new IdentityHashMap<>() {});
|
|
Set<Symbol> notExpected = Collections.newSetFromMap(new IdentityHashMap<>());
|
|
WriteableScope s1 = WriteableScope.create(symtab.unnamedModule.unnamedPackage);
|
|
ClassSymbol acceptSym = symtab.arrayClass;
|
|
s1.enter(acceptSym);
|
|
expected.add(acceptSym);
|
|
WriteableScope s2 = s1.dup();
|
|
fillScope(s2, notExpected, a);
|
|
WriteableScope s3 = s2.dup();
|
|
fillScope(s3, notExpected, b);
|
|
WriteableScope s4 = s1.dupUnshared();
|
|
assertEquals(toSet(s4.getSymbols()), expected);
|
|
assertEquals(toSet(s4.getSymbolsByName(a)), Collections.emptySet());
|
|
assertEquals(toSet(s4.getSymbolsByName(b)), Collections.emptySet());
|
|
assertEquals(toSet(s4.getSymbolsByName(acceptSym.name)), expected);
|
|
for (Symbol sym : notExpected) {
|
|
try {
|
|
s4.remove(sym);
|
|
} catch (Exception ex) {
|
|
System.err.println("s4.remove(" + sym + "); crashes with exception:");
|
|
ex.printStackTrace();
|
|
errors++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void fillScope(WriteableScope scope, Set<Symbol> notExpected, Name name) {
|
|
VarSymbol var1 = new VarSymbol(0, name, Type.noType, symtab.arrayClass);
|
|
VarSymbol var2 = new VarSymbol(0, name, Type.noType, symtab.autoCloseableClose.owner);
|
|
scope.enter(var1);
|
|
scope.enter(var2);
|
|
scope.remove(var1);
|
|
notExpected.add(var1);
|
|
notExpected.add(var2);
|
|
}
|
|
|
|
Set<Symbol> toSet(Iterable<Symbol> it) {
|
|
Set<Symbol> result = Collections.newSetFromMap(new IdentityHashMap<>() {});
|
|
|
|
for (Symbol sym : it) {
|
|
result.add(sym);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void assertEquals(Set<Symbol> set1, Set<Symbol> set2) {
|
|
if (!Objects.equals(set1, set2)) {
|
|
System.err.println("Sets are not equals: s1=" + set1 + "; s2=" + set2);
|
|
errors++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This tests the following situation.
|
|
* - consider empty Scope S1
|
|
* - a Symbol with name 'A' is added into S1
|
|
* - S1 is dupped into S2
|
|
* - a Symbol with name 'B', clashing with 'A', is added into S2
|
|
* - so the table now looks like: [..., A, ..., B, ...]
|
|
* - S2 is doubled. As a consequence, the table is re-hashed, and looks like:
|
|
* [..., B, ..., A, ...] (note that re-hashing goes from the end, hence the original order).
|
|
* - B has been chosen so that it clashes in the doubled scope as well. So when looking up 'A',
|
|
* B is found (and rejected) first, and only then the A's bucket is tested.
|
|
* - S2 is dupUshared - the resulting table needs to look like: [..., /sentinel/, ..., A, ...], not
|
|
* [..., null, ..., A, ...], as in the latter case lookups would see 'null' while looking for
|
|
* 'A' and would stop the search prematurely.
|
|
*/
|
|
void runClashTest() throws Exception {
|
|
WriteableScope emptyScope = WriteableScope.create(symtab.unnamedModule.unnamedPackage);
|
|
Field tableField = emptyScope.getClass().getDeclaredField("table");
|
|
tableField.setAccessible(true);
|
|
Method dble = emptyScope.getClass().getDeclaredMethod("dble");
|
|
dble.setAccessible(true);
|
|
Method getIndex = emptyScope.getClass().getDeclaredMethod("getIndex", Name.class);
|
|
getIndex.setAccessible(true);
|
|
|
|
int tries = 0;
|
|
|
|
//find a name that will be in the first bucket in table (so that a conflicting name
|
|
//will be in placed in a bucket after this one).
|
|
Name first = names.fromString("a");
|
|
while ((Integer) getIndex.invoke(emptyScope, first) != 0) {
|
|
if (tries++ > MAX_TRIES) {
|
|
System.err.println("could not find a name that would be placed in the first bucket");
|
|
errors++;
|
|
return ;
|
|
}
|
|
first = names.fromString("a" + first.toString());
|
|
}
|
|
|
|
System.out.println("first name: " + first);
|
|
|
|
//now, find another name, that will clash with the first one both in the empty and a doubled scope:
|
|
Scope doubledEmptyScope = WriteableScope.create(symtab.unnamedModule.unnamedPackage);
|
|
dble.invoke(doubledEmptyScope);
|
|
Integer firstNameTestScopeIndex = (Integer) getIndex.invoke(emptyScope, first);
|
|
Integer firstNameDoubleScopeIndex = (Integer) getIndex.invoke(doubledEmptyScope, first);
|
|
Name other = names.fromString("b");
|
|
while (!Objects.equals(firstNameTestScopeIndex, getIndex.invoke(emptyScope, other)) ||
|
|
!Objects.equals(firstNameDoubleScopeIndex, getIndex.invoke(doubledEmptyScope, other))) {
|
|
if (tries++ > MAX_TRIES) {
|
|
System.err.println("could not find a name that would properly clash with the first chosen name");
|
|
errors++;
|
|
return ;
|
|
}
|
|
other = names.fromString("b" + other);
|
|
}
|
|
|
|
System.out.println("other name: " + other);
|
|
|
|
Symbol firstSymbol = new VarSymbol(0, first, Type.noType, null);
|
|
Symbol otherSymbol = new VarSymbol(0, other, Type.noType, null);
|
|
|
|
//test the situation described above:
|
|
WriteableScope testScope1 = WriteableScope.create(symtab.unnamedModule.unnamedPackage);
|
|
testScope1.enter(firstSymbol);
|
|
|
|
WriteableScope dupped1 = testScope1.dup();
|
|
|
|
dupped1.enter(otherSymbol);
|
|
dble.invoke(dupped1);
|
|
|
|
if (testScope1.dupUnshared().findFirst(first) != firstSymbol) {
|
|
System.err.println("cannot find the Symbol in the dupUnshared scope (1)");
|
|
errors++;
|
|
}
|
|
|
|
//also check a situation where the clashing Symbol is removed from the dupped scope:
|
|
WriteableScope testScope2 = WriteableScope.create(symtab.unnamedModule.unnamedPackage);
|
|
testScope2.enter(firstSymbol);
|
|
|
|
WriteableScope dupped2 = testScope2.dup();
|
|
|
|
dupped2.enter(otherSymbol);
|
|
dble.invoke(dupped2);
|
|
dupped2.remove(otherSymbol);
|
|
|
|
if (testScope2.dupUnshared().findFirst(first) != firstSymbol) {
|
|
System.err.println("cannot find the Symbol in the dupUnshared scope (2)");
|
|
errors++;
|
|
}
|
|
}
|
|
|
|
int MAX_TRIES = 100; // max tries to find a hash clash before giving up.
|
|
|
|
}
|