From 40b2478d3d7f239d41836981805a6b8f204fb46a Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 11 Jun 2013 14:12:59 +0400 Subject: [PATCH] Validation integrated into NamespaceComparator --- ...actCompileKotlinAgainstCustomJavaTest.java | 6 +-- .../AbstractLoadCompiledKotlinTest.java | 15 +++---- .../jvm/compiler/AbstractLoadJavaTest.java | 6 +-- .../jet/jvm/compiler/LoadDescriptorUtil.java | 3 -- .../jvm/compiler/LoadKotlinCustomTest.java | 9 ++--- .../AbstractLazyResolveDiagnosticsTest.java | 7 ++-- ...ractLazyResolveNamespaceComparingTest.java | 15 +++---- .../lazy/LazyResolveBuiltinClassesTest.java | 8 +--- .../lazy/LazyResolveStdlibLoadingTest.java | 4 +- .../jet/test/util/DescriptorValidator.java | 11 +++-- .../jet/test/util/NamespaceComparator.java | 40 +++++++++++++++++++ 11 files changed, 69 insertions(+), 55 deletions(-) diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractCompileKotlinAgainstCustomJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractCompileKotlinAgainstCustomJavaTest.java index 8a6f8df3a38..47d8acfe310 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractCompileKotlinAgainstCustomJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractCompileKotlinAgainstCustomJavaTest.java @@ -34,7 +34,6 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.test.TestCaseWithTmpdir; -import org.jetbrains.jet.test.util.DescriptorValidator; import org.jetbrains.jet.test.util.NamespaceComparator; import org.junit.Assert; @@ -45,7 +44,7 @@ import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; import java.util.regex.Pattern; -import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaceWithFile; +import static org.jetbrains.jet.test.util.NamespaceComparator.validateAndCompareNamespaceWithFile; public abstract class AbstractCompileKotlinAgainstCustomJavaTest extends TestCaseWithTmpdir { protected void doTest(String ktFilePath) throws Exception { @@ -71,8 +70,7 @@ public abstract class AbstractCompileKotlinAgainstCustomJavaTest extends TestCas NamespaceDescriptor namespaceDescriptor = bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, namespaceFqn); assertNotNull("Failed to find namespace: " + namespaceFqn, namespaceDescriptor); - DescriptorValidator.validate(namespaceDescriptor); - compareNamespaceWithFile(namespaceDescriptor, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, expectedFile); + validateAndCompareNamespaceWithFile(namespaceDescriptor, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, expectedFile); } private JetCoreEnvironment getEnvironment(File ktFile) { diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java index a32f2ad7a0a..ceabcd5a33d 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java @@ -23,14 +23,13 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.test.TestCaseWithTmpdir; -import org.jetbrains.jet.test.util.DescriptorValidator; import org.jetbrains.jet.test.util.NamespaceComparator; import java.io.File; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.TEST_PACKAGE_FQNAME; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalyzeExhaust; -import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces; +import static org.jetbrains.jet.test.util.NamespaceComparator.validateAndCompareNamespaces; /** * Compile Kotlin and then parse model from .class files. @@ -57,15 +56,13 @@ public abstract class AbstractLoadCompiledKotlinTest extends TestCaseWithTmpdir assert namespaceFromSource != null; Assert.assertEquals("test", namespaceFromSource.getName().asString()); - DescriptorValidator.validate(namespaceFromSource); - NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.loadTestNamespaceAndBindingContextFromJavaRoot( tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY).first; - compareNamespaces(namespaceFromSource, namespaceFromClass, - NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT - .checkPrimaryConstructors(true) - .checkPropertyAccessors(includeAccessors), - txtFile); + validateAndCompareNamespaces(namespaceFromSource, namespaceFromClass, + NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT + .checkPrimaryConstructors(true) + .checkPropertyAccessors(includeAccessors), + txtFile); } } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index f4809446297..4f3f51842ad 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java @@ -42,7 +42,6 @@ import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.test.TestCaseWithTmpdir; -import org.jetbrains.jet.test.util.DescriptorValidator; import org.junit.Assert; import java.io.File; @@ -165,7 +164,6 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { LoadDescriptorUtil.TEST_PACKAGE_FQNAME, DescriptorSearchRule.INCLUDE_KOTLIN); assert namespaceDescriptor != null : "Test namespace not found"; - DescriptorValidator.validate(namespaceDescriptor); checkJavaNamespace(expectedFile, namespaceDescriptor, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT); } @@ -205,7 +203,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { checkForLoadErrorsAndCompare(javaNamespace, bindingContext, new Runnable() { @Override public void run() { - compareNamespaces(kotlinNamespace, javaNamespace, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); + validateAndCompareNamespaces(kotlinNamespace, javaNamespace, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); } }); } @@ -219,7 +217,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { checkForLoadErrorsAndCompare(javaNamespace, bindingContext, new Runnable() { @Override public void run() { - compareNamespaceWithFile(javaNamespace, configuration, txtFile); + validateAndCompareNamespaceWithFile(javaNamespace, configuration, txtFile); } }); } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java index cac81dec73a..cc5a56fd4a4 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java @@ -42,7 +42,6 @@ import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.test.util.DescriptorValidator; import java.io.File; import java.io.IOException; @@ -108,7 +107,6 @@ public final class LoadDescriptorUtil { javaDescriptorResolver.resolveNamespace(TEST_PACKAGE_FQNAME, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); assert namespaceDescriptor != null; - DescriptorValidator.validateIgnoringErrorTypes(namespaceDescriptor); return Pair.create(namespaceDescriptor, injector.getBindingTrace().getBindingContext()); } @@ -141,7 +139,6 @@ public final class LoadDescriptorUtil { NamespaceDescriptor namespace = fileAndExhaust.getExhaust().getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, TEST_PACKAGE_FQNAME); assert namespace != null: TEST_PACKAGE_FQNAME + " package not found in " + ktFile.getName(); - DescriptorValidator.validate(namespace); return namespace; } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinCustomTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinCustomTest.java index 7d990d68ca5..54b7a121da3 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinCustomTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinCustomTest.java @@ -22,14 +22,12 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.test.TestCaseWithTmpdir; -import org.jetbrains.jet.test.util.DescriptorValidator; import org.jetbrains.jet.test.util.NamespaceComparator; import java.io.File; 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.compareNamespaceWithFile; +import static org.jetbrains.jet.test.util.NamespaceComparator.*; /* * This test should be implemented via AbstractLoadCompiledKotlinTest. @@ -45,7 +43,7 @@ public final class LoadKotlinCustomTest extends TestCaseWithTmpdir { throws Exception { NamespaceDescriptor namespaceFromClass = compileKotlinAndLoadTestNamespaceDescriptorFromBinary(kotlinFile, tmpdir, myTestRootDisposable, ConfigurationKind.JDK_ONLY); - compareNamespaceWithFile(namespaceFromClass, DONT_INCLUDE_METHODS_OF_OBJECT, expectedFile); + validateAndCompareNamespaceWithFile(namespaceFromClass, DONT_INCLUDE_METHODS_OF_OBJECT, expectedFile); } private void loadDescriptorsFromSourceAndCompareWithTxt(@NotNull File expectedFile, @NotNull File kotlinFile) @@ -54,8 +52,7 @@ public final class LoadKotlinCustomTest extends TestCaseWithTmpdir { NamespaceDescriptor namespaceFromSource = exhaust.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, TEST_PACKAGE_FQNAME); assert namespaceFromSource != null; - DescriptorValidator.validate(namespaceFromSource); - compareNamespaceWithFile(namespaceFromSource, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT.checkPrimaryConstructors(true), + validateAndCompareNamespaceWithFile(namespaceFromSource, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT.checkPrimaryConstructors(true), expectedFile); } 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 6cea9ee3eb0..f0fec8481a2 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java @@ -26,13 +26,13 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.test.util.DescriptorValidator; import java.io.File; import java.util.List; import java.util.Set; -import static org.jetbrains.jet.test.util.NamespaceComparator.*; +import static org.jetbrains.jet.test.util.NamespaceComparator.RECURSIVE; +import static org.jetbrains.jet.test.util.NamespaceComparator.validateAndCompareNamespaces; public abstract class AbstractLazyResolveDiagnosticsTest extends AbstractJetDiagnosticsTest { @@ -47,7 +47,6 @@ public abstract class AbstractLazyResolveDiagnosticsTest extends AbstractJetDiag String path = JetTestUtils.getFilePath(new File(FileUtil.getRelativePath(TEST_DATA_DIR, testDataFile))); NamespaceDescriptor expected = eagerModule.getNamespace(FqName.ROOT); NamespaceDescriptor actual = lazyModule.getNamespace(FqName.ROOT); - DescriptorValidator.validate(expected, actual); String txtFileRelativePath = path.replaceAll("\\.kt$|\\.ktscript", ".txt"); File txtFile = new File("compiler/testData/lazyResolve/diagnostics/" + txtFileRelativePath); @@ -55,7 +54,7 @@ public abstract class AbstractLazyResolveDiagnosticsTest extends AbstractJetDiag // Only recurse into those namespaces mentioned in the files // Otherwise we'll be examining the whole JDK final Set names = LazyResolveTestUtil.getTopLevelPackagesFromFileList(jetFiles); - compareNamespaces( + validateAndCompareNamespaces( expected, actual, RECURSIVE.filterRecursion(new Predicate() { @Override 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 3aee75d6546..1b18c6fcc17 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java @@ -28,7 +28,6 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.test.util.DescriptorValidator; import org.jetbrains.jet.test.util.NamespaceComparator; import org.junit.Assert; @@ -36,6 +35,9 @@ import java.io.File; import java.io.IOException; import java.util.List; +import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.ALLOW_ERROR_TYPES; +import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.FORBID_ERROR_TYPES; + public abstract class AbstractLazyResolveNamespaceComparingTest extends KotlinTestWithEnvironment { @Override @@ -78,15 +80,8 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends KotlinTe File serializeResultsTo = new File(FileUtil.getNameWithoutExtension(testFileName) + ".txt"); - if (allowErrorTypes) { - DescriptorValidator.validateIgnoringErrorTypes(expected, actual); - } - else { - DescriptorValidator.validate(expected, actual); - } - - - NamespaceComparator.compareNamespaces( + NamespaceComparator.validateAndCompareNamespaces( + allowErrorTypes ? ALLOW_ERROR_TYPES : FORBID_ERROR_TYPES, expected, actual, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT.filterRecursion( new Predicate() { @Override diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java index 2ae15fe6753..c28e1a3c742 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java @@ -20,13 +20,11 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.test.util.DescriptorValidator; -import org.junit.Test; import java.io.File; import static org.jetbrains.jet.test.util.NamespaceComparator.RECURSIVE_ALL; -import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaceWithFile; +import static org.jetbrains.jet.test.util.NamespaceComparator.validateAndCompareNamespaceWithFile; public class LazyResolveBuiltinClassesTest extends KotlinTestWithEnvironment { @Override @@ -34,10 +32,8 @@ public class LazyResolveBuiltinClassesTest extends KotlinTestWithEnvironment { return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY); } - @Test public void testBuiltIns() throws Exception { NamespaceDescriptor builtInsPackage = KotlinBuiltIns.getInstance().getBuiltInsPackage(); - DescriptorValidator.validate(builtInsPackage); - compareNamespaceWithFile(builtInsPackage, RECURSIVE_ALL, new File("compiler/testData/builtin-classes.txt")); + validateAndCompareNamespaceWithFile(builtInsPackage, RECURSIVE_ALL, new File("compiler/testData/builtin-classes.txt")); } } 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 f79c704bf2f..189ac4296ea 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java @@ -29,7 +29,6 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.test.util.DescriptorValidator; import org.jetbrains.jet.test.util.NamespaceComparator; import java.io.File; @@ -60,8 +59,7 @@ public class LazyResolveStdlibLoadingTest extends KotlinTestWithEnvironmentManag for (Name name : namespaceShortNames) { NamespaceDescriptor eager = module.getNamespace(FqName.topLevel(name)); NamespaceDescriptor lazy = lazyModule.getNamespace(FqName.topLevel(name)); - DescriptorValidator.validate(eager, lazy); - NamespaceComparator.compareNamespaces(eager, lazy, NamespaceComparator.RECURSIVE, null); + NamespaceComparator.validateAndCompareNamespaces(eager, lazy, NamespaceComparator.RECURSIVE, null); } } diff --git a/compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java b/compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java index ed69a2e33fe..489b2b00ee9 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java +++ b/compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java @@ -32,15 +32,12 @@ import java.util.List; public class DescriptorValidator { - public static final ValidationVisitor FORBID_ERROR_TYPES = new ValidationVisitor(false); - public static final ValidationVisitor ALLOW_ERROR_TYPES = new ValidationVisitor(true); - public static void validate(DeclarationDescriptor... descriptors) { - validate(FORBID_ERROR_TYPES, Arrays.asList(descriptors)); + validate(ValidationVisitor.FORBID_ERROR_TYPES, Arrays.asList(descriptors)); } - public static void validateIgnoringErrorTypes(DeclarationDescriptor... descriptors) { - validate(ALLOW_ERROR_TYPES, Arrays.asList(descriptors)); + public static void validate(@NotNull ValidationVisitor validationStrategy, DeclarationDescriptor... descriptors) { + validate(validationStrategy, Arrays.asList(descriptors)); } public static void validate(@NotNull ValidationVisitor validator, @NotNull Collection descriptors) { @@ -68,6 +65,8 @@ public class DescriptorValidator { } public static class ValidationVisitor implements DeclarationDescriptorVisitor { + public static final ValidationVisitor FORBID_ERROR_TYPES = new ValidationVisitor(false); + public static final ValidationVisitor ALLOW_ERROR_TYPES = new ValidationVisitor(true); private final boolean allowErrorTypes; diff --git a/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java b/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java index d50c518533a..c5acc602a85 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java +++ b/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java @@ -44,6 +44,8 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.FORBID_ERROR_TYPES; + public class NamespaceComparator { public static final Configuration DONT_INCLUDE_METHODS_OF_OBJECT = new Configuration(false, false, false, Predicates.alwaysTrue()); public static final Configuration RECURSIVE = new Configuration(false, false, true, Predicates.alwaysTrue()); @@ -179,6 +181,44 @@ public class NamespaceComparator { doCompareNamespaces(expectedNamespace, actualNamespace, configuration, txtFile); } + public static void validateAndCompareNamespaceWithFile( + @NotNull NamespaceDescriptor actualNamespace, + @NotNull Configuration configuration, + @NotNull File txtFile + ) { + validateAndCompareNamespaceWithFile(FORBID_ERROR_TYPES, actualNamespace, configuration, txtFile); + } + + public static void validateAndCompareNamespaceWithFile( + @NotNull DescriptorValidator.ValidationVisitor validationStrategy, + @NotNull NamespaceDescriptor actualNamespace, + @NotNull Configuration configuration, + @NotNull File txtFile + ) { + DescriptorValidator.validate(validationStrategy, actualNamespace); + compareNamespaceWithFile(actualNamespace, configuration, txtFile); + } + + public static void validateAndCompareNamespaces( + @NotNull NamespaceDescriptor expectedNamespace, + @NotNull NamespaceDescriptor actualNamespace, + @NotNull Configuration configuration, + @Nullable File txtFile + ) { + validateAndCompareNamespaces(FORBID_ERROR_TYPES, expectedNamespace, actualNamespace, configuration, txtFile); + } + + public static void validateAndCompareNamespaces( + @NotNull DescriptorValidator.ValidationVisitor validationStrategy, + @NotNull NamespaceDescriptor expectedNamespace, + @NotNull NamespaceDescriptor actualNamespace, + @NotNull Configuration configuration, + @Nullable File txtFile + ) { + DescriptorValidator.validate(validationStrategy, expectedNamespace, actualNamespace); + compareNamespaces(expectedNamespace, actualNamespace, configuration, txtFile); + } + private static void doCompareNamespaces( @Nullable NamespaceDescriptor expectedNamespace, @NotNull NamespaceDescriptor actualNamespace,