← Back to branch summary

~james-page/ubuntu/natty/rhino/fix-304702

« back to all changes in this revision

Viewing changes to testsrc/org/mozilla/javascript/drivers/JsDriver.java

  • Committer: Bazaar Package Importer
  • Author(s): Damien Raude-Morvan, Marcus Better, Matthias Klose, Damien Raude-Morvan
  • Date: 2009-04-13 02:40:15 UTC
  • mfrom: (11.1.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090413024015-i21xnoehukpipbcw
Tags: 1.7R2-1
http://bugs.debian.org/512498
[ Marcus Better ]
* Updated package descriptions.

[ Matthias Klose ]
* (Build-)depend on default-jre-headless/-jdk.
* Drop alternate dependencies on java2-runtime-headless and
  java2-runtime-headless. The binary package is currently built to
  require a java5 runtime.

[ Damien Raude-Morvan ]
* New upstream release.
  - new 02_exclude-jdk15 patch to exclude already compiled classes
    for jdk15 rebuild: gcj doesn't handle compiling classes already
    on its classpath
  - new "rhino-debugger" launcher for Rhino Debugger Swing UI
  - update "rhino" launcher to exclude OpenJDK bundled rhino (Closes: #512498)
* debian/{postinst,prerm }: scripts should take care of errors,
  add set -e before any instruction
* debian/rules: add new get-orig-source target using uscan
* debian/control:
  - Build-Depends on specialized default-jdk-builddep instead of
  default-jdk
  - Bump Standards-Version to 3.8.1: Wrap Uploaders field
  - add Depends on ${misc:Depends}

Show diffs side-by-side

added added

removed removed

Lines of Context:
testsrc/org/mozilla/javascript/drivers/JsDriver.java
45
45
import org.mozilla.javascript.tools.shell.*;
46
46
 
47
47
/**
48
 
 * @version $Id: JsDriver.java,v 1.5 2007/10/11 19:44:10 szegedia%freemail.hu Exp $
 
48
 * @version $Id: JsDriver.java,v 1.8.2.1 2008/12/12 10:27:42 hannes%helma.at Exp $
49
49
 */
50
50
public class JsDriver {
51
51
    private JsDriver() {
67
67
        private String[] list;
68
68
        private String[] skip;
69
69
 
70
 
        Tests(File testDirectory, String[] list, String[] skip) {
 
70
        Tests(File testDirectory, String[] list, String[] skip) throws IOException {
71
71
            this.testDirectory = testDirectory;
72
72
            this.list = getTestList(list);
73
73
            this.skip = getTestList(skip);
74
74
        }
75
75
        
76
 
        private String[] getTestList(String[] tests) {
77
 
          ArrayList list = new ArrayList();
 
76
        private String[] getTestList(String[] tests) throws IOException {
 
77
          ArrayList<String> list = new ArrayList<String>();
78
78
          for (int i=0; i < tests.length; i++) {
79
79
            if (tests[i].startsWith("@"))
80
 
              addTestsFromFile(tests[i].substring(1), list);
 
80
              TestUtils.addTestsFromFile(tests[i].substring(1), list);
81
81
            else
82
82
              list.add(tests[i]);
83
83
          }
84
 
          return (String[])list.toArray(new String[0]);
85
 
        }
86
 
        
87
 
        private void addTestsFromFile(String filename, ArrayList list) {
88
 
            try {
89
 
                Properties props = new Properties();
90
 
                props.load(new FileInputStream(new File(filename)));
91
 
                list.addAll(props.keySet());
92
 
            } catch (IOException e) {
93
 
                throw new RuntimeException("Could not read file '" + filename + "'", e);
94
 
            }           
95
 
        }
96
 
 
97
 
        private boolean matches(String[] patterns, String path) {
98
 
            for (int i=0; i<patterns.length; i++) {
99
 
                if (path.startsWith(patterns[i])) {
100
 
                    return true;
101
 
                }
102
 
            }
103
 
            return false;
 
84
          return list.toArray(new String[0]);
104
85
        }
105
86
 
106
87
        private boolean matches(String path) {
107
88
            if (list.length == 0) return true;
108
 
            return matches(list, path);
 
89
            return TestUtils.matches(list, path);
109
90
        }
110
91
 
111
92
        private boolean excluded(String path) {
112
93
            if (skip.length == 0) return false;
113
 
            return matches(skip, path);
 
94
            return TestUtils.matches(skip, path);
114
95
        }
115
96
 
116
 
        private void addFiles(List rv, String prefix, File directory) {
 
97
        private void addFiles(List<Script> rv, String prefix, File directory) {
117
98
            File[] files = directory.listFiles();
118
99
            if (files == null) throw new RuntimeException("files null for " + directory);
119
100
            for (int i=0; i<files.length; i++) {
148
129
        }
149
130
 
150
131
        Script[] getFiles() {
151
 
            ArrayList rv = new ArrayList();
 
132
            ArrayList<Script> rv = new ArrayList<Script>();
152
133
            addFiles(rv, "", testDirectory);
153
 
            return (Script[])rv.toArray(new Script[0]);
 
134
            return rv.toArray(new Script[0]);
154
135
        }
155
136
    }
156
137
 
167
148
            this.trace = trace;
168
149
        }
169
150
 
 
151
        @Override
170
152
        void running(File jsFile) {
171
153
            try {
172
154
                console.println("Running: " + jsFile.getCanonicalPath());
176
158
            }
177
159
        }
178
160
 
 
161
        @Override
179
162
        void failed(String s) {
180
163
            console.println("Failed: " + jsFile + ": " + s);
181
164
            failed = true;
182
165
        }
183
166
 
 
167
        @Override
184
168
        void threw(Throwable t) {
185
169
            console.println("Failed: " + jsFile + " with exception.");
186
170
            console.println(ShellTest.getStackTrace(t));
187
171
            failed = true;
188
172
        }
189
173
 
 
174
        @Override
190
175
        void timedOut() {
191
176
            console.println("Failed: " + jsFile + ": timed out.");
192
177
            failed = true;
193
178
        }
194
179
 
 
180
        @Override
195
181
        void exitCodesWere(int expected, int actual) {
196
182
            if (expected != actual) {
197
183
                console.println("Failed: " + jsFile + " expected " + expected + " actual " + actual);
199
185
            }
200
186
        }
201
187
 
 
188
        @Override
202
189
        void outputWas(String s) {
203
190
            if (!failed) {
204
191
                console.println("Passed: " + jsFile);
281
268
            this.failureHtml = failureHtml;
282
269
        }
283
270
 
 
271
        @Override
284
272
        void running(File file) {
285
273
        }
286
274
 
 
275
        @Override
287
276
        void failed(String s) {
288
277
            failed = true;
289
278
            setContent(failureHtml, "failureDetails.reason", "Failure reason: \n" + s);
290
279
        }
291
280
 
 
281
        @Override
292
282
        void exitCodesWere(int expected, int actual) {
293
283
            if (expected != actual) {
294
284
                failed = true;
296
286
            }
297
287
        }
298
288
 
 
289
        @Override
299
290
        void threw(Throwable e) {
300
291
            failed = true;
301
292
            setContent(failureHtml, "failureDetails.reason", "Threw Java exception:\n" + newlineLineEndings(ShellTest.getStackTrace(e)));
302
293
        }
303
294
 
 
295
        @Override
304
296
        void timedOut() {
305
297
            failed = true;
306
298
            setContent(failureHtml, "failureDetails.reason", "Timed out.");
307
299
        }
308
300
 
 
301
        @Override
309
302
        void outputWas(String s) {
310
303
            this.output = s;
311
304
        }
375
368
                        root.appendChild(target);
376
369
                }
377
370
                
 
371
                @Override
378
372
                void running(File file) {
379
373
                        this.start = new Date();
380
374
                }
395
389
                        e.setTextContent( newlineLineEndings(content) );
396
390
                }
397
391
                
 
392
        @Override
398
393
                void exitCodesWere(int expected, int actual) {
399
394
                        finish();
400
395
                        Element exit = createElement(target, "exit");
402
397
                        exit.setAttribute("actual", String.valueOf(actual));
403
398
                }
404
399
                
 
400
        @Override
405
401
                void timedOut() {
406
402
                        finish();
407
403
                        createElement(target, "timedOut");
408
404
                }
409
405
                
 
406
        @Override
410
407
                void failed(String s) {
411
408
                        finish();
412
409
                        Element failed = createElement(target, "failed");
413
410
                        setTextContent(failed, s);
414
411
                }
415
412
                
 
413
        @Override
416
414
                void outputWas(String message) {
417
415
                        finish();
418
416
                        Element output = createElement(target, "output");
419
417
                        setTextContent(output, message);
420
418
                }
421
419
                
 
420
        @Override
422
421
                void threw(Throwable t) {
423
422
                        finish();
424
423
                        Element threw = createElement(target, "threw");
577
576
            this.timeout = timeout;
578
577
        }
579
578
 
 
579
        @Override
580
580
        int getTimeoutMilliseconds() {
581
581
            return timeout;
582
582
        }
619
619
    }
620
620
 
621
621
    private static class Arguments {
622
 
        private ArrayList options = new ArrayList();
 
622
        private ArrayList<Option> options = new ArrayList<Option>();
623
623
 
624
624
        private Option bugUrl = new Option("b", "bugurl", false, false, "http://bugzilla.mozilla.org/show_bug.cgi?id=");
625
625
        private Option optimizationLevel = new Option("o", "optimization", false, false, "-1");
651
651
            private boolean flag;
652
652
            private boolean ignored;
653
653
 
654
 
            private ArrayList values = new ArrayList();
 
654
            private ArrayList<String> values = new ArrayList<String>();
655
655
 
656
656
            //    array: can this option have multiple values?
657
657
            //    flag: is this option a simple true/false switch?
658
 
            Option(String letterOption, String wordOption, boolean array, boolean flag, String unspecified) {
 
658
            Option(String letterOption, String wordOption, boolean array,
 
659
                   boolean flag, String unspecified)
 
660
            {
659
661
                this.letterOption = letterOption;
660
662
                this.wordOption = wordOption;
661
663
                this.flag = flag;
676
678
            }
677
679
 
678
680
            String getValue() {
679
 
                return (String)values.get(0);
 
681
                return values.get(0);
680
682
            }
681
683
 
682
684
            boolean getSwitch() {
689
691
            }
690
692
 
691
693
            String[] getValues() {
692
 
                return (String[])values.toArray(new String[0]);
 
694
                return values.toArray(new String[0]);
693
695
            }
694
696
 
695
 
            void process(List arguments) {
696
 
                String option = (String)arguments.get(0);
 
697
            void process(List<String> arguments) {
 
698
                String option = arguments.get(0);
697
699
                String dashLetter = (letterOption == null) ? (String)null : "-" + letterOption;
698
700
                if (option.equals(dashLetter) || option.equals("--" + wordOption)) {
699
701
                    arguments.remove(0);
700
702
                    if (flag) {
701
703
                        values.add(0, (String)null );
702
704
                    } else if (array) {
703
 
                        while( arguments.size() > 0 && !( (String)arguments.get(0) ).startsWith("-") ) {
 
705
                        while (arguments.size() > 0 &&
 
706
                               !arguments.get(0).startsWith("-"))
 
707
                        {
704
708
                            values.add(arguments.remove(0));
705
709
                        }
706
710
                    } else {
796
800
            return console;
797
801
        }
798
802
        
799
 
        void process(List arguments) {
 
803
        void process(List<String> arguments) {
800
804
            while(arguments.size() > 0) {
801
 
                String option = (String)arguments.get(0);
 
805
                String option = arguments.get(0);
802
806
                if (option.startsWith("--")) {
803
807
                    //    preprocess --name=value options into --name value
804
808
                    if (option.indexOf("=") != -1) {
817
821
                int lengthBefore = arguments.size();
818
822
                for (int i=0; i<options.size(); i++) {
819
823
                    if (arguments.size() > 0) {
820
 
                        ((Option)options.get(i)).process(arguments);
 
824
                        options.get(i).process(arguments);
821
825
                    }
822
826
                }
823
827
                
829
833
    }
830
834
 
831
835
    public static void main(String[] args) throws Throwable {
832
 
        ArrayList arguments = new ArrayList();
 
836
        ArrayList<String> arguments = new ArrayList<String>();
833
837
        arguments.addAll(Arrays.asList(args));
834
838
        Arguments clArguments = new Arguments();
835
839
        clArguments.process(arguments);