timcharper-CalendarDateSelect 1.11.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (40) hide show
  1. data/History.txt +216 -0
  2. data/MIT-LICENSE +20 -0
  3. data/Manifest.txt +39 -0
  4. data/Rakefile +31 -0
  5. data/Readme.txt +16 -0
  6. data/init.rb +1 -0
  7. data/js_test/functional/cds_test.html +334 -0
  8. data/js_test/prototype.js +4184 -0
  9. data/js_test/test.css +40 -0
  10. data/js_test/unit/cds_helper_methods.html +46 -0
  11. data/js_test/unittest.js +564 -0
  12. data/lib/calendar_date_select.rb +19 -0
  13. data/lib/calendar_date_select/calendar_date_select.rb +223 -0
  14. data/lib/calendar_date_select/includes_helper.rb +38 -0
  15. data/public/blank_iframe.html +2 -0
  16. data/public/images/calendar_date_select/calendar.gif +0 -0
  17. data/public/javascripts/calendar_date_select/calendar_date_select.js +442 -0
  18. data/public/javascripts/calendar_date_select/format_american.js +34 -0
  19. data/public/javascripts/calendar_date_select/format_db.js +27 -0
  20. data/public/javascripts/calendar_date_select/format_euro_24hr.js +7 -0
  21. data/public/javascripts/calendar_date_select/format_euro_24hr_ymd.js +7 -0
  22. data/public/javascripts/calendar_date_select/format_finnish.js +32 -0
  23. data/public/javascripts/calendar_date_select/format_hyphen_ampm.js +36 -0
  24. data/public/javascripts/calendar_date_select/format_iso_date.js +46 -0
  25. data/public/javascripts/calendar_date_select/format_italian.js +24 -0
  26. data/public/javascripts/calendar_date_select/locale/de.js +10 -0
  27. data/public/javascripts/calendar_date_select/locale/fi.js +10 -0
  28. data/public/javascripts/calendar_date_select/locale/fr.js +10 -0
  29. data/public/javascripts/calendar_date_select/locale/pl.js +10 -0
  30. data/public/javascripts/calendar_date_select/locale/pt.js +11 -0
  31. data/public/javascripts/calendar_date_select/locale/ru.js +10 -0
  32. data/public/stylesheets/calendar_date_select/blue.css +130 -0
  33. data/public/stylesheets/calendar_date_select/default.css +135 -0
  34. data/public/stylesheets/calendar_date_select/plain.css +128 -0
  35. data/public/stylesheets/calendar_date_select/red.css +135 -0
  36. data/public/stylesheets/calendar_date_select/silver.css +133 -0
  37. data/test/functional/calendar_date_select_test.rb +157 -0
  38. data/test/functional/helper_methods_test.rb +15 -0
  39. data/test/test_helper.rb +19 -0
  40. metadata +103 -0
