SDEDebugger.java

/*
 * Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package nsk.share.jdi.sde;

import java.io.*;
import java.nio.channels.FileChannel;
import java.util.*;
import com.sun.jdi.*;
import com.sun.jdi.event.BreakpointEvent;
import com.sun.jdi.event.Event;
import com.sun.jdi.event.StepEvent;
import nsk.share.ClassFileFinder;
import nsk.share.TestBug;
import nsk.share.jdi.EventHandler;
import nsk.share.jdi.TestDebuggerType2;

/*
 * Class is used as base debugger for SDE tests.
 *
 * This class contains several methods called 'prepareDefaultPatchedClassFile_TypeXXX' which create
 * class file with added SourceDebugExtension attribute and return debug information about created file.
 * (this methods was moved in SDEDebugger class if similar generated class files were used in 2 or more tests)
 *
 *
 */
public class SDEDebugger extends TestDebuggerType2 {
    protected static final int INIT_LINE = 32;    // n.s.j.sde.TestClass1::<init>
    protected static final int METHOD1_LINE = 43; // n.s.j.sde.TestClass1::sde_testMethod1
    protected static final int METHOD2_LINE = 54; // n.s.j.sde.TestClass1::sde_testMethod2
    public static String javaStratumName = "Java";

    // Set debug data for "Java" stratum for TestClass1
    public static List<DebugLocation> javaStratumLocations_TestClass1 = new ArrayList<DebugLocation>();

    public static String javaSourceName_TestClass1 = "TestClass1.java";

    public static String javaSourcePath_TestClass1 = "nsk" + File.separator + "share" + File.separator + "jdi"
            + File.separator + "sde" + File.separator + "TestClass1.java";

    static {
        for (int i = 0; i < 8; i++) {
            javaStratumLocations_TestClass1.add(new DebugLocation(javaSourceName_TestClass1, javaSourcePath_TestClass1,
                    "<init>", INIT_LINE + i, INIT_LINE + i));
            javaStratumLocations_TestClass1.add(new DebugLocation(javaSourceName_TestClass1, javaSourcePath_TestClass1,
                    "sde_testMethod1", METHOD1_LINE + i, METHOD1_LINE + i));
            javaStratumLocations_TestClass1.add(new DebugLocation(javaSourceName_TestClass1, javaSourcePath_TestClass1,
                    "sde_testMethod2", METHOD2_LINE + i, METHOD2_LINE + i));
        }
    }

    // insert debug information about "Java" stratum in the given Map<String,
    // LocationsData>
    static protected void addJavaLocations(Map<String, LocationsData> testStratumData, boolean setJavaStratumDefault) {
        LocationsData locationsData = new LocationsData(javaStratumName);

        if (setJavaStratumDefault)
            locationsData.isDefault = true;

        locationsData.paths.add(javaSourcePath_TestClass1);
        locationsData.allLocations.addAll(javaStratumLocations_TestClass1);
        locationsData.sourceLocations.put(javaSourceName_TestClass1, javaStratumLocations_TestClass1);

        testStratumData.put(javaStratumName, locationsData);

    }

    // common base names for test stratum, stratum source name and stratum
    // source path
    public static final String testStratumName = "TestStratum";

    public static final String testStratumSourceName = "testSource";

    public static final String testStratumSourcePath = "testSourcePath";

    // Event listener thread which saves all received StepEvents
    public class StepEventListener extends EventHandler.EventListener {
        // is BreakpointEvent was received (debuggee should stop at breakpoint
        // after StepEvents generation)
        private volatile boolean breakpointEventReceived;

        private List<Location> stepLocations = new ArrayList<Location>();

        public List<Location> stepLocations() {
            return stepLocations;
        }

        public void clearLocations() {
            stepLocations.clear();
        }

        public boolean eventReceived(Event event) {
            if (event instanceof StepEvent) {
                StepEvent stepEvent = (StepEvent) event;

                stepLocations.add(stepEvent.location());

                vm.resume();

                return true;
            }
            // debuggee should stop after event generation
            else if (event instanceof BreakpointEvent) {
                breakpointEventReceived = true;
                vm.resume();

                return true;
            }

            return false;
        }

        public void waitBreakpointEvent() {
            while (!breakpointEventReceived)
                Thread.yield();
        }
    }

    // debug information about location (implements Comparable to make possible
    // using DebugLocation with java.util.Set)
    public static class DebugLocation implements Comparable<DebugLocation> {
        public DebugLocation(String sourceName, String sourcePath, String methodName, int inputLine, int outputLine) {
            this.sourceName = sourceName;
            this.sourcePath = sourcePath;
            this.inputLine = inputLine;
            this.outputLine = outputLine;
            this.methodName = methodName;
        }

        public String sourceName;

        public String sourcePath;

        public String methodName;

        public int inputLine;

        public int outputLine;

        public String toString() {
            return "Line number: " + inputLine + " SourceName: " + sourceName + " SourcePath: " + sourcePath;
        }

