001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.tools;
016    
017    import com.liferay.portal.kernel.util.CharPool;
018    import com.liferay.portal.kernel.util.FileUtil;
019    import com.liferay.portal.kernel.util.GetterUtil;
020    import com.liferay.portal.kernel.util.IntegerWrapper;
021    import com.liferay.portal.kernel.util.ObjectValuePair;
022    import com.liferay.portal.kernel.util.StringBundler;
023    import com.liferay.portal.kernel.util.StringComparator;
024    import com.liferay.portal.kernel.util.StringPool;
025    import com.liferay.portal.kernel.util.StringUtil;
026    import com.liferay.portal.kernel.util.UnicodeFormatter;
027    import com.liferay.portal.tools.servicebuilder.ServiceBuilder;
028    
029    import jargs.gnu.CmdLineParser;
030    
031    import java.io.File;
032    
033    import java.util.ArrayList;
034    import java.util.Collections;
035    import java.util.Comparator;
036    import java.util.HashMap;
037    import java.util.List;
038    import java.util.Map;
039    import java.util.Set;
040    import java.util.TreeSet;
041    
042    import org.apache.tools.ant.DirectoryScanner;
043    
044    /**
045     * @author Brian Wing Shun Chan
046     */
047    public class SeleneseToJavaBuilder {
048    
049            public static void main(String[] args) throws Exception {
050                    ToolDependencies.wireBasic();
051    
052                    new SeleneseToJavaBuilder(args);
053            }
054    
055            public SeleneseToJavaBuilder(String[] args) throws Exception {
056                    CmdLineParser cmdLineParser = new CmdLineParser();
057    
058                    CmdLineParser.Option basedirOption = cmdLineParser.addStringOption(
059                            "basedir");
060                    CmdLineParser.Option minimizeOption = cmdLineParser.addStringOption(
061                            "minimize");
062                    CmdLineParser.Option reportDuplicatesOption =
063                            cmdLineParser.addStringOption("reportDuplicates");
064    
065                    cmdLineParser.parse(args);
066    
067                    _basedir = (String)cmdLineParser.getOptionValue(basedirOption);
068    
069                    String minimizeTestFileName = (String)cmdLineParser.getOptionValue(
070                            minimizeOption);
071    
072                    minimizeTestFileName = normalizeFileName(minimizeTestFileName);
073    
074                    String minimizeTestContent = getNormalizedContent(minimizeTestFileName);
075    
076                    _reportDuplicates = GetterUtil.getBoolean(
077                            (String)cmdLineParser.getOptionValue(reportDuplicatesOption));
078    
079                    int testHtmlCount = 0;
080    
081                    Map<String, ObjectValuePair<String, IntegerWrapper>> testHtmlMap =
082                            new HashMap<String, ObjectValuePair<String, IntegerWrapper>>();
083    
084                    Set<String> fileNames = getFileNames();
085    
086                    for (String fileName : fileNames) {
087                            if (fileName.length() > 161) {
088                                    System.out.println(
089                                            "Exceeds 177 characters: portal-web/test/" + fileName);
090                            }
091    
092                            if (fileName.endsWith("Test.html")) {
093                                    testHtmlCount++;
094    
095                                    String content = getNormalizedContent(fileName);
096    
097                                    if ((content != null) && content.equals(minimizeTestContent)) {
098                                            minimizeTestCase(fileName, minimizeTestFileName);
099                                    }
100    
101                                    ObjectValuePair<String, IntegerWrapper> testHtmlOVP =
102                                            testHtmlMap.get(content);
103    
104                                    if (testHtmlOVP == null) {
105                                            testHtmlOVP = new ObjectValuePair<String, IntegerWrapper>(
106                                                    fileName, new IntegerWrapper());
107    
108                                            testHtmlMap.put(content, testHtmlOVP);
109                                    }
110                                    else {
111                                            IntegerWrapper integerWrapper = testHtmlOVP.getValue();
112    
113                                            integerWrapper.increment();
114                                    }
115    
116                                    translateTestCase(fileName);
117                            }
118                            else if (fileName.endsWith("Tests.html")) {
119                                    translateTestSuite(fileName);
120                            }
121                            else if (fileName.endsWith("Test.java") ||
122                                             fileName.endsWith("Tests.java")) {
123    
124                                    if (!fileNames.contains(
125                                                    fileName.substring(0, fileName.length() - 5) +
126                                                            ".html")) {
127    
128                                            System.out.println("Unused: " + fileName);
129                                    }
130                            }
131                    }
132    
133                    List<ObjectValuePair<String, IntegerWrapper>> testHtmlOVPs =
134                            new ArrayList<ObjectValuePair<String, IntegerWrapper>>();
135    
136                    int duplicateTestHtmlCount = 0;
137    
138                    for (Map.Entry<String, ObjectValuePair<String, IntegerWrapper>> entry :
139                                    testHtmlMap.entrySet()) {
140    
141                            ObjectValuePair<String, IntegerWrapper> testHtmlOVP =
142                                    entry.getValue();
143    
144                            testHtmlOVPs.add(testHtmlOVP);
145    
146                            IntegerWrapper integerWrapper = testHtmlOVP.getValue();
147    
148                            duplicateTestHtmlCount += integerWrapper.getValue();
149                    }
150    
151                    Collections.sort(testHtmlOVPs, new TestHtmlCountComparator());
152    
153                    StringBundler sb = new StringBundler();
154    
155                    for (ObjectValuePair<String, IntegerWrapper> testHtmlOVP :
156                                    testHtmlOVPs) {
157    
158                            String fileName = testHtmlOVP.getKey();
159                            IntegerWrapper integerWrapper = testHtmlOVP.getValue();
160    
161                            if (integerWrapper.getValue() > 0) {
162                                    sb.append(fileName);
163                                    sb.append(",");
164                                    sb.append(integerWrapper.getValue());
165                                    sb.append("\n");
166                            }
167                    }
168    
169                    if (_reportDuplicates && (sb.index() > 0)) {
170                            System.out.println(
171                                    "There are " + duplicateTestHtmlCount +
172                                            " duplicate tests out of " + testHtmlCount +
173                                                    ". See duplicate_selenium_tests.txt.");
174    
175                            FileUtil.write("duplicate_selenium_tests.txt", sb.toString());
176                    }
177            }
178    
179            protected String fixParam(String param) {
180                    StringBuilder sb = new StringBuilder();
181    
182                    char[] array = param.toCharArray();
183    
184                    for (char c : array) {
185                            if (c == CharPool.BACK_SLASH) {
186                                    sb.append("\\\\");
187                            }
188                            else if (c == CharPool.QUOTE) {
189                                    sb.append("\\\"");
190                            }
191                            else if (Character.isWhitespace(c)) {
192                                    sb.append(c);
193                            }
194                            else if ((c < 0x0020) || (c > 0x007e)) {
195                                    sb.append("\\u");
196                                    sb.append(UnicodeFormatter.charToHex(c));
197                            }
198                            else {
199                                    sb.append(c);
200                            }
201                    }
202    
203                    return StringUtil.replace(
204                            sb.toString(), _FIX_PARAM_OLD_SUBS, _FIX_PARAM_NEW_SUBS);
205            }
206    
207            protected String formatTestSuite(String fileName, String oldContent)
208                    throws Exception {
209    
210                    if (!oldContent.contains("..")) {
211                            return oldContent;
212                    }
213    
214                    String newContent = oldContent;
215    
216                    int x = 0;
217                    int y = 0;
218    
219                    while (oldContent.indexOf("<a href=\"", x) != -1) {
220                            x = oldContent.indexOf("<a href=\"", x) + 9;
221                            y = oldContent.indexOf("\">", x);
222    
223                            String testCaseName = oldContent.substring(x, y);
224    
225                            if (!testCaseName.contains("..")) {
226                                    continue;
227                            }
228    
229                            int z = fileName.lastIndexOf(StringPool.SLASH);
230    
231                            String importClassName = fileName.substring(0, z);
232    
233                            if (!FileUtil.exists(
234                                            _basedir + "/" + importClassName + "/" + testCaseName)) {
235    
236                                    throw new IllegalArgumentException(
237                                            fileName + " has improper relative path");
238                            }
239    
240                            if (testCaseName.contains("../portalweb/")) {
241                                    continue;
242                            }
243    
244                            int count = StringUtil.count(testCaseName, "..");
245    
246                            for (int i = 0; i < count; i++) {
247                                    z = importClassName.lastIndexOf(StringPool.SLASH);
248    
249                                    importClassName = fileName.substring(0, z);
250                            }
251    
252                            z = testCaseName.lastIndexOf("../", z);
253    
254                            importClassName += testCaseName.substring(z + 2);
255    
256                            count = StringUtil.count(fileName, "/") - 2;
257    
258                            String relativePath = "" ;
259    
260                            for (int i = 0; i < count; i++) {
261                                    relativePath += "../";
262                            }
263    
264                            importClassName = StringUtil.replace(
265                                    importClassName, "com/liferay/", relativePath);
266    
267                            newContent = StringUtil.replace(
268                                    newContent, testCaseName, importClassName);
269                    }
270    
271                    if (!oldContent.equals(newContent)) {
272                            writeFile(fileName, newContent, false);
273                    }
274    
275                    return newContent;
276            }
277    
278            protected Set<String> getFileNames() throws Exception {
279                    DirectoryScanner directoryScanner = new DirectoryScanner();
280    
281                    directoryScanner.setBasedir(_basedir);
282                    directoryScanner.setExcludes(
283                            new String[] {
284                                    "**\\EvaluateLogTest.java", "**\\EvaluateUserCSVFileTest.java",
285                                    "**\\IterateThemeTest.java", "**\\StopSeleniumTest.java",
286                                    "**\\WaitForSystemShutdownTest.java"
287                            });
288                    directoryScanner.setIncludes(
289                            new String[] {
290                                    "**\\*Test.html", "**\\*Test.java", "**\\*Tests.html",
291                                    "**\\*Tests.java", "**\\*TestSuite.java"
292                            });
293    
294                    directoryScanner.scan();
295    
296                    Set<String> fileNames = new TreeSet<String>(
297                            new StringComparator() {
298    
299                                    @Override
300                                    public int compare(String s1, String s2) {
301                                            if (s1.endsWith("Test.html") && s2.contains("Tests.html")) {
302                                                    return -1;
303                                            }
304    
305                                            if (s1.endsWith("Tests.html") && s2.contains("Test.html")) {
306                                                    return 1;
307                                            }
308    
309                                            if (s1.endsWith(".html") && s2.contains(".java")) {
310                                                    return -1;
311                                            }
312    
313                                            if (s1.endsWith(".java") && s2.contains(".html")) {
314                                                    return 1;
315                                            }
316    
317                                            return super.compare(s1, s2);
318                                    }
319    
320                            });
321    
322                    for (String fileName : directoryScanner.getIncludedFiles()) {
323                            fileName = normalizeFileName(fileName);
324    
325                            fileNames.add(fileName);
326                    }
327    
328                    if (false) {
329                            StringBundler sb = new StringBundler();
330    
331                            for (String fileName : fileNames) {
332                                    sb.append(fileName);
333                                    sb.append("\n");
334                            }
335    
336                            writeFile("selenium_included_files.txt", sb.toString(), false);
337                    }
338    
339                    return fileNames;
340            }
341    
342            protected String getNormalizedContent(String fileName) throws Exception {
343                    String content = readFile(fileName);
344    
345                    if (content != null) {
346                            content = content.trim();
347                            content = StringUtil.replace(content, "\n", "");
348                            content = StringUtil.replace(content, "\r\n", "");
349                    }
350    
351                    return content;
352            }
353    
354            protected String[] getParams(String step) throws Exception {
355                    String[] params = new String[3];
356    
357                    int x = 0;
358                    int y = 0;
359    
360                    for (int i = 0; i < 3; i++) {
361                            x = step.indexOf("<td>", x) + 4;
362                            y = step.indexOf("\n", x);
363                            y = step.lastIndexOf("</td>", y);
364    
365                            params[i] = step.substring(x, y);
366                    }
367    
368                    return params;
369            }
370    
371            protected void minimizeTestCase(
372                            String fileName, String minimizeTestFileName)
373                    throws Exception {
374    
375                    int x = fileName.lastIndexOf(StringPool.SLASH);
376    
377                    String dirName = fileName.substring(0, x);
378    
379                    x = minimizeTestFileName.lastIndexOf(StringPool.SLASH);
380    
381                    String minimizeTestDirName = minimizeTestFileName.substring(0, x);
382    
383                    if (dirName.equals(minimizeTestDirName)) {
384                            return;
385                    }
386    
387                    String minimizeTestName = minimizeTestFileName.substring(x + 1);
388    
389                    x = fileName.indexOf("portalweb");
390    
391                    int count = StringUtil.count(fileName.substring(x), StringPool.SLASH);
392    
393                    String relativeMinimizeTestFileName = "";
394    
395                    while (count > 0) {
396                            relativeMinimizeTestFileName += "../";
397    
398                            count--;
399                    }
400    
401                    relativeMinimizeTestFileName += minimizeTestFileName.substring(
402                            minimizeTestFileName.lastIndexOf("/", x) + 1);
403    
404                    File minimizeTestFile = new File(
405                            _basedir + "/" + dirName + "/" + relativeMinimizeTestFileName);
406    
407                    if (!minimizeTestFile.exists()) {
408                            throw new IllegalArgumentException(
409                                    minimizeTestFile.toString() + " does not exist");
410                    }
411    
412                    String[] subfileNames = FileUtil.listFiles(_basedir + "/" + dirName);
413    
414                    for (String subfileName : subfileNames) {
415                            if (!subfileName.endsWith("Tests.html")) {
416                                    continue;
417                            }
418    
419                            File subfile = new File(
420                                    _basedir + "/" + dirName + "/" + subfileName);
421    
422                            String content = FileUtil.read(subfile);
423    
424                            content = StringUtil.replace(
425                                    content, "\"" + minimizeTestName + "\"",
426                                    "\"" + relativeMinimizeTestFileName + "\"");
427    
428                            FileUtil.write(subfile, content);
429                    }
430    
431                    FileUtil.delete(_basedir + "/" + fileName);
432                    FileUtil.delete(
433                            _basedir + "/" + fileName.substring(0, fileName.length() - 5) +
434                                    ".java");
435            }
436    
437            protected String normalizeFileName(String fileName) {
438                    return StringUtil.replace(
439                            fileName, StringPool.BACK_SLASH, StringPool.SLASH);
440            }
441    
442            protected String readFile(String fileName) throws Exception {
443                    return FileUtil.read(_basedir + "/" + fileName);
444            }
445    
446            protected void translateTestCase(String fileName) throws Exception {
447                    if (!FileUtil.exists(_basedir + "/" + fileName)) {
448                            return;
449                    }
450    
451                    int x = fileName.lastIndexOf(StringPool.SLASH);
452                    int y = fileName.indexOf(CharPool.PERIOD);
453    
454                    String testPackagePath = StringUtil.replace(
455                            fileName.substring(0, x), StringPool.SLASH, StringPool.PERIOD);
456                    String testName = fileName.substring(x + 1, y);
457                    String testMethodName =
458                            "test" + testName.substring(0, testName.length() - 4);
459                    String testFileName = fileName.substring(0, y) + ".java";
460    
461                    StringBundler sb = new StringBundler();
462    
463                    sb.append("package ");
464                    sb.append(testPackagePath);
465                    sb.append(";\n");
466    
467                    sb.append("import com.liferay.portal.kernel.util.FileUtil;\n");
468                    sb.append("import com.liferay.portal.kernel.util.StringPool;\n");
469                    sb.append("import com.liferay.portalweb.portal.BaseTestCase;\n");
470                    sb.append(
471                            "import com.liferay.portalweb.portal.util.BrowserCommands;\n");
472                    sb.append(
473                            "import com.liferay.portalweb.portal.util.RuntimeVariables;\n");
474    
475                    sb.append("public class ");
476                    sb.append(testName);
477                    sb.append(" extends BaseTestCase {");
478    
479                    sb.append("public void ");
480                    sb.append(testMethodName);
481                    sb.append("() throws Exception {");
482    
483                    String content = readFile(fileName);
484    
485                    if (!content.contains("<title>" + testName + "</title>") ||
486                            !content.contains("colspan=\"3\">" + testName + "</td>")) {
487    
488                            System.out.println(testName + " has an invalid test name");
489                    }
490    
491                    if (content.contains("&amp;")) {
492                            content = StringUtil.replace(content, "&amp;", "&");
493    
494                            writeFile(fileName, content, false);
495                    }
496    
497                    if (content.contains("&gt;")) {
498                            content = StringUtil.replace(content, "&gt;", ">");
499    
500                            writeFile(fileName, content, false);
501                    }
502    
503                    if (content.contains("&lt;")) {
504                            content = StringUtil.replace(content, "&lt;", "<");
505    
506                            writeFile(fileName, content, false);
507                    }
508    
509                    if (content.contains("&quot;")) {
510                            content = StringUtil.replace(content, "&quot;", "\"");
511    
512                            writeFile(fileName, content, false);
513                    }
514    
515                    x = content.indexOf("<tbody>");
516                    y = content.indexOf("</tbody>");
517    
518                    content = content.substring(x, y + 8);
519    
520                    Map<String, String> labels = new HashMap<String, String>();
521    
522                    int labelCount = 1;
523    
524                    Map<Integer, Boolean> takeScreenShots = new HashMap<Integer, Boolean>();
525    
526                    x = 0;
527                    y = 0;
528    
529                    while (true) {
530                            x = content.indexOf("<tr>", y);
531                            y = content.indexOf("\n</tr>", x);
532    
533                            if ((x == -1) || (y == -1)) {
534                                    break;
535                            }
536    
537                            x += 6;
538                            y++;
539    
540                            String step = content.substring(x, y);
541    
542                            String[] params = getParams(step);
543    
544                            String param1 = params[0];
545                            String param2 = fixParam(params[1]);
546    
547                            if (param1.equals("assertConfirmation")) {
548                                    int previousX = x - 6;
549    
550                                    previousX = content.lastIndexOf("<tr>", previousX - 1);
551                                    previousX += 6;
552    
553                                    takeScreenShots.put(previousX, Boolean.FALSE);
554                            }
555                            else if (param1.equals("label")) {
556                                    String label = labels.get(param2);
557    
558                                    if (label == null) {
559                                            labelCount++;
560    
561                                            label = labels.put(param2, String.valueOf(labelCount));
562                                    }
563                            }
564                    }
565    
566                    if (!labels.isEmpty()) {
567                            sb.append("int label = 1;");
568    
569                            sb.append("while (label >= 1) {");
570                            sb.append("switch (label) {");
571                            sb.append("case 1:");
572                    }
573    
574                    x = 0;
575                    y = 0;
576    
577                    sb.append("selenium.selectWindow(\"null\");");
578                    sb.append("selenium.selectFrame(\"relative=top\");");
579    
580                    while (true) {
581                            x = content.indexOf("<tr>", y);
582                            y = content.indexOf("\n</tr>", x);
583    
584                            if ((x == -1) || (y == -1)) {
585                                    break;
586                            }
587    
588                            x += 6;
589                            y++;
590    
591                            String step = content.substring(x, y);
592    
593                            String[] params = getParams(step);
594    
595                            String param1 = params[0];
596                            String param2 = fixParam(params[1]);
597                            String param3 = fixParam(params[2]);
598    
599                            if (param1.equals("addSelection") || param1.equals("clickAt") ||
600                                    param1.equals("doubleClickAt") || param1.equals("keyDown") ||
601                                    param1.equals("keyPress") || param1.equals("keyUp") ||
602                                    param1.equals("mouseMoveAt") || param1.equals("openWindow") ||
603                                    param1.equals("select") || param1.equals("sendKeys") ||
604                                    param1.equals("type") || param1.equals("typeFrame") ||
605                                    param1.equals("typeKeys") ||
606                                    param1.equals("uploadCommonFile") ||
607                                    param1.equals("uploadFile") ||
608                                    param1.equals("uploadTempFile") ||
609                                    param1.equals("waitForPopUp")) {
610    
611                                    sb.append("selenium.");
612                                    sb.append(param1);
613                                    sb.append(StringPool.OPEN_PARENTHESIS);
614    
615                                    if (param2.startsWith("${")) {
616                                            sb.append("RuntimeVariables.getValue(\"");
617    
618                                            String text = param2.substring(2, param2.length() - 1);
619    
620                                            sb.append(text);
621                                            sb.append("\")");
622                                    }
623                                    else {
624                                            sb.append("\"");
625                                            sb.append(param2);
626                                            sb.append("\"");
627                                    }
628    
629                                    sb.append(", RuntimeVariables.replace(");
630    
631                                    if (param3.startsWith("${")) {
632                                            sb.append("RuntimeVariables.getValue(\"");
633    
634                                            String text = param3.substring(2, param3.length() - 1);
635    
636                                            sb.append(text);
637                                            sb.append("\")");
638                                    }
639                                    else if (param3.startsWith("value=${")) {
640                                            sb.append("\"value=\" + RuntimeVariables.getValue(\"");
641    
642                                            String text = param3.substring(8, param3.length() - 1);
643    
644                                            sb.append(text);
645                                            sb.append("\")");
646                                    }
647                                    else {
648                                            sb.append("\"");
649                                            sb.append(param3);
650                                            sb.append("\"");
651                                    }
652    
653                                    sb.append("));");
654                            }
655                            else if (param1.equals("assertAlert") ||
656                                             param1.equals("assertNotAlert")) {
657    
658                                    if (param1.equals("assertAlert")) {
659                                            sb.append("assertEquals");
660                                    }
661                                    else if (param1.equals("assertNotAlert")) {
662                                            sb.append("assertNotEquals");
663                                    }
664    
665                                    sb.append("(\"");
666                                    sb.append(param2);
667                                    sb.append("\", selenium.getAlert());");
668                            }
669                            else if (param1.equals("assertChecked") ||
670                                             param1.equals("assertNotChecked")) {
671    
672                                    if (param1.equals("assertChecked")) {
673                                            sb.append("assertTrue");
674                                    }
675                                    else if (param1.equals("assertNotChecked")) {
676                                            sb.append("assertFalse");
677                                    }
678    
679                                    sb.append("(selenium.isChecked(\"");
680                                    sb.append(param2);
681                                    sb.append("\"));");
682                            }
683                            else if (param1.equals("assertConfirmation")) {
684                                    param2 = StringUtil.replace(param2, "?", "[\\\\s\\\\S]");
685    
686                                    sb.append("assertTrue(selenium.getConfirmation().matches(\"^");
687                                    sb.append(param2);
688                                    sb.append("$\"));");
689                            }
690                            else if (param1.equals("assertLocation") ||
691                                             param1.equals("assertNotLocation")) {
692    
693                                    if (param1.equals("assertLocation")) {
694                                            sb.append("assertEquals");
695                                    }
696                                    else if (param1.equals("assertNotLocation")) {
697                                            sb.append("assertNotEquals");
698                                    }
699    
700                                    sb.append("(RuntimeVariables.replace(\"");
701                                    sb.append(param2);
702                                    sb.append("\"), selenium.getLocation());");
703                            }
704                            else if (param1.equals("assertElementNotPresent") ||
705                                             param1.equals("assertElementPresent")) {
706    
707                                    sb.append("assertTrue(selenium.");
708    
709                                    if (param1.equals("assertElementNotPresent")) {
710                                            sb.append("isElementNotPresent");
711                                    }
712                                    else if (param1.equals("assertElementPresent")) {
713                                            sb.append("isElementPresent");
714                                    }
715    
716                                    sb.append("(\"");
717                                    sb.append(param2);
718                                    sb.append("\"));");
719                            }
720                            else if (param1.equals("assertNotPartialText") ||
721                                             param1.equals("assertPartialText")) {
722    
723                                    if (param1.equals("assertNotPartialText")) {
724                                            sb.append("assertFalse");
725                                    }
726                                    else if (param1.equals("assertPartialText")) {
727                                            sb.append("assertTrue");
728                                    }
729    
730                                    sb.append("(selenium.isPartialText(\"");
731                                    sb.append(param2);
732                                    sb.append("\", ");
733    
734                                    if (param3.startsWith("${")) {
735                                            sb.append("RuntimeVariables.getValue(\"");
736    
737                                            String text = param3.substring(2, param3.length() - 1);
738    
739                                            sb.append(text);
740                                            sb.append("\")");
741                                    }
742                                    else {
743                                            sb.append("\"");
744                                            sb.append(param3);
745                                            sb.append("\"");
746                                    }
747    
748                                    sb.append("));");
749                            }
750                            else if (param1.equals("assertNotSelectedLabel") ||
751                                             param1.equals("assertSelectedLabel")) {
752    
753                                    if (param1.equals("assertNotSelectedLabel")) {
754                                            sb.append("assertNotEquals");
755                                    }
756                                    else if (param1.equals("assertSelectedLabel")) {
757                                            sb.append("assertEquals");
758                                    }
759    
760                                    sb.append(StringPool.OPEN_PARENTHESIS);
761    
762                                    if (param3.startsWith("${")) {
763                                            sb.append("RuntimeVariables.getValue(\"");
764    
765                                            String text = param3.substring(2, param3.length() - 1);
766    
767                                            sb.append(text);
768                                            sb.append("\")");
769                                    }
770                                    else {
771                                            sb.append("\"");
772                                            sb.append(param3);
773                                            sb.append("\"");
774                                    }
775    
776                                    sb.append(", selenium.getSelectedLabel(\"");
777                                    sb.append(param2);
778                                    sb.append("\"));");
779                            }
780                            else if (param1.equals("assertNotSelectedLabels") ||
781                                             param1.equals("assertSelectedLabels")) {
782    
783                                    if (param1.equals("assertNotSelectedLabels")) {
784                                            sb.append("assertNotEquals");
785                                    }
786                                    else if (param1.equals("assertSelectedLabels")) {
787                                            sb.append("assertEquals");
788                                    }
789    
790                                    sb.append("(\"");
791                                    sb.append(param3);
792                                    sb.append("\", join(selenium.getSelectedLabels(\"");
793                                    sb.append(param2);
794                                    sb.append("\"), \',\'));");
795                            }
796                            else if (param1.equals("assertNotText") ||
797                                             param1.equals("assertText")) {
798    
799                                    if (param1.equals("assertNotText")) {
800                                            sb.append("assertNotEquals");
801                                    }
802                                    else if (param1.equals("assertText")) {
803                                            sb.append("assertEquals");
804                                    }
805    
806                                    sb.append("(RuntimeVariables.replace(\"");
807                                    sb.append(param3);
808                                    sb.append("\"), selenium.getText(\"");
809                                    sb.append(param2);
810                                    sb.append("\"));");
811                            }
812                            else if (param1.equals("assertNotValue") ||
813                                             param1.equals("assertValue")) {
814    
815                                    if (param1.equals("assertNotValue")) {
816                                            sb.append("assertNotEquals");
817                                    }
818                                    else if (param1.equals("assertValue")) {
819                                            sb.append("assertEquals");
820                                    }
821    
822                                    sb.append("(\"");
823                                    sb.append(param3);
824                                    sb.append("\", selenium.getValue(\"");
825                                    sb.append(param2);
826                                    sb.append("\"));");
827                            }
828                            else if (param1.equals("assertNotVisible") ||
829                                             param1.equals("assertVisible")) {
830    
831                                    if (param1.equals("assertNotVisible")) {
832                                            sb.append("assertFalse");
833                                    }
834                                    else if (param1.equals("assertVisible")) {
835                                            sb.append("assertTrue");
836                                    }
837    
838                                    sb.append(StringPool.OPEN_PARENTHESIS);
839                                    sb.append("selenium.isVisible(\"");
840                                    sb.append(param2);
841                                    sb.append("\"));");
842                            }
843                            else if (param1.equals("assertSelectOptions")) {
844                                    String[] expectedArray = StringUtil.split(param3);
845    
846                                    sb.append("String[] actualArray = ");
847                                    sb.append("selenium.getSelectOptions(\"");
848                                    sb.append(param2);
849                                    sb.append("\");");
850    
851                                    sb.append("assertEquals(");
852                                    sb.append(expectedArray.length);
853                                    sb.append(", actualArray.length);");
854    
855                                    for (int i = 0; i < expectedArray.length; i++) {
856                                            sb.append("assertEquals(\"");
857                                            sb.append(expectedArray[i]);
858                                            sb.append("\", actualArray[");
859                                            sb.append(i);
860                                            sb.append("]);");
861                                    }
862                            }
863                            else if (param1.equals("assertTextNotPresent") ||
864                                             param1.equals("assertTextPresent")) {
865    
866                                    if (param1.equals("assertTextNotPresent")) {
867                                            sb.append("assertFalse");
868                                    }
869                                    else if (param1.equals("assertTextPresent")) {
870                                            sb.append("assertTrue");
871                                    }
872    
873                                    sb.append("(selenium.isTextPresent(\"");
874                                    sb.append(param2);
875                                    sb.append("\"));");
876                            }
877                            else if (param1.equals("captureEntirePageScreenshot")) {
878                                    int pos = param2.lastIndexOf("\\");
879    
880                                    String dirName = param2.substring(0, pos + 1);
881    
882                                    sb.append("FileUtil.mkdirs(RuntimeVariables.replace(\"");
883                                    sb.append(dirName);
884                                    sb.append("\"));");
885                                    sb.append("selenium.captureEntirePageScreenshot(");
886                                    sb.append("RuntimeVariables.replace(\"");
887                                    sb.append(param2);
888                                    sb.append("\"), \"\");");
889                            }
890                            else if (param1.equals("check") || param1.equals("click") ||
891                                             param1.equals("doubleClick") ||
892                                             param1.equals("downloadTempFile") ||
893                                             param1.equals("makeVisible") ||
894                                             param1.equals("mouseDown") || param1.equals("mouseMove") ||
895                                             param1.equals("mouseOver") || param1.equals("mouseUp") ||
896                                             param1.equals("open") || param1.equals("runScript") ||
897                                             param1.equals("selectFrame") ||
898                                             param1.equals("selectPopUp") ||
899                                             param1.equals("selectWindow") ||
900                                             param1.equals("setTimeout") ||
901                                             param1.equals("setTimeoutImplicit") ||
902                                             param1.equals("uncheck") ||
903                                             param1.equals("waitForConfirmation") ||
904                                             param1.equals("waitForElementPresent") ||
905                                             param1.equals("waitForElementNotPresent") ||
906                                             param1.equals("waitForNotVisible") ||
907                                             param1.equals("waitForTextNotPresent") ||
908                                             param1.equals("waitForTextPresent") ||
909                                             param1.equals("waitForVisible")) {
910    
911                                    if (param1.equals("downloadTempFile")) {
912                                            sb.append("BrowserCommands.");
913                                    }
914                                    else {
915                                            sb.append("selenium.");
916                                    }
917    
918                                    sb.append(param1);
919                                    sb.append(StringPool.OPEN_PARENTHESIS);
920    
921                                    if (param2.startsWith("${")) {
922                                            sb.append("RuntimeVariables.getValue(\"");
923    
924                                            String text = param2.substring(2, param2.length() - 1);
925    
926                                            sb.append(text);
927                                            sb.append("\")");
928                                    }
929                                    else {
930                                            sb.append("\"");
931                                            sb.append(param2);
932                                            sb.append("\"");
933                                    }
934    
935                                    sb.append(");");
936                            }
937                            else if (param1.equals("clickAndWait")) {
938                                    sb.append("selenium.click(RuntimeVariables.replace(\"");
939                                    sb.append(param2);
940                                    sb.append("\"));");
941                                    sb.append("selenium.waitForPageToLoad(\"30000\");");
942                            }
943                            else if (param1.equals("clickAtAndWait") ||
944                                             param1.equals("keyDownAndWait") ||
945                                             param1.equals("keyPressAndWait") ||
946                                             param1.equals("keyUpAndWait") ||
947                                             param1.equals("selectAndWait")) {
948    
949                                    sb.append("selenium.");
950    
951                                    String text = param1.substring(0, param1.length() - 7);
952    
953                                    sb.append(text);
954                                    sb.append("(\"");
955                                    sb.append(param2);
956                                    sb.append("\", RuntimeVariables.replace(\"");
957                                    sb.append(param3);
958                                    sb.append("\"));");
959                                    sb.append("selenium.waitForPageToLoad(\"30000\");");
960                            }
961                            else if (param1.equals("close") || param1.equals("goBack") ||
962                                             param1.equals("refresh") ||
963                                             param1.equals("setBrowserOption") ||
964                                             param1.equals("setDefaultTimeout") ||
965                                             param1.equals("setDefaultTimeoutImplicit") ||
966                                             param1.equals("windowFocus") ||
967                                             param1.equals("windowMaximize")) {
968    
969                                    if (param1.equals("setBrowserOption")) {
970                                            sb.append("BrowserCommands.");
971                                    }
972                                    else {
973                                            sb.append("selenium.");
974                                    }
975    
976                                    sb.append(param1);
977                                    sb.append("();");
978                            }
979                            else if (param1.equals("dragAndDropToObject")) {
980                                    sb.append("selenium.");
981                                    sb.append("dragAndDropToObject(\"");
982                                    sb.append(param2);
983                                    sb.append("\", \"");
984                                    sb.append(param3);
985                                    sb.append("\");");
986                            }
987                            else if (param1.equals("echo")) {
988                                    sb.append("System.out.println(");
989    
990                                    if (param2.startsWith("${")) {
991                                            sb.append("RuntimeVariables.getValue(\"");
992    
993                                            String text = param2.substring(2, param2.length() - 1);
994    
995                                            sb.append(text);
996                                            sb.append("\")");
997                                    }
998                                    else {
999                                            sb.append("\"");
1000                                            sb.append(param2);
1001                                            sb.append("\"");
1002                                    }
1003    
1004                                    sb.append(");");
1005                            }
1006                            else if (param1.equals("goBackAndWait") ||
1007                                             param1.equals("refreshAndWait") ||
1008                                             param1.equals("windowMaximizeAndWait")) {
1009    
1010                                    String text = param1.substring(0, param1.length() - 7);
1011    
1012                                    sb.append("selenium.");
1013                                    sb.append(text);
1014                                    sb.append("();");
1015                                    sb.append("selenium.waitForPageToLoad(\"30000\");");
1016                            }
1017                            else if (param1.equals("gotoIf")) {
1018                                    String conditional = StringUtil.replace(
1019                                            param2, new String[] {"${", "}"}, new String[] {"", ""});
1020    
1021                                    sb.append("if (");
1022                                    sb.append(conditional);
1023                                    sb.append(") {");
1024                                    sb.append("label =");
1025                                    sb.append(labels.get(param3));
1026                                    sb.append(";");
1027                                    sb.append("continue;");
1028                                    sb.append("}");
1029                            }
1030                            else if (param1.equals("label")) {
1031                                    String label = labels.get(param2);
1032    
1033                                    sb.append("case ");
1034                                    sb.append(label);
1035                                    sb.append(":");
1036                            }
1037                            else if (param1.equals("pause")) {
1038                                    sb.append("Thread.sleep(");
1039                                    sb.append(param2);
1040                                    sb.append(");");
1041                            }
1042                            else if (param1.equals("store")) {
1043                                    sb.append("boolean ");
1044                                    sb.append(param3);
1045                                    sb.append(" = ");
1046    
1047                                    if (param2.startsWith("eval(")) {
1048                                            String eval = param2.substring(5, param2.length() - 1);
1049    
1050                                            eval = StringUtil.replace(eval, "'", "\"");
1051    
1052                                            sb.append(eval);
1053                                    }
1054    
1055                                    sb.append(";");
1056                            }
1057                            else if (param1.equals("storeAttribute")) {
1058                                    sb.append("String ");
1059                                    sb.append(param3);
1060                                    sb.append(" = selenium.getAttribute(\"");
1061                                    sb.append(param2);
1062                                    sb.append("\");");
1063    
1064                                    sb.append("RuntimeVariables.setValue(\"");
1065                                    sb.append(param3);
1066                                    sb.append("\", ");
1067                                    sb.append(param3);
1068                                    sb.append(");");
1069                            }
1070                            else if (param1.equals("storeChecked")) {
1071                                    sb.append("boolean ");
1072                                    sb.append(param3);
1073                                    sb.append(" = selenium.isChecked(\"");
1074                                    sb.append(param2);
1075                                    sb.append("\");");
1076                            }
1077                            else if (param1.equals("storeCurrentDay")) {
1078                                    sb.append("String ");
1079                                    sb.append(param2);
1080                                    sb.append(" = selenium.getCurrentDay();");
1081    
1082                                    sb.append("RuntimeVariables.setValue(\"");
1083                                    sb.append(param2);
1084                                    sb.append("\", ");
1085                                    sb.append(param2);
1086                                    sb.append(");");
1087                            }
1088                            else if (param1.equals("storeCurrentMonth")) {
1089                                    sb.append("String ");
1090                                    sb.append(param2);
1091                                    sb.append(" = selenium.getCurrentMonth();");
1092    
1093                                    sb.append("RuntimeVariables.setValue(\"");
1094                                    sb.append(param2);
1095                                    sb.append("\", ");
1096                                    sb.append(param2);
1097                                    sb.append(");");
1098                            }
1099                            else if (param1.equals("storeCurrentYear")) {
1100                                    sb.append("String ");
1101                                    sb.append(param2);
1102                                    sb.append(" = selenium.getCurrentYear();");
1103    
1104                                    sb.append("RuntimeVariables.setValue(\"");
1105                                    sb.append(param2);
1106                                    sb.append("\", ");
1107                                    sb.append(param2);
1108                                    sb.append(");");
1109                            }
1110                            else if (param1.equals("storeElementPresent")) {
1111                                    sb.append("boolean ");
1112                                    sb.append(param3);
1113                                    sb.append(" = selenium.isElementPresent(\"");
1114                                    sb.append(param2);
1115                                    sb.append("\");");
1116                            }
1117                            else if (param1.equals("storeFirstNumber")) {
1118                                    sb.append("String ");
1119                                    sb.append(param3);
1120                                    sb.append(" = selenium.getFirstNumber(\"");
1121                                    sb.append(param2);
1122                                    sb.append("\");");
1123    
1124                                    sb.append("RuntimeVariables.setValue(\"");
1125                                    sb.append(param3);
1126                                    sb.append("\", ");
1127                                    sb.append(param3);
1128                                    sb.append(");");
1129                            }
1130                            else if (param1.equals("storeFirstNumberIncrement")) {
1131                                    sb.append("String ");
1132                                    sb.append(param3);
1133                                    sb.append(" = selenium.getFirstNumberIncrement(\"");
1134                                    sb.append(param2);
1135                                    sb.append("\");");
1136    
1137                                    sb.append("RuntimeVariables.setValue(\"");
1138                                    sb.append(param3);
1139                                    sb.append("\", ");
1140                                    sb.append(param3);
1141                                    sb.append(");");
1142                            }
1143                            else if (param1.equals("storeLocation")) {
1144                                    sb.append("String ");
1145                                    sb.append(param2);
1146                                    sb.append(" = selenium.getLocation();");
1147    
1148                                    sb.append("RuntimeVariables.setValue(\"");
1149                                    sb.append(param2);
1150                                    sb.append("\", ");
1151                                    sb.append(param2);
1152                                    sb.append(");");
1153                            }
1154                            else if (param1.equals("storeNumberIncrement")) {
1155                                    sb.append("String ");
1156                                    sb.append(param3);
1157                                    sb.append(" = selenium.getNumberIncrement(");
1158                                    sb.append("RuntimeVariables.getValue(\"");
1159    
1160                                    String expression = param2.substring(2, param2.length() - 1);
1161    
1162                                    sb.append(expression);
1163                                    sb.append("\"));");
1164    
1165                                    sb.append("RuntimeVariables.setValue(\"");
1166                                    sb.append(param3);
1167                                    sb.append("\", ");
1168                                    sb.append(param3);
1169                                    sb.append(");");
1170                            }
1171                            else if (param1.equals("storeNumberDecrement")) {
1172                                    sb.append("String ");
1173                                    sb.append(param3);
1174                                    sb.append(" = selenium.getNumberDecrement(");
1175                                    sb.append("RuntimeVariables.getValue(\"");
1176    
1177                                    String expression = param2.substring(2, param2.length() - 1);
1178    
1179                                    sb.append(expression);
1180                                    sb.append("\"));");
1181    
1182                                    sb.append("RuntimeVariables.setValue(\"");
1183                                    sb.append(param3);
1184                                    sb.append("\", ");
1185                                    sb.append(param3);
1186                                    sb.append(");");
1187                            }
1188                            else if (param1.equals("storeText")) {
1189                                    sb.append("String ");
1190                                    sb.append(param3);
1191                                    sb.append(" = selenium.getText(\"");
1192                                    sb.append(param2);
1193                                    sb.append("\");");
1194    
1195                                    sb.append("RuntimeVariables.setValue(\"");
1196                                    sb.append(param3);
1197                                    sb.append("\", ");
1198                                    sb.append(param3);
1199                                    sb.append(");");
1200                            }
1201                            else if (param1.equals("storeValue")) {
1202                                    sb.append("String ");
1203                                    sb.append(param3);
1204                                    sb.append(" = selenium.getValue(\"");
1205                                    sb.append(param2);
1206                                    sb.append("\");");
1207    
1208                                    sb.append("RuntimeVariables.setValue(\"");
1209                                    sb.append(param3);
1210                                    sb.append("\", ");
1211                                    sb.append(param3);
1212                                    sb.append(");");
1213                            }
1214                            else if (param1.equals("storeVisible")) {
1215                                    sb.append("boolean ");
1216                                    sb.append(param3);
1217                                    sb.append(" = selenium.isVisible(\"");
1218                                    sb.append(param2);
1219                                    sb.append("\");");
1220                            }
1221                            else if (param1.equals("verifyElementNotPresent") ||
1222                                             param1.equals("verifyElementPresent")) {
1223    
1224                                    if (param1.equals("verifyElementNotPresent")) {
1225                                            sb.append("verifyFalse");
1226                                    }
1227                                    else if (param1.equals("verifyElementPresent")) {
1228                                            sb.append("verifyTrue");
1229                                    }
1230    
1231                                    sb.append("(selenium.isElementPresent(\"");
1232                                    sb.append(param2);
1233                                    sb.append("\"));");
1234                            }
1235                            else if (param1.equals("verifyTextNotPresent") ||
1236                                             param1.equals("verifyTextPresent")) {
1237    
1238                                    if (param1.equals("verifyTextNotPresent")) {
1239                                            sb.append("verifyFalse");
1240                                    }
1241                                    else if (param1.equals("verifyTextPresent")) {
1242                                            sb.append("verifyTrue");
1243                                    }
1244    
1245                                    sb.append("(selenium.isTextPresent(\"");
1246                                    sb.append(param2);
1247                                    sb.append("\"));");
1248                            }
1249                            else if (param1.equals("verifyTitle")) {
1250                                    sb.append("verifyEquals(\"");
1251                                    sb.append(param2);
1252                                    sb.append("\", selenium.getTitle());");
1253                            }
1254                            else if (param1.equals("waitForNotPartialText") ||
1255                                             param1.equals("waitForNotSelectedLabel") ||
1256                                             param1.equals("waitForNotText") ||
1257                                             param1.equals("waitForNotValue") ||
1258                                             param1.equals("waitForPartialText") ||
1259                                             param1.equals("waitForSelectedLabel") ||
1260                                             param1.equals("waitForText") ||
1261                                             param1.equals("waitForValue")) {
1262    
1263                                    sb.append("selenium.");
1264                                    sb.append(param1);
1265                                    sb.append("(\"");
1266                                    sb.append(param2);
1267                                    sb.append("\",");
1268    
1269                                    if (param3.startsWith("${")) {
1270                                            sb.append("RuntimeVariables.getValue(\"");
1271    
1272                                            String text = param3.substring(2, param3.length() - 1);
1273    
1274                                            sb.append(text);
1275                                            sb.append("\")");
1276                                    }
1277                                    else {
1278                                            sb.append("\"");
1279                                            sb.append(param3);
1280                                            sb.append("\"");
1281                                    }
1282    
1283                                    sb.append(");");
1284                            }
1285                            else {
1286                                    System.out.println(
1287                                            testFileName + " has an unknown command " + param1);
1288                            }
1289                    }
1290    
1291                    if (!labels.isEmpty()) {
1292                            sb.append("case 100:");
1293                            sb.append("label = -1;");
1294                            sb.append("}");
1295                            sb.append("}");
1296                    }
1297    
1298                    sb.append("}");
1299                    sb.append("}");
1300    
1301                    writeFile(testFileName, sb.toString(), true);
1302            }
1303    
1304            protected void translateTestSuite(String fileName) throws Exception {
1305                    int x = fileName.lastIndexOf(StringPool.SLASH);
1306                    int y = fileName.indexOf(StringPool.PERIOD);
1307    
1308                    String testPackagePath = StringUtil.replace(
1309                            fileName.substring(0, x), StringPool.SLASH, StringPool.PERIOD);
1310                    String testName = fileName.substring(x + 1, y);
1311                    String testFileName = fileName.substring(0, y) + ".java";
1312    
1313                    StringBundler sb = new StringBundler();
1314    
1315                    sb.append("package ");
1316                    sb.append(testPackagePath);
1317                    sb.append(";\n");
1318    
1319                    sb.append("import com.liferay.portalweb.portal.BaseTestSuite;\n");
1320                    sb.append("import com.liferay.portalweb.portal.StopSeleniumTest;\n");
1321    
1322                    String content = readFile(fileName);
1323    
1324                    content = formatTestSuite(fileName, content);
1325    
1326                    x = 0;
1327                    y = 0;
1328    
1329                    while (content.indexOf("<a href=\"", x) != -1) {
1330                            x = content.indexOf("<a href=\"", x) + 9;
1331                            y = content.indexOf("\">", x);
1332    
1333                            String testCaseName = content.substring(x, y);
1334    
1335                            if (!testCaseName.contains("..")) {
1336                                    continue;
1337                            }
1338    
1339                            if (!testCaseName.contains("../portalweb/")) {
1340                                    throw new IllegalArgumentException(
1341                                            fileName + " has improper relative path");
1342                            }
1343    
1344                            testCaseName = StringUtil.replace(
1345                                    testCaseName, "../../portalweb/", "../");
1346    
1347                            int z = fileName.lastIndexOf(StringPool.SLASH);
1348    
1349                            String importClassName = fileName.substring(0, z);
1350    
1351                            int count = StringUtil.count(testCaseName, "..");
1352    
1353                            for (int i = 0; i < count; i++) {
1354                                    z = importClassName.lastIndexOf(StringPool.SLASH);
1355    
1356                                    importClassName = fileName.substring(0, z);
1357                            }
1358    
1359                            z = testCaseName.lastIndexOf("../", z);
1360    
1361                            importClassName += testCaseName.substring(
1362                                    z + 2, testCaseName.length() -5);
1363                            importClassName = StringUtil.replace(
1364                                    importClassName, StringPool.SLASH, StringPool.PERIOD);
1365    
1366                            sb.append("import ");
1367                            sb.append(importClassName);
1368                            sb.append(";\n");
1369                    }
1370    
1371                    sb.append("import junit.framework.Test;\n");
1372                    sb.append("import junit.framework.TestSuite;\n");
1373    
1374                    sb.append("public class ");
1375                    sb.append(testName);
1376                    sb.append(" extends BaseTestSuite {");
1377    
1378                    sb.append("public static Test suite() {");
1379    
1380                    sb.append("TestSuite testSuite = new TestSuite();");
1381    
1382                    x = content.indexOf("</b></td></tr>");
1383                    y = content.indexOf("</tbody>");
1384    
1385                    content = content.substring(x + 15, y);
1386    
1387                    x = 0;
1388                    y = 0;
1389    
1390                    while (true) {
1391                            x = content.indexOf("\">", x);
1392                            y = content.indexOf("</a>", x);
1393    
1394                            if ((x == -1) || (y == -1)) {
1395                                    break;
1396                            }
1397    
1398                            String className = content.substring(x + 2, y);
1399    
1400                            x += className.length();
1401    
1402                            sb.append("testSuite.addTestSuite(");
1403                            sb.append(className);
1404                            sb.append(".class);");
1405                    }
1406    
1407                    sb.append("return testSuite;");
1408                    sb.append("}");
1409                    sb.append("}");
1410    
1411                    writeFile(testFileName, sb.toString(), true);
1412            }
1413    
1414            protected void writeFile(String fileName, String content, boolean format)
1415                    throws Exception {
1416    
1417                    File file = new File(_basedir + "/" + fileName);
1418    
1419                    if (format) {
1420                            ServiceBuilder.writeFile(file, content);
1421                    }
1422                    else {
1423                            System.out.println("Writing " + file);
1424    
1425                            FileUtil.write(file, content);
1426                    }
1427            }
1428    
1429            private static final String[] _FIX_PARAM_NEW_SUBS = {"\\n", "\\n"};
1430    
1431            private static final String[] _FIX_PARAM_OLD_SUBS = {"\\\\n", "<br />"};
1432    
1433            private String _basedir;
1434            private boolean _reportDuplicates;
1435    
1436            private class TestHtmlCountComparator
1437                    implements Comparator<ObjectValuePair<String, IntegerWrapper>> {
1438    
1439                    @Override
1440                    public int compare(
1441                            ObjectValuePair<String, IntegerWrapper> object1,
1442                            ObjectValuePair<String, IntegerWrapper> object2) {
1443    
1444                            IntegerWrapper integerWrapper1 = object1.getValue();
1445                            IntegerWrapper integerWrapper2 = object2.getValue();
1446    
1447                            if (integerWrapper1.getValue() > integerWrapper2.getValue()) {
1448                                    return -1;
1449                            }
1450                            else if (integerWrapper1.getValue() < integerWrapper2.getValue()) {
1451                                    return 1;
1452                            }
1453                            else {
1454                                    return 0;
1455                            }
1456                    }
1457    
1458            }
1459    
1460    }