Simple LR Tests don't need to compare all the packages in the world

compiler/testData/lazyResolve/namespaceComparator/InnerClassNameClash.kt

@@ -1,3 +1,5 @@
+package test
+
 class B {
     class B {
       fun foo(b: B.C) {

compiler/testData/lazyResolve/namespaceComparator/InnerClassNameClash.txt

@@ -1,12 +1,12 @@
-namespace <root>
+namespace test
 
-internal final class B : jet.Any {
+internal final class test.B : jet.Any {
-    public final /*constructor*/ fun <init>(): B
+    public final /*constructor*/ fun <init>(): test.B
-    internal final class B.B : jet.Any {
+    internal final class test.B.B : jet.Any {
-        public final /*constructor*/ fun <init>(): B.B
+        public final /*constructor*/ fun <init>(): test.B.B
-        internal final class B.B.C : jet.Any {
+        internal final fun foo(/*0*/ b: test.B.B.C): jet.Tuple0
-            public final /*constructor*/ fun <init>(): B.B.C
+        internal final class test.B.B.C : jet.Any {
+            public final /*constructor*/ fun <init>(): test.B.B.C
         }
-        internal final fun foo(/*0*/ b: B.B.C): jet.Tuple0
     }
 }

compiler/testData/lazyResolve/namespaceComparator/enum.kt

@@ -1,3 +1,5 @@
+package test
+
 enum class Test(a : Int) {
   A : Test(0)
   B(x : Int) : Test(x)

compiler/testData/lazyResolve/namespaceComparator/enum.txt

@@ -1,10 +1,10 @@
-namespace <root>
+namespace test
 
-internal final enum class Test : jet.Any {
+internal final enum class test.Test : jet.Any {
-    public final /*constructor*/ fun <init>(/*0*/ a: jet.Int): Test
+    public final /*constructor*/ fun <init>(/*0*/ a: jet.Int): test.Test
-    internal final class object Test.<class-object-for-Test> {
+    internal final class object test.Test.<class-object-for-Test> {
-        internal final /*constructor*/ fun <init>(): Test.<class-object-for-Test>
+        internal final /*constructor*/ fun <init>(): test.Test.<class-object-for-Test>
-        internal final val A: Test.<class-object-for-Test>.A
+        internal final val A: test.Test.<class-object-for-Test>.A
-        internal final val C: Test.<class-object-for-Test>.C
+        internal final val C: test.Test.<class-object-for-Test>.C
     }
 }

compiler/testData/lazyResolve/namespaceComparator/genericFunction.kt

@@ -1 +1,3 @@
+package test
+
 fun <T> foo(t : T) : T {}

compiler/testData/lazyResolve/namespaceComparator/genericFunction.txt

@@ -1,3 +1,3 @@
-namespace <root>
+namespace test
 
 internal final fun </*0*/ T : jet.Any?>foo(/*0*/ t: T): T

compiler/testData/lazyResolve/namespaceComparator/innerObject.kt

@@ -1,3 +1,5 @@
+package test
+
 class B {
   object Obj {}
 }

compiler/testData/lazyResolve/namespaceComparator/innerObject.txt

@@ -1,6 +1,6 @@
-namespace <root>
+namespace test
 
-internal final class B : jet.Any {
+internal final class test.B : jet.Any {
-    public final /*constructor*/ fun <init>(): B
+    public final /*constructor*/ fun <init>(): test.B
-    internal final val Obj: B.Obj
+    internal final val Obj: test.B.Obj
 }

compiler/testData/lazyResolve/namespaceComparator/packageLevelObject.kt

@@ -1,4 +1,4 @@
-package foo
+package test
 
 object Bar {
 }

compiler/testData/lazyResolve/namespaceComparator/packageLevelObject.txt

@@ -1,7 +1,3 @@
-namespace <root>
+namespace test
 
-// <namespace name="foo">
+internal final val Bar: test.Bar
-namespace foo
-
-internal final val Bar: foo.Bar
-// </namespace name="foo">

compiler/testData/lazyResolve/namespaceComparator/simpleClass.kt

@@ -1,17 +1,19 @@
 // FILE: a.kt
+package test
+
 class A {}
 
 // FILE: b.kt
-package p; class C {fun f() {}}
+package test.p; class C {fun f() {}}
 
 // FILE: c.kt
-package p; open class G<T> {open fun f(): T {} fun a() {}}
+package test.p; open class G<T> {open fun f(): T {} fun a() {}}
 
 // FILE: d.kt
-package p; class G2<E> : G<E> { fun g() : E {} override fun f() : E {}}
+package test.p; class G2<E> : G<E> { fun g() : E {} override fun f() : E {}}
 
 // FILE: e.kt
-package p; fun foo() {}
+package test.p; fun foo() {}
 
 // FILE: f.kt
-package p; fun foo(a: C) {}
+package test.p; fun foo(a: C) {}

compiler/testData/lazyResolve/namespaceComparator/simpleClass.txt

@@ -1,26 +1,26 @@
-namespace <root>
+namespace test
 
 // <namespace name="p">
 namespace p
 
-internal final class p.C : jet.Any {
+internal final class test.p.C : jet.Any {
-    public final /*constructor*/ fun <init>(): p.C
+    public final /*constructor*/ fun <init>(): test.p.C
     internal final fun f(): jet.Tuple0
 }
-internal open class p.G</*0*/ T : jet.Any?> : jet.Any {
+internal open class test.p.G</*0*/ T : jet.Any?> : jet.Any {
-    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): p.G<T>
+    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): test.p.G<T>
     internal final fun a(): jet.Tuple0
     internal open fun f(): T
 }
-internal final class p.G2</*0*/ E : jet.Any?> : p.G<E> {
+internal final class test.p.G2</*0*/ E : jet.Any?> : test.p.G<E> {
-    public final /*constructor*/ fun </*0*/ E : jet.Any?><init>(): p.G2<E>
+    public final /*constructor*/ fun </*0*/ E : jet.Any?><init>(): test.p.G2<E>
     internal final override /*1*/ fun a(): jet.Tuple0
     internal open override /*1*/ fun f(): E
     internal final fun g(): E
 }
 internal final fun foo(): jet.Tuple0
-internal final fun foo(/*0*/ a: p.C): jet.Tuple0
+internal final fun foo(/*0*/ a: test.p.C): jet.Tuple0
 // </namespace name="p">
-internal final class A : jet.Any {
+internal final class test.A : jet.Any {
-    public final /*constructor*/ fun <init>(): A
+    public final /*constructor*/ fun <init>(): test.A
 }

compiler/testData/lazyResolve/namespaceComparator/varargIterator.kt

@@ -1,3 +1,5 @@
+package test
+
 class CompositeIterator<T>(vararg iterators: java.util.Iterator<T>){
     val iteratorsIter = iterators.iterator()
 }

compiler/testData/lazyResolve/namespaceComparator/varargIterator.txt

@@ -1,6 +1,6 @@
-namespace <root>
+namespace test
 
-internal final class CompositeIterator</*0*/ T : jet.Any?> : jet.Any {
+internal final class test.CompositeIterator</*0*/ T : jet.Any?> : jet.Any {
-    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ vararg iterators: java.util.Iterator<T> /*jet.Array<java.util.Iterator<T>>*/): CompositeIterator<T>
+    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ vararg iterators: java.util.Iterator<T> /*jet.Array<java.util.Iterator<T>>*/): test.CompositeIterator<T>
     internal final val iteratorsIter: jet.Iterator<java.util.Iterator<T>>
 }

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java

@@ -150,7 +150,7 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends KotlinTe
                     new SimpleTestClassModel(new File("compiler/testData/lazyResolve/namespaceComparator"),
                                              true,
                                              extension,
-                                             "doTest")
+                                             "doTestSinglePackage")
             ),
             AbstractLazyResolveNamespaceComparingTest.class
         ).generateAndSave();

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java

@@ -1269,37 +1269,37 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
         
         @TestMetadata("enum.kt")
         public void testEnum() throws Exception {
-            doTest("compiler/testData/lazyResolve/namespaceComparator/enum.kt");
+            doTestSinglePackage("compiler/testData/lazyResolve/namespaceComparator/enum.kt");
         }
         
         @TestMetadata("genericFunction.kt")
         public void testGenericFunction() throws Exception {
-            doTest("compiler/testData/lazyResolve/namespaceComparator/genericFunction.kt");
+            doTestSinglePackage("compiler/testData/lazyResolve/namespaceComparator/genericFunction.kt");
         }
         
         @TestMetadata("InnerClassNameClash.kt")
         public void testInnerClassNameClash() throws Exception {
-            doTest("compiler/testData/lazyResolve/namespaceComparator/InnerClassNameClash.kt");
+            doTestSinglePackage("compiler/testData/lazyResolve/namespaceComparator/InnerClassNameClash.kt");
         }
         
         @TestMetadata("innerObject.kt")
         public void testInnerObject() throws Exception {
-            doTest("compiler/testData/lazyResolve/namespaceComparator/innerObject.kt");
+            doTestSinglePackage("compiler/testData/lazyResolve/namespaceComparator/innerObject.kt");
         }
         
         @TestMetadata("packageLevelObject.kt")
         public void testPackageLevelObject() throws Exception {
-            doTest("compiler/testData/lazyResolve/namespaceComparator/packageLevelObject.kt");
+            doTestSinglePackage("compiler/testData/lazyResolve/namespaceComparator/packageLevelObject.kt");
         }
         
         @TestMetadata("simpleClass.kt")
         public void testSimpleClass() throws Exception {
-            doTest("compiler/testData/lazyResolve/namespaceComparator/simpleClass.kt");
+            doTestSinglePackage("compiler/testData/lazyResolve/namespaceComparator/simpleClass.kt");
         }
         
         @TestMetadata("varargIterator.kt")
         public void testVarargIterator() throws Exception {
-            doTest("compiler/testData/lazyResolve/namespaceComparator/varargIterator.kt");
+            doTestSinglePackage("compiler/testData/lazyResolve/namespaceComparator/varargIterator.kt");
         }
         
     }