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