atd-calendar_date_select 1.11.20090108

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (37) hide show
  1. data/History.txt +231 -0
  2. data/MIT-LICENSE +20 -0
  3. data/Manifest.txt +42 -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 +33 -0
  13. data/lib/calendar_date_select/calendar_date_select.rb +116 -0
  14. data/lib/calendar_date_select/includes_helper.rb +29 -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 +443 -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 +11 -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. 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
+ };