test/langtools/jdk/jshell/WrapperTest.java - openjdk/jdk25u - Git at Google


            
            /*

            
             * Copyright (c) 2016, 2019, 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.

            
             */


            /*

            
             * @test

            
             * @bug 8159111 8159740

            
             * @summary test wrappers and dependencies

            
             * @modules jdk.jshell/jdk.jshell

            
             * @build KullaTesting

            
             * @run testng WrapperTest

            
             */


            import java.util.Collection;

            
            import java.util.List;

            
            import org.testng.annotations.Test;

            
            import jdk.jshell.ErroneousSnippet;

            
            import jdk.jshell.Snippet;

            
            import jdk.jshell.Snippet.Kind;

            
            import jdk.jshell.SourceCodeAnalysis.SnippetWrapper;

            
            import static org.testng.Assert.assertEquals;

            
            import static org.testng.Assert.assertTrue;

            
            import static jdk.jshell.Snippet.Status.RECOVERABLE_DEFINED;

            
            import static jdk.jshell.Snippet.Status.VALID;


            @Test

            
            public class WrapperTest extends KullaTesting {


                public void testMethod() {

            
                    String src = "void glib() { System.out.println(\"hello\"); }";

            
                    List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);

            
                    assertEquals(swl.size(), 1, "unexpected list length");

            
                    assertWrapperHas(swl.get(0), src, Kind.METHOD, "void", "glib", "println");

            
                    assertPosition(swl.get(0), src, 0, 4);

            
                    assertPosition(swl.get(0), src, 5, 4);

            
                    assertPosition(swl.get(0), src, 15, 6);


                    Snippet g = methodKey(assertEval(src, added(VALID)));

            
                    SnippetWrapper swg = getState().sourceCodeAnalysis().wrapper(g);

            
                    assertWrapperHas(swg, src, Kind.METHOD, "void", "glib", "println");

            
                    assertPosition(swg, src, 0, 4);

            
                    assertPosition(swg, src, 5, 4);

            
                    assertPosition(swg, src, 15, 6);

            
                }


                // test 8159740

            
                public void testMethodCorralled() {

            
                    String src = "void glib() { f(); }";

            
                    //            _123456789_123456789

            
                    Snippet g = methodKey(assertEval(src, added(RECOVERABLE_DEFINED)));

            
                    SnippetWrapper swg = getState().sourceCodeAnalysis().wrapper(g);

            
                    assertWrapperHas(swg, src, Kind.METHOD, "SPIResolutionException",

            
                            "void", "glib");

            
                    assertPosition(swg, src, 0, 4);

            
                    assertPosition(swg, src, 5, 4);

            
                }


                // test 8159740

            
                public void testClassCorralled0() {

            
                    String src = "class AAA { float mmm(double d1234) { return (float) (f0 * d1234); } }";

            
                    //            _123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789

            
                    Snippet a = classKey(assertEval(src, added(RECOVERABLE_DEFINED)));

            
                    SnippetWrapper swa = getState().sourceCodeAnalysis().wrapper(a);

            
                    assertWrapperHas(swa, src, Kind.TYPE_DECL, "SPIResolutionException",

            
                            "class", "AAA", "float", "mmm", "double", "d1234");

            
                    assertPosition(swa, src, 0, 5);

            
                    assertPosition(swa, src, 6, 3);

            
                    assertPosition(swa, src, 12, 5);

            
                    assertPosition(swa, src, 18, 3);

            
                    assertPosition(swa, src, 22, 6);

            
                    assertPosition(swa, src, 29, 5);

            
                }


                // test 8159740

            
                public void testClassCorralled() {

            
                    String src = "class AAA { int xxx = x0 + 4; float mmm(float ffff) { return f0 * ffff; } }";

            
                    //            _123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789

            
                    Snippet a = classKey(assertEval(src, added(RECOVERABLE_DEFINED)));

            
                    SnippetWrapper swa = getState().sourceCodeAnalysis().wrapper(a);

            
                    assertWrapperHas(swa, src, Kind.TYPE_DECL, "SPIResolutionException",

            
                            "class", "AAA", "int", "xxx", "float", "mmm", "ffff");

            
                    assertPosition(swa, src, 0, 5);

            
                    assertPosition(swa, src, 6, 3);

            
                    assertPosition(swa, src, 12, 3);

            
                    assertPosition(swa, src, 16, 3);

            
                    assertPosition(swa, src, 30, 5);

            
                    assertPosition(swa, src, 36, 3);

            
                    assertPosition(swa, src, 40, 5);

            
                    assertPosition(swa, src, 46, 4);

            
                }


                // test 8159740

            
                public void testClassWithConstructorCorralled() {

            
                    String src = "public class AAA { AAA(String b) {} int xxx = x0 + 4; float mmm(float ffff) { return f0 * ffff; } }";

            
                    //            _123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789

            
                    Snippet a = classKey(assertEval(src, added(RECOVERABLE_DEFINED)));

            
                    SnippetWrapper swa = getState().sourceCodeAnalysis().wrapper(a);

            
                    assertWrapperHas(swa, src, Kind.TYPE_DECL, "SPIResolutionException",

            
                            "class", "AAA", "String", "int", "xxx", "float", "mmm", "ffff");

            
                    assertPosition(swa, src, 7, 5);

            
                    assertPosition(swa, src, 13, 3);

            
                    assertPosition(swa, src, 19, 3);

            
                    assertPosition(swa, src, 23, 5);

            
                    assertPosition(swa, src, 30, 1);

            
                    assertPosition(swa, src, 36, 3);

            
                    assertPosition(swa, src, 40, 3);

            
                    assertPosition(swa, src, 54, 5);

            
                    assertPosition(swa, src, 60, 3);

            
                    assertPosition(swa, src, 64, 5);

            
                    assertPosition(swa, src, 70, 4);

            
                }


                // test 8159740

            
                public void testInterfaceCorralled() {

            
                    String src = "interface AAA { default float mmm(double d1234) { return (float) (f0 * d1234); } }";

            
                    //            _123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789

            
                    Snippet a = classKey(assertEval(src, added(RECOVERABLE_DEFINED)));

            
                    SnippetWrapper swa = getState().sourceCodeAnalysis().wrapper(a);

            
                    assertWrapperHas(swa, src, Kind.TYPE_DECL, "SPIResolutionException",

            
                            "interface", "AAA", "float", "mmm", "double", "d1234");

            
                    assertPosition(swa, src, 0, 9);

            
                    assertPosition(swa, src, 10, 3);

            
                    assertPosition(swa, src, 16, 7);

            
                    assertPosition(swa, src, 24, 5);

            
                    assertPosition(swa, src, 30, 3);

            
                    assertPosition(swa, src, 34, 6);

            
                    assertPosition(swa, src, 41, 5);

            
                }


                // test 8159740

            
                public void testEnumCorralled() {

            
                    String src =

            
                            "public enum Planet {\n" +

            
                            "    MERCURY (3.303e+23, 2.4397e6),\n" +

            
                            "    VENUS   (4.869e+24, 6.0518e6),\n" +

            
                            "    EARTH   (5.976e+24, 6.37814e6),\n" +

            
                            "    MARS    (6.421e+23, 3.3972e6),\n" +

            
                            "    JUPITER (1.9e+27,   7.1492e7),\n" +

            
                            "    SATURN  (5.688e+26, 6.0268e7),\n" +

            
                            "    URANUS  (8.686e+25, 2.5559e7),\n" +

            
                            "    NEPTUNE (1.024e+26, 2.4746e7);\n" +

            
                            "\n" +

            
                            "    private final double mass;   // in kilograms\n" +

            
                            "    private final double radius; // in meters\n" +

            
                            "    Planet(double mass, double radius) {\n" +

            
                            "        this.mass = mass;\n" +

            
                            "        this.radius = radius;\n" +

            
                            "    }\n" +

            
                            "    private double mass() { return mass; }\n" +

            
                            "    private double radius() { return radius; }\n" +

            
                            "\n" +

            
                            "    double surfaceGravity() {\n" +

            
                            "        return GRAVITATIONAL_CONSTANT * mass / (radius * radius);\n" +

            
                            "    }\n" +

            
                            "    double surfaceWeight(double otherMass) {\n" +

            
                            "        return otherMass * surfaceGravity();\n" +

            
                            "    }\n" +

            
                            "}\n";

            
                    Snippet a = classKey(assertEval(src, added(RECOVERABLE_DEFINED)));

            
                    SnippetWrapper swa = getState().sourceCodeAnalysis().wrapper(a);

            
                    assertWrapperHas(swa, src, Kind.TYPE_DECL, "SPIResolutionException",

            
                            "enum", "Planet", "double", "mass", "EARTH", "NEPTUNE", "MERCURY",

            
                            "radius", "surfaceGravity", "surfaceWeight");

            
                }


                public void testMethodBad() {

            
                    String src = "void flob() { ?????; }";

            
                    List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);

            
                    assertEquals(swl.size(), 1, "unexpected list length");

            
                    assertWrapperHas(swl.get(0), src, Kind.METHOD, "void", "flob", "?????");

            
                    assertPosition(swl.get(0), src, 9, 2);


                    Snippet f = key(assertEvalFail(src));

            
                    assertEquals(f.kind(), Kind.ERRONEOUS);

            
                    assertEquals(((ErroneousSnippet)f).probableKind(), Kind.METHOD);

            
                    SnippetWrapper sw = getState().sourceCodeAnalysis().wrapper(f);

            
                    assertWrapperHas(sw, src, Kind.METHOD, "void", "flob", "?????");

            
                    assertPosition(swl.get(0), src, 14, 5);

            
                }


                public void testVar() {

            
                    String src = "int gx = 1234;";

            
                    List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);

            
                    assertEquals(swl.size(), 1, "unexpected list length");

            
                    assertWrapperHas(swl.get(0), src, Kind.VAR, "int", "gx", "1234");

            
                    assertPosition(swl.get(0), src, 4, 2);


                    Snippet g = varKey(assertEval(src, added(VALID)));

            
                    SnippetWrapper swg = getState().sourceCodeAnalysis().wrapper(g);

            
                    assertWrapperHas(swg, src, Kind.VAR, "int", "gx", "1234");

            
                    assertPosition(swg, src, 0, 3);

            
                }


                public void testVarBad() {

            
                    String src = "double dd = ?????;";

            
                    List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);

            
                    assertEquals(swl.size(), 1, "unexpected list length");

            
                    assertWrapperHas(swl.get(0), src, Kind.VAR, "double", "dd", "?????");

            
                    assertPosition(swl.get(0), src, 9, 2);


                    Snippet f = key(assertEvalFail(src));

            
                    assertEquals(f.kind(), Kind.ERRONEOUS);

            
                    assertEquals(((ErroneousSnippet)f).probableKind(), Kind.VAR);

            
                    SnippetWrapper sw = getState().sourceCodeAnalysis().wrapper(f);

            
                    assertWrapperHas(sw, src, Kind.VAR, "double", "dd", "?????");

            
                    assertPosition(swl.get(0), src, 12, 5);

            
                }


                public void testImport() {

            
                    String src = "import java.lang.*;";

            
                    List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);

            
                    assertEquals(swl.size(), 1, "unexpected list length");

            
                    assertWrapperHas(swl.get(0), src, Kind.IMPORT, "import", "java.lang");

            
                    assertPosition(swl.get(0), src, 7, 4);


                    Snippet g = key(assertEval(src, added(VALID)));

            
                    SnippetWrapper swg = getState().sourceCodeAnalysis().wrapper(g);

            
                    assertWrapperHas(swg, src, Kind.IMPORT, "import", "java.lang");

            
                    assertPosition(swg, src, 0, 6);

            
                }


                public void testImportBad() {

            
                    String src = "import java.?????;";

            
                    List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);

            
                    assertEquals(swl.size(), 1, "unexpected list length");

            
                    assertWrapperHas(swl.get(0), src, Kind.IMPORT, "import", "?????");

            
                    assertPosition(swl.get(0), src, 7, 4);


                    Snippet f = key(assertEvalFail(src));

            
                    assertEquals(f.kind(), Kind.ERRONEOUS);

            
                    assertEquals(((ErroneousSnippet)f).probableKind(), Kind.IMPORT);

            
                    SnippetWrapper sw = getState().sourceCodeAnalysis().wrapper(f);

            
                    assertWrapperHas(sw, src, Kind.IMPORT, "import", "?????");

            
                    assertPosition(swl.get(0), src, 0, 6);

            
                }


                public void testErroneous() {

            
                    String src = "@@@@@@@@@@";

            
                    List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);

            
                    assertEquals(swl.size(), 1, "unexpected list length");

            
                    assertWrapperHas(swl.get(0), src, Kind.ERRONEOUS, "@@@@@@@@@@");

            
                    assertPosition(swl.get(0), src, 0, 10);


                    Snippet f = key(assertEvalFail(src));

            
                    assertEquals(f.kind(), Kind.ERRONEOUS);

            
                    assertEquals(((ErroneousSnippet)f).probableKind(), Kind.ERRONEOUS);

            
                    SnippetWrapper sw = getState().sourceCodeAnalysis().wrapper(f);

            
                    assertWrapperHas(sw, src, Kind.ERRONEOUS, "@@@@@@@@@@");

            
                    assertPosition(swl.get(0), src, 0, 10);

            
                }


                public void testEmpty() {

            
                    String src = "";

            
                    List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);

            
                    assertEquals(swl.size(), 0, "expected empty list");

            
                }


                public void testDependencies() {

            
                    Snippet a = key(assertEval("int aaa = 6;", added(VALID)));

            
                    Snippet b = key(assertEval("class B { B(int x) { aaa = x; } }", added(VALID)));

            
                    Snippet c = key(assertEval("B ccc() { return new B(aaa); }", added(VALID)));

            
                    Collection<Snippet> dep;

            
                    dep = getState().sourceCodeAnalysis().dependents(c);

            
                    assertEquals(dep.size(), 0);

            
                    dep = getState().sourceCodeAnalysis().dependents(b);

            
                    assertEquals(dep.size(), 1);

            
                    assertTrue(dep.contains(c));

            
                    dep = getState().sourceCodeAnalysis().dependents(a);

            
                    assertEquals(dep.size(), 2);

            
                    assertTrue(dep.contains(c));

            
                    assertTrue(dep.contains(b));

            
                }


                private void assertWrapperHas(SnippetWrapper sw, String source, Kind kind, String... has) {

            
                    assertEquals(sw.source(), source);

            
                    assertEquals(sw.kind(), kind);

            
                    String s = sw.wrapped();

            
                    if (kind == Kind.IMPORT) {

            
                        assertHas(s, "import");

            
                    } else {

            
                        String cn = sw.fullClassName();

            
                        int idx = cn.lastIndexOf(".");

            
                        assertHas(s, cn.substring(idx+1));

            
                        assertHas(s, "class");

            
                    }

            
                    for (String hx : has) {

            
                        assertHas(s, hx);

            
                    }

            
                }


                private void assertHas(String s, String has) {

            
                    assertTrue(s.contains(has), "Expected to find '" + has + "' in: '" + s + "'");

            
                }


                private void assertPosition(SnippetWrapper sw, String source, int start, int length) {

            
                    //System.err.printf("\n#assertPosition:\n#  debug-source: %s\n#  SnippetWrapper --\n#    source: %s\n#    wrapped: %s\n",

            
                    //        source, sw.source(), sw.wrapped());

            
                    //System.err.printf("#  start: %d    length: %d\n", start, length);

            
                    int wpg = sw.sourceToWrappedPosition(start);

            
                    //System.err.printf("#  wrappedPos: %d\n", wpg);

            
                    String wrappedPart = sw.wrapped().substring(wpg, wpg+length);

            
                    String sourcePart = source.substring(start, start+length);

            
                    //System.err.printf("#  wrapped @ wrappedPos: %s\n", wrappedPart);

            
                    //System.err.printf("#  source @ start: %s\n", sourcePart);


                    assertEquals(wrappedPart, sourcePart,

            
                            "position " + wpg + " in " + sw.wrapped());

            
                    assertEquals(sw.wrappedToSourcePosition(wpg), start);

            
                }

            
            }
	/*
	* Copyright (c) 2016, 2019, 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.
	*/

	/*
	* @test
	* @bug 8159111 8159740
	* @summary test wrappers and dependencies
	* @modules jdk.jshell/jdk.jshell
	* @build KullaTesting
	* @run testng WrapperTest
	*/

	import java.util.Collection;
	import java.util.List;
	import org.testng.annotations.Test;
	import jdk.jshell.ErroneousSnippet;
	import jdk.jshell.Snippet;
	import jdk.jshell.Snippet.Kind;
	import jdk.jshell.SourceCodeAnalysis.SnippetWrapper;
	import static org.testng.Assert.assertEquals;
	import static org.testng.Assert.assertTrue;
	import static jdk.jshell.Snippet.Status.RECOVERABLE_DEFINED;
	import static jdk.jshell.Snippet.Status.VALID;

	@Test
	public class WrapperTest extends KullaTesting {

	public void testMethod() {
	String src = "void glib() { System.out.println(\"hello\"); }";
	List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);
	assertEquals(swl.size(), 1, "unexpected list length");
	assertWrapperHas(swl.get(0), src, Kind.METHOD, "void", "glib", "println");
	assertPosition(swl.get(0), src, 0, 4);
	assertPosition(swl.get(0), src, 5, 4);
	assertPosition(swl.get(0), src, 15, 6);

	Snippet g = methodKey(assertEval(src, added(VALID)));
	SnippetWrapper swg = getState().sourceCodeAnalysis().wrapper(g);
	assertWrapperHas(swg, src, Kind.METHOD, "void", "glib", "println");
	assertPosition(swg, src, 0, 4);
	assertPosition(swg, src, 5, 4);
	assertPosition(swg, src, 15, 6);
	}

	// test 8159740
	public void testMethodCorralled() {
	String src = "void glib() { f(); }";
	// _123456789_123456789
	Snippet g = methodKey(assertEval(src, added(RECOVERABLE_DEFINED)));
	SnippetWrapper swg = getState().sourceCodeAnalysis().wrapper(g);
	assertWrapperHas(swg, src, Kind.METHOD, "SPIResolutionException",
	"void", "glib");
	assertPosition(swg, src, 0, 4);
	assertPosition(swg, src, 5, 4);
	}

	// test 8159740
	public void testClassCorralled0() {
	String src = "class AAA { float mmm(double d1234) { return (float) (f0 * d1234); } }";
	// _123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
	Snippet a = classKey(assertEval(src, added(RECOVERABLE_DEFINED)));
	SnippetWrapper swa = getState().sourceCodeAnalysis().wrapper(a);
	assertWrapperHas(swa, src, Kind.TYPE_DECL, "SPIResolutionException",
	"class", "AAA", "float", "mmm", "double", "d1234");
	assertPosition(swa, src, 0, 5);
	assertPosition(swa, src, 6, 3);
	assertPosition(swa, src, 12, 5);
	assertPosition(swa, src, 18, 3);
	assertPosition(swa, src, 22, 6);
	assertPosition(swa, src, 29, 5);
	}

	// test 8159740
	public void testClassCorralled() {
	String src = "class AAA { int xxx = x0 + 4; float mmm(float ffff) { return f0 * ffff; } }";
	// _123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
	Snippet a = classKey(assertEval(src, added(RECOVERABLE_DEFINED)));
	SnippetWrapper swa = getState().sourceCodeAnalysis().wrapper(a);
	assertWrapperHas(swa, src, Kind.TYPE_DECL, "SPIResolutionException",
	"class", "AAA", "int", "xxx", "float", "mmm", "ffff");
	assertPosition(swa, src, 0, 5);
	assertPosition(swa, src, 6, 3);
	assertPosition(swa, src, 12, 3);
	assertPosition(swa, src, 16, 3);
	assertPosition(swa, src, 30, 5);
	assertPosition(swa, src, 36, 3);
	assertPosition(swa, src, 40, 5);
	assertPosition(swa, src, 46, 4);
	}

	// test 8159740
	public void testClassWithConstructorCorralled() {
	String src = "public class AAA { AAA(String b) {} int xxx = x0 + 4; float mmm(float ffff) { return f0 * ffff; } }";
	// _123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
	Snippet a = classKey(assertEval(src, added(RECOVERABLE_DEFINED)));
	SnippetWrapper swa = getState().sourceCodeAnalysis().wrapper(a);
	assertWrapperHas(swa, src, Kind.TYPE_DECL, "SPIResolutionException",
	"class", "AAA", "String", "int", "xxx", "float", "mmm", "ffff");
	assertPosition(swa, src, 7, 5);
	assertPosition(swa, src, 13, 3);
	assertPosition(swa, src, 19, 3);
	assertPosition(swa, src, 23, 5);
	assertPosition(swa, src, 30, 1);
	assertPosition(swa, src, 36, 3);
	assertPosition(swa, src, 40, 3);
	assertPosition(swa, src, 54, 5);
	assertPosition(swa, src, 60, 3);
	assertPosition(swa, src, 64, 5);
	assertPosition(swa, src, 70, 4);
	}

	// test 8159740
	public void testInterfaceCorralled() {
	String src = "interface AAA { default float mmm(double d1234) { return (float) (f0 * d1234); } }";
	// _123456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
	Snippet a = classKey(assertEval(src, added(RECOVERABLE_DEFINED)));
	SnippetWrapper swa = getState().sourceCodeAnalysis().wrapper(a);
	assertWrapperHas(swa, src, Kind.TYPE_DECL, "SPIResolutionException",
	"interface", "AAA", "float", "mmm", "double", "d1234");
	assertPosition(swa, src, 0, 9);
	assertPosition(swa, src, 10, 3);
	assertPosition(swa, src, 16, 7);
	assertPosition(swa, src, 24, 5);
	assertPosition(swa, src, 30, 3);
	assertPosition(swa, src, 34, 6);
	assertPosition(swa, src, 41, 5);
	}

	// test 8159740
	public void testEnumCorralled() {
	String src =
	"public enum Planet {\n" +
	" MERCURY (3.303e+23, 2.4397e6),\n" +
	" VENUS (4.869e+24, 6.0518e6),\n" +
	" EARTH (5.976e+24, 6.37814e6),\n" +
	" MARS (6.421e+23, 3.3972e6),\n" +
	" JUPITER (1.9e+27, 7.1492e7),\n" +
	" SATURN (5.688e+26, 6.0268e7),\n" +
	" URANUS (8.686e+25, 2.5559e7),\n" +
	" NEPTUNE (1.024e+26, 2.4746e7);\n" +
	"\n" +
	" private final double mass; // in kilograms\n" +
	" private final double radius; // in meters\n" +
	" Planet(double mass, double radius) {\n" +
	" this.mass = mass;\n" +
	" this.radius = radius;\n" +
	" }\n" +
	" private double mass() { return mass; }\n" +
	" private double radius() { return radius; }\n" +
	"\n" +
	" double surfaceGravity() {\n" +
	" return GRAVITATIONAL_CONSTANT * mass / (radius * radius);\n" +
	" }\n" +
	" double surfaceWeight(double otherMass) {\n" +
	" return otherMass * surfaceGravity();\n" +
	" }\n" +
	"}\n";
	Snippet a = classKey(assertEval(src, added(RECOVERABLE_DEFINED)));
	SnippetWrapper swa = getState().sourceCodeAnalysis().wrapper(a);
	assertWrapperHas(swa, src, Kind.TYPE_DECL, "SPIResolutionException",
	"enum", "Planet", "double", "mass", "EARTH", "NEPTUNE", "MERCURY",
	"radius", "surfaceGravity", "surfaceWeight");
	}

	public void testMethodBad() {
	String src = "void flob() { ?????; }";
	List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);
	assertEquals(swl.size(), 1, "unexpected list length");
	assertWrapperHas(swl.get(0), src, Kind.METHOD, "void", "flob", "?????");
	assertPosition(swl.get(0), src, 9, 2);

	Snippet f = key(assertEvalFail(src));
	assertEquals(f.kind(), Kind.ERRONEOUS);
	assertEquals(((ErroneousSnippet)f).probableKind(), Kind.METHOD);
	SnippetWrapper sw = getState().sourceCodeAnalysis().wrapper(f);
	assertWrapperHas(sw, src, Kind.METHOD, "void", "flob", "?????");
	assertPosition(swl.get(0), src, 14, 5);
	}

	public void testVar() {
	String src = "int gx = 1234;";
	List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);
	assertEquals(swl.size(), 1, "unexpected list length");
	assertWrapperHas(swl.get(0), src, Kind.VAR, "int", "gx", "1234");
	assertPosition(swl.get(0), src, 4, 2);

	Snippet g = varKey(assertEval(src, added(VALID)));
	SnippetWrapper swg = getState().sourceCodeAnalysis().wrapper(g);
	assertWrapperHas(swg, src, Kind.VAR, "int", "gx", "1234");
	assertPosition(swg, src, 0, 3);
	}

	public void testVarBad() {
	String src = "double dd = ?????;";
	List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);
	assertEquals(swl.size(), 1, "unexpected list length");
	assertWrapperHas(swl.get(0), src, Kind.VAR, "double", "dd", "?????");
	assertPosition(swl.get(0), src, 9, 2);

	Snippet f = key(assertEvalFail(src));
	assertEquals(f.kind(), Kind.ERRONEOUS);
	assertEquals(((ErroneousSnippet)f).probableKind(), Kind.VAR);
	SnippetWrapper sw = getState().sourceCodeAnalysis().wrapper(f);
	assertWrapperHas(sw, src, Kind.VAR, "double", "dd", "?????");
	assertPosition(swl.get(0), src, 12, 5);
	}

	public void testImport() {
	String src = "import java.lang.*;";
	List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);
	assertEquals(swl.size(), 1, "unexpected list length");
	assertWrapperHas(swl.get(0), src, Kind.IMPORT, "import", "java.lang");
	assertPosition(swl.get(0), src, 7, 4);

	Snippet g = key(assertEval(src, added(VALID)));
	SnippetWrapper swg = getState().sourceCodeAnalysis().wrapper(g);
	assertWrapperHas(swg, src, Kind.IMPORT, "import", "java.lang");
	assertPosition(swg, src, 0, 6);
	}

	public void testImportBad() {
	String src = "import java.?????;";
	List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);
	assertEquals(swl.size(), 1, "unexpected list length");
	assertWrapperHas(swl.get(0), src, Kind.IMPORT, "import", "?????");
	assertPosition(swl.get(0), src, 7, 4);

	Snippet f = key(assertEvalFail(src));
	assertEquals(f.kind(), Kind.ERRONEOUS);
	assertEquals(((ErroneousSnippet)f).probableKind(), Kind.IMPORT);
	SnippetWrapper sw = getState().sourceCodeAnalysis().wrapper(f);
	assertWrapperHas(sw, src, Kind.IMPORT, "import", "?????");
	assertPosition(swl.get(0), src, 0, 6);
	}

	public void testErroneous() {
	String src = "@@@@@@@@@@";
	List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);
	assertEquals(swl.size(), 1, "unexpected list length");
	assertWrapperHas(swl.get(0), src, Kind.ERRONEOUS, "@@@@@@@@@@");
	assertPosition(swl.get(0), src, 0, 10);

	Snippet f = key(assertEvalFail(src));
	assertEquals(f.kind(), Kind.ERRONEOUS);
	assertEquals(((ErroneousSnippet)f).probableKind(), Kind.ERRONEOUS);
	SnippetWrapper sw = getState().sourceCodeAnalysis().wrapper(f);
	assertWrapperHas(sw, src, Kind.ERRONEOUS, "@@@@@@@@@@");
	assertPosition(swl.get(0), src, 0, 10);
	}

	public void testEmpty() {
	String src = "";
	List<SnippetWrapper> swl = getState().sourceCodeAnalysis().wrappers(src);
	assertEquals(swl.size(), 0, "expected empty list");
	}

	public void testDependencies() {
	Snippet a = key(assertEval("int aaa = 6;", added(VALID)));
	Snippet b = key(assertEval("class B { B(int x) { aaa = x; } }", added(VALID)));
	Snippet c = key(assertEval("B ccc() { return new B(aaa); }", added(VALID)));
	Collection<Snippet> dep;
	dep = getState().sourceCodeAnalysis().dependents(c);
	assertEquals(dep.size(), 0);
	dep = getState().sourceCodeAnalysis().dependents(b);
	assertEquals(dep.size(), 1);
	assertTrue(dep.contains(c));
	dep = getState().sourceCodeAnalysis().dependents(a);
	assertEquals(dep.size(), 2);
	assertTrue(dep.contains(c));
	assertTrue(dep.contains(b));
	}

	private void assertWrapperHas(SnippetWrapper sw, String source, Kind kind, String... has) {
	assertEquals(sw.source(), source);
	assertEquals(sw.kind(), kind);
	String s = sw.wrapped();
	if (kind == Kind.IMPORT) {
	assertHas(s, "import");
	} else {
	String cn = sw.fullClassName();
	int idx = cn.lastIndexOf(".");
	assertHas(s, cn.substring(idx+1));
	assertHas(s, "class");
	}
	for (String hx : has) {
	assertHas(s, hx);
	}
	}

	private void assertHas(String s, String has) {
	assertTrue(s.contains(has), "Expected to find '" + has + "' in: '" + s + "'");
	}

	private void assertPosition(SnippetWrapper sw, String source, int start, int length) {
	//System.err.printf("\n#assertPosition:\n# debug-source: %s\n# SnippetWrapper --\n# source: %s\n# wrapped: %s\n",
	// source, sw.source(), sw.wrapped());
	//System.err.printf("# start: %d length: %d\n", start, length);
	int wpg = sw.sourceToWrappedPosition(start);
	//System.err.printf("# wrappedPos: %d\n", wpg);
	String wrappedPart = sw.wrapped().substring(wpg, wpg+length);
	String sourcePart = source.substring(start, start+length);
	//System.err.printf("# wrapped @ wrappedPos: %s\n", wrappedPart);
	//System.err.printf("# source @ start: %s\n", sourcePart);

	assertEquals(wrappedPart, sourcePart,
	"position " + wpg + " in " + sw.wrapped());
	assertEquals(sw.wrappedToSourcePosition(wpg), start);
	}
	}