        // compare DebugLocation with com.sun.jdi.Location
        public boolean compare(Location location, String stratum) {
            try {
                if (stratum == null) {
                    return (location.lineNumber() == inputLine) && location.sourceName().equals(sourceName)
                            && location.sourcePath().equals(sourcePath);
                } else {
                    return (location.lineNumber(stratum) == inputLine)
                            && location.sourceName(stratum).equals(sourceName)
                            && location.sourcePath(stratum).equals(sourcePath);
                }
            } catch (AbsentInformationException e) {
                return false;
            }
        }

        // used to find locations for given line
        public boolean isConform(String sourceName, int lineNumber) {
            boolean sourceConform = (sourceName == null ? true : this.sourceName.equals(sourceName));

            return sourceConform && (this.inputLine == lineNumber);
        }

        // implements this method to make possible using DebugLocation with java.util.Set
        public int compareTo(DebugLocation location) {
            return (this.sourceName.equals(location.sourceName) && this.inputLine == location.inputLine) ? 0 : 1;
        }
    }

    // Class contains debug information about sources, paths, locations
    // available for class
    public static class LocationsData {
        public LocationsData(String stratumName) {
            this.stratumName = stratumName;
        }

        public List<String> sourceNames() {
            List<String> sourceNames = new ArrayList<String>();
            sourceNames.addAll(sourceLocations.keySet());

            return sourceNames;
        }

        public String stratumName;

        // is stratum default for ReferenceType
        public boolean isDefault;

        // locations for source files
        public Map<String, List<DebugLocation>> sourceLocations = new TreeMap<String, List<DebugLocation>>();

        // all locations for stratum
        public List<DebugLocation> allLocations = new ArrayList<DebugLocation>();

        // all paths for stratum
        public List<String> paths = new ArrayList<String>();
    }

    static protected String locationToString(Location location, String stratum) {
        String result;

        result = "Line number: " + (stratum == null ? location.lineNumber() : location.lineNumber(stratum));

        try {
            result += (" Source name: " + (stratum == null ? location.sourceName() : location.sourceName(stratum)));
        } catch (AbsentInformationException e) {
            result += (" Source name: " + " INFORMATION IS ABSENT");
        }

        try {
            result += (" Source path: " + (stratum == null ? location.sourcePath() : location.sourcePath(stratum)));
        } catch (AbsentInformationException e) {
            result += (" Source path: " + " INFORMATION IS ABSENT");
        }

        return result;
    }

    // seach class file for given class and create copy of this class file in
    // 'testWorkDir' directory
    protected File createLocalClassfileCopy(String className) throws IOException {
        int index = className.lastIndexOf(".");

        String path;

        if (index < 0)
            path = "";
        else
            path = className.substring(0, index).replace(".", "/");

        File dirs = new File(testWorkDir + "/" + path);
        dirs.mkdirs();

        File oldFile = null;
        {
            java.nio.file.Path tmp = ClassFileFinder.findClassFile(className, classpath);
            oldFile = tmp == null ? null : tmp.toFile();
        }
        File newFile = copyFile(oldFile,
                testWorkDir + "/" + className.replace(".", "/") + ".class");

        return newFile;
    }

    // create class file with multiple strata
    protected void savePathcedClassFile(String className, SmapGenerator smapGenerator, String smapFileName) {
        File patchedClassFile = null;

        try {
            patchedClassFile = createLocalClassfileCopy(className);
        } catch (IOException e) {
            e.printStackTrace(log.getOutStream());
            throw new TestBug("Unexpected IO exception: " + e);
        }

        smapFileName = testWorkDir + "/" + smapFileName;
        smapGenerator.setOutputFileName(smapFileName);

        File smapFile = null;

        try {
            smapFile = smapGenerator.saveToFile(smapFileName);
        } catch (IOException e) {
            e.printStackTrace(log.getOutStream());
            throw new TestBug("Unexpected IO exception: " + e);
        }

        log.display("Add for class " + className + " following SDE: ");
        log.display(smapGenerator.getString());

        try {
            InstallSDE.install(patchedClassFile, smapFile, false);
        } catch (IOException e) {
            e.printStackTrace(log.getOutStream());
            throw new TestBug("Unexpected IO exception: " + e);
        }
    }

    // common for SDE tests debuggee name
    protected String debuggeeClassName() {
        if (classpath == null) {
            throw new TestBug("Debugger requires 'testClassPath' parameter");
        }

        return SDEDebuggee.class.getName() + " -testClassPath " + testWorkDir;
    }

    // parses common for all SDE - tests parameters
    protected String[] doInit(String args[], PrintStream out) {
        args = super.doInit(args, out);

        if (classpath == null) {
            throw new TestBug("Debugger requires 'testClassPath' parameter");
        }
        if (testWorkDir == null) {
            throw new TestBug("Debugger requires 'testWorkDir' parameter");
        }

        return args;
    }