data/js_test/test.css ADDED
@@ -0,0 +1,40 @@
1
+ body, div, p, h1, h2, h3, ul, ol, span, a, table, td, form, img, li {
2
+ font-family: sans-serif;
3
+ }
4
+
5
+ body {
6
+ font-size:0.8em;
7
+ }
8
+
9
+ #log {
10
+ padding-bottom: 1em;
11
+ border-bottom: 2px solid #000;
12
+ margin-bottom: 2em;
13
+ }
14
+
15
+ #logsummary {
16
+ margin-bottom: 1em;
17
+ padding: 1ex;
18
+ border: 1px solid #000;
19
+ font-weight: bold;
20
+ }
21
+
22
+ #logtable {
23
+ width:100%;
24
+ border-collapse: collapse;
25
+ border: 1px dotted #666;
26
+ }
27
+
28
+ #logtable td, #logtable th {
29
+ text-align: left;
30
+ padding: 3px 8px;
31
+ border: 1px dotted #666;
32
+ }
33
+
34
+ #logtable .passed {
35
+ background-color: #cfc;
36
+ }
37
+
38
+ #logtable .failed, #logtable .error {
39
+ background-color: #fcc;
40
+ }
data/js_test/unit/cds_helper_methods.html ADDED
@@ -0,0 +1,46 @@
1
+
2
+ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
3
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
4
+ <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
5
+ <head>
6
+ <title>Calendar Date Select Test Cases</title>
7
+ <script src="../prototype.js" type="text/javascript"></script>
8
+ <script src="../unittest.js" type="text/javascript"></script>
9
+ <!-- other JavaScript includes -->
10
+ <script src="../../public/javascripts/calendar_date_select/calendar_date_select.js" type="text/javascript"></script>
11
+
12
+ <link rel="stylesheet" href="../../public/stylesheets/calendar_date_select/red.css" type="text/css" />
13
+ <link rel="stylesheet" href="../test.css" type="text/css" />
14
+ </head>
15
+ <body>
16
+
17
+ <!-- Log output -->
18
+ <div id="testlog"> </div>
19
+
20
+ <!-- here go any elements you do the testing on -->
21
+ <input type="text" id="cds_test" />
22
+
23
+ <!-- Tests -->
24
+ <script type="text/javascript" language="javascript">
25
+ // <![CDATA[
26
+ new Test.Unit.Runner({
27
+ setup: function() { with(this){
28
+ $("cds_test").value="";
29
+ $("cds_test").disabled = false;
30
+ $("cds_test").readOnly = false;
31
+ }},
32
+ test_math_floor_to_interval: function() { with(this) {
33
+ assertEqual(5, Math.floor_to_interval(9,5));
34
+ assertEqual(5, Math.floor_to_interval(5,5));
35
+ assertEqual(0, Math.floor_to_interval(1,5));
36
+ }},
37
+ test_padded2__should_pad_properly_and_interpret_base_10: function() {with(this) {
38
+ assertEqual("11", Date.padded2("011"));
39
+ assertEqual("09", Date.padded2("09"));
40
+ assertEqual("09", Date.padded2("9"));
41
+ }}
42
+ });
43
+ // ]]>
44
+ </script>
45
+ </body>
46
+ </html>
data/js_test/unittest.js ADDED
@@ -0,0 +1,564 @@
1
+ // script.aculo.us unittest.js v1.7.0, Fri Jan 19 19:16:36 CET 2007
2
+
3
+ // Copyright (c) 2005, 2006 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
4
+ // (c) 2005, 2006 Jon Tirsen (http://www.tirsen.com)
5
+ // (c) 2005, 2006 Michael Schuerig (http://www.schuerig.de/michael/)
6
+ //
7
+ // script.aculo.us is freely distributable under the terms of an MIT-style license.
8
+ // For details, see the script.aculo.us web site: http://script.aculo.us/
9
+
10
+ // experimental, Firefox-only
11
+ Event.simulateMouse = function(element, eventName) {
12
+ var options = Object.extend({
13
+ pointerX: 0,
14
+ pointerY: 0,
15
+ buttons: 0,
16
+ ctrlKey: false,
17
+ altKey: false,
18
+ shiftKey: false,
19
+ metaKey: false
20
+ }, arguments[2] || {});
21
+ var oEvent = document.createEvent("MouseEvents");
22
+ oEvent.initMouseEvent(eventName, true, true, document.defaultView,
23
+ options.buttons, options.pointerX, options.pointerY, options.pointerX, options.pointerY,
24
+ options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, 0, $(element));
25
+
26
+ if(this.mark) Element.remove(this.mark);
27
+ this.mark = document.createElement('div');
28
+ this.mark.appendChild(document.createTextNode(" "));
29
+ document.body.appendChild(this.mark);
30
+ this.mark.style.position = 'absolute';
31
+ this.mark.style.top = options.pointerY + "px";
32
+ this.mark.style.left = options.pointerX + "px";
33
+ this.mark.style.width = "5px";
34
+ this.mark.style.height = "5px;";
35
+ this.mark.style.borderTop = "1px solid red;"
36
+ this.mark.style.borderLeft = "1px solid red;"
37
+
38
+ if(this.step)
39
+ alert('['+new Date().getTime().toString()+'] '+eventName+'/'+Test.Unit.inspect(options));
40
+
41
+ $(element).dispatchEvent(oEvent);
42
+ };
43
+
44
+ // Note: Due to a fix in Firefox 1.0.5/6 that probably fixed "too much", this doesn't work in 1.0.6 or DP2.
45
+ // You need to downgrade to 1.0.4 for now to get this working
46
+ // See https://bugzilla.mozilla.org/show_bug.cgi?id=289940 for the fix that fixed too much
47
+ Event.simulateKey = function(element, eventName) {
48
+ var options = Object.extend({
49
+ ctrlKey: false,
50
+ altKey: false,
51
+ shiftKey: false,
52
+ metaKey: false,
53
+ keyCode: 0,
54
+ charCode: 0
55
+ }, arguments[2] || {});
56
+
57
+ var oEvent = document.createEvent("KeyEvents");
58
+ oEvent.initKeyEvent(eventName, true, true, window,
59
+ options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
60
+ options.keyCode, options.charCode );
61
+ $(element).dispatchEvent(oEvent);
62
+ };
63
+
64
+ Event.simulateKeys = function(element, command) {
65
+ for(var i=0; i<command.length; i++) {
66
+ Event.simulateKey(element,'keypress',{charCode:command.charCodeAt(i)});
67
+ }
68
+ };
69
+
70
+ var Test = {}
71
+ Test.Unit = {};
72
+
73
+ // security exception workaround
74
+ Test.Unit.inspect = Object.inspect;
75
+
76
+ Test.Unit.Logger = Class.create();
77
+ Test.Unit.Logger.prototype = {
78
+ initialize: function(log) {
79
+ this.log = $(log);
80
+ if (this.log) {
81
+ this._createLogTable();
82
+ }
83
+ },
84
+ start: function(testName) {
85
+ if (!this.log) return;
86
+ this.testName = testName;
87
+ this.lastLogLine = document.createElement('tr');
88
+ this.statusCell = document.createElement('td');
89
+ this.nameCell = document.createElement('td');
90
+ this.nameCell.className = "nameCell";
91
+ this.nameCell.appendChild(document.createTextNode(testName));
92
+ this.messageCell = document.createElement('td');
93
+ this.lastLogLine.appendChild(this.statusCell);
94
+ this.lastLogLine.appendChild(this.nameCell);
95
+ this.lastLogLine.appendChild(this.messageCell);
96
+ this.loglines.appendChild(this.lastLogLine);
97
+ },
98
+ finish: function(status, summary) {
99
+ if (!this.log) return;
100
+ this.lastLogLine.className = status;
101
+ this.statusCell.innerHTML = status;
102
+ this.messageCell.innerHTML = this._toHTML(summary);
103
+ this.addLinksToResults();
104
+ },
105
+ message: function(message) {
106
+ if (!this.log) return;
107
+ this.messageCell.innerHTML = this._toHTML(message);
108
+ },
109
+ summary: function(summary) {
110
+ if (!this.log) return;
111
+ this.logsummary.innerHTML = this._toHTML(summary);
112
+ },
113
+ _createLogTable: function() {
114
+ this.log.innerHTML =
115
+ '<div id="logsummary"></div>' +
116
+ '<table id="logtable">' +
117
+ '<thead><tr><th>Status</th><th>Test</th><th>Message</th></tr></thead>' +
118
+ '<tbody id="loglines"></tbody>' +
119
+ '</table>';
120
+ this.logsummary = $('logsummary')
121
+ this.loglines = $('loglines');
122
+ },
123
+ _toHTML: function(txt) {
124
+ return txt.escapeHTML().replace(/\n/g,"<br/>");
125
+ },
126
+ addLinksToResults: function(){
127
+ $$("tr.failed .nameCell").each( function(td){ // todo: limit to children of this.log
128
+ td.title = "Run only this test"
129
+ Event.observe(td, 'click', function(){ window.location.search = "?tests=" + td.innerHTML;});
130
+ });
131
+ $$("tr.passed .nameCell").each( function(td){ // todo: limit to children of this.log
132
+ td.title = "Run all tests"
133
+ Event.observe(td, 'click', function(){ window.location.search = "";});
134
+ });
135
+ }
136
+ }
137
+
138
+ Test.Unit.Runner = Class.create();
139
+ Test.Unit.Runner.prototype = {
140
+ initialize: function(testcases) {
141
+ this.options = Object.extend({
142
+ testLog: 'testlog'
143
+ }, arguments[1] || {});
144
+ this.options.resultsURL = this.parseResultsURLQueryParameter();
145
+ this.options.tests = this.parseTestsQueryParameter();
146
+ if (this.options.testLog) {
147
+ this.options.testLog = $(this.options.testLog) || null;
148
+ }
149
+ if(this.options.tests) {
150
+ this.tests = [];
151
+ for(var i = 0; i < this.options.tests.length; i++) {
152
+ if(/^test/.test(this.options.tests[i])) {
153
+ this.tests.push(new Test.Unit.Testcase(this.options.tests[i], testcases[this.options.tests[i]], testcases["setup"], testcases["teardown"]));
154
+ }
155
+ }
156
+ } else {
157
+ if (this.options.test) {
158
+ this.tests = [new Test.Unit.Testcase(this.options.test, testcases[this.options.test], testcases["setup"], testcases["teardown"])];
159
+ } else {
160
+ this.tests = [];
161
+ for(var testcase in testcases) {
162
+ if(/^test/.test(testcase)) {
163
+ this.tests.push(
164
+ new Test.Unit.Testcase(
165
+ this.options.context ? ' -> ' + this.options.titles[testcase] : testcase,
166
+ testcases[testcase], testcases["setup"], testcases["teardown"]
167
+ ));
168
+ }
169
+ }
170
+ }
171
+ }
172
+ this.currentTest = 0;
173
+ this.logger = new Test.Unit.Logger(this.options.testLog);
174
+ setTimeout(this.runTests.bind(this), 1000);
175
+ },
176
+ parseResultsURLQueryParameter: function() {
177
+ return window.location.search.parseQuery()["resultsURL"];
178
+ },
179
+ parseTestsQueryParameter: function(){
180
+ if (window.location.search.parseQuery()["tests"]){
181
+ return window.location.search.parseQuery()["tests"].split(',');
182
+ };
183
+ },
184
+ // Returns:
185
+ // "ERROR" if there was an error,
186
+ // "FAILURE" if there was a failure, or
187
+ // "SUCCESS" if there was neither
188
+ getResult: function() {
189
+ var hasFailure = false;
190
+ for(var i=0;i<this.tests.length;i++) {
191
+ if (this.tests[i].errors > 0) {
192
+ return "ERROR";
193
+ }
194
+ if (this.tests[i].failures > 0) {
195
+ hasFailure = true;
196
+ }
197
+ }
198
+ if (hasFailure) {
199
+ return "FAILURE";
200
+ } else {
201
+ return "SUCCESS";
202
+ }
203
+ },
204
+ postResults: function() {
205
+ if (this.options.resultsURL) {
206
+ new Ajax.Request(this.options.resultsURL,
207
+ { method: 'get', parameters: 'result=' + this.getResult(), asynchronous: false });
208
+ }
209
+ },
210
+ runTests: function() {
211
+ var test = this.tests[this.currentTest];
212
+ if (!test) {
213
+ // finished!
214
+ this.postResults();
215
+ this.logger.summary(this.summary());
216
+ return;
217
+ }
218
+ if(!test.isWaiting) {
219
+ this.logger.start(test.name);
220
+ }
221
+ test.run();
222
+ if(test.isWaiting) {
223
+ this.logger.message("Waiting for " + test.timeToWait + "ms");
224
+ setTimeout(this.runTests.bind(this), test.timeToWait || 1000);
225
+ } else {
226
+ this.logger.finish(test.status(), test.summary());
227
+ this.currentTest++;
228
+ // tail recursive, hopefully the browser will skip the stackframe
229
+ this.runTests();
230
+ }
231
+ },
232
+ summary: function() {
233
+ var assertions = 0;
234
+ var failures = 0;
235
+ var errors = 0;
236
+ var messages = [];
237
+ for(var i=0;i<this.tests.length;i++) {
238
+ assertions += this.tests[i].assertions;
239
+ failures += this.tests[i].failures;
240
+ errors += this.tests[i].errors;
241
+ }
242
+ return (
243
+ (this.options.context ? this.options.context + ': ': '') +
244
+ this.tests.length + " tests, " +
245
+ assertions + " assertions, " +
246
+ failures + " failures, " +
247
+ errors + " errors");
248
+ }
249
+ }
250
+
251
+ Test.Unit.Assertions = Class.create();
252
+ Test.Unit.Assertions.prototype = {
253
+ initialize: function() {
254
+ this.assertions = 0;
255
+ this.failures = 0;
256
+ this.errors = 0;
257
+ this.messages = [];
258
+ },
259
+ summary: function() {
260
+ return (
261
+ this.assertions + " assertions, " +
262
+ this.failures + " failures, " +
263
+ this.errors + " errors" + "\n" +
264
+ this.messages.join("\n"));
265
+ },
266
+ pass: function() {
267
+ this.assertions++;
268
+ },
269
+ fail: function(message) {
270
+ this.failures++;
271
+ this.messages.push("Failure: " + message);
272
+ },
273
+ info: function(message) {
274
+ this.messages.push("Info: " + message);
275
+ },
276
+ error: function(error) {
277
+ this.errors++;
278
+ this.messages.push(error.name + ": "+ error.message + "(" + Test.Unit.inspect(error) +")");
279
+ },
280
+ status: function() {
281
+ if (this.failures > 0) return 'failed';
282
+ if (this.errors > 0) return 'error';
283
+ return 'passed';
284
+ },
285
+ assert: function(expression, message) {
286
+ var message = arguments[1] || 'assert: got "' + Test.Unit.inspect(expression) + '"' + (message||"");
287
+ try { expression ? this.pass() :
288
+ this.fail(message); }
289
+ catch(e) { this.error(e); }
290
+ },
291
+ assertEqual: function(expected, actual, message) {
292
+ var message = arguments[2] || "assertEqual";
293
+ try { (expected == actual) ? this.pass() :
294
+ this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
295
+ '", actual "' + Test.Unit.inspect(actual) + '"' + (message||"")); }
296
+ catch(e) { this.error(e); }
297
+ },
298
+ assertInspect: function(expected, actual) {
299
+ var message = arguments[2] || "assertInspect";
300
+ try { (expected == actual.inspect()) ? this.pass() :
301
+ this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
302
+ '", actual "' + Test.Unit.inspect(actual) + '"'); }
303
+ catch(e) { this.error(e); }
304
+ },
305
+ assertEnumEqual: function(expected, actual) {
306
+ var message = arguments[2] || "assertEnumEqual";
307
+ try { $A(expected).length == $A(actual).length &&
308
+ expected.zip(actual).all(function(pair) { return pair[0] == pair[1] }) ?
309
+ this.pass() : this.fail(message + ': expected ' + Test.Unit.inspect(expected) +
310
+ ', actual ' + Test.Unit.inspect(actual)); }
311
+ catch(e) { this.error(e); }
312
+ },
313
+ assertNotEqual: function(expected, actual, message) {
314
+ var message = arguments[2] || "assertNotEqual";
315
+ try { (expected != actual) ? this.pass() :
316
+ this.fail(message + ': got "' + Test.Unit.inspect(actual) + '"' + (message||"")); }
317
+ catch(e) { this.error(e); }
318
+ },
319
+ assertIdentical: function(expected, actual, message) {
320
+ var message = arguments[2] || "assertIdentical";
321
+ try { (expected === actual) ? this.pass() :
322
+ this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
323
+ '", actual "' + Test.Unit.inspect(actual) + '"' + (message||"")); }
324
+ catch(e) { this.error(e); }
325
+ },
326
+ assertNotIdentical: function(expected, actual,message) {
327
+ var message = arguments[2] || "assertNotIdentical";
328
+ try { !(expected === actual) ? this.pass() :
329
+ this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
330
+ '", actual "' + Test.Unit.inspect(actual) + '"' + (message||"")); }
331
+ catch(e) { this.error(e); }
332
+ },
333
+ assertNull: function(obj, message) {
334
+ var message = arguments[1] || 'assertNull'
335
+ try { (obj==null) ? this.pass() :
336
+ this.fail(message + ': got "' + Test.Unit.inspect(obj) + '"' + (message||"")); }
337
+ catch(e) { this.error(e); }
338
+ },
339
+ assertMatch: function(expected, actual, message) {
340
+ var message = arguments[2] || 'assertMatch';
341
+ var regex = new RegExp(expected);
342
+ try { (regex.exec(actual)) ? this.pass() :
343
+ this.fail(message + ' : regex: "' + Test.Unit.inspect(expected) + ' did not match: ' + Test.Unit.inspect(actual) + '"' + (message||"")); }
344
+ catch(e) { this.error(e); }
345
+ },
346
+ assertHidden: function(element) {
347
+ var message = arguments[1] || 'assertHidden';
348
+ this.assertEqual("none", element.style.display, message);
349
+ },
350
+ assertNotNull: function(object) {
351
+ var message = arguments[1] || 'assertNotNull';
352
+ this.assert(object != null, message);
353
+ },
354
+ assertType: function(expected, actual) {
355
+ var message = arguments[2] || 'assertType';
356
+ try {
357
+ (actual.constructor == expected) ? this.pass() :
358
+ this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
359
+ '", actual "' + (actual.constructor) + '"'); }
360
+ catch(e) { this.error(e); }
361
+ },
362
+ assertNotOfType: function(expected, actual) {
363
+ var message = arguments[2] || 'assertNotOfType';
364
+ try {
365
+ (actual.constructor != expected) ? this.pass() :
366
+ this.fail(message + ': expected "' + Test.Unit.inspect(expected) +
367
+ '", actual "' + (actual.constructor) + '"'); }
368
+ catch(e) { this.error(e); }
369
+ },
370
+ assertInstanceOf: function(expected, actual) {
371
+ var message = arguments[2] || 'assertInstanceOf';
372
+ try {
373
+ (actual instanceof expected) ? this.pass() :
374
+ this.fail(message + ": object was not an instance of the expected type"); }
375
+ catch(e) { this.error(e); }
376
+ },
377
+ assertNotInstanceOf: function(expected, actual) {
378
+ var message = arguments[2] || 'assertNotInstanceOf';
379
+ try {
380
+ !(actual instanceof expected) ? this.pass() :
381
+ this.fail(message + ": object was an instance of the not expected type"); }
382
+ catch(e) { this.error(e); }
383
+ },
384
+ assertRespondsTo: function(method, obj) {
385
+ var message = arguments[2] || 'assertRespondsTo';
386
+ try {
387
+ (obj[method] && typeof obj[method] == 'function') ? this.pass() :
388
+ this.fail(message + ": object doesn't respond to [" + method + "]"); }
389
+ catch(e) { this.error(e); }
390
+ },
391
+ assertReturnsTrue: function(method, obj) {
392
+ var message = arguments[2] || 'assertReturnsTrue';
393
+ try {
394
+ var m = obj[method];
395
+ if(!m) m = obj['is'+method.charAt(0).toUpperCase()+method.slice(1)];
396
+ m() ? this.pass() :
397
+ this.fail(message + ": method returned false"); }
398
+ catch(e) { this.error(e); }
399
+ },
400
+ assertReturnsFalse: function(method, obj) {
401
+ var message = arguments[2] || 'assertReturnsFalse';
402
+ try {
403
+ var m = obj[method];
404
+ if(!m) m = obj['is'+method.charAt(0).toUpperCase()+method.slice(1)];
405
+ !m() ? this.pass() :
406
+ this.fail(message + ": method returned true"); }
407
+ catch(e) { this.error(e); }
408
+ },
409
+ assertRaise: function(exceptionName, method) {
410
+ var message = arguments[2] || 'assertRaise';
411
+ try {
412
+ method();
413
+ this.fail(message + ": exception expected but none was raised"); }
414
+ catch(e) {
415
+ ((exceptionName == null) || (e.name==exceptionName)) ? this.pass() : this.error(e);
416
+ }
417
+ },
418
+ assertElementsMatch: function() {
419
+ var expressions = $A(arguments), elements = $A(expressions.shift());
420
+ if (elements.length != expressions.length) {
421
+ this.fail('assertElementsMatch: size mismatch: ' + elements.length + ' elements, ' + expressions.length + ' expressions');
422
+ return false;
423
+ }
424
+ elements.zip(expressions).all(function(pair, index) {
425
+ var element = $(pair.first()), expression = pair.last();
426
+ if (element.match(expression)) return true;
427
+ this.fail('assertElementsMatch: (in index ' + index + ') expected ' + expression.inspect() + ' but got ' + element.inspect());
428
+ }.bind(this)) && this.pass();
429
+ },
430
+ assertElementMatches: function(element, expression) {
431
+ this.assertElementsMatch([element], expression);
432
+ },
433
+ benchmark: function(operation, iterations) {
434
+ var startAt = new Date();
435
+ (iterations || 1).times(operation);
436
+ var timeTaken = ((new Date())-startAt);
437
+ this.info((arguments[2] || 'Operation') + ' finished ' +
438
+ iterations + ' iterations in ' + (timeTaken/1000)+'s' );
439
+ return timeTaken;
440
+ },
441
+ _isVisible: function(element) {
442
+ element = $(element);
443
+ if(!element.parentNode) return true;
444
+ this.assertNotNull(element);
445
+ if(element.style && Element.getStyle(element, 'display') == 'none')
446
+ return false;
447
+
448
+ return this._isVisible(element.parentNode);
449
+ },
450
+ assertNotVisible: function(element) {
451
+ this.assert(!this._isVisible(element), Test.Unit.inspect(element) + " was not hidden and didn't have a hidden parent either. " + ("" || arguments[1]));
452
+ },
453
+ assertVisible: function(element) {
454
+ this.assert(this._isVisible(element), Test.Unit.inspect(element) + " was not visible. " + ("" || arguments[1]));
455
+ },
456
+ benchmark: function(operation, iterations) {
457
+ var startAt = new Date();
458
+ (iterations || 1).times(operation);
459
+ var timeTaken = ((new Date())-startAt);
460
+ this.info((arguments[2] || 'Operation') + ' finished ' +
461
+ iterations + ' iterations in ' + (timeTaken/1000)+'s' );
462
+ return timeTaken;
463
+ }
464
+ }
465
+
466
+ Test.Unit.Testcase = Class.create();
467
+ Object.extend(Object.extend(Test.Unit.Testcase.prototype, Test.Unit.Assertions.prototype), {
468
+ initialize: function(name, test, setup, teardown) {
469
+ Test.Unit.Assertions.prototype.initialize.bind(this)();
470
+ this.name = name;
471
+
472
+ if(typeof test == 'string') {
473
+ test = test.gsub(/(\.should[^\(]+\()/,'#{0}this,');
474
+ test = test.gsub(/(\.should[^\(]+)\(this,\)/,'#{1}(this)');
475
+ this.test = function() {
476
+ eval('with(this){'+test+'}');
477
+ }
478
+ } else {
479
+ this.test = test || function() {};
480
+ }
481
+
482
+ this.setup = setup || function() {};
483
+ this.teardown = teardown || function() {};
484
+ this.isWaiting = false;
485
+ this.timeToWait = 1000;
486
+ },
487
+ wait: function(time, nextPart) {
488
+ this.isWaiting = true;
489
+ this.test = nextPart;
490
+ this.timeToWait = time;
491
+ },
492
+ run: function() {
493
+ try {
494
+ try {
495
+ if (!this.isWaiting) this.setup.bind(this)();
496
+ this.isWaiting = false;
497
+ this.test.bind(this)();
498
+ } finally {
499
+ if(!this.isWaiting) {
500
+ this.teardown.bind(this)();
501
+ }
502
+ }
503
+ }
504
+ catch(e) { this.error(e); }
505
+ }
506
+ });
507
+
508
+ // *EXPERIMENTAL* BDD-style testing to please non-technical folk
509
+ // This draws many ideas from RSpec http://rspec.rubyforge.org/
510
+
511
+ Test.setupBDDExtensionMethods = function(){
512
+ var METHODMAP = {
513
+ shouldEqual: 'assertEqual',
514
+ shouldNotEqual: 'assertNotEqual',
515
+ shouldEqualEnum: 'assertEnumEqual',
516
+ shouldBeA: 'assertType',
517
+ shouldNotBeA: 'assertNotOfType',
518
+ shouldBeAn: 'assertType',
519
+ shouldNotBeAn: 'assertNotOfType',
520
+ shouldBeNull: 'assertNull',
521
+ shouldNotBeNull: 'assertNotNull',
522
+
523
+ shouldBe: 'assertReturnsTrue',
524
+ shouldNotBe: 'assertReturnsFalse',
525
+ shouldRespondTo: 'assertRespondsTo'
526
+ };
527
+ Test.BDDMethods = {};
528
+ for(m in METHODMAP) {
529
+ Test.BDDMethods[m] = eval(
530
+ 'function(){'+
531
+ 'var args = $A(arguments);'+
532
+ 'var scope = args.shift();'+
533
+ 'scope.'+METHODMAP[m]+'.apply(scope,(args || []).concat([this])); }');
534
+ }
535
+ [Array.prototype, String.prototype, Number.prototype].each(
536
+ function(p){ Object.extend(p, Test.BDDMethods) }
537
+ );
538
+ }
539
+
540
+ Test.context = function(name, spec, log){
541
+ Test.setupBDDExtensionMethods();
542
+
543
+ var compiledSpec = {};
544
+ var titles = {};
545
+ for(specName in spec) {
546
+ switch(specName){
547
+ case "setup":
548
+ case "teardown":
549
+ compiledSpec[specName] = spec[specName];
550
+ break;
551
+ default:
552
+ var testName = 'test'+specName.gsub(/\s+/,'-').camelize();
553
+ var body = spec[specName].toString().split('\n').slice(1);
554
+ if(/^\{/.test(body[0])) body = body.slice(1);
555
+ body.pop();
556
+ body = body.map(function(statement){
557
+ return statement.strip()
558
+ });
559
+ compiledSpec[testName] = body.join('\n');
560
+ titles[testName] = specName;
561
+ }
562
+ }
563
+ new Test.Unit.Runner(compiledSpec, { titles: titles, testLog: log || 'testlog', context: name });
564
+ };