azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Introduced compareNamespaceWithFile() method.

Browse Source
This commit is contained in:
Evgeny Gerashchenko
2012-12-26 23:21:05 +04:00
parent da7f4f3421
commit 8659d14ba0
9 changed files with 93 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java
+35 -10
View File
@@ -31,6 +31,7 @@ import java.util.Arrays;
import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.analyzeKotlinAndLoadTestNamespace; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.analyzeKotlinAndLoadTestNamespace;
import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndLoadTestNamespaceAndBindingContextFromBinary; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndLoadTestNamespaceAndBindingContextFromBinary;
import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT; import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT;
import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaceWithFile;
import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces; import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces;
/** /**
@@ -46,23 +47,22 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
File javaFile = new File(javaFileName); File javaFile = new File(javaFileName);
File ktFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".kt")); File ktFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".kt"));
File txtFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".txt")); File txtFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".txt"));
NamespaceDescriptor nsa = analyzeKotlinAndLoadTestNamespace(ktFile, myTestRootDisposable, ConfigurationKind.JDK_AND_ANNOTATIONS); NamespaceDescriptor kotlinNamespace = analyzeKotlinAndLoadTestNamespace(ktFile, myTestRootDisposable, ConfigurationKind.JDK_AND_ANNOTATIONS);
Pair<NamespaceDescriptor, BindingContext> nsbAndBindingContext = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary( Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndContext = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(
Arrays.asList(javaFile, ExpectedLoadErrorsUtil.ANNOTATION_SOURCE_FILE), Arrays.asList(javaFile, ExpectedLoadErrorsUtil.ANNOTATION_SOURCE_FILE),
tmpdir, myTestRootDisposable, ConfigurationKind.JDK_AND_ANNOTATIONS); tmpdir, myTestRootDisposable, ConfigurationKind.JDK_AND_ANNOTATIONS);
checkLoadedNamespaces(txtFile, nsa, nsbAndBindingContext); checkLoadedNamespaces(txtFile, kotlinNamespace, javaNamespaceAndContext);
} }
public static void checkLoadedNamespaces( private static void checkForLoadErrorsAndCompare(
File txtFile, @NotNull Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndContext,
NamespaceDescriptor nsa, @NotNull Runnable compareNamespacesRunnable
Pair<NamespaceDescriptor, BindingContext> nsbAndBindingContext
) { ) {
NamespaceDescriptor nsb = nsbAndBindingContext.first; NamespaceDescriptor javaNamespace = javaNamespaceAndContext.first;
boolean fail = false; boolean fail = false;
try { try {
ExpectedLoadErrorsUtil.checkForLoadErrors(nsb, nsbAndBindingContext.second); ExpectedLoadErrorsUtil.checkForLoadErrors(javaNamespace, javaNamespaceAndContext.second);
} }
catch (ComparisonFailure e) { catch (ComparisonFailure e) {
// to let the next check run even if this one failed // to let the next check run even if this one failed
@@ -76,9 +76,34 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
fail = true; fail = true;
} }
compareNamespaces(nsa, nsb, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); compareNamespacesRunnable.run();
if (fail) { if (fail) {
fail("See error above"); fail("See error above");
} }
} }
public static void checkLoadedNamespaces(
final File txtFile,
final NamespaceDescriptor kotlinNamespace,
final Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndContext
) {
checkForLoadErrorsAndCompare(javaNamespaceAndContext, new Runnable() {
@Override
public void run() {
compareNamespaces(kotlinNamespace, javaNamespaceAndContext.first, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
}
});
}
public static void checkJavaNamespace(
final File txtFile,
final Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndContext
) {
checkForLoadErrorsAndCompare(javaNamespaceAndContext, new Runnable() {
@Override
public void run() {
compareNamespaceWithFile(javaNamespaceAndContext.first, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
}
});
}
} }
compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaCustomTest.java
+6 -7
View File
@@ -49,6 +49,7 @@ import java.util.Collections;
import java.util.List; import java.util.List;
import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndLoadTestNamespaceAndBindingContextFromBinary; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndLoadTestNamespaceAndBindingContextFromBinary;
import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaceWithFile;
/** /**
* @author Pavel Talanov * @author Pavel Talanov
@@ -73,16 +74,14 @@ public final class LoadJavaCustomTest extends KotlinTestWithEnvironment {
} }
}); });
files.add(ExpectedLoadErrorsUtil.ANNOTATION_SOURCE_FILE); files.add(ExpectedLoadErrorsUtil.ANNOTATION_SOURCE_FILE);
File expected = new File(expectedFileName); File expectedFile = new File(expectedFileName);
File tmpDir = JetTestUtils.tmpDir(expected.getName()); File tmpDir = JetTestUtils.tmpDir(expectedFile.getName());
Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndBindingContext Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndBindingContext
= compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(files, tmpDir, getTestRootDisposable(), = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(files, tmpDir, getTestRootDisposable(),
ConfigurationKind.JDK_ONLY); ConfigurationKind.JDK_ONLY);
NamespaceDescriptor javaNamespace = javaNamespaceAndBindingContext.first; AbstractLoadJavaTest.checkJavaNamespace(expectedFile, javaNamespaceAndBindingContext);
//NOTE: comparing namespace to file (hack)
AbstractLoadJavaTest.checkLoadedNamespaces(expected, javaNamespace, javaNamespaceAndBindingContext);
} }
public void testPackageLocalVisibility() throws Exception { public void testPackageLocalVisibility() throws Exception {
@@ -172,8 +171,8 @@ public final class LoadJavaCustomTest extends KotlinTestWithEnvironment {
LoadDescriptorUtil.TEST_PACKAGE_FQNAME, DescriptorSearchRule.INCLUDE_KOTLIN); LoadDescriptorUtil.TEST_PACKAGE_FQNAME, DescriptorSearchRule.INCLUDE_KOTLIN);
assert namespaceDescriptor != null; assert namespaceDescriptor != null;
NamespaceComparator.compareNamespaces(namespaceDescriptor, namespaceDescriptor, compareNamespaceWithFile(namespaceDescriptor, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT,
NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, new File(dir, "expected.txt")); new File(dir, "expected.txt"));
ExpectedLoadErrorsUtil.checkForLoadErrors(namespaceDescriptor, bindingTrace.getBindingContext()); ExpectedLoadErrorsUtil.checkForLoadErrors(namespaceDescriptor, bindingTrace.getBindingContext());
} }
compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinCustomTest.java
+4 -4
View File
@@ -28,7 +28,7 @@ import java.io.File;
import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.*; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.*;
import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT; import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT;
import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces; import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaceWithFile;
/** /**
* @author Pavel Talanov * @author Pavel Talanov
@@ -48,7 +48,7 @@ public final class LoadKotlinCustomTest extends TestCaseWithTmpdir {
NamespaceDescriptor namespaceFromClass = NamespaceDescriptor namespaceFromClass =
compileKotlinAndLoadTestNamespaceDescriptorFromBinary(kotlinFile, tmpdir, myTestRootDisposable, ConfigurationKind.JDK_ONLY); compileKotlinAndLoadTestNamespaceDescriptorFromBinary(kotlinFile, tmpdir, myTestRootDisposable, ConfigurationKind.JDK_ONLY);
compareNamespaces(namespaceFromClass, namespaceFromClass, DONT_INCLUDE_METHODS_OF_OBJECT, expectedFile); compareNamespaceWithFile(namespaceFromClass, DONT_INCLUDE_METHODS_OF_OBJECT, expectedFile);
} }
private void loadDescriptorsFromSourceAndCompareWithTxt(@NotNull File expectedFile, @NotNull File kotlinFile) private void loadDescriptorsFromSourceAndCompareWithTxt(@NotNull File expectedFile, @NotNull File kotlinFile)
@@ -57,8 +57,8 @@ public final class LoadKotlinCustomTest extends TestCaseWithTmpdir {
NamespaceDescriptor namespaceFromSource = exhaust.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, NamespaceDescriptor namespaceFromSource = exhaust.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR,
TEST_PACKAGE_FQNAME); TEST_PACKAGE_FQNAME);
assert namespaceFromSource != null; assert namespaceFromSource != null;
compareNamespaces(namespaceFromSource, namespaceFromSource, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT.checkPrimaryConstructors(true), compareNamespaceWithFile(namespaceFromSource, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT.checkPrimaryConstructors(true),
expectedFile); expectedFile);
} }
private void doTest( private void doTest(
compiler/tests/org/jetbrains/jet/jvm/compiler/StaticMembersJavaDescriptorResolverTest.java
+3 -4
View File
@@ -25,7 +25,7 @@ import java.io.File;
import java.io.IOException; import java.io.IOException;
import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT; import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT;
import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces; import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaceWithFile;
public final class StaticMembersJavaDescriptorResolverTest extends AbstractJavaResolverDescriptorTest { public final class StaticMembersJavaDescriptorResolverTest extends AbstractJavaResolverDescriptorTest {
@@ -59,15 +59,14 @@ public final class StaticMembersJavaDescriptorResolverTest extends AbstractJavaR
compileJavaFile(name + ".java"); compileJavaFile(name + ".java");
NamespaceDescriptor namespaceWithClass = javaDescriptorResolver.resolveNamespace(new FqName(DEFAULT_PACKAGE)); NamespaceDescriptor namespaceWithClass = javaDescriptorResolver.resolveNamespace(new FqName(DEFAULT_PACKAGE));
Assert.assertNotNull(namespaceWithClass); Assert.assertNotNull(namespaceWithClass);
compareNamespaces(namespaceWithClass, namespaceWithClass, DONT_INCLUDE_METHODS_OF_OBJECT, new File(PATH + name + "_non_static.txt")); compareNamespaceWithFile(namespaceWithClass, DONT_INCLUDE_METHODS_OF_OBJECT, new File(PATH + name + "_non_static.txt"));
NamespaceDescriptor namespaceWithStaticMembers = javaDescriptorResolver.resolveNamespace(new FqName(DEFAULT_PACKAGE + "." + name)); NamespaceDescriptor namespaceWithStaticMembers = javaDescriptorResolver.resolveNamespace(new FqName(DEFAULT_PACKAGE + "." + name));
File fileWithStaticMembers = new File(PATH + name + "_static.txt"); File fileWithStaticMembers = new File(PATH + name + "_static.txt");
if (namespaceWithStaticMembers == null) { if (namespaceWithStaticMembers == null) {
Assert.assertTrue(!fileWithStaticMembers.exists()); Assert.assertTrue(!fileWithStaticMembers.exists());
} else { } else {
compareNamespaces(namespaceWithStaticMembers, namespaceWithStaticMembers, DONT_INCLUDE_METHODS_OF_OBJECT, compareNamespaceWithFile(namespaceWithStaticMembers, DONT_INCLUDE_METHODS_OF_OBJECT, fileWithStaticMembers);
fileWithStaticMembers);
} }
} }
} }
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java
+4 -3
View File
@@ -25,12 +25,13 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.test.util.NamespaceComparator;
import java.io.File; import java.io.File;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
import static org.jetbrains.jet.test.util.NamespaceComparator.*;
/** /**
* @author abreslav * @author abreslav
*/ */
@@ -54,9 +55,9 @@ public abstract class AbstractLazyResolveDiagnosticsTest extends AbstractJetDiag
// Only recurse into those namespaces mentioned in the files // Only recurse into those namespaces mentioned in the files
// Otherwise we'll be examining the whole JDK // Otherwise we'll be examining the whole JDK
final Set<Name> names = LazyResolveTestUtil.getTopLevelPackagesFromFileList(jetFiles); final Set<Name> names = LazyResolveTestUtil.getTopLevelPackagesFromFileList(jetFiles);
NamespaceComparator.compareNamespaces( compareNamespaces(
expected, actual, expected, actual,
NamespaceComparator.RECURSIVE.filterRecursion(new Predicate<FqNameUnsafe>() { RECURSIVE.filterRecursion(new Predicate<FqNameUnsafe>() {
@Override @Override
public boolean apply(FqNameUnsafe fqName) { public boolean apply(FqNameUnsafe fqName) {
if (fqName.isRoot()) return true; if (fqName.isRoot()) return true;
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java
+8 -8
View File
@@ -71,13 +71,13 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends KotlinTe
File serializeResultsTo = new File(FileUtil.getNameWithoutExtension(testFileName) + ".txt"); File serializeResultsTo = new File(FileUtil.getNameWithoutExtension(testFileName) + ".txt");
NamespaceComparator.compareNamespaces(expected, actual, NamespaceComparator.compareNamespaces(
NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT.filterRecursion( expected, actual, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT.filterRecursion(
new Predicate<FqNameUnsafe>() { new Predicate<FqNameUnsafe>() {
@Override @Override
public boolean apply(FqNameUnsafe fqName) { public boolean apply(FqNameUnsafe fqName) {
return !KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.toUnsafe().equals(fqName); return !KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.toUnsafe().equals(fqName);
} }
}).checkPrimaryConstructors(checkPrimaryConstructors), serializeResultsTo); }).checkPrimaryConstructors(checkPrimaryConstructors), serializeResultsTo);
} }
} }
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java
+3 -3
View File
@@ -25,6 +25,8 @@ import org.junit.Test;
import java.io.File; import java.io.File;
import static org.jetbrains.jet.test.util.NamespaceComparator.*;
/** /**
* @author abreslav * @author abreslav
*/ */
@@ -37,8 +39,6 @@ public class LazyResolveBuiltinClassesTest extends KotlinTestWithEnvironment {
@Test @Test
public void testJetStandardLibrary() throws Exception { public void testJetStandardLibrary() throws Exception {
NamespaceDescriptor builtInsPackage = KotlinBuiltIns.getInstance().getBuiltInsPackage(); NamespaceDescriptor builtInsPackage = KotlinBuiltIns.getInstance().getBuiltInsPackage();
NamespaceComparator.compareNamespaces(builtInsPackage, builtInsPackage, compareNamespaceWithFile(builtInsPackage, RECURSIVE, new File("compiler/testData/builtin-classes.txt"));
NamespaceComparator.RECURSIVE, new File("compiler/testData/builtin-classes.txt"));
} }
} }
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java
+3 -3
View File
@@ -59,9 +59,9 @@ public class LazyResolveStdlibLoadingTest extends KotlinTestWithEnvironmentManag
ModuleDescriptor lazyModule = LazyResolveTestUtil.resolveLazily(files, stdlibEnvironment); ModuleDescriptor lazyModule = LazyResolveTestUtil.resolveLazily(files, stdlibEnvironment);
for (Name name : namespaceShortNames) { for (Name name : namespaceShortNames) {
NamespaceDescriptor a = module.getRootNamespace().getMemberScope().getNamespace(name); NamespaceDescriptor eager = module.getRootNamespace().getMemberScope().getNamespace(name);
NamespaceDescriptor b = lazyModule.getRootNamespace().getMemberScope().getNamespace(name); NamespaceDescriptor lazy = lazyModule.getRootNamespace().getMemberScope().getNamespace(name);
NamespaceComparator.compareNamespaces(a, b, NamespaceComparator.RECURSIVE, null); NamespaceComparator.compareNamespaces(eager, lazy, NamespaceComparator.RECURSIVE, null);
} }
} }
compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java
+27 -3
View File
@@ -130,18 +130,42 @@ public class NamespaceComparator {
} }
} }
public static void compareNamespaceWithFile(
@NotNull NamespaceDescriptor actualNamespace,
@NotNull Configuration configuration,
@NotNull File txtFile
) {
doCompareNamespaces(null, actualNamespace, configuration, txtFile);
}
public static void compareNamespaces( public static void compareNamespaces(
@NotNull NamespaceDescriptor expectedNamespace, @NotNull NamespaceDescriptor expectedNamespace,
@NotNull NamespaceDescriptor actualNamespace, @NotNull NamespaceDescriptor actualNamespace,
@NotNull Configuration configuration, @NotNull Configuration configuration,
@Nullable File txtFile @Nullable File txtFile
) {
if (expectedNamespace == actualNamespace) {
throw new IllegalArgumentException("Don't invoke this method with expectedNamespace == actualNamespace." +
"Invoke compareNamespaceWithFile() instead.");
}
doCompareNamespaces(expectedNamespace, actualNamespace, configuration, txtFile);
}
private static void doCompareNamespaces(
@Nullable NamespaceDescriptor expectedNamespace,
@NotNull NamespaceDescriptor actualNamespace,
@NotNull Configuration configuration,
@Nullable File txtFile
) { ) {
NamespaceComparator comparator = new NamespaceComparator(configuration); NamespaceComparator comparator = new NamespaceComparator(configuration);
String expectedSerialized = comparator.serializeRecursively(expectedNamespace);
String actualSerialized = comparator.serializeRecursively(actualNamespace); String actualSerialized = comparator.serializeRecursively(actualNamespace);
Assert.assertEquals("Expected and actual namespaces differ", expectedSerialized, actualSerialized); if (expectedNamespace != null) {
String expectedSerialized = comparator.serializeRecursively(expectedNamespace);
Assert.assertEquals("Expected and actual namespaces differ", expectedSerialized, actualSerialized);
}
if (txtFile != null) { if (txtFile != null) {
try { try {
@@ -151,7 +175,7 @@ public class NamespaceComparator {
} }
String expected = FileUtil.loadFile(txtFile, true); String expected = FileUtil.loadFile(txtFile, true);
// compare with hardcopy: make sure nothing is lost in output // compare with hard copy: make sure nothing is lost in output
Assert.assertEquals("Expected and actual namespaces differ from " + txtFile.getName(), expected, actualSerialized); Assert.assertEquals("Expected and actual namespaces differ from " + txtFile.getName(), expected, actualSerialized);
} }
catch (IOException e) { catch (IOException e) {