Refactor LineNumberTest

Extract methods, annotate with NotNull, inline base code into test class,
other minor stuff

compiler/testData/lineNumber/base.kt

@@ -1,3 +0,0 @@
-package test
-
-public fun lineNumber(): Int = 0

compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java

@@ -20,6 +20,7 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.*;
 import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.ConfigurationKind;
@@ -29,6 +30,7 @@ import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.parsing.JetParsingTest;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
 import org.jetbrains.jet.utils.ExceptionUtils;
@@ -45,29 +47,36 @@ import java.util.regex.Pattern;
  */
 public class LineNumberTest extends TestCaseWithTmpdir {
 
-    private final String LINE_NUMBER_FUN = "lineNumber";
+    private static final String LINE_NUMBER_FUN = "lineNumber";
-    private final Pattern TEST_LINE_NUMBER_PATTERN = Pattern.compile("^.*test." + LINE_NUMBER_FUN + "\\(\\).*$");
+    private static final Pattern TEST_LINE_NUMBER_PATTERN = Pattern.compile("^.*test." + LINE_NUMBER_FUN + "\\(\\).*$");
 
+    @NotNull
     private String getTestDataPath() {
         return JetParsingTest.getTestDataDir() + "/lineNumber";
     }
 
+    @NotNull
+    private JetCoreEnvironment createEnvironment() {
+        return new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest
+                .compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir));
+    }
+
     @Override
     public void setUp() throws Exception {
         super.setUp();
 
-        JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_ONLY);
+        JetCoreEnvironment environment = createEnvironment();
-        File base = new File(getTestDataPath(), "base.kt");
+        JetFile psiFile = JetPsiFactory.createFile(environment.getProject(),
-        String text = FileUtil.loadFile(base);
+                                                   "package test;\n\npublic fun " + LINE_NUMBER_FUN + "(): Int = 0\n");
 
-        JetFile psiFile = JetTestUtils.createFile(base.getName(), text, jetCoreEnvironment.getProject());
         ClassFileFactory classFileFactory = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile);
         CompileEnvironmentUtil.writeToOutputDirectory(classFileFactory, tmpdir);
     }
 
-    private void doTest(File file) {
+    @NotNull
-        JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest
+    private JetFile createPsiFile(@NotNull String filename) {
-                .compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir));
+        File file = new File(getTestDataPath() + "/" + filename);
+        JetCoreEnvironment environment = createEnvironment();
 
         String text;
         try {
@@ -77,14 +86,22 @@ public class LineNumberTest extends TestCaseWithTmpdir {
             throw ExceptionUtils.rethrow(e);
         }
 
-        JetFile psiFile = JetTestUtils.createFile(file.getName(), text, jetCoreEnvironment.getProject());
+        return JetTestUtils.createFile(file.getName(), text, environment.getProject());
-        assert psiFile != null;
+    }
-
-        List<Integer> expectedLineNumbers = extractSelectedLineNumbers(text);
 
+    private void doTest(@NotNull String filename) {
+        JetFile psiFile = createPsiFile(filename);
         GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile);
-        ClassFileFactory factory = state.getFactory();
 
+        List<Integer> expectedLineNumbers = extractSelectedLineNumbersFromSource(psiFile);
+        List<Integer> actualLineNumbers = extractActualLineNumbersFromBytecode(state);
+
+        assertSameElements(actualLineNumbers, expectedLineNumbers);
+    }
+
+    @NotNull
+    private List<Integer> extractActualLineNumbersFromBytecode(@NotNull GenerationState state) {
+        ClassFileFactory factory = state.getFactory();
         List<Integer> actualLineNumbers = Lists.newArrayList();
         for (String filename : factory.files()) {
             ClassReader cr = new ClassReader(factory.asBytes(filename));
@@ -92,18 +109,21 @@ public class LineNumberTest extends TestCaseWithTmpdir {
                 actualLineNumbers.addAll(readLineNumbers(cr));
             }
             catch (Throwable e) {
-                System.out.println(state.getFactory().createText());
+                System.out.println(factory.createText());
                 throw ExceptionUtils.rethrow(e);
             }
         }
-        assertSameElements(actualLineNumbers, expectedLineNumbers);
+
+        return actualLineNumbers;
     }
 
     private void doTest() {
-        doTest(new File(getTestDataPath() + "/" + getTestName(true) + ".kt"));
+        doTest(getTestName(true) + ".kt");
     }
 
-    private List<Integer> extractSelectedLineNumbers(String fileContent) {
+    @NotNull
+    private List<Integer> extractSelectedLineNumbersFromSource(@NotNull JetFile file) {
+        String fileContent = file.getText();
         List<Integer> lineNumbers = Lists.newArrayList();
         String[] lines = StringUtil.convertLineSeparators(fileContent).split("\n");
 
@@ -117,7 +137,8 @@ public class LineNumberTest extends TestCaseWithTmpdir {
         return lineNumbers;
     }
 
-    private List<Integer> readLineNumbers(ClassReader cr) {
+    @NotNull
+    private List<Integer> readLineNumbers(@NotNull ClassReader cr) {
         final List<Label> labels = Lists.newArrayList();
         final Map<Label, Integer> labels2LineNumbers = Maps.newHashMap();