    // single input line is mapped to the single output line, test stratum has
    // single source
    protected Map<String, LocationsData> prepareDefaultPatchedClassFile_Type1(String className, int testStratumCount,
            boolean setJavaStratumDefault) {
        /*
         * "Java" "TestStratum"
         *
         * <init>
         * 32 --> 1000, source1
         * 33 --> 1001, source1
         * ...
         * ...
         * 39 --> 1007, source1
         *
         * sde_testMethod1
         *
         * 43 --> 1100, source1
         * 44 --> 1101, source1
         * ...
         * ...
         * 50 --> 1107, source1
         *
         * sde_testMethod1
         * 54 --> 1200, source1
         * 55 --> 1201, source1
         * ...
         * ...
         * 61 --> 1207, source1
         */

        Map<String, LocationsData> testStratumData = new TreeMap<String, LocationsData>();

        String smapFileName = "TestSMAP.smap";
        SmapGenerator smapGenerator = new SmapGenerator();

        for (int i = 0; i < testStratumCount; i++) {
            String stratumName = testStratumName + (i + 1);

            LocationsData locationsData = new LocationsData(stratumName);

            String sourceName = testStratumSourceName + (i + 1);
            String sourcePath = testStratumSourcePath + (i + 1);

            locationsData.paths.add(sourcePath);

            SmapStratum smapStratum = new SmapStratum(stratumName);

            List<DebugLocation> sourceLocations = new ArrayList<DebugLocation>();

            int baseLineNumber = 1000 * (i + 1);

            for (int j = 0; j < 8; j++) {
                sourceLocations.add(new DebugLocation(sourceName, sourcePath,
                        "<init>", baseLineNumber + j, INIT_LINE + j));
                sourceLocations.add(new DebugLocation(sourceName, sourcePath,
                        "sde_testMethod1", baseLineNumber + 100 + j, METHOD1_LINE + j));
                sourceLocations.add(new DebugLocation(sourceName, sourcePath,
                        "sde_testMethod2", baseLineNumber + 200 + j, METHOD2_LINE + j));
            }

            locationsData.sourceLocations.put(sourceName, sourceLocations);
            locationsData.allLocations.addAll(sourceLocations);

            testStratumData.put(stratumName, locationsData);

            smapStratum.addFile(sourceName, sourcePath);

            for (DebugLocation debugLocation : sourceLocations) {
                smapStratum.addLineData(debugLocation.inputLine, sourceName, 1, debugLocation.outputLine, 1);
            }

            // if setJavaStratumDefault == false do first test stratum default
            if (!(setJavaStratumDefault) && (i == 0)) {
                locationsData.isDefault = true;
                smapGenerator.addStratum(smapStratum, true);
            } else
                smapGenerator.addStratum(smapStratum, false);
        }

        savePathcedClassFile(className, smapGenerator, smapFileName);

        addJavaLocations(testStratumData, setJavaStratumDefault);

        return testStratumData;
    }

