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