diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java index 57ec7899109..e228818d57b 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java @@ -56,7 +56,7 @@ public abstract class AbstractLazyResolveDiagnosticsTest extends AbstractJetDiag final Set names = LazyResolveTestUtil.getTopLevelPackagesFromFileList(jetFiles); NamespaceComparator.compareNamespaces( expected, actual, - NamespaceComparator.RECURSIVE.filterRecusion(new Predicate() { + NamespaceComparator.RECURSIVE.filterRecursion(new Predicate() { @Override public boolean apply(FqNameUnsafe fqName) { if (fqName.isRoot()) return true; diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java index 9a6b6b148bd..b724b7e4760 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java @@ -72,7 +72,7 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends KotlinTe File serializeResultsTo = new File(FileUtil.getNameWithoutExtension(testFileName) + ".txt"); NamespaceComparator.compareNamespaces(expected, actual, - NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT.filterRecusion( + NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT.filterRecursion( new Predicate() { @Override public boolean apply(FqNameUnsafe fqName) { diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java index 621cf3444dc..8747be2bd6c 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java @@ -61,7 +61,7 @@ public class LazyResolveStdlibLoadingTest extends KotlinTestWithEnvironmentManag for (Name name : namespaceShortNames) { NamespaceDescriptor a = module.getRootNamespace().getMemberScope().getNamespace(name); NamespaceDescriptor b = lazyModule.getRootNamespace().getMemberScope().getNamespace(name); - NamespaceComparator.assertNamespacesEqual(a, b, NamespaceComparator.RECURSIVE); + NamespaceComparator.compareNamespaces(a, b, NamespaceComparator.RECURSIVE, null); } } diff --git a/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java b/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java index cea741d5736..f4cad2923e7 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java +++ b/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java @@ -22,6 +22,7 @@ import com.google.common.collect.Lists; import com.intellij.openapi.util.io.FileUtil; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.jvm.compiler.ExpectedLoadErrorsUtil; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.DescriptorUtils; @@ -44,89 +45,21 @@ import java.util.List; * @author Stepan Koltsov */ public class NamespaceComparator { + public static final Configuration DONT_INCLUDE_METHODS_OF_OBJECT = new Configuration(false, false, Predicates.alwaysTrue()); + public static final Configuration RECURSIVE = new Configuration(false, true, Predicates.alwaysTrue()); + private static final DescriptorRenderer RENDERER = new DescriptorRendererBuilder() .setWithDefinedIn(false) .setExcludedAnnotationClasses(Arrays.asList(new FqName(ExpectedLoadErrorsUtil.ANNOTATION_CLASS_NAME))) .setVerbose(true).build(); - public static void compareNamespaces( - @NotNull NamespaceDescriptor expectedNamespace, - @NotNull NamespaceDescriptor actualNamespace, - @NotNull Configuration configuration, - @NotNull File txtFile - ) { - String serializedFormWithDemarkedNames = assertNamespacesEqual(expectedNamespace, actualNamespace, configuration); - // The serializer puts "!" in front of the name because it allows for speedy sorting of members - // see MemberComparator.normalize() - String serialized = serializedFormWithDemarkedNames.replace("!", ""); - try { - if (!txtFile.exists()) { - FileUtil.writeToFile(txtFile, serialized); - Assert.fail("Expected data file did not exist. Generating: " + txtFile); - } - String expected = FileUtil.loadFile(txtFile, true); - - // compare with hardcopy: make sure nothing is lost in output - Assert.assertEquals(expected, serialized); - } - catch (IOException e) { - throw new RuntimeException(e); - } - } - - public static String assertNamespacesEqual( - NamespaceDescriptor expectedNamespace, - NamespaceDescriptor actualNamespace, - @NotNull Configuration configuration - ) { - NamespaceComparator comparator = new NamespaceComparator(configuration); - String serialized = comparator.doCompareNamespaces(expectedNamespace, actualNamespace); - return serialized; - } - - public static final Configuration DONT_INCLUDE_METHODS_OF_OBJECT = new Configuration(false, false, Predicates.alwaysTrue()); - public static final Configuration RECURSIVE = new Configuration(false, true, Predicates.alwaysTrue()); - - public static class Configuration { - - private final boolean checkPrimaryConstructors; - private final boolean includeObject; - private final Predicate recurseIntoPackage; - - public Configuration( - boolean checkPrimaryConstructors, - boolean includeObject, - Predicate recurseIntoPackage - ) { - this.checkPrimaryConstructors = checkPrimaryConstructors; - this.includeObject = includeObject; - this.recurseIntoPackage = recurseIntoPackage; - } - - public Configuration filterRecusion(@NotNull Predicate recurseIntoPackage) { - return new Configuration(checkPrimaryConstructors, includeObject, recurseIntoPackage); - } - - public Configuration checkPrimaryConstructors(boolean checkPrimaryConstructors) { - return new Configuration(checkPrimaryConstructors, includeObject, recurseIntoPackage); - } - } - private final Configuration conf; private NamespaceComparator(@NotNull Configuration conf) { this.conf = conf; } - private String doCompareNamespaces(@NotNull NamespaceDescriptor expectedNamespace, @NotNull NamespaceDescriptor actualNamespace) { - String expectedSerialized = recursiveSerialize(expectedNamespace); - String actualSerialized = recursiveSerialize(actualNamespace); - - Assert.assertEquals(expectedSerialized, actualSerialized); - return actualSerialized; - } - - private String recursiveSerialize(@NotNull DeclarationDescriptor declarationDescriptor) { + private String serializeRecursively(@NotNull DeclarationDescriptor declarationDescriptor) { StringBuilder result = new StringBuilder(); appendDeclarationRecursively(declarationDescriptor, new Printer(result, 1), true); return result.toString(); @@ -172,7 +105,7 @@ public class NamespaceComparator { Collections.sort(subDescriptors, MemberComparator.INSTANCE); for (DeclarationDescriptor subDescriptor : subDescriptors) { - if (!conf.includeObject) { + if (!conf.includeMethodsOfJavaObject) { // TODO regexp check? oh dear if (subDescriptor.getName().getName().matches("equals|hashCode|finalize|wait|notify(All)?|toString|clone|getClass")) { continue; @@ -192,4 +125,58 @@ public class NamespaceComparator { printer.printlnWithNoIndent(); } } + + public static void compareNamespaces( + @NotNull NamespaceDescriptor expectedNamespace, + @NotNull NamespaceDescriptor actualNamespace, + @NotNull Configuration configuration, + @Nullable File txtFile + ) { + NamespaceComparator comparator = new NamespaceComparator(configuration); + + String expectedSerialized = comparator.serializeRecursively(expectedNamespace); + String actualSerialized = comparator.serializeRecursively(actualNamespace); + + Assert.assertEquals("Expected and actual namespaces differ", expectedSerialized, actualSerialized); + + if (txtFile != null) { + try { + if (!txtFile.exists()) { + FileUtil.writeToFile(txtFile, actualSerialized); + Assert.fail("Expected data file did not exist. Generating: " + txtFile); + } + String expected = FileUtil.loadFile(txtFile, true); + + // compare with hardcopy: make sure nothing is lost in output + Assert.assertEquals("Expected and actual namespaces differ from " + txtFile.getName(), expected, actualSerialized); + } + catch (IOException e) { + throw new RuntimeException(e); + } + } + } + + public static class Configuration { + private final boolean checkPrimaryConstructors; + private final boolean includeMethodsOfJavaObject; + private final Predicate recurseIntoPackage; + + public Configuration( + boolean checkPrimaryConstructors, + boolean includeMethodsOfJavaObject, + Predicate recurseIntoPackage + ) { + this.checkPrimaryConstructors = checkPrimaryConstructors; + this.includeMethodsOfJavaObject = includeMethodsOfJavaObject; + this.recurseIntoPackage = recurseIntoPackage; + } + + public Configuration filterRecursion(@NotNull Predicate recurseIntoPackage) { + return new Configuration(checkPrimaryConstructors, includeMethodsOfJavaObject, recurseIntoPackage); + } + + public Configuration checkPrimaryConstructors(boolean checkPrimaryConstructors) { + return new Configuration(checkPrimaryConstructors, includeMethodsOfJavaObject, recurseIntoPackage); + } + } }