    // single input line is mapped to the single output line, test stratum has 3
    // sources
    protected Map<String, LocationsData> prepareDefaultPatchedClassFile_Type2(String className, int testStratumCount) {
        /*
         * "Java" "TestStratum"
         *
         * <init>
         * 32 --> 1000, source1, path1
         * 33 --> 1001, source2, path2
         * 34 --> 1002, source3, path3
         * ...
         * ...
         *
         * sde_testMethod1
         * 43 --> 1100, source1, path1
         * 44 --> 1101, source2, path2
         * 45 --> 1102, source3, path3
         * ...
         * ...
         *
         * sde_testMethod2
         * 54 --> 1200, source1, path1
         * 55 --> 1201, source2, path2
         * 56 --> 1207, source3, path3
         * ...
         * ...
         */

        Map<String, LocationsData> testStratumData = new TreeMap<String, LocationsData>();

        String smapFileName = "TestSMAP.smap";
        SmapGenerator smapGenerator = new SmapGenerator();

        for (int i = 0; i < testStratumCount; i++) {
            String stratumName = testStratumName + (i + 1);
            SmapStratum smapStratum = new SmapStratum(stratumName);

            LocationsData locationsData = new LocationsData(stratumName);

            String sourceName1 = testStratumSourceName + (i + 1) + "_1";
            String sourcePath1 = testStratumSourcePath + (i + 1) + "_1";
            locationsData.paths.add(sourcePath1);
            smapStratum.addFile(sourceName1, sourcePath1);

            String sourceName2 = testStratumSourceName + (i + 1) + "_2";
            String sourcePath2 = testStratumSourcePath + (i + 1) + "_2";
            locationsData.paths.add(sourcePath2);
            smapStratum.addFile(sourceName2, sourcePath2);

            String sourceName3 = testStratumSourceName + (i + 1) + "_3";
            String sourcePath3 = testStratumSourcePath + (i + 1) + "_3";
            locationsData.paths.add(sourcePath3);
            smapStratum.addFile(sourceName3, sourcePath3);

            List<DebugLocation> source1Locations = new ArrayList<DebugLocation>();
            List<DebugLocation> source2Locations = new ArrayList<DebugLocation>();
            List<DebugLocation> source3Locations = new ArrayList<DebugLocation>();

            for (int j = 0; j < 8; j++) {
                if (j % 3 == 0) {
                    source1Locations.add(new DebugLocation(sourceName1, sourcePath1,
                            "<init>", 1000 + j, INIT_LINE + j));
                    source1Locations.add(new DebugLocation(sourceName1, sourcePath1,
                            "sde_testMethod1", 1101 + j, METHOD1_LINE + j));
                    source1Locations.add(new DebugLocation(sourceName1, sourcePath1,
                            "sde_testMethod2", 1201 + j, METHOD2_LINE + j));
                } else if (j % 3 == 1) {
                    source2Locations.add(new DebugLocation(sourceName2, sourcePath2,
                            "<init>", 1000 + j, INIT_LINE + j));
                    source2Locations.add(new DebugLocation(sourceName2, sourcePath2,
                            "sde_testMethod1", 1101 + j, METHOD1_LINE + j));
                    source2Locations.add(new DebugLocation(sourceName2, sourcePath2,
                            "sde_testMethod2", 1201 + j, METHOD2_LINE + j));
                } else {
                    source3Locations.add(new DebugLocation(sourceName3, sourcePath3,
                            "<init>", 1000 + j, INIT_LINE + j));
                    source3Locations.add(new DebugLocation(sourceName3, sourcePath3,
                            "sde_testMethod1", 1101 + j, METHOD1_LINE + j));
                    source3Locations.add(new DebugLocation(sourceName3, sourcePath3,
                            "sde_testMethod2", 1201 + j, METHOD2_LINE + j));
                }
            }

            locationsData.sourceLocations.put(sourceName1, source1Locations);
            locationsData.sourceLocations.put(sourceName2, source2Locations);
            locationsData.sourceLocations.put(sourceName3, source3Locations);

            locationsData.allLocations.addAll(source1Locations);
            locationsData.allLocations.addAll(source2Locations);
            locationsData.allLocations.addAll(source3Locations);

            for (DebugLocation debugLocation : locationsData.allLocations) {
                smapStratum.addLineData(
                        debugLocation.inputLine,
                        debugLocation.sourceName,
                        1,
                        debugLocation.outputLine,
                        1);
            }

            smapGenerator.addStratum(smapStratum, false);

            testStratumData.put(stratumName, locationsData);
        }

        savePathcedClassFile(className, smapGenerator, smapFileName);

        addJavaLocations(testStratumData, true);

        return testStratumData;
    }

    // single input line is mapped to two output lines
    protected Map<String, LocationsData> prepareDefaultPatchedClassFile_Type3(String className, int testStratumCount,
            boolean setJavaStratumDefault) {
        /*
         * "Java" "TestStratum"
         *
         * <init>
         * 32 --> 1001, source1
         * 34 --> 1002, source1
         * 36 --> 1003, source1
         * 38 --> 1004, source1
         *
         * sde_testMethod1
         * 43 --> 1101, source1
         * 45 --> 1102, source1
         * 47 --> 1103, source1
         * 49 --> 1104, source1
         *
         * sde_testMethod2
         * 54 --> 1201, source1
         * 56 --> 1202, source1
         * 58 --> 1203, source1
         * 60 --> 1204, source1
         */

        Map<String, LocationsData> testStratumData = new TreeMap<String, LocationsData>();

        String smapFileName = "TestSMAP.smap";
        SmapGenerator smapGenerator = new SmapGenerator();

        for (int i = 0; i < testStratumCount; i++) {
            String stratumName = testStratumName + (i + 1);
            LocationsData locationsData = new LocationsData(stratumName);

            String sourceName = testStratumSourceName + (i + 1);
            String sourcePath = testStratumSourcePath + (i + 1);
            locationsData.paths.add(sourcePath);

            SmapStratum smapStratum = new SmapStratum(stratumName);

            List<DebugLocation> sourceLocations = new ArrayList<DebugLocation>();

            int baseLineNumber = 1000 * (i + 1);

            for (int j = 0; j < 4; j++) {
                sourceLocations.add(new DebugLocation(sourceName, sourcePath,
                        "<init>", baseLineNumber + j, INIT_LINE + j * 2));
                sourceLocations.add(new DebugLocation(sourceName, sourcePath,
                        "sde_testMethod1", baseLineNumber + 100 + j, METHOD1_LINE + j * 2));
                sourceLocations.add(new DebugLocation(sourceName, sourcePath,
                        "sde_testMethod2", baseLineNumber + 200 + j, METHOD2_LINE + j * 2));
            }

            locationsData.allLocations.addAll(sourceLocations);
            locationsData.sourceLocations.put(sourceName, sourceLocations);

            testStratumData.put(stratumName, locationsData);

            smapStratum.addFile(sourceName, sourcePath);

            for (DebugLocation debugLocation : locationsData.allLocations) {
                smapStratum.addLineData(debugLocation.inputLine, sourceName, 1, debugLocation.outputLine, 1);
            }

            // if setJavaStratumDefault == false do first stratum default
            if (!setJavaStratumDefault && (i == 0)) {
                locationsData.isDefault = true;
                smapGenerator.addStratum(smapStratum, true);
            } else
                smapGenerator.addStratum(smapStratum, false);
        }

        savePathcedClassFile(className, smapGenerator, smapFileName);

        addJavaLocations(testStratumData, setJavaStratumDefault);

        return testStratumData;
    }

