/*
* 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
* @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 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.
}