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