    // 3 different test stratums define disjoint locations sets
    protected Map<String, LocationsData> prepareDefaultPatchedClassFile_Type4(String className) {
        /*
         * "Java" "TestStratum1" "TestStratum2" "TestStratum3"
         *
         * <init>
         * 32 --> 1000
         * ...
         * ...
         * 39 --> 1007
         *
         * sde_testMethod1
         * 43 --> 1100
         * ...
         * ...
         * 50 --> 1107
         *
         * sde_testMethod2
         * 54 --> 1200
         * ...
         * ...
         * 61 --> 1207
         */
        Map<String, LocationsData> testStratumData = new TreeMap<String, LocationsData>();

        String smapFileName = "TestSMAP.smap";

        SmapGenerator smapGenerator = new SmapGenerator();

        String stratumName = testStratumName + "1";
        LocationsData locationsData = new LocationsData(stratumName);
        List<DebugLocation> sourceLocations = new ArrayList<DebugLocation>();
        String methodName = "<init>";
        for (int i = 0; i < 8; i++) {
            sourceLocations.add(new DebugLocation(
                    testStratumSourceName, testStratumSourcePath, methodName,
                    1000 + i, INIT_LINE + i));
        }
        locationsData.allLocations.addAll(sourceLocations);
        locationsData.sourceLocations.put(testStratumSourceName, sourceLocations);
        testStratumData.put(stratumName, locationsData);

        stratumName = testStratumName + "2";
        locationsData = new LocationsData(stratumName);
        sourceLocations = new ArrayList<DebugLocation>();
        methodName = "sde_testMethod1";
        for (int i = 0; i < 8; i++) {
            sourceLocations.add(new DebugLocation(
                    testStratumSourceName, testStratumSourcePath, methodName,
                    1100 + i, METHOD1_LINE + i));
        }
        locationsData.allLocations.addAll(sourceLocations);
        locationsData.sourceLocations.put(testStratumSourceName, sourceLocations);
        testStratumData.put(stratumName, locationsData);

        stratumName = testStratumName + "3";
        locationsData = new LocationsData(stratumName);
        sourceLocations = new ArrayList<DebugLocation>();
        methodName = "sde_testMethod2";
        for (int i = 0; i < 8; i++) {
            sourceLocations.add(new DebugLocation(testStratumSourceName, testStratumSourcePath,
                    methodName, 1200 + i, METHOD2_LINE + i));
        }
        locationsData.allLocations.addAll(sourceLocations);
        locationsData.sourceLocations.put(testStratumSourceName, sourceLocations);
        testStratumData.put(stratumName, locationsData);

        for (String stratum : testStratumData.keySet()) {
            SmapStratum smapStratum = new SmapStratum(stratum);
            smapStratum.addFile(testStratumSourceName, testStratumSourcePath);

            for (DebugLocation debugLocation : testStratumData.get(stratum).allLocations)
                smapStratum.addLineData(
                        debugLocation.inputLine,
                        debugLocation.sourceName,
                        1,
                        debugLocation.outputLine,
                        1);

            smapGenerator.addStratum(smapStratum, false);
        }

        savePathcedClassFile(className, smapGenerator, smapFileName);

        return testStratumData;
    }

