langtools/test/com/sun/javadoc/testOrdering/TestOrdering.java
changeset 24399 af1a0220d0fa
parent 24394 74279778c307
child 25004 b33effe4f252
equal deleted inserted replaced
24398:601a611d0aee 24399:af1a0220d0fa
    26  * @bug 8039410 8042601
    26  * @bug 8039410 8042601
    27  * @summary test to determine if members are ordered correctly
    27  * @summary test to determine if members are ordered correctly
    28  * @author ksrini
    28  * @author ksrini
    29  * @library ../lib/
    29  * @library ../lib/
    30  * @build JavadocTester
    30  * @build JavadocTester
    31  * @build TestOrdering
       
    32  * @run main TestOrdering
    31  * @run main TestOrdering
    33  */
    32  */
    34 
    33 
    35 import java.util.regex.Matcher;
    34 public class TestOrdering extends JavadocTester {
    36 import java.util.regex.Pattern;
       
    37 
    35 
    38 public class TestOrdering extends JavadocTester {
       
    39     /**
       
    40      * The entry point of the test.
       
    41      * @param args the array of command line arguments.
       
    42      */
       
    43     public static void main(String[] args) throws Exception {
    36     public static void main(String[] args) throws Exception {
    44         TestOrdering tester = new TestOrdering();
    37         TestOrdering tester = new TestOrdering();
    45         // test unnamed packages
    38         tester.runTests();
    46         String[] ARGS = {
       
    47             "-d", OUTPUT_DIR, "-sourcepath", SRC_DIR, "-use",
       
    48              SRC_DIR + "/C.java", SRC_DIR + "/UsedInC.java"
       
    49         };
       
    50         tester.runJavadoc(ARGS);
       
    51         checkExecutableMemberOrdering(tester.readFileToString("class-use/UsedInC.html"));
       
    52 
       
    53         // next test using packages
       
    54         String[] ARGS1 = {
       
    55             "-d", OUTPUT_DIR + "-1", "-sourcepath", SRC_DIR, "-use",
       
    56             "pkg1"
       
    57         };
       
    58         tester.runJavadoc(ARGS1);
       
    59         checkClassUseOrdering(tester.readFileToString("pkg1/class-use/UsedClass.html"));
       
    60         checkIndexPathOrdering(tester.readFileToString("index-all.html"));
       
    61     }
    39     }
    62 
    40 
    63     static void checkExecutableMemberOrdering(String usePage) {
    41     @Test
       
    42     void testUnnamedPackages() {
       
    43         javadoc("-d", "out",
       
    44                 "-sourcepath", testSrc,
       
    45                 "-use",
       
    46                 testSrc("C.java"), testSrc("UsedInC.java"));
       
    47         checkExit(Exit.OK);
       
    48         checkExecutableMemberOrdering("class-use/UsedInC.html");
       
    49     }
       
    50 
       
    51     @Test
       
    52     void testNamedPackages() {
       
    53         javadoc("-d", "out-1",
       
    54                 "-sourcepath", testSrc,
       
    55                 "-use",
       
    56                 "pkg1");
       
    57         checkExit(Exit.OK);
       
    58         checkClassUseOrdering("pkg1/class-use/UsedClass.html");
       
    59         checkIndexPathOrdering("index-all.html");
       
    60     }
       
    61 
       
    62     void checkExecutableMemberOrdering(String usePage) {
       
    63         String contents = readFile(usePage);
    64         // check constructors
    64         // check constructors
    65         int idx1 = usePage.indexOf("C.html#C-UsedInC");
    65         checking("constructors");
    66         int idx2 = usePage.indexOf("C.html#C-UsedInC-int");
    66         int idx1 = contents.indexOf("C.html#C-UsedInC");
    67         int idx3 = usePage.indexOf("C.html#C-UsedInC-java.lang.String");
    67         int idx2 = contents.indexOf("C.html#C-UsedInC-int");
       
    68         int idx3 = contents.indexOf("C.html#C-UsedInC-java.lang.String");
    68         if (idx1 == -1 || idx2 == -1 || idx3 == -1) {
    69         if (idx1 == -1 || idx2 == -1 || idx3 == -1) {
    69             throw new Error("ctor strings not found");
    70             failed("ctor strings not found");
    70         }
    71         } else if (idx1 > idx2 || idx2 > idx3 || idx1 > idx3) {
    71         if (idx1 > idx2 || idx2 > idx3 || idx1 > idx3) {
    72             failed("ctor strings are out of order");
    72             throw new Error("ctor strings are out of order");
    73         } else
    73         }
    74             passed("ctor strings are in order");
    74 
    75 
    75         // check methods
    76         // check methods
    76         idx1 = usePage.indexOf("C.html#ymethod-int");
    77         checking("methods");
    77         idx2 = usePage.indexOf("C.html#ymethod-java.lang.String");
    78         idx1 = contents.indexOf("C.html#ymethod-int");
       
    79         idx2 = contents.indexOf("C.html#ymethod-java.lang.String");
    78         if (idx1 == -1 || idx2 == -1) {
    80         if (idx1 == -1 || idx2 == -1) {
    79             throw new Error("#ymethod strings not found");
    81             failed("#ymethod strings not found");
    80         }
    82         } else if (idx1 > idx2) {
    81         if (idx1 > idx2) {
    83             failed("#ymethod strings are out of order");
    82             throw new Error("#ymethod strings are out of order");
    84         } else
    83         }
    85             passed("Executable Member Ordering: OK");
    84         System.out.println("Executable Member Ordering: OK");
       
    85     }
    86     }
    86 
    87 
    87     static void checkClassUseOrdering(String usePage) {
    88     void checkClassUseOrdering(String usePage) {
    88         checkClassUseOrdering(usePage, "pkg1/C#ITERATION#.html#zfield");
    89         checkClassUseOrdering(usePage, "pkg1/C#ITERATION#.html#zfield");
    89         checkClassUseOrdering(usePage, "pkg1/C#ITERATION#.html#fieldInC#ITERATION#");
    90         checkClassUseOrdering(usePage, "pkg1/C#ITERATION#.html#fieldInC#ITERATION#");
    90         checkClassUseOrdering(usePage, "pkg1/C#ITERATION#.html#zmethod-pkg1.UsedClass");
    91         checkClassUseOrdering(usePage, "pkg1/C#ITERATION#.html#zmethod-pkg1.UsedClass");
    91         checkClassUseOrdering(usePage, "pkg1/C#ITERATION#.html#methodInC#ITERATION#");
    92         checkClassUseOrdering(usePage, "pkg1/C#ITERATION#.html#methodInC#ITERATION#");
    92     }
    93     }
    93 
    94 
    94     static void checkClassUseOrdering(String usePage, String searchString) {
    95     void checkClassUseOrdering(String usePage, String searchString) {
       
    96         String contents = readFile(usePage);
    95         int lastidx = 0;
    97         int lastidx = 0;
    96         System.out.println("testing for " + searchString);
    98         System.out.println("testing for " + searchString);
    97         for (int i = 1; i < 5; i++) {
    99         for (int i = 1; i < 5; i++) {
    98             String s = searchString.replaceAll("#ITERATION#", Integer.toString(i));
   100             String s = searchString.replaceAll("#ITERATION#", Integer.toString(i));
    99             System.out.println(s);
   101             checking(s);
   100             int idx = usePage.indexOf(s);
   102             int idx = contents.indexOf(s);
   101             if (idx < lastidx) {
   103             if (idx < lastidx) {
   102                 throw new Error(s + ", member ordering error, last:" + lastidx + ", got:" + idx);
   104                 failed(s + ", member ordering error, last:" + lastidx + ", got:" + idx);
       
   105             } else {
       
   106                 passed("\tlast: " + lastidx + " got:" + idx);
   103             }
   107             }
   104             System.out.println("\tlast: " + lastidx + " got:" + idx);
       
   105             lastidx = idx;
   108             lastidx = idx;
   106         }
   109         }
   107     }
   110     }
   108 
   111 
   109     static void checkIndexPathOrdering(String indexPage) {
   112     void checkIndexPathOrdering(String indexPage) {
   110         String[] OrderedExpectedStrings = {
   113         checkOrder(indexPage,
   111             "pkg1/UsedClass.html#add--",
   114             "pkg1/UsedClass.html#add--",
   112             "pkg1/ZZTop.html#add--",
   115             "pkg1/ZZTop.html#add--",
   113             "pkg1/UsedClass.html#add-double-",
   116             "pkg1/UsedClass.html#add-double-",
   114             "pkg1/UsedClass.html#add-java.lang.Double-",
   117             "pkg1/UsedClass.html#add-java.lang.Double-",
   115             "pkg1/ZZTop.html#add-double-",
   118             "pkg1/ZZTop.html#add-double-",
   127             "pkg1/UsedClass.html#add-int-",
   130             "pkg1/UsedClass.html#add-int-",
   128             "pkg1/ZZTop.html#add-int-",
   131             "pkg1/ZZTop.html#add-int-",
   129             "pkg1/UsedClass.html#add-int-float-",
   132             "pkg1/UsedClass.html#add-int-float-",
   130             "pkg1/ZZTop.html#add-int-float-",
   133             "pkg1/ZZTop.html#add-int-float-",
   131             "pkg1/UsedClass.html#add-java.lang.Integer-",
   134             "pkg1/UsedClass.html#add-java.lang.Integer-",
   132             "pkg1/ZZTop.html#add-java.lang.Integer-"
   135             "pkg1/ZZTop.html#add-java.lang.Integer-");
   133         };
       
   134         int lastidx = 0;
       
   135         for (String x : OrderedExpectedStrings) {
       
   136             int idx = indexPage.indexOf(x);
       
   137             if (idx < lastidx) {
       
   138                 throw new Error(x + ", index is out of order, last:" + lastidx + ", got:" + idx);
       
   139             }
       
   140             System.out.println(x + ": OK");
       
   141             lastidx = idx;
       
   142         }
       
   143     }
   136     }
   144 }
   137 }