    // single input line is mapped to the single output line, test stratum has 3
    // sources,
    // lines in each method has same numbers, each method has locations in 3
    // sources
    protected Map<String, LocationsData> prepareDefaultPatchedClassFile_Type5(String className, int testStratumCount) {
        /*
         * "Java" "TestStratum"
         *
         * <init>
         * 32 --> 1000, source1, path1
         * 33 --> 1000, source2, path2
         * 34 --> 1000, source3, path3
         * ...
         * ...
         *
         * sde_testMethod1
         * 43 --> 1100, source1, path1
         * 44 --> 1100, source2, path2
         * 45 --> 1100, source3, path3
         * ...
         * ...
         *
         * sde_testMethod2
         * 54 --> 1200, source1, path1
         * 55 --> 1200, source2, path2
         * 56 --> 1200, source3, path3
         * ...
         * ...
         */

        Map<String, LocationsData> testStratumData = new TreeMap<String, LocationsData>();

        String smapFileName = "TestSMAP.smap";
        SmapGenerator smapGenerator = new SmapGenerator();

        for (int i = 0; i < testStratumCount; i++) {
            String stratumName = testStratumName + (i + 1);
            SmapStratum smapStratum = new SmapStratum(stratumName);

            LocationsData locationsData = new LocationsData(stratumName);

            String sourceName1 = testStratumSourceName + (i + 1) + "_1";
            String sourcePath1 = testStratumSourcePath + (i + 1) + "_1";
            locationsData.paths.add(sourcePath1);
            smapStratum.addFile(sourceName1, sourcePath1);

            String sourceName2 = testStratumSourceName + (i + 1) + "_2";
            String sourcePath2 = testStratumSourcePath + (i + 1) + "_2";
            locationsData.paths.add(sourcePath2);
            smapStratum.addFile(sourceName2, sourcePath2);

            String sourceName3 = testStratumSourceName + (i + 1) + "_3";
            String sourcePath3 = testStratumSourcePath + (i + 1) + "_3";
            locationsData.paths.add(sourcePath3);
            smapStratum.addFile(sourceName3, sourcePath3);

            List<DebugLocation> source1Locations = new ArrayList<DebugLocation>();
            List<DebugLocation> source2Locations = new ArrayList<DebugLocation>();
            List<DebugLocation> source3Locations = new ArrayList<DebugLocation>();

            for (int j = 0; j < 8; j++) {
                if (j % 3 == 0) {
                    source1Locations.add(new DebugLocation(sourceName1, sourcePath1,
                            "<init>", 1000, INIT_LINE + j));
                    source1Locations.add(new DebugLocation(sourceName1, sourcePath1,
                            "sde_testMethod1", 1100, METHOD1_LINE + j));
                    source1Locations.add(new DebugLocation(sourceName1, sourcePath1,
                            "sde_testMethod2", 1200, METHOD2_LINE + j));
                } else if (j % 3 == 1) {
                    source2Locations.add(new DebugLocation(sourceName2, sourcePath2,
                            "<init>", 1000, INIT_LINE + j));
                    source2Locations.add(new DebugLocation(sourceName2, sourcePath2,
                            "sde_testMethod1", 1100, METHOD1_LINE + j));
                    source2Locations.add(new DebugLocation(sourceName2, sourcePath2,
                            "sde_testMethod2", 1200, METHOD2_LINE + j));
                } else {
                    source3Locations.add(new DebugLocation(sourceName3, sourcePath3,
                            "<init>", 1000, INIT_LINE + j));
                    source3Locations.add(new DebugLocation(sourceName3, sourcePath3,
                            "sde_testMethod1", 1100, METHOD1_LINE + j));
                    source3Locations.add(new DebugLocation(sourceName3, sourcePath3,
                            "sde_testMethod2", 1200, METHOD2_LINE + j));
                }
            }

            locationsData.sourceLocations.put(sourceName1, source1Locations);
            locationsData.sourceLocations.put(sourceName2, source2Locations);
            locationsData.sourceLocations.put(sourceName3, source3Locations);

            locationsData.allLocations.addAll(source1Locations);
            locationsData.allLocations.addAll(source2Locations);
            locationsData.allLocations.addAll(source3Locations);

            for (DebugLocation debugLocation : locationsData.allLocations) {
                smapStratum.addLineData(
                        debugLocation.inputLine,
                        debugLocation.sourceName,
                        1,
                        debugLocation.outputLine,
                        1);
            }

            smapGenerator.addStratum(smapStratum, false);

            testStratumData.put(stratumName, locationsData);
        }

        savePathcedClassFile(className, smapGenerator, smapFileName);

        return testStratumData;
    }

    public static File copyFile(File srcFile, String newFileName) throws IOException {
        FileChannel inChannel = new FileInputStream(srcFile).getChannel();

        File newFile = new File(newFileName);
        newFile.createNewFile();
        FileChannel outChannel = new FileOutputStream(newFile).getChannel();

        outChannel.transferFrom(inChannel, 0, inChannel.size());

        outChannel.close();
        inChannel.close();

        return newFile;
    }

    // find all locations of method with given name
    // (used to check result of 'Method.allLineLocations()')
    static protected List<DebugLocation> locationsOfMethod(List<DebugLocation> debugLocations, String methodName) {
        List<DebugLocation> result = new ArrayList<DebugLocation>();

        for (DebugLocation debugLocation : debugLocations) {
            if (debugLocation.methodName.equals(methodName))
                result.add(debugLocation);
        }

        return result;
    }

    // find all locations for given line and source name
    // (used to check result of 'Method.locationsOfLine()' and
    // 'ReferenceType.locationsOfLine()')
    static protected List<DebugLocation> locationsOfLine(List<DebugLocation> debugLocations, String sourceName,
            int lineNumber) {
        List<DebugLocation> result = new ArrayList<DebugLocation>();

        for (DebugLocation debugLocation : debugLocations) {
            if (debugLocation.isConform(sourceName, lineNumber))
                result.add(debugLocation);
        }

        return result;
    }

    // find locations unique by line number and source name
    // (used in 'check_ReferenceType_locationsOfLine' and
    // 'check_Method_locationsOfLine' to find all line numbers available for
    // ReferenceType or Method)
    static protected Set<DebugLocation> allUniqueLocations(List<DebugLocation> debugLocations) {
        Set<DebugLocation> result = new TreeSet<DebugLocation>();

        for (DebugLocation debugLocation : debugLocations) {
            if (!result.contains(debugLocation)) {
                result.add(debugLocation);
            }
        }

        return result;
    }

    // check is list of Locations contains only expected locations
    protected void compareLocations(List<Location> locations, List<DebugLocation> expectedLocations, String stratum) {
        boolean success = true;

        List<Location> tempLocations = new LinkedList<Location>(locations);

        List<DebugLocation> tempExpectedLocations = new LinkedList<DebugLocation>(expectedLocations);

        for(Iterator<Location> locationsIterator = tempLocations.iterator(); locationsIterator.hasNext();) {
            boolean isExpected = false;
            Location location = locationsIterator.next();

            for(Iterator<DebugLocation> expectedLocationsIterator = tempExpectedLocations.iterator(); expectedLocationsIterator.hasNext();) {
                DebugLocation expectedLocation = expectedLocationsIterator.next();
                if (expectedLocation.compare(location, stratum)) {
                    isExpected = true;
                    locationsIterator.remove();
                    expectedLocationsIterator.remove();
                    break;
                }
            }
            if (!isExpected) {
                success = false;
                log.complain("Location " + location + " were not found in expected locations");
            }
        }

        if (tempLocations.size() != 0) {
            success = false;
            setSuccess(false);
            log.complain("Not all locations were found in expected");
        }

        if (tempExpectedLocations.size() != 0) {
            success = false;
            setSuccess(false);
            log.complain("Following expected locations were not found in received");
            for (DebugLocation expectedLocation : tempExpectedLocations) {
                log.complain(expectedLocation.toString());
            }
        }

        if (!success) {
            setSuccess(false);
            log.complain("Expected and actual locations differ");

            log.complain("Actual locations: ");
            for (Location location : locations) {
                log.complain(locationToString(location, stratum));
            }

            log.complain("Expected locations: ");
            for (DebugLocation expectedLocation : expectedLocations) {
                log.complain(expectedLocation.toString());
            }
        }
    }

    // test all SDE related methods of ReferenceType
    protected void checkReferenceType(String stratum, ReferenceType referenceType, List<String> expectedSourceNames,
            List<String> expectedSourcePaths, List<DebugLocation> expectedLocations) {
        log.display("Check sourceNames");
        check_ReferenceType_sourceNames(referenceType, stratum, expectedSourceNames);
        log.display("Check sourcePaths");
        check_ReferenceType_sourcePaths(referenceType, stratum, expectedSourcePaths);
        log.display("Check allLocations");
        check_ReferenceType_allLineLocations(referenceType, stratum, expectedLocations);
        log.display("Check locationsOfLine");
        check_ReferenceType_locationsOfLine(referenceType, stratum, false, expectedLocations);

        for (Method method : referenceType.methods()) {
            List<DebugLocation> expectedLocationsOfMethod = locationsOfMethod(expectedLocations, method.name());

            log.display("Check allLineLocations for method '" + method.name() + "'");
            check_Method_allLineLocations(method, stratum, expectedLocationsOfMethod);
            log.display("Check locationsOfLine for method '" + method.name() + "'");
            check_Method_locationsOfLine(method, stratum, false, expectedLocationsOfMethod);
        }
    }

    // check is 'ReferenceType.sourceNames' returns only expected sources
    protected void check_ReferenceType_sourceNames(ReferenceType referenceType, String stratum,
            List<String> expectedSourceNames) {
        try {
            if (stratum == null) {
                String sourceName = referenceType.sourceName();
                String expectedSourceName = expectedSourceNames.get(0);

                if (!sourceName.equals(expectedSourceName)) {
                    setSuccess(false);
                    log.complain("Unexpected result of ReferenceType.sourceName(): " + sourceName + ", expected is "
                            + expectedSourceName);
                }
            } else {
                boolean success = true;

                List<String> sourceNames = referenceType.sourceNames(stratum);

                if (!expectedSourceNames.containsAll(sourceNames)) {
                    success = false;
                    log.complain("ReferenceType.sourceNames() returns unexpected names");
                }

                if (!sourceNames.containsAll(expectedSourceNames)) {
                    success = false;
                    log.complain("Not all expected source names was returned by ReferenceType.sourceNames()");
                }

                if (!success) {
                    log.complain("Expected source names:");
                    for (String name : expectedSourceNames)
                        log.complain(name);
                    log.complain("Actual source names:");
                    for (String name : sourceNames)
                        log.complain(name);
                }
            }
        } catch (AbsentInformationException e) {
            setSuccess(false);
            log.complain("Unexpected exception: " + e);
            e.printStackTrace(log.getOutStream());
        }
    }

    // check is 'ReferenceType.sourcePaths' returns only expected paths
    protected void check_ReferenceType_sourcePaths(ReferenceType referenceType, String stratum,
            List<String> expectedSourcePaths) {
        try {
            boolean success = true;

            List<String> sourcePaths = referenceType.sourcePaths(stratum);

            if (!expectedSourcePaths.containsAll(sourcePaths)) {
                success = false;
                log.complain("ReferenceType.sourcePaths() returns unexpected paths");
            }

            if (!sourcePaths.containsAll(expectedSourcePaths)) {
                success = false;
                log.complain("Not all expected paths was returned by ReferenceType.sourcePaths()");
            }

            if (!success) {
                log.complain("Expected paths:");
                for (String path : expectedSourcePaths)
                    log.complain(path);
                log.complain("Actual paths:");
                for (String path : sourcePaths)
                    log.complain(path);
            }
        } catch (AbsentInformationException e) {
            setSuccess(false);
            log.complain("Unexpected exception: " + e);
            e.printStackTrace(log.getOutStream());
        }
    }

    // check that method 'ReferenceType.allLineLocations' returns only expected
    // locations
    protected void check_ReferenceType_allLineLocations(ReferenceType referenceType, String stratum,
            List<DebugLocation> expectedLocations) {
        try {
            List<Location> locations = referenceType.allLineLocations();
            compareLocations(locations, expectedLocations, stratum);
        } catch (AbsentInformationException e) {
            setSuccess(false);
            log.complain("Unexpected exception: " + e);
            e.printStackTrace(log.getOutStream());
        }

    }

    // check that method 'Method.allLineLocations' returns only expected
    // locations
    protected void check_Method_allLineLocations(Method method, String stratum,
            List<DebugLocation> expectedLocationsOfMethod) {
        try {
            List<Location> methodAllLineLocations = method.allLineLocations();
            compareLocations(methodAllLineLocations, expectedLocationsOfMethod, stratum);
        } catch (AbsentInformationException e) {
            setSuccess(false);
            log.complain("Unexpected exception: " + e);
            e.printStackTrace(log.getOutStream());
        }
    }

    // for each line available for method check result of
    // 'Method.locationsOfLine'
    protected void check_Method_locationsOfLine(Method method, String stratum, boolean allSources,
            List<DebugLocation> expectedLocationsOfMethod) {
        try {
            for (DebugLocation uniqueLocation : allUniqueLocations(expectedLocationsOfMethod)) {
                String sourceName = allSources ? null : uniqueLocation.sourceName;

                List<DebugLocation> expectedLocationsOfLine = locationsOfLine(
                        expectedLocationsOfMethod,
                        sourceName,
                        uniqueLocation.inputLine);

                List<Location> locationsOfLine = (stratum == null) ? method.locationsOfLine(uniqueLocation.inputLine)
                        : method.locationsOfLine(stratum, sourceName, uniqueLocation.inputLine);

                compareLocations(locationsOfLine, expectedLocationsOfLine, stratum);
            }
        } catch (AbsentInformationException e) {
            setSuccess(false);
            log.complain("Unexpected exception: " + e);
            e.printStackTrace(log.getOutStream());
        }
    }

    // for each line available for ReferenceType check result of
    // 'ReferenceType.locationsOfLine'
    protected void check_ReferenceType_locationsOfLine(ReferenceType referenceType, String stratum, boolean allSources,
            List<DebugLocation> expectedLocations) {
        try {
            for (DebugLocation uniqueLocation : allUniqueLocations(expectedLocations)) {
                String sourceName = allSources ? null : uniqueLocation.sourceName;

                List<DebugLocation> expectedLocationsOfLine = locationsOfLine(
                        expectedLocations,
                        sourceName,
                        uniqueLocation.inputLine);

                List<Location> locations = (stratum == null) ? referenceType.locationsOfLine(uniqueLocation.inputLine)
                        : referenceType.locationsOfLine(stratum, sourceName, uniqueLocation.inputLine);

                compareLocations(locations, expectedLocationsOfLine, stratum);
            }
        } catch (AbsentInformationException e) {
            setSuccess(false);
            log.complain("Unexpected exception: " + e);
            e.printStackTrace(log.getOutStream());
        }

    }

    // check that method 'ReferenceType.availableStrata' returns only expected
    // stratums
    protected void check_ReferenceType_availableStrata(ReferenceType referenceType, List<String> expectedStrata) {
        boolean success = true;

        List<String> strata = referenceType.availableStrata();

        if (!expectedStrata.containsAll(strata)) {
            success = false;
            log.complain("ReferenceType.availableStrata() returns unexpected values");
        }

        if (!strata.containsAll(expectedStrata)) {
            success = false;
            log.complain("Not all expected stratums was returned by ReferenceType.availableStrata()");
        }

        if (!success) {
            log.complain("Expected stratums:");
            for (String name : expectedStrata)
                log.complain(name);
            log.complain("Actual stratums:");
            for (String name : strata)
                log.complain(name);
        }
    }

}