├── test ├── assets │ └── test.css ├── lib │ └── jasmine-1.3.0 │ │ ├── MIT.LICENSE │ │ ├── jasmine.css │ │ ├── jasmine-html.js │ │ └── jasmine.js ├── SpecRunner.html └── spec │ └── xmlToJSONSpec.js ├── bower.json ├── package.json ├── LICENSE ├── lib ├── xmlToJSON.min.js └── xmlToJSON.js └── README.md /test/assets/test.css: -------------------------------------------------------------------------------- 1 | 2 | div.cssassist { 3 | display: inline; 4 | } -------------------------------------------------------------------------------- /bower.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "xmltojson", 3 | "version": "1.3.4", 4 | "main": "./lib/xmlToJSON.js", 5 | "dependencies": {}, 6 | "ignore": [ 7 | "*", 8 | "!lib/*", 9 | "!LICENSE", 10 | "!README.md" 11 | ] 12 | } -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "xmltojson", 3 | "version": "1.3.4", 4 | "description": "Configurable, lightweight XML to JSON converter.", 5 | "main": "./lib/xmlToJSON.js", 6 | "directories": { 7 | "test": "test" 8 | }, 9 | "scripts": { 10 | "test": "open test/SpecRunner.html" 11 | }, 12 | "repository": { 13 | "type": "git", 14 | "url": "https://github.com/metatribal/xmlToJSON.git" 15 | }, 16 | "keywords": [ 17 | "xml", 18 | "convert", 19 | "transform", 20 | "json" 21 | ], 22 | "author": "metatribal", 23 | "license": "MIT", 24 | "bugs": { 25 | "url": "https://github.com/metatribal/xmlToJSON/issues" 26 | }, 27 | "homepage": "https://github.com/metatribal/xmlToJSON" 28 | } -------------------------------------------------------------------------------- /test/lib/jasmine-1.3.0/MIT.LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2008-2011 Pivotal Labs 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be 12 | included in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 William Summers & MetaTribal LLC 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /test/SpecRunner.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | Jasmine Spec Runner 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | -------------------------------------------------------------------------------- /lib/xmlToJSON.min.js: -------------------------------------------------------------------------------- 1 | var xmlToJSON = function () { this.version = "1.3.4"; var e = { mergeCDATA: !0, grokAttr: !0, grokText: !0, normalize: !0, xmlns: !0, namespaceKey: "_ns", textKey: "_text", valueKey: "_value", attrKey: "_attr", cdataKey: "_cdata", attrsAsObject: !0, stripAttrPrefix: !0, stripElemPrefix: !0, childrenAsArray: !0 }, t = new RegExp(/(?!xmlns)^.*:/), r = new RegExp(/^\s+|\s+$/g); return this.grokType = function (e) { return /^\s*$/.test(e) ? null : /^(?:true|false)$/i.test(e) ? "true" === e.toLowerCase() : isFinite(e) ? parseFloat(e) : e }, this.parseString = function (e, t) { return this.parseXML(this.stringToXML(e), t) }, this.parseXML = function (a, n) { for (var s in n) e[s] = n[s]; var l = {}, i = 0, o = ""; if (e.xmlns && a.namespaceURI && (l[e.namespaceKey] = a.namespaceURI), a.attributes && a.attributes.length > 0) { var c = {}; for (i; i < a.attributes.length; i++) { var u = a.attributes.item(i); m = {}; var p = ""; p = e.stripAttrPrefix ? u.name.replace(t, "") : u.name, e.grokAttr ? m[e.valueKey] = this.grokType(u.value.replace(r, "")) : m[e.valueKey] = u.value.replace(r, ""), e.xmlns && u.namespaceURI && (m[e.namespaceKey] = u.namespaceURI), e.attrsAsObject ? c[p] = m : l[e.attrKey + p] = m } e.attrsAsObject && (l[e.attrKey] = c) } if (a.hasChildNodes()) for (var y, d, m, h = 0; h < a.childNodes.length; h++)4 === (y = a.childNodes.item(h)).nodeType ? e.mergeCDATA ? o += y.nodeValue : l.hasOwnProperty(e.cdataKey) ? (l[e.cdataKey].constructor !== Array && (l[e.cdataKey] = [l[e.cdataKey]]), l[e.cdataKey].push(y.nodeValue)) : e.childrenAsArray ? (l[e.cdataKey] = [], l[e.cdataKey].push(y.nodeValue)) : l[e.cdataKey] = y.nodeValue : 3 === y.nodeType ? o += y.nodeValue : 1 === y.nodeType && (0 === i && (l = {}), d = e.stripElemPrefix ? y.nodeName.replace(t, "") : y.nodeName, m = xmlToJSON.parseXML(y), l.hasOwnProperty(d) ? (l[d].constructor !== Array && (l[d] = [l[d]]), l[d].push(m)) : (e.childrenAsArray ? (l[d] = [], l[d].push(m)) : l[d] = m, i++)); else o || (e.childrenAsArray ? (l[e.textKey] = [], l[e.textKey].push(null)) : l[e.textKey] = null); if (o) if (e.grokText) { var x = this.grokType(o.replace(r, "")); null !== x && void 0 !== x && (l[e.textKey] = x) } else e.normalize ? l[e.textKey] = o.replace(r, "").replace(/\s+/g, " ") : l[e.textKey] = o.replace(r, ""); return l }, this.xmlToString = function (e) { try { return e.xml ? e.xml : (new XMLSerializer).serializeToString(e) } catch (e) { return null } }, this.stringToXML = function (e) { try { var t = null; return window.DOMParser ? t = (new DOMParser).parseFromString(e, "text/xml") : (t = new ActiveXObject("Microsoft.XMLDOM"), t.async = !1, t.loadXML(e), t) } catch (e) { return null } }, this }.call({}); "undefined" != typeof module && null !== module && module.exports ? module.exports = xmlToJSON : "function" == typeof define && define.amd && define(function () { return xmlToJSON }); -------------------------------------------------------------------------------- /test/spec/xmlToJSONSpec.js: -------------------------------------------------------------------------------- 1 | 2 | describe("Version", function() { 3 | 4 | it("print version", function() { 5 | expect(xmlToJSON.version).toMatch(/^1\.3/); 6 | }); 7 | 8 | }); 9 | 10 | describe("Parsing - grokAttr=true, grokText=true", function() { 11 | 12 | var xml; 13 | var result; 14 | var options = {grokAttr: true, grokText: true}; 15 | 16 | it("Setting up xml, options", function () { 17 | options = {}; 18 | xml = ['', 19 | '', 20 | ' ', 21 | ' one', 22 | ' true', 23 | ' false', 24 | ' ]]>two', 25 | ' three', 26 | ' ', 27 | ' true', 28 | ' false', 29 | ''].join('\n'); 30 | 31 | console.debug(xml); 32 | result = xmlToJSON.parseString(xml, options); 33 | console.log(JSON.stringify(result)) 34 | 35 | expect(result).toBeDefined(); 36 | }); 37 | 38 | it("reading text node", function() { 39 | expect(result.xml[0].a[0].b[0]._text).toEqual("one"); 40 | }); 41 | 42 | it("reading numeric attribute", function() { 43 | expect(result.xml[0].a[0].b[0]._attr.id._value).toEqual(1); 44 | }); 45 | 46 | it("reading true attribute", function() { 47 | expect(result.xml[0].a[0].b[1]._attr.id._value).toEqual(true); 48 | }); 49 | 50 | it("reading false attribute", function() { 51 | expect(result.xml[0].a[0].b[2]._attr.id._value).toEqual(false); 52 | }); 53 | 54 | it("reading true node", function() { 55 | expect(result.xml[0].e[0]._text).toEqual(true); 56 | }); 57 | 58 | it("reading false node", function() { 59 | expect(result.xml[0].f[0]._text).toEqual(false); 60 | }); 61 | 62 | }); 63 | 64 | describe("Parsing - grokAttr=false, grokTest=false", function() { 65 | 66 | var xml; 67 | var result; 68 | var options = {grokAttr: false, grokText: false}; 69 | 70 | it("Setting up xml, options", function () { 71 | xml = ['', 72 | '', 73 | ' ', 74 | ' one', 75 | ' true', 76 | ' false', 77 | ' ]]>two', 78 | ' three', 79 | ' ', 80 | ' true', 81 | ' false', 82 | ''].join('\n'); 83 | 84 | console.debug(xml); 85 | result = xmlToJSON.parseString(xml, options); 86 | console.log(JSON.stringify(result)) 87 | 88 | expect(result).toBeDefined(); 89 | }); 90 | 91 | it("reading text node", function() { 92 | expect(result.xml[0].a[0].b[0]._text).toEqual("one"); 93 | }); 94 | 95 | it("reading numeric attribute", function() { 96 | expect(result.xml[0].a[0].b[0]._attr.id._value).toEqual("1"); 97 | }); 98 | 99 | it("reading true attribute", function() { 100 | expect(result.xml[0].a[0].b[1]._attr.id._value).toEqual("true"); 101 | }); 102 | 103 | it("reading false attribute", function() { 104 | expect(result.xml[0].a[0].b[2]._attr.id._value).toEqual("false"); 105 | }); 106 | 107 | it("reading true node", function() { 108 | expect(result.xml[0].e[0]._text).toEqual("true"); 109 | }); 110 | 111 | it("reading false node", function() { 112 | expect(result.xml[0].f[0]._text).toEqual("false"); 113 | }); 114 | 115 | }); 116 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | xmlToJSON 2 | ========= 3 | 4 | A simple javascript module for converting XML into JSON within the browser. 5 | 6 | Features 7 | * no external dependencies 8 | * small (~3kb minified) 9 | * simple parsing. pass either a string or xml node and get back a javascipt object ( use JSON.stringify(obj) to get the string representation ) 10 | * supports atrributes, text, cdata, namespaces, default namespaces, attributes with namespaces... you get the idea 11 | * lots of rendering of options 12 | * consistent, predictable output 13 | * browser support - it works on IE 9+, and nearly every version of Chrome, Safari, and Firefox as well as iOS, Android, and Blackberry. (xmlToJSON will work for IE 7/8 as well if you set the xmlns option to false) 14 | 15 | Parsing XML (esp. with namespaces) with javascript remains one of the great frustrations of writing web applications. 16 | Most methods are limited by such things as poor browser support, poor or non-existent namespace support, poor attribute handling, incomplete representation, and bloated dependencies. 17 | 18 | xmlToJSON may not solve all of your woes, but it solved some of mine :) 19 | 20 | Usage 21 | ----- 22 | Include the src 23 | ``` 24 | 25 | ``` 26 | and enjoy! xmlToJSON is packaged as a simple module, so use it like this 27 | ```javascript 28 | testString = 'It Works!'; // get some xml (string or document/node) 29 | result = xmlToJSON.parseString(testString); // parse 30 | ``` 31 | The (prettified) result of the above code is 32 | ```javascript 33 | { 34 | "xml": { 35 | "a": [ 36 | { 37 | "text": "It Works!" 38 | } 39 | ] 40 | } 41 | } 42 | ``` 43 | 44 | Node Usage 45 | ---------- 46 | While this library does not officialy support use in the NodeJS environment; several users have reported good results by requiring the xmldom package. 47 | 48 | User [sethb0](https://github.com/sethb0) has suggested the following workaround example. 49 | 50 | ``` 51 | const { DOMParser } = require('xmldom'); 52 | const xmlToJSON = require('xmlToJSON'); 53 | xmlToJSON.stringToXML = (string) => new DOMParser().parseFromString(string, 'text/xml'); 54 | ``` 55 | 56 | 57 | Options 58 | ------- 59 | ```javascript 60 | // These are the option defaults 61 | var options = { 62 | mergeCDATA: true, // extract cdata and merge with text nodes 63 | grokAttr: true, // convert truthy attributes to boolean, etc 64 | grokText: true, // convert truthy text/attr to boolean, etc 65 | normalize: true, // collapse multiple spaces to single space 66 | xmlns: true, // include namespaces as attributes in output 67 | namespaceKey: '_ns', // tag name for namespace objects 68 | textKey: '_text', // tag name for text nodes 69 | valueKey: '_value', // tag name for attribute values 70 | attrKey: '_attr', // tag for attr groups 71 | cdataKey: '_cdata', // tag for cdata nodes (ignored if mergeCDATA is true) 72 | attrsAsObject: true, // if false, key is used as prefix to name, set prefix to '' to merge children and attrs. 73 | stripAttrPrefix: true, // remove namespace prefixes from attributes 74 | stripElemPrefix: true, // for elements of same name in diff namespaces, you can enable namespaces and access the nskey property 75 | childrenAsArray: true // force children into arrays 76 | }; 77 | 78 | // you can change the defaults by passing the parser an options object of your own 79 | var myOptions = { 80 | mergeCDATA: false, 81 | xmlns: false, 82 | attrsAsObject: false 83 | } 84 | 85 | result = xmlToJSON.parseString(xmlString, myOptions); 86 | ``` 87 | 88 | A more complicated example (with xmlns: true) 89 | ```xml 90 | 91 | 92 | 93 | one 94 | ]]>two 95 | three 96 | 97 | 98 | ``` 99 | 100 | results in 101 | ```javascript 102 | { 103 | "xml": [{ 104 | "attr": { 105 | "xmlns": { 106 | "value": "http://default.namespace.uri" 107 | } 108 | }, 109 | "a": [{ 110 | "b": [{ 111 | "attr": { 112 | "id": { 113 | "value": 1 114 | } 115 | }, 116 | "text": "one" 117 | }, { 118 | "attr": { 119 | "id": { 120 | "value": 2 121 | } 122 | }, 123 | "text": "some two" 124 | }], 125 | "c": [{ 126 | "attr": { 127 | "xmlns:ns": { 128 | "value": "http://another.namespace" 129 | }, 130 | "id": { 131 | "value": 3 132 | } 133 | }, 134 | "text": "three" 135 | }] 136 | }] 137 | }] 138 | } 139 | ``` 140 | 141 | -------------------------------------------------------------------------------- /test/lib/jasmine-1.3.0/jasmine.css: -------------------------------------------------------------------------------- 1 | body { background-color: #eeeeee; padding: 0; margin: 5px; overflow-y: scroll; } 2 | 3 | #HTMLReporter { font-size: 11px; font-family: Monaco, "Lucida Console", monospace; line-height: 14px; color: #333333; } 4 | #HTMLReporter a { text-decoration: none; } 5 | #HTMLReporter a:hover { text-decoration: underline; } 6 | #HTMLReporter p, #HTMLReporter h1, #HTMLReporter h2, #HTMLReporter h3, #HTMLReporter h4, #HTMLReporter h5, #HTMLReporter h6 { margin: 0; line-height: 14px; } 7 | #HTMLReporter .banner, #HTMLReporter .symbolSummary, #HTMLReporter .summary, #HTMLReporter .resultMessage, #HTMLReporter .specDetail .description, #HTMLReporter .alert .bar, #HTMLReporter .stackTrace { padding-left: 9px; padding-right: 9px; } 8 | #HTMLReporter #jasmine_content { position: fixed; right: 100%; } 9 | #HTMLReporter .version { color: #aaaaaa; } 10 | #HTMLReporter .banner { margin-top: 14px; } 11 | #HTMLReporter .duration { color: #aaaaaa; float: right; } 12 | #HTMLReporter .symbolSummary { overflow: hidden; *zoom: 1; margin: 14px 0; } 13 | #HTMLReporter .symbolSummary li { display: block; float: left; height: 7px; width: 14px; margin-bottom: 7px; font-size: 16px; } 14 | #HTMLReporter .symbolSummary li.passed { font-size: 14px; } 15 | #HTMLReporter .symbolSummary li.passed:before { color: #5e7d00; content: "\02022"; } 16 | #HTMLReporter .symbolSummary li.failed { line-height: 9px; } 17 | #HTMLReporter .symbolSummary li.failed:before { color: #b03911; content: "x"; font-weight: bold; margin-left: -1px; } 18 | #HTMLReporter .symbolSummary li.skipped { font-size: 14px; } 19 | #HTMLReporter .symbolSummary li.skipped:before { color: #bababa; content: "\02022"; } 20 | #HTMLReporter .symbolSummary li.pending { line-height: 11px; } 21 | #HTMLReporter .symbolSummary li.pending:before { color: #aaaaaa; content: "-"; } 22 | #HTMLReporter .exceptions { color: #fff; float: right; margin-top: 5px; margin-right: 5px; } 23 | #HTMLReporter .bar { line-height: 28px; font-size: 14px; display: block; color: #eee; } 24 | #HTMLReporter .runningAlert { background-color: #666666; } 25 | #HTMLReporter .skippedAlert { background-color: #aaaaaa; } 26 | #HTMLReporter .skippedAlert:first-child { background-color: #333333; } 27 | #HTMLReporter .skippedAlert:hover { text-decoration: none; color: white; text-decoration: underline; } 28 | #HTMLReporter .passingAlert { background-color: #a6b779; } 29 | #HTMLReporter .passingAlert:first-child { background-color: #5e7d00; } 30 | #HTMLReporter .failingAlert { background-color: #cf867e; } 31 | #HTMLReporter .failingAlert:first-child { background-color: #b03911; } 32 | #HTMLReporter .results { margin-top: 14px; } 33 | #HTMLReporter #details { display: none; } 34 | #HTMLReporter .resultsMenu, #HTMLReporter .resultsMenu a { background-color: #fff; color: #333333; } 35 | #HTMLReporter.showDetails .summaryMenuItem { font-weight: normal; text-decoration: inherit; } 36 | #HTMLReporter.showDetails .summaryMenuItem:hover { text-decoration: underline; } 37 | #HTMLReporter.showDetails .detailsMenuItem { font-weight: bold; text-decoration: underline; } 38 | #HTMLReporter.showDetails .summary { display: none; } 39 | #HTMLReporter.showDetails #details { display: block; } 40 | #HTMLReporter .summaryMenuItem { font-weight: bold; text-decoration: underline; } 41 | #HTMLReporter .summary { margin-top: 14px; } 42 | #HTMLReporter .summary .suite .suite, #HTMLReporter .summary .specSummary { margin-left: 14px; } 43 | #HTMLReporter .summary .specSummary.passed a { color: #5e7d00; } 44 | #HTMLReporter .summary .specSummary.failed a { color: #b03911; } 45 | #HTMLReporter .description + .suite { margin-top: 0; } 46 | #HTMLReporter .suite { margin-top: 14px; } 47 | #HTMLReporter .suite a { color: #333333; } 48 | #HTMLReporter #details .specDetail { margin-bottom: 28px; } 49 | #HTMLReporter #details .specDetail .description { display: block; color: white; background-color: #b03911; } 50 | #HTMLReporter .resultMessage { padding-top: 14px; color: #333333; } 51 | #HTMLReporter .resultMessage span.result { display: block; } 52 | #HTMLReporter .stackTrace { margin: 5px 0 0 0; max-height: 224px; overflow: auto; line-height: 18px; color: #666666; border: 1px solid #ddd; background: white; white-space: pre; } 53 | 54 | #TrivialReporter { padding: 8px 13px; position: absolute; top: 0; bottom: 0; left: 0; right: 0; overflow-y: scroll; background-color: white; font-family: "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif; /*.resultMessage {*/ /*white-space: pre;*/ /*}*/ } 55 | #TrivialReporter a:visited, #TrivialReporter a { color: #303; } 56 | #TrivialReporter a:hover, #TrivialReporter a:active { color: blue; } 57 | #TrivialReporter .run_spec { float: right; padding-right: 5px; font-size: .8em; text-decoration: none; } 58 | #TrivialReporter .banner { color: #303; background-color: #fef; padding: 5px; } 59 | #TrivialReporter .logo { float: left; font-size: 1.1em; padding-left: 5px; } 60 | #TrivialReporter .logo .version { font-size: .6em; padding-left: 1em; } 61 | #TrivialReporter .runner.running { background-color: yellow; } 62 | #TrivialReporter .options { text-align: right; font-size: .8em; } 63 | #TrivialReporter .suite { border: 1px outset gray; margin: 5px 0; padding-left: 1em; } 64 | #TrivialReporter .suite .suite { margin: 5px; } 65 | #TrivialReporter .suite.passed { background-color: #dfd; } 66 | #TrivialReporter .suite.failed { background-color: #fdd; } 67 | #TrivialReporter .spec { margin: 5px; padding-left: 1em; clear: both; } 68 | #TrivialReporter .spec.failed, #TrivialReporter .spec.passed, #TrivialReporter .spec.skipped { padding-bottom: 5px; border: 1px solid gray; } 69 | #TrivialReporter .spec.failed { background-color: #fbb; border-color: red; } 70 | #TrivialReporter .spec.passed { background-color: #bfb; border-color: green; } 71 | #TrivialReporter .spec.skipped { background-color: #bbb; } 72 | #TrivialReporter .messages { border-left: 1px dashed gray; padding-left: 1em; padding-right: 1em; } 73 | #TrivialReporter .passed { background-color: #cfc; display: none; } 74 | #TrivialReporter .failed { background-color: #fbb; } 75 | #TrivialReporter .skipped { color: #777; background-color: #eee; display: none; } 76 | #TrivialReporter .resultMessage span.result { display: block; line-height: 2em; color: black; } 77 | #TrivialReporter .resultMessage .mismatch { color: black; } 78 | #TrivialReporter .stackTrace { white-space: pre; font-size: .8em; margin-left: 10px; max-height: 5em; overflow: auto; border: 1px inset red; padding: 1em; background: #eef; } 79 | #TrivialReporter .finished-at { padding-left: 1em; font-size: .6em; } 80 | #TrivialReporter.show-passed .passed, #TrivialReporter.show-skipped .skipped { display: block; } 81 | #TrivialReporter #jasmine_content { position: fixed; right: 100%; } 82 | #TrivialReporter .runner { border: 1px solid gray; display: block; margin: 5px 0; padding: 2px 0 2px 10px; } 83 | -------------------------------------------------------------------------------- /lib/xmlToJSON.js: -------------------------------------------------------------------------------- 1 | /* Copyright 2015 William Summers, MetaTribal LLC 2 | * adapted from https://developer.mozilla.org/en-US/docs/JXON 3 | * 4 | * Licensed under the MIT License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * https://opensource.org/licenses/MIT 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | /** 17 | * @author William Summers 18 | * 19 | */ 20 | 21 | var xmlToJSON = (function () { 22 | 23 | this.version = "1.3.4"; 24 | 25 | var options = { // set up the default options 26 | mergeCDATA: true, // extract cdata and merge with text 27 | grokAttr: true, // convert truthy attributes to boolean, etc 28 | grokText: true, // convert truthy text/attr to boolean, etc 29 | normalize: true, // collapse multiple spaces to single space 30 | xmlns: true, // include namespaces as attribute in output 31 | namespaceKey: '_ns', // tag name for namespace objects 32 | textKey: '_text', // tag name for text nodes 33 | valueKey: '_value', // tag name for attribute values 34 | attrKey: '_attr', // tag for attr groups 35 | cdataKey: '_cdata', // tag for cdata nodes (ignored if mergeCDATA is true) 36 | attrsAsObject: true, // if false, key is used as prefix to name, set prefix to '' to merge children and attrs. 37 | stripAttrPrefix: true, // remove namespace prefixes from attributes 38 | stripElemPrefix: true, // for elements of same name in diff namespaces, you can enable namespaces and access the nskey property 39 | childrenAsArray: true // force children into arrays 40 | }; 41 | 42 | var prefixMatch = new RegExp(/(?!xmlns)^.*:/); 43 | var trimMatch = new RegExp(/^\s+|\s+$/g); 44 | 45 | this.grokType = function (sValue) { 46 | if (/^\s*$/.test(sValue)) { 47 | return null; 48 | } 49 | if (/^(?:true|false)$/i.test(sValue)) { 50 | return sValue.toLowerCase() === "true"; 51 | } 52 | if (isFinite(sValue)) { 53 | return parseFloat(sValue); 54 | } 55 | return sValue; 56 | }; 57 | 58 | this.parseString = function (xmlString, opt) { 59 | return this.parseXML(this.stringToXML(xmlString), opt); 60 | } 61 | 62 | this.parseXML = function (oXMLParent, opt) { 63 | 64 | // initialize options 65 | for (var key in opt) { 66 | options[key] = opt[key]; 67 | } 68 | 69 | var vResult = {}, 70 | nLength = 0, 71 | sCollectedTxt = ""; 72 | 73 | // parse namespace information 74 | if (options.xmlns && oXMLParent.namespaceURI) { 75 | vResult[options.namespaceKey] = oXMLParent.namespaceURI; 76 | } 77 | 78 | // parse attributes 79 | // using attributes property instead of hasAttributes method to support older browsers 80 | if (oXMLParent.attributes && oXMLParent.attributes.length > 0) { 81 | var vAttribs = {}; 82 | 83 | for (nLength; nLength < oXMLParent.attributes.length; nLength++) { 84 | var oAttrib = oXMLParent.attributes.item(nLength); 85 | vContent = {}; 86 | var attribName = ''; 87 | 88 | if (options.stripAttrPrefix) { 89 | attribName = oAttrib.name.replace(prefixMatch, ''); 90 | 91 | } else { 92 | attribName = oAttrib.name; 93 | } 94 | 95 | if (options.grokAttr) { 96 | vContent[options.valueKey] = this.grokType(oAttrib.value.replace(trimMatch, '')); 97 | } else { 98 | vContent[options.valueKey] = oAttrib.value.replace(trimMatch, ''); 99 | } 100 | 101 | if (options.xmlns && oAttrib.namespaceURI) { 102 | vContent[options.namespaceKey] = oAttrib.namespaceURI; 103 | } 104 | 105 | if (options.attrsAsObject) { // attributes with same local name must enable prefixes 106 | vAttribs[attribName] = vContent; 107 | } else { 108 | vResult[options.attrKey + attribName] = vContent; 109 | } 110 | } 111 | 112 | if (options.attrsAsObject) { 113 | vResult[options.attrKey] = vAttribs; 114 | } else { } 115 | } 116 | 117 | // iterate over the children 118 | if (oXMLParent.hasChildNodes()) { 119 | for (var oNode, sProp, vContent, nItem = 0; nItem < oXMLParent.childNodes.length; nItem++) { 120 | oNode = oXMLParent.childNodes.item(nItem); 121 | 122 | if (oNode.nodeType === 4) { 123 | if (options.mergeCDATA) { 124 | sCollectedTxt += oNode.nodeValue; 125 | } else { 126 | if (vResult.hasOwnProperty(options.cdataKey)) { 127 | if (vResult[options.cdataKey].constructor !== Array) { 128 | vResult[options.cdataKey] = [vResult[options.cdataKey]]; 129 | } 130 | vResult[options.cdataKey].push(oNode.nodeValue); 131 | 132 | } else { 133 | if (options.childrenAsArray) { 134 | vResult[options.cdataKey] = []; 135 | vResult[options.cdataKey].push(oNode.nodeValue); 136 | } else { 137 | vResult[options.cdataKey] = oNode.nodeValue; 138 | } 139 | } 140 | } 141 | } /* nodeType is "CDATASection" (4) */ 142 | else if (oNode.nodeType === 3) { 143 | sCollectedTxt += oNode.nodeValue; 144 | } /* nodeType is "Text" (3) */ 145 | else if (oNode.nodeType === 1) { /* nodeType is "Element" (1) */ 146 | 147 | if (nLength === 0) { 148 | vResult = {}; 149 | } 150 | 151 | // using nodeName to support browser (IE) implementation with no 'localName' property 152 | if (options.stripElemPrefix) { 153 | sProp = oNode.nodeName.replace(prefixMatch, ''); 154 | } else { 155 | sProp = oNode.nodeName; 156 | } 157 | 158 | vContent = xmlToJSON.parseXML(oNode); 159 | 160 | if (vResult.hasOwnProperty(sProp)) { 161 | if (vResult[sProp].constructor !== Array) { 162 | vResult[sProp] = [vResult[sProp]]; 163 | } 164 | vResult[sProp].push(vContent); 165 | 166 | } else { 167 | if (options.childrenAsArray) { 168 | vResult[sProp] = []; 169 | vResult[sProp].push(vContent); 170 | } else { 171 | vResult[sProp] = vContent; 172 | } 173 | nLength++; 174 | } 175 | } 176 | } 177 | } else if (!sCollectedTxt) { // no children and no text, return null 178 | if (options.childrenAsArray) { 179 | vResult[options.textKey] = []; 180 | vResult[options.textKey].push(null); 181 | } else { 182 | vResult[options.textKey] = null; 183 | } 184 | } 185 | 186 | if (sCollectedTxt) { 187 | if (options.grokText) { 188 | var value = this.grokType(sCollectedTxt.replace(trimMatch, '')); 189 | if (value !== null && value !== undefined) { 190 | vResult[options.textKey] = value; 191 | } 192 | } else if (options.normalize) { 193 | vResult[options.textKey] = sCollectedTxt.replace(trimMatch, '').replace(/\s+/g, " "); 194 | } else { 195 | vResult[options.textKey] = sCollectedTxt.replace(trimMatch, ''); 196 | } 197 | } 198 | 199 | return vResult; 200 | } 201 | 202 | 203 | // Convert xmlDocument to a string 204 | // Returns null on failure 205 | this.xmlToString = function (xmlDoc) { 206 | try { 207 | var xmlString = xmlDoc.xml ? xmlDoc.xml : (new XMLSerializer()).serializeToString(xmlDoc); 208 | return xmlString; 209 | } catch (err) { 210 | return null; 211 | } 212 | } 213 | 214 | // Convert a string to XML Node Structure 215 | // Returns null on failure 216 | this.stringToXML = function (xmlString) { 217 | try { 218 | var xmlDoc = null; 219 | 220 | if (window.DOMParser) { 221 | 222 | var parser = new DOMParser(); 223 | xmlDoc = parser.parseFromString(xmlString, "text/xml"); 224 | 225 | return xmlDoc; 226 | } else { 227 | xmlDoc = new ActiveXObject("Microsoft.XMLDOM"); 228 | xmlDoc.async = false; 229 | xmlDoc.loadXML(xmlString); 230 | 231 | return xmlDoc; 232 | } 233 | } catch (e) { 234 | return null; 235 | } 236 | } 237 | 238 | return this; 239 | }).call({}); 240 | 241 | if (typeof module != "undefined" && module !== null && module.exports) module.exports = xmlToJSON; 242 | else if (typeof define === "function" && define.amd) define(function () { return xmlToJSON }); 243 | -------------------------------------------------------------------------------- /test/lib/jasmine-1.3.0/jasmine-html.js: -------------------------------------------------------------------------------- 1 | jasmine.HtmlReporterHelpers = {}; 2 | 3 | jasmine.HtmlReporterHelpers.createDom = function(type, attrs, childrenVarArgs) { 4 | var el = document.createElement(type); 5 | 6 | for (var i = 2; i < arguments.length; i++) { 7 | var child = arguments[i]; 8 | 9 | if (typeof child === 'string') { 10 | el.appendChild(document.createTextNode(child)); 11 | } else { 12 | if (child) { 13 | el.appendChild(child); 14 | } 15 | } 16 | } 17 | 18 | for (var attr in attrs) { 19 | if (attr == "className") { 20 | el[attr] = attrs[attr]; 21 | } else { 22 | el.setAttribute(attr, attrs[attr]); 23 | } 24 | } 25 | 26 | return el; 27 | }; 28 | 29 | jasmine.HtmlReporterHelpers.getSpecStatus = function(child) { 30 | var results = child.results(); 31 | var status = results.passed() ? 'passed' : 'failed'; 32 | if (results.skipped) { 33 | status = 'skipped'; 34 | } 35 | 36 | return status; 37 | }; 38 | 39 | jasmine.HtmlReporterHelpers.appendToSummary = function(child, childElement) { 40 | var parentDiv = this.dom.summary; 41 | var parentSuite = (typeof child.parentSuite == 'undefined') ? 'suite' : 'parentSuite'; 42 | var parent = child[parentSuite]; 43 | 44 | if (parent) { 45 | if (typeof this.views.suites[parent.id] == 'undefined') { 46 | this.views.suites[parent.id] = new jasmine.HtmlReporter.SuiteView(parent, this.dom, this.views); 47 | } 48 | parentDiv = this.views.suites[parent.id].element; 49 | } 50 | 51 | parentDiv.appendChild(childElement); 52 | }; 53 | 54 | 55 | jasmine.HtmlReporterHelpers.addHelpers = function(ctor) { 56 | for(var fn in jasmine.HtmlReporterHelpers) { 57 | ctor.prototype[fn] = jasmine.HtmlReporterHelpers[fn]; 58 | } 59 | }; 60 | 61 | jasmine.HtmlReporter = function(_doc) { 62 | var self = this; 63 | var doc = _doc || window.document; 64 | 65 | var reporterView; 66 | 67 | var dom = {}; 68 | 69 | // Jasmine Reporter Public Interface 70 | self.logRunningSpecs = false; 71 | 72 | self.reportRunnerStarting = function(runner) { 73 | var specs = runner.specs() || []; 74 | 75 | if (specs.length == 0) { 76 | return; 77 | } 78 | 79 | createReporterDom(runner.env.versionString()); 80 | doc.body.appendChild(dom.reporter); 81 | setExceptionHandling(); 82 | 83 | reporterView = new jasmine.HtmlReporter.ReporterView(dom); 84 | reporterView.addSpecs(specs, self.specFilter); 85 | }; 86 | 87 | self.reportRunnerResults = function(runner) { 88 | reporterView && reporterView.complete(); 89 | }; 90 | 91 | self.reportSuiteResults = function(suite) { 92 | reporterView.suiteComplete(suite); 93 | }; 94 | 95 | self.reportSpecStarting = function(spec) { 96 | if (self.logRunningSpecs) { 97 | self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...'); 98 | } 99 | }; 100 | 101 | self.reportSpecResults = function(spec) { 102 | reporterView.specComplete(spec); 103 | }; 104 | 105 | self.log = function() { 106 | var console = jasmine.getGlobal().console; 107 | if (console && console.log) { 108 | if (console.log.apply) { 109 | console.log.apply(console, arguments); 110 | } else { 111 | console.log(arguments); // ie fix: console.log.apply doesn't exist on ie 112 | } 113 | } 114 | }; 115 | 116 | self.specFilter = function(spec) { 117 | if (!focusedSpecName()) { 118 | return true; 119 | } 120 | 121 | return spec.getFullName().indexOf(focusedSpecName()) === 0; 122 | }; 123 | 124 | return self; 125 | 126 | function focusedSpecName() { 127 | var specName; 128 | 129 | (function memoizeFocusedSpec() { 130 | if (specName) { 131 | return; 132 | } 133 | 134 | var paramMap = []; 135 | var params = jasmine.HtmlReporter.parameters(doc); 136 | 137 | for (var i = 0; i < params.length; i++) { 138 | var p = params[i].split('='); 139 | paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]); 140 | } 141 | 142 | specName = paramMap.spec; 143 | })(); 144 | 145 | return specName; 146 | } 147 | 148 | function createReporterDom(version) { 149 | dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' }, 150 | dom.banner = self.createDom('div', { className: 'banner' }, 151 | self.createDom('span', { className: 'title' }, "Jasmine "), 152 | self.createDom('span', { className: 'version' }, version)), 153 | 154 | dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}), 155 | dom.alert = self.createDom('div', {className: 'alert'}, 156 | self.createDom('span', { className: 'exceptions' }, 157 | self.createDom('label', { className: 'label', for: 'no_try_catch' }, 'No try/catch'), 158 | self.createDom('input', { id: 'no_try_catch', type: 'checkbox' }))), 159 | dom.results = self.createDom('div', {className: 'results'}, 160 | dom.summary = self.createDom('div', { className: 'summary' }), 161 | dom.details = self.createDom('div', { id: 'details' })) 162 | ); 163 | } 164 | 165 | function noTryCatch() { 166 | return window.location.search.match(/catch=false/); 167 | } 168 | 169 | function searchWithCatch() { 170 | var params = jasmine.HtmlReporter.parameters(window.document); 171 | var removed = false; 172 | var i = 0; 173 | 174 | while (!removed && i < params.length) { 175 | if (params[i].match(/catch=/)) { 176 | params.splice(i, 1); 177 | removed = true; 178 | } 179 | i++; 180 | } 181 | if (jasmine.CATCH_EXCEPTIONS) { 182 | params.push("catch=false"); 183 | } 184 | 185 | return params.join("&"); 186 | } 187 | 188 | function setExceptionHandling() { 189 | var chxCatch = document.getElementById('no_try_catch'); 190 | 191 | if (noTryCatch()) { 192 | chxCatch.setAttribute('checked', true); 193 | jasmine.CATCH_EXCEPTIONS = false; 194 | } 195 | chxCatch.onclick = function() { 196 | window.location.search = searchWithCatch(); 197 | }; 198 | } 199 | }; 200 | jasmine.HtmlReporter.parameters = function(doc) { 201 | var paramStr = doc.location.search.substring(1); 202 | var params = []; 203 | 204 | if (paramStr.length > 0) { 205 | params = paramStr.split('&'); 206 | } 207 | return params; 208 | } 209 | jasmine.HtmlReporter.sectionLink = function(sectionName) { 210 | var link = '?'; 211 | var params = []; 212 | 213 | if (sectionName) { 214 | params.push('spec=' + encodeURIComponent(sectionName)); 215 | } 216 | if (!jasmine.CATCH_EXCEPTIONS) { 217 | params.push("catch=false"); 218 | } 219 | if (params.length > 0) { 220 | link += params.join("&"); 221 | } 222 | 223 | return link; 224 | }; 225 | jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter); 226 | jasmine.HtmlReporter.ReporterView = function(dom) { 227 | this.startedAt = new Date(); 228 | this.runningSpecCount = 0; 229 | this.completeSpecCount = 0; 230 | this.passedCount = 0; 231 | this.failedCount = 0; 232 | this.skippedCount = 0; 233 | 234 | this.createResultsMenu = function() { 235 | this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'}, 236 | this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: "#"}, '0 specs'), 237 | ' | ', 238 | this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: "#"}, '0 failing')); 239 | 240 | this.summaryMenuItem.onclick = function() { 241 | dom.reporter.className = dom.reporter.className.replace(/ showDetails/g, ''); 242 | }; 243 | 244 | this.detailsMenuItem.onclick = function() { 245 | showDetails(); 246 | }; 247 | }; 248 | 249 | this.addSpecs = function(specs, specFilter) { 250 | this.totalSpecCount = specs.length; 251 | 252 | this.views = { 253 | specs: {}, 254 | suites: {} 255 | }; 256 | 257 | for (var i = 0; i < specs.length; i++) { 258 | var spec = specs[i]; 259 | this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views); 260 | if (specFilter(spec)) { 261 | this.runningSpecCount++; 262 | } 263 | } 264 | }; 265 | 266 | this.specComplete = function(spec) { 267 | this.completeSpecCount++; 268 | 269 | if (isUndefined(this.views.specs[spec.id])) { 270 | this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom); 271 | } 272 | 273 | var specView = this.views.specs[spec.id]; 274 | 275 | switch (specView.status()) { 276 | case 'passed': 277 | this.passedCount++; 278 | break; 279 | 280 | case 'failed': 281 | this.failedCount++; 282 | break; 283 | 284 | case 'skipped': 285 | this.skippedCount++; 286 | break; 287 | } 288 | 289 | specView.refresh(); 290 | this.refresh(); 291 | }; 292 | 293 | this.suiteComplete = function(suite) { 294 | var suiteView = this.views.suites[suite.id]; 295 | if (isUndefined(suiteView)) { 296 | return; 297 | } 298 | suiteView.refresh(); 299 | }; 300 | 301 | this.refresh = function() { 302 | 303 | if (isUndefined(this.resultsMenu)) { 304 | this.createResultsMenu(); 305 | } 306 | 307 | // currently running UI 308 | if (isUndefined(this.runningAlert)) { 309 | this.runningAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "runningAlert bar" }); 310 | dom.alert.appendChild(this.runningAlert); 311 | } 312 | this.runningAlert.innerHTML = "Running " + this.completeSpecCount + " of " + specPluralizedFor(this.totalSpecCount); 313 | 314 | // skipped specs UI 315 | if (isUndefined(this.skippedAlert)) { 316 | this.skippedAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "skippedAlert bar" }); 317 | } 318 | 319 | this.skippedAlert.innerHTML = "Skipping " + this.skippedCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all"; 320 | 321 | if (this.skippedCount === 1 && isDefined(dom.alert)) { 322 | dom.alert.appendChild(this.skippedAlert); 323 | } 324 | 325 | // passing specs UI 326 | if (isUndefined(this.passedAlert)) { 327 | this.passedAlert = this.createDom('span', { href: jasmine.HtmlReporter.sectionLink(), className: "passingAlert bar" }); 328 | } 329 | this.passedAlert.innerHTML = "Passing " + specPluralizedFor(this.passedCount); 330 | 331 | // failing specs UI 332 | if (isUndefined(this.failedAlert)) { 333 | this.failedAlert = this.createDom('span', {href: "?", className: "failingAlert bar"}); 334 | } 335 | this.failedAlert.innerHTML = "Failing " + specPluralizedFor(this.failedCount); 336 | 337 | if (this.failedCount === 1 && isDefined(dom.alert)) { 338 | dom.alert.appendChild(this.failedAlert); 339 | dom.alert.appendChild(this.resultsMenu); 340 | } 341 | 342 | // summary info 343 | this.summaryMenuItem.innerHTML = "" + specPluralizedFor(this.runningSpecCount); 344 | this.detailsMenuItem.innerHTML = "" + this.failedCount + " failing"; 345 | }; 346 | 347 | this.complete = function() { 348 | dom.alert.removeChild(this.runningAlert); 349 | 350 | this.skippedAlert.innerHTML = "Ran " + this.runningSpecCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all"; 351 | 352 | if (this.failedCount === 0) { 353 | dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, "Passing " + specPluralizedFor(this.passedCount))); 354 | } else { 355 | showDetails(); 356 | } 357 | 358 | dom.banner.appendChild(this.createDom('span', {className: 'duration'}, "finished in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s")); 359 | }; 360 | 361 | return this; 362 | 363 | function showDetails() { 364 | if (dom.reporter.className.search(/showDetails/) === -1) { 365 | dom.reporter.className += " showDetails"; 366 | } 367 | } 368 | 369 | function isUndefined(obj) { 370 | return typeof obj === 'undefined'; 371 | } 372 | 373 | function isDefined(obj) { 374 | return !isUndefined(obj); 375 | } 376 | 377 | function specPluralizedFor(count) { 378 | var str = count + " spec"; 379 | if (count > 1) { 380 | str += "s" 381 | } 382 | return str; 383 | } 384 | 385 | }; 386 | 387 | jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView); 388 | 389 | 390 | jasmine.HtmlReporter.SpecView = function(spec, dom, views) { 391 | this.spec = spec; 392 | this.dom = dom; 393 | this.views = views; 394 | 395 | this.symbol = this.createDom('li', { className: 'pending' }); 396 | this.dom.symbolSummary.appendChild(this.symbol); 397 | 398 | this.summary = this.createDom('div', { className: 'specSummary' }, 399 | this.createDom('a', { 400 | className: 'description', 401 | href: jasmine.HtmlReporter.sectionLink(this.spec.getFullName()), 402 | title: this.spec.getFullName() 403 | }, this.spec.description) 404 | ); 405 | 406 | this.detail = this.createDom('div', { className: 'specDetail' }, 407 | this.createDom('a', { 408 | className: 'description', 409 | href: '?spec=' + encodeURIComponent(this.spec.getFullName()), 410 | title: this.spec.getFullName() 411 | }, this.spec.getFullName()) 412 | ); 413 | }; 414 | 415 | jasmine.HtmlReporter.SpecView.prototype.status = function() { 416 | return this.getSpecStatus(this.spec); 417 | }; 418 | 419 | jasmine.HtmlReporter.SpecView.prototype.refresh = function() { 420 | this.symbol.className = this.status(); 421 | 422 | switch (this.status()) { 423 | case 'skipped': 424 | break; 425 | 426 | case 'passed': 427 | this.appendSummaryToSuiteDiv(); 428 | break; 429 | 430 | case 'failed': 431 | this.appendSummaryToSuiteDiv(); 432 | this.appendFailureDetail(); 433 | break; 434 | } 435 | }; 436 | 437 | jasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() { 438 | this.summary.className += ' ' + this.status(); 439 | this.appendToSummary(this.spec, this.summary); 440 | }; 441 | 442 | jasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() { 443 | this.detail.className += ' ' + this.status(); 444 | 445 | var resultItems = this.spec.results().getItems(); 446 | var messagesDiv = this.createDom('div', { className: 'messages' }); 447 | 448 | for (var i = 0; i < resultItems.length; i++) { 449 | var result = resultItems[i]; 450 | 451 | if (result.type == 'log') { 452 | messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString())); 453 | } else if (result.type == 'expect' && result.passed && !result.passed()) { 454 | messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message)); 455 | 456 | if (result.trace.stack) { 457 | messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack)); 458 | } 459 | } 460 | } 461 | 462 | if (messagesDiv.childNodes.length > 0) { 463 | this.detail.appendChild(messagesDiv); 464 | this.dom.details.appendChild(this.detail); 465 | } 466 | }; 467 | 468 | jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);jasmine.HtmlReporter.SuiteView = function(suite, dom, views) { 469 | this.suite = suite; 470 | this.dom = dom; 471 | this.views = views; 472 | 473 | this.element = this.createDom('div', { className: 'suite' }, 474 | this.createDom('a', { className: 'description', href: jasmine.HtmlReporter.sectionLink(this.suite.getFullName()) }, this.suite.description) 475 | ); 476 | 477 | this.appendToSummary(this.suite, this.element); 478 | }; 479 | 480 | jasmine.HtmlReporter.SuiteView.prototype.status = function() { 481 | return this.getSpecStatus(this.suite); 482 | }; 483 | 484 | jasmine.HtmlReporter.SuiteView.prototype.refresh = function() { 485 | this.element.className += " " + this.status(); 486 | }; 487 | 488 | jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView); 489 | 490 | /* @deprecated Use jasmine.HtmlReporter instead 491 | */ 492 | jasmine.TrivialReporter = function(doc) { 493 | this.document = doc || document; 494 | this.suiteDivs = {}; 495 | this.logRunningSpecs = false; 496 | }; 497 | 498 | jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) { 499 | var el = document.createElement(type); 500 | 501 | for (var i = 2; i < arguments.length; i++) { 502 | var child = arguments[i]; 503 | 504 | if (typeof child === 'string') { 505 | el.appendChild(document.createTextNode(child)); 506 | } else { 507 | if (child) { el.appendChild(child); } 508 | } 509 | } 510 | 511 | for (var attr in attrs) { 512 | if (attr == "className") { 513 | el[attr] = attrs[attr]; 514 | } else { 515 | el.setAttribute(attr, attrs[attr]); 516 | } 517 | } 518 | 519 | return el; 520 | }; 521 | 522 | jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) { 523 | var showPassed, showSkipped; 524 | 525 | this.outerDiv = this.createDom('div', { id: 'TrivialReporter', className: 'jasmine_reporter' }, 526 | this.createDom('div', { className: 'banner' }, 527 | this.createDom('div', { className: 'logo' }, 528 | this.createDom('span', { className: 'title' }, "Jasmine"), 529 | this.createDom('span', { className: 'version' }, runner.env.versionString())), 530 | this.createDom('div', { className: 'options' }, 531 | "Show ", 532 | showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }), 533 | this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "), 534 | showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }), 535 | this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped") 536 | ) 537 | ), 538 | 539 | this.runnerDiv = this.createDom('div', { className: 'runner running' }, 540 | this.createDom('a', { className: 'run_spec', href: '?' }, "run all"), 541 | this.runnerMessageSpan = this.createDom('span', {}, "Running..."), 542 | this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, "")) 543 | ); 544 | 545 | this.document.body.appendChild(this.outerDiv); 546 | 547 | var suites = runner.suites(); 548 | for (var i = 0; i < suites.length; i++) { 549 | var suite = suites[i]; 550 | var suiteDiv = this.createDom('div', { className: 'suite' }, 551 | this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"), 552 | this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description)); 553 | this.suiteDivs[suite.id] = suiteDiv; 554 | var parentDiv = this.outerDiv; 555 | if (suite.parentSuite) { 556 | parentDiv = this.suiteDivs[suite.parentSuite.id]; 557 | } 558 | parentDiv.appendChild(suiteDiv); 559 | } 560 | 561 | this.startedAt = new Date(); 562 | 563 | var self = this; 564 | showPassed.onclick = function(evt) { 565 | if (showPassed.checked) { 566 | self.outerDiv.className += ' show-passed'; 567 | } else { 568 | self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, ''); 569 | } 570 | }; 571 | 572 | showSkipped.onclick = function(evt) { 573 | if (showSkipped.checked) { 574 | self.outerDiv.className += ' show-skipped'; 575 | } else { 576 | self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, ''); 577 | } 578 | }; 579 | }; 580 | 581 | jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) { 582 | var results = runner.results(); 583 | var className = (results.failedCount > 0) ? "runner failed" : "runner passed"; 584 | this.runnerDiv.setAttribute("class", className); 585 | //do it twice for IE 586 | this.runnerDiv.setAttribute("className", className); 587 | var specs = runner.specs(); 588 | var specCount = 0; 589 | for (var i = 0; i < specs.length; i++) { 590 | if (this.specFilter(specs[i])) { 591 | specCount++; 592 | } 593 | } 594 | var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s"); 595 | message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s"; 596 | this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild); 597 | 598 | this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString())); 599 | }; 600 | 601 | jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) { 602 | var results = suite.results(); 603 | var status = results.passed() ? 'passed' : 'failed'; 604 | if (results.totalCount === 0) { // todo: change this to check results.skipped 605 | status = 'skipped'; 606 | } 607 | this.suiteDivs[suite.id].className += " " + status; 608 | }; 609 | 610 | jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) { 611 | if (this.logRunningSpecs) { 612 | this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...'); 613 | } 614 | }; 615 | 616 | jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) { 617 | var results = spec.results(); 618 | var status = results.passed() ? 'passed' : 'failed'; 619 | if (results.skipped) { 620 | status = 'skipped'; 621 | } 622 | var specDiv = this.createDom('div', { className: 'spec ' + status }, 623 | this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"), 624 | this.createDom('a', { 625 | className: 'description', 626 | href: '?spec=' + encodeURIComponent(spec.getFullName()), 627 | title: spec.getFullName() 628 | }, spec.description)); 629 | 630 | 631 | var resultItems = results.getItems(); 632 | var messagesDiv = this.createDom('div', { className: 'messages' }); 633 | for (var i = 0; i < resultItems.length; i++) { 634 | var result = resultItems[i]; 635 | 636 | if (result.type == 'log') { 637 | messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString())); 638 | } else if (result.type == 'expect' && result.passed && !result.passed()) { 639 | messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message)); 640 | 641 | if (result.trace.stack) { 642 | messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack)); 643 | } 644 | } 645 | } 646 | 647 | if (messagesDiv.childNodes.length > 0) { 648 | specDiv.appendChild(messagesDiv); 649 | } 650 | 651 | this.suiteDivs[spec.suite.id].appendChild(specDiv); 652 | }; 653 | 654 | jasmine.TrivialReporter.prototype.log = function() { 655 | var console = jasmine.getGlobal().console; 656 | if (console && console.log) { 657 | if (console.log.apply) { 658 | console.log.apply(console, arguments); 659 | } else { 660 | console.log(arguments); // ie fix: console.log.apply doesn't exist on ie 661 | } 662 | } 663 | }; 664 | 665 | jasmine.TrivialReporter.prototype.getLocation = function() { 666 | return this.document.location; 667 | }; 668 | 669 | jasmine.TrivialReporter.prototype.specFilter = function(spec) { 670 | var paramMap = {}; 671 | var params = this.getLocation().search.substring(1).split('&'); 672 | for (var i = 0; i < params.length; i++) { 673 | var p = params[i].split('='); 674 | paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]); 675 | } 676 | 677 | if (!paramMap.spec) { 678 | return true; 679 | } 680 | return spec.getFullName().indexOf(paramMap.spec) === 0; 681 | }; 682 | -------------------------------------------------------------------------------- /test/lib/jasmine-1.3.0/jasmine.js: -------------------------------------------------------------------------------- 1 | var isCommonJS = typeof window == "undefined" && typeof exports == "object"; 2 | 3 | /** 4 | * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework. 5 | * 6 | * @namespace 7 | */ 8 | var jasmine = {}; 9 | if (isCommonJS) exports.jasmine = jasmine; 10 | /** 11 | * @private 12 | */ 13 | jasmine.unimplementedMethod_ = function() { 14 | throw new Error("unimplemented method"); 15 | }; 16 | 17 | /** 18 | * Use jasmine.undefined instead of undefined, since undefined is just 19 | * a plain old variable and may be redefined by somebody else. 20 | * 21 | * @private 22 | */ 23 | jasmine.undefined = jasmine.___undefined___; 24 | 25 | /** 26 | * Show diagnostic messages in the console if set to true 27 | * 28 | */ 29 | jasmine.VERBOSE = false; 30 | 31 | /** 32 | * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed. 33 | * 34 | */ 35 | jasmine.DEFAULT_UPDATE_INTERVAL = 250; 36 | 37 | /** 38 | * Maximum levels of nesting that will be included when an object is pretty-printed 39 | */ 40 | jasmine.MAX_PRETTY_PRINT_DEPTH = 40; 41 | 42 | /** 43 | * Default timeout interval in milliseconds for waitsFor() blocks. 44 | */ 45 | jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000; 46 | 47 | /** 48 | * By default exceptions thrown in the context of a test are caught by jasmine so that it can run the remaining tests in the suite. 49 | * Set to false to let the exception bubble up in the browser. 50 | * 51 | */ 52 | jasmine.CATCH_EXCEPTIONS = true; 53 | 54 | jasmine.getGlobal = function() { 55 | function getGlobal() { 56 | return this; 57 | } 58 | 59 | return getGlobal(); 60 | }; 61 | 62 | /** 63 | * Allows for bound functions to be compared. Internal use only. 64 | * 65 | * @ignore 66 | * @private 67 | * @param base {Object} bound 'this' for the function 68 | * @param name {Function} function to find 69 | */ 70 | jasmine.bindOriginal_ = function(base, name) { 71 | var original = base[name]; 72 | if (original.apply) { 73 | return function() { 74 | return original.apply(base, arguments); 75 | }; 76 | } else { 77 | // IE support 78 | return jasmine.getGlobal()[name]; 79 | } 80 | }; 81 | 82 | jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout'); 83 | jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout'); 84 | jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval'); 85 | jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval'); 86 | 87 | jasmine.MessageResult = function(values) { 88 | this.type = 'log'; 89 | this.values = values; 90 | this.trace = new Error(); // todo: test better 91 | }; 92 | 93 | jasmine.MessageResult.prototype.toString = function() { 94 | var text = ""; 95 | for (var i = 0; i < this.values.length; i++) { 96 | if (i > 0) text += " "; 97 | if (jasmine.isString_(this.values[i])) { 98 | text += this.values[i]; 99 | } else { 100 | text += jasmine.pp(this.values[i]); 101 | } 102 | } 103 | return text; 104 | }; 105 | 106 | jasmine.ExpectationResult = function(params) { 107 | this.type = 'expect'; 108 | this.matcherName = params.matcherName; 109 | this.passed_ = params.passed; 110 | this.expected = params.expected; 111 | this.actual = params.actual; 112 | this.message = this.passed_ ? 'Passed.' : params.message; 113 | 114 | var trace = (params.trace || new Error(this.message)); 115 | this.trace = this.passed_ ? '' : trace; 116 | }; 117 | 118 | jasmine.ExpectationResult.prototype.toString = function () { 119 | return this.message; 120 | }; 121 | 122 | jasmine.ExpectationResult.prototype.passed = function () { 123 | return this.passed_; 124 | }; 125 | 126 | /** 127 | * Getter for the Jasmine environment. Ensures one gets created 128 | */ 129 | jasmine.getEnv = function() { 130 | var env = jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env(); 131 | return env; 132 | }; 133 | 134 | /** 135 | * @ignore 136 | * @private 137 | * @param value 138 | * @returns {Boolean} 139 | */ 140 | jasmine.isArray_ = function(value) { 141 | return jasmine.isA_("Array", value); 142 | }; 143 | 144 | /** 145 | * @ignore 146 | * @private 147 | * @param value 148 | * @returns {Boolean} 149 | */ 150 | jasmine.isString_ = function(value) { 151 | return jasmine.isA_("String", value); 152 | }; 153 | 154 | /** 155 | * @ignore 156 | * @private 157 | * @param value 158 | * @returns {Boolean} 159 | */ 160 | jasmine.isNumber_ = function(value) { 161 | return jasmine.isA_("Number", value); 162 | }; 163 | 164 | /** 165 | * @ignore 166 | * @private 167 | * @param {String} typeName 168 | * @param value 169 | * @returns {Boolean} 170 | */ 171 | jasmine.isA_ = function(typeName, value) { 172 | return Object.prototype.toString.apply(value) === '[object ' + typeName + ']'; 173 | }; 174 | 175 | /** 176 | * Pretty printer for expecations. Takes any object and turns it into a human-readable string. 177 | * 178 | * @param value {Object} an object to be outputted 179 | * @returns {String} 180 | */ 181 | jasmine.pp = function(value) { 182 | var stringPrettyPrinter = new jasmine.StringPrettyPrinter(); 183 | stringPrettyPrinter.format(value); 184 | return stringPrettyPrinter.string; 185 | }; 186 | 187 | /** 188 | * Returns true if the object is a DOM Node. 189 | * 190 | * @param {Object} obj object to check 191 | * @returns {Boolean} 192 | */ 193 | jasmine.isDomNode = function(obj) { 194 | return obj.nodeType > 0; 195 | }; 196 | 197 | /** 198 | * Returns a matchable 'generic' object of the class type. For use in expecations of type when values don't matter. 199 | * 200 | * @example 201 | * // don't care about which function is passed in, as long as it's a function 202 | * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function)); 203 | * 204 | * @param {Class} clazz 205 | * @returns matchable object of the type clazz 206 | */ 207 | jasmine.any = function(clazz) { 208 | return new jasmine.Matchers.Any(clazz); 209 | }; 210 | 211 | /** 212 | * Returns a matchable subset of a JSON object. For use in expectations when you don't care about all of the 213 | * attributes on the object. 214 | * 215 | * @example 216 | * // don't care about any other attributes than foo. 217 | * expect(mySpy).toHaveBeenCalledWith(jasmine.objectContaining({foo: "bar"}); 218 | * 219 | * @param sample {Object} sample 220 | * @returns matchable object for the sample 221 | */ 222 | jasmine.objectContaining = function (sample) { 223 | return new jasmine.Matchers.ObjectContaining(sample); 224 | }; 225 | 226 | /** 227 | * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks. 228 | * 229 | * Spies should be created in test setup, before expectations. They can then be checked, using the standard Jasmine 230 | * expectation syntax. Spies can be checked if they were called or not and what the calling params were. 231 | * 232 | * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs). 233 | * 234 | * Spies are torn down at the end of every spec. 235 | * 236 | * Note: Do not call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj. 237 | * 238 | * @example 239 | * // a stub 240 | * var myStub = jasmine.createSpy('myStub'); // can be used anywhere 241 | * 242 | * // spy example 243 | * var foo = { 244 | * not: function(bool) { return !bool; } 245 | * } 246 | * 247 | * // actual foo.not will not be called, execution stops 248 | * spyOn(foo, 'not'); 249 | 250 | // foo.not spied upon, execution will continue to implementation 251 | * spyOn(foo, 'not').andCallThrough(); 252 | * 253 | * // fake example 254 | * var foo = { 255 | * not: function(bool) { return !bool; } 256 | * } 257 | * 258 | * // foo.not(val) will return val 259 | * spyOn(foo, 'not').andCallFake(function(value) {return value;}); 260 | * 261 | * // mock example 262 | * foo.not(7 == 7); 263 | * expect(foo.not).toHaveBeenCalled(); 264 | * expect(foo.not).toHaveBeenCalledWith(true); 265 | * 266 | * @constructor 267 | * @see spyOn, jasmine.createSpy, jasmine.createSpyObj 268 | * @param {String} name 269 | */ 270 | jasmine.Spy = function(name) { 271 | /** 272 | * The name of the spy, if provided. 273 | */ 274 | this.identity = name || 'unknown'; 275 | /** 276 | * Is this Object a spy? 277 | */ 278 | this.isSpy = true; 279 | /** 280 | * The actual function this spy stubs. 281 | */ 282 | this.plan = function() { 283 | }; 284 | /** 285 | * Tracking of the most recent call to the spy. 286 | * @example 287 | * var mySpy = jasmine.createSpy('foo'); 288 | * mySpy(1, 2); 289 | * mySpy.mostRecentCall.args = [1, 2]; 290 | */ 291 | this.mostRecentCall = {}; 292 | 293 | /** 294 | * Holds arguments for each call to the spy, indexed by call count 295 | * @example 296 | * var mySpy = jasmine.createSpy('foo'); 297 | * mySpy(1, 2); 298 | * mySpy(7, 8); 299 | * mySpy.mostRecentCall.args = [7, 8]; 300 | * mySpy.argsForCall[0] = [1, 2]; 301 | * mySpy.argsForCall[1] = [7, 8]; 302 | */ 303 | this.argsForCall = []; 304 | this.calls = []; 305 | }; 306 | 307 | /** 308 | * Tells a spy to call through to the actual implemenatation. 309 | * 310 | * @example 311 | * var foo = { 312 | * bar: function() { // do some stuff } 313 | * } 314 | * 315 | * // defining a spy on an existing property: foo.bar 316 | * spyOn(foo, 'bar').andCallThrough(); 317 | */ 318 | jasmine.Spy.prototype.andCallThrough = function() { 319 | this.plan = this.originalValue; 320 | return this; 321 | }; 322 | 323 | /** 324 | * For setting the return value of a spy. 325 | * 326 | * @example 327 | * // defining a spy from scratch: foo() returns 'baz' 328 | * var foo = jasmine.createSpy('spy on foo').andReturn('baz'); 329 | * 330 | * // defining a spy on an existing property: foo.bar() returns 'baz' 331 | * spyOn(foo, 'bar').andReturn('baz'); 332 | * 333 | * @param {Object} value 334 | */ 335 | jasmine.Spy.prototype.andReturn = function(value) { 336 | this.plan = function() { 337 | return value; 338 | }; 339 | return this; 340 | }; 341 | 342 | /** 343 | * For throwing an exception when a spy is called. 344 | * 345 | * @example 346 | * // defining a spy from scratch: foo() throws an exception w/ message 'ouch' 347 | * var foo = jasmine.createSpy('spy on foo').andThrow('baz'); 348 | * 349 | * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch' 350 | * spyOn(foo, 'bar').andThrow('baz'); 351 | * 352 | * @param {String} exceptionMsg 353 | */ 354 | jasmine.Spy.prototype.andThrow = function(exceptionMsg) { 355 | this.plan = function() { 356 | throw exceptionMsg; 357 | }; 358 | return this; 359 | }; 360 | 361 | /** 362 | * Calls an alternate implementation when a spy is called. 363 | * 364 | * @example 365 | * var baz = function() { 366 | * // do some stuff, return something 367 | * } 368 | * // defining a spy from scratch: foo() calls the function baz 369 | * var foo = jasmine.createSpy('spy on foo').andCall(baz); 370 | * 371 | * // defining a spy on an existing property: foo.bar() calls an anonymnous function 372 | * spyOn(foo, 'bar').andCall(function() { return 'baz';} ); 373 | * 374 | * @param {Function} fakeFunc 375 | */ 376 | jasmine.Spy.prototype.andCallFake = function(fakeFunc) { 377 | this.plan = fakeFunc; 378 | return this; 379 | }; 380 | 381 | /** 382 | * Resets all of a spy's the tracking variables so that it can be used again. 383 | * 384 | * @example 385 | * spyOn(foo, 'bar'); 386 | * 387 | * foo.bar(); 388 | * 389 | * expect(foo.bar.callCount).toEqual(1); 390 | * 391 | * foo.bar.reset(); 392 | * 393 | * expect(foo.bar.callCount).toEqual(0); 394 | */ 395 | jasmine.Spy.prototype.reset = function() { 396 | this.wasCalled = false; 397 | this.callCount = 0; 398 | this.argsForCall = []; 399 | this.calls = []; 400 | this.mostRecentCall = {}; 401 | }; 402 | 403 | jasmine.createSpy = function(name) { 404 | 405 | var spyObj = function() { 406 | spyObj.wasCalled = true; 407 | spyObj.callCount++; 408 | var args = jasmine.util.argsToArray(arguments); 409 | spyObj.mostRecentCall.object = this; 410 | spyObj.mostRecentCall.args = args; 411 | spyObj.argsForCall.push(args); 412 | spyObj.calls.push({object: this, args: args}); 413 | return spyObj.plan.apply(this, arguments); 414 | }; 415 | 416 | var spy = new jasmine.Spy(name); 417 | 418 | for (var prop in spy) { 419 | spyObj[prop] = spy[prop]; 420 | } 421 | 422 | spyObj.reset(); 423 | 424 | return spyObj; 425 | }; 426 | 427 | /** 428 | * Determines whether an object is a spy. 429 | * 430 | * @param {jasmine.Spy|Object} putativeSpy 431 | * @returns {Boolean} 432 | */ 433 | jasmine.isSpy = function(putativeSpy) { 434 | return putativeSpy && putativeSpy.isSpy; 435 | }; 436 | 437 | /** 438 | * Creates a more complicated spy: an Object that has every property a function that is a spy. Used for stubbing something 439 | * large in one call. 440 | * 441 | * @param {String} baseName name of spy class 442 | * @param {Array} methodNames array of names of methods to make spies 443 | */ 444 | jasmine.createSpyObj = function(baseName, methodNames) { 445 | if (!jasmine.isArray_(methodNames) || methodNames.length === 0) { 446 | throw new Error('createSpyObj requires a non-empty array of method names to create spies for'); 447 | } 448 | var obj = {}; 449 | for (var i = 0; i < methodNames.length; i++) { 450 | obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]); 451 | } 452 | return obj; 453 | }; 454 | 455 | /** 456 | * All parameters are pretty-printed and concatenated together, then written to the current spec's output. 457 | * 458 | * Be careful not to leave calls to jasmine.log in production code. 459 | */ 460 | jasmine.log = function() { 461 | var spec = jasmine.getEnv().currentSpec; 462 | spec.log.apply(spec, arguments); 463 | }; 464 | 465 | /** 466 | * Function that installs a spy on an existing object's method name. Used within a Spec to create a spy. 467 | * 468 | * @example 469 | * // spy example 470 | * var foo = { 471 | * not: function(bool) { return !bool; } 472 | * } 473 | * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops 474 | * 475 | * @see jasmine.createSpy 476 | * @param obj 477 | * @param methodName 478 | * @return {jasmine.Spy} a Jasmine spy that can be chained with all spy methods 479 | */ 480 | var spyOn = function(obj, methodName) { 481 | return jasmine.getEnv().currentSpec.spyOn(obj, methodName); 482 | }; 483 | if (isCommonJS) exports.spyOn = spyOn; 484 | 485 | /** 486 | * Creates a Jasmine spec that will be added to the current suite. 487 | * 488 | * // TODO: pending tests 489 | * 490 | * @example 491 | * it('should be true', function() { 492 | * expect(true).toEqual(true); 493 | * }); 494 | * 495 | * @param {String} desc description of this specification 496 | * @param {Function} func defines the preconditions and expectations of the spec 497 | */ 498 | var it = function(desc, func) { 499 | return jasmine.getEnv().it(desc, func); 500 | }; 501 | if (isCommonJS) exports.it = it; 502 | 503 | /** 504 | * Creates a disabled Jasmine spec. 505 | * 506 | * A convenience method that allows existing specs to be disabled temporarily during development. 507 | * 508 | * @param {String} desc description of this specification 509 | * @param {Function} func defines the preconditions and expectations of the spec 510 | */ 511 | var xit = function(desc, func) { 512 | return jasmine.getEnv().xit(desc, func); 513 | }; 514 | if (isCommonJS) exports.xit = xit; 515 | 516 | /** 517 | * Starts a chain for a Jasmine expectation. 518 | * 519 | * It is passed an Object that is the actual value and should chain to one of the many 520 | * jasmine.Matchers functions. 521 | * 522 | * @param {Object} actual Actual value to test against and expected value 523 | * @return {jasmine.Matchers} 524 | */ 525 | var expect = function(actual) { 526 | return jasmine.getEnv().currentSpec.expect(actual); 527 | }; 528 | if (isCommonJS) exports.expect = expect; 529 | 530 | /** 531 | * Defines part of a jasmine spec. Used in cominbination with waits or waitsFor in asynchrnous specs. 532 | * 533 | * @param {Function} func Function that defines part of a jasmine spec. 534 | */ 535 | var runs = function(func) { 536 | jasmine.getEnv().currentSpec.runs(func); 537 | }; 538 | if (isCommonJS) exports.runs = runs; 539 | 540 | /** 541 | * Waits a fixed time period before moving to the next block. 542 | * 543 | * @deprecated Use waitsFor() instead 544 | * @param {Number} timeout milliseconds to wait 545 | */ 546 | var waits = function(timeout) { 547 | jasmine.getEnv().currentSpec.waits(timeout); 548 | }; 549 | if (isCommonJS) exports.waits = waits; 550 | 551 | /** 552 | * Waits for the latchFunction to return true before proceeding to the next block. 553 | * 554 | * @param {Function} latchFunction 555 | * @param {String} optional_timeoutMessage 556 | * @param {Number} optional_timeout 557 | */ 558 | var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) { 559 | jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments); 560 | }; 561 | if (isCommonJS) exports.waitsFor = waitsFor; 562 | 563 | /** 564 | * A function that is called before each spec in a suite. 565 | * 566 | * Used for spec setup, including validating assumptions. 567 | * 568 | * @param {Function} beforeEachFunction 569 | */ 570 | var beforeEach = function(beforeEachFunction) { 571 | jasmine.getEnv().beforeEach(beforeEachFunction); 572 | }; 573 | if (isCommonJS) exports.beforeEach = beforeEach; 574 | 575 | /** 576 | * A function that is called after each spec in a suite. 577 | * 578 | * Used for restoring any state that is hijacked during spec execution. 579 | * 580 | * @param {Function} afterEachFunction 581 | */ 582 | var afterEach = function(afterEachFunction) { 583 | jasmine.getEnv().afterEach(afterEachFunction); 584 | }; 585 | if (isCommonJS) exports.afterEach = afterEach; 586 | 587 | /** 588 | * Defines a suite of specifications. 589 | * 590 | * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared 591 | * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization 592 | * of setup in some tests. 593 | * 594 | * @example 595 | * // TODO: a simple suite 596 | * 597 | * // TODO: a simple suite with a nested describe block 598 | * 599 | * @param {String} description A string, usually the class under test. 600 | * @param {Function} specDefinitions function that defines several specs. 601 | */ 602 | var describe = function(description, specDefinitions) { 603 | return jasmine.getEnv().describe(description, specDefinitions); 604 | }; 605 | if (isCommonJS) exports.describe = describe; 606 | 607 | /** 608 | * Disables a suite of specifications. Used to disable some suites in a file, or files, temporarily during development. 609 | * 610 | * @param {String} description A string, usually the class under test. 611 | * @param {Function} specDefinitions function that defines several specs. 612 | */ 613 | var xdescribe = function(description, specDefinitions) { 614 | return jasmine.getEnv().xdescribe(description, specDefinitions); 615 | }; 616 | if (isCommonJS) exports.xdescribe = xdescribe; 617 | 618 | 619 | // Provide the XMLHttpRequest class for IE 5.x-6.x: 620 | jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() { 621 | function tryIt(f) { 622 | try { 623 | return f(); 624 | } catch(e) { 625 | } 626 | return null; 627 | } 628 | 629 | var xhr = tryIt(function() { 630 | return new ActiveXObject("Msxml2.XMLHTTP.6.0"); 631 | }) || 632 | tryIt(function() { 633 | return new ActiveXObject("Msxml2.XMLHTTP.3.0"); 634 | }) || 635 | tryIt(function() { 636 | return new ActiveXObject("Msxml2.XMLHTTP"); 637 | }) || 638 | tryIt(function() { 639 | return new ActiveXObject("Microsoft.XMLHTTP"); 640 | }); 641 | 642 | if (!xhr) throw new Error("This browser does not support XMLHttpRequest."); 643 | 644 | return xhr; 645 | } : XMLHttpRequest; 646 | /** 647 | * @namespace 648 | */ 649 | jasmine.util = {}; 650 | 651 | /** 652 | * Declare that a child class inherit it's prototype from the parent class. 653 | * 654 | * @private 655 | * @param {Function} childClass 656 | * @param {Function} parentClass 657 | */ 658 | jasmine.util.inherit = function(childClass, parentClass) { 659 | /** 660 | * @private 661 | */ 662 | var subclass = function() { 663 | }; 664 | subclass.prototype = parentClass.prototype; 665 | childClass.prototype = new subclass(); 666 | }; 667 | 668 | jasmine.util.formatException = function(e) { 669 | var lineNumber; 670 | if (e.line) { 671 | lineNumber = e.line; 672 | } 673 | else if (e.lineNumber) { 674 | lineNumber = e.lineNumber; 675 | } 676 | 677 | var file; 678 | 679 | if (e.sourceURL) { 680 | file = e.sourceURL; 681 | } 682 | else if (e.fileName) { 683 | file = e.fileName; 684 | } 685 | 686 | var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString(); 687 | 688 | if (file && lineNumber) { 689 | message += ' in ' + file + ' (line ' + lineNumber + ')'; 690 | } 691 | 692 | return message; 693 | }; 694 | 695 | jasmine.util.htmlEscape = function(str) { 696 | if (!str) return str; 697 | return str.replace(/&/g, '&') 698 | .replace(//g, '>'); 700 | }; 701 | 702 | jasmine.util.argsToArray = function(args) { 703 | var arrayOfArgs = []; 704 | for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]); 705 | return arrayOfArgs; 706 | }; 707 | 708 | jasmine.util.extend = function(destination, source) { 709 | for (var property in source) destination[property] = source[property]; 710 | return destination; 711 | }; 712 | 713 | /** 714 | * Environment for Jasmine 715 | * 716 | * @constructor 717 | */ 718 | jasmine.Env = function() { 719 | this.currentSpec = null; 720 | this.currentSuite = null; 721 | this.currentRunner_ = new jasmine.Runner(this); 722 | 723 | this.reporter = new jasmine.MultiReporter(); 724 | 725 | this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL; 726 | this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL; 727 | this.lastUpdate = 0; 728 | this.specFilter = function() { 729 | return true; 730 | }; 731 | 732 | this.nextSpecId_ = 0; 733 | this.nextSuiteId_ = 0; 734 | this.equalityTesters_ = []; 735 | 736 | // wrap matchers 737 | this.matchersClass = function() { 738 | jasmine.Matchers.apply(this, arguments); 739 | }; 740 | jasmine.util.inherit(this.matchersClass, jasmine.Matchers); 741 | 742 | jasmine.Matchers.wrapInto_(jasmine.Matchers.prototype, this.matchersClass); 743 | }; 744 | 745 | 746 | jasmine.Env.prototype.setTimeout = jasmine.setTimeout; 747 | jasmine.Env.prototype.clearTimeout = jasmine.clearTimeout; 748 | jasmine.Env.prototype.setInterval = jasmine.setInterval; 749 | jasmine.Env.prototype.clearInterval = jasmine.clearInterval; 750 | 751 | /** 752 | * @returns an object containing jasmine version build info, if set. 753 | */ 754 | jasmine.Env.prototype.version = function () { 755 | if (jasmine.version_) { 756 | return jasmine.version_; 757 | } else { 758 | throw new Error('Version not set'); 759 | } 760 | }; 761 | 762 | /** 763 | * @returns string containing jasmine version build info, if set. 764 | */ 765 | jasmine.Env.prototype.versionString = function() { 766 | if (!jasmine.version_) { 767 | return "version unknown"; 768 | } 769 | 770 | var version = this.version(); 771 | var versionString = version.major + "." + version.minor + "." + version.build; 772 | if (version.release_candidate) { 773 | versionString += ".rc" + version.release_candidate; 774 | } 775 | versionString += " revision " + version.revision; 776 | return versionString; 777 | }; 778 | 779 | /** 780 | * @returns a sequential integer starting at 0 781 | */ 782 | jasmine.Env.prototype.nextSpecId = function () { 783 | return this.nextSpecId_++; 784 | }; 785 | 786 | /** 787 | * @returns a sequential integer starting at 0 788 | */ 789 | jasmine.Env.prototype.nextSuiteId = function () { 790 | return this.nextSuiteId_++; 791 | }; 792 | 793 | /** 794 | * Register a reporter to receive status updates from Jasmine. 795 | * @param {jasmine.Reporter} reporter An object which will receive status updates. 796 | */ 797 | jasmine.Env.prototype.addReporter = function(reporter) { 798 | this.reporter.addReporter(reporter); 799 | }; 800 | 801 | jasmine.Env.prototype.execute = function() { 802 | this.currentRunner_.execute(); 803 | }; 804 | 805 | jasmine.Env.prototype.describe = function(description, specDefinitions) { 806 | var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite); 807 | 808 | var parentSuite = this.currentSuite; 809 | if (parentSuite) { 810 | parentSuite.add(suite); 811 | } else { 812 | this.currentRunner_.add(suite); 813 | } 814 | 815 | this.currentSuite = suite; 816 | 817 | var declarationError = null; 818 | try { 819 | specDefinitions.call(suite); 820 | } catch(e) { 821 | declarationError = e; 822 | } 823 | 824 | if (declarationError) { 825 | this.it("encountered a declaration exception", function() { 826 | throw declarationError; 827 | }); 828 | } 829 | 830 | this.currentSuite = parentSuite; 831 | 832 | return suite; 833 | }; 834 | 835 | jasmine.Env.prototype.beforeEach = function(beforeEachFunction) { 836 | if (this.currentSuite) { 837 | this.currentSuite.beforeEach(beforeEachFunction); 838 | } else { 839 | this.currentRunner_.beforeEach(beforeEachFunction); 840 | } 841 | }; 842 | 843 | jasmine.Env.prototype.currentRunner = function () { 844 | return this.currentRunner_; 845 | }; 846 | 847 | jasmine.Env.prototype.afterEach = function(afterEachFunction) { 848 | if (this.currentSuite) { 849 | this.currentSuite.afterEach(afterEachFunction); 850 | } else { 851 | this.currentRunner_.afterEach(afterEachFunction); 852 | } 853 | 854 | }; 855 | 856 | jasmine.Env.prototype.xdescribe = function(desc, specDefinitions) { 857 | return { 858 | execute: function() { 859 | } 860 | }; 861 | }; 862 | 863 | jasmine.Env.prototype.it = function(description, func) { 864 | var spec = new jasmine.Spec(this, this.currentSuite, description); 865 | this.currentSuite.add(spec); 866 | this.currentSpec = spec; 867 | 868 | if (func) { 869 | spec.runs(func); 870 | } 871 | 872 | return spec; 873 | }; 874 | 875 | jasmine.Env.prototype.xit = function(desc, func) { 876 | return { 877 | id: this.nextSpecId(), 878 | runs: function() { 879 | } 880 | }; 881 | }; 882 | 883 | jasmine.Env.prototype.compareRegExps_ = function(a, b, mismatchKeys, mismatchValues) { 884 | if (a.source != b.source) 885 | mismatchValues.push("expected pattern /" + b.source + "/ is not equal to the pattern /" + a.source + "/"); 886 | 887 | if (a.ignoreCase != b.ignoreCase) 888 | mismatchValues.push("expected modifier i was" + (b.ignoreCase ? " " : " not ") + "set and does not equal the origin modifier"); 889 | 890 | if (a.global != b.global) 891 | mismatchValues.push("expected modifier g was" + (b.global ? " " : " not ") + "set and does not equal the origin modifier"); 892 | 893 | if (a.multiline != b.multiline) 894 | mismatchValues.push("expected modifier m was" + (b.multiline ? " " : " not ") + "set and does not equal the origin modifier"); 895 | 896 | if (a.sticky != b.sticky) 897 | mismatchValues.push("expected modifier y was" + (b.sticky ? " " : " not ") + "set and does not equal the origin modifier"); 898 | 899 | return (mismatchValues.length === 0); 900 | }; 901 | 902 | jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) { 903 | if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) { 904 | return true; 905 | } 906 | 907 | a.__Jasmine_been_here_before__ = b; 908 | b.__Jasmine_been_here_before__ = a; 909 | 910 | var hasKey = function(obj, keyName) { 911 | return obj !== null && obj[keyName] !== jasmine.undefined; 912 | }; 913 | 914 | for (var property in b) { 915 | if (!hasKey(a, property) && hasKey(b, property)) { 916 | mismatchKeys.push("expected has key '" + property + "', but missing from actual."); 917 | } 918 | } 919 | for (property in a) { 920 | if (!hasKey(b, property) && hasKey(a, property)) { 921 | mismatchKeys.push("expected missing key '" + property + "', but present in actual."); 922 | } 923 | } 924 | for (property in b) { 925 | if (property == '__Jasmine_been_here_before__') continue; 926 | if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) { 927 | mismatchValues.push("'" + property + "' was '" + (b[property] ? jasmine.util.htmlEscape(b[property].toString()) : b[property]) + "' in expected, but was '" + (a[property] ? jasmine.util.htmlEscape(a[property].toString()) : a[property]) + "' in actual."); 928 | } 929 | } 930 | 931 | if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) { 932 | mismatchValues.push("arrays were not the same length"); 933 | } 934 | 935 | delete a.__Jasmine_been_here_before__; 936 | delete b.__Jasmine_been_here_before__; 937 | return (mismatchKeys.length === 0 && mismatchValues.length === 0); 938 | }; 939 | 940 | jasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) { 941 | mismatchKeys = mismatchKeys || []; 942 | mismatchValues = mismatchValues || []; 943 | 944 | for (var i = 0; i < this.equalityTesters_.length; i++) { 945 | var equalityTester = this.equalityTesters_[i]; 946 | var result = equalityTester(a, b, this, mismatchKeys, mismatchValues); 947 | if (result !== jasmine.undefined) return result; 948 | } 949 | 950 | if (a === b) return true; 951 | 952 | if (a === jasmine.undefined || a === null || b === jasmine.undefined || b === null) { 953 | return (a == jasmine.undefined && b == jasmine.undefined); 954 | } 955 | 956 | if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) { 957 | return a === b; 958 | } 959 | 960 | if (a instanceof Date && b instanceof Date) { 961 | return a.getTime() == b.getTime(); 962 | } 963 | 964 | if (a.jasmineMatches) { 965 | return a.jasmineMatches(b); 966 | } 967 | 968 | if (b.jasmineMatches) { 969 | return b.jasmineMatches(a); 970 | } 971 | 972 | if (a instanceof jasmine.Matchers.ObjectContaining) { 973 | return a.matches(b); 974 | } 975 | 976 | if (b instanceof jasmine.Matchers.ObjectContaining) { 977 | return b.matches(a); 978 | } 979 | 980 | if (jasmine.isString_(a) && jasmine.isString_(b)) { 981 | return (a == b); 982 | } 983 | 984 | if (jasmine.isNumber_(a) && jasmine.isNumber_(b)) { 985 | return (a == b); 986 | } 987 | 988 | if (a instanceof RegExp && b instanceof RegExp) { 989 | return this.compareRegExps_(a, b, mismatchKeys, mismatchValues); 990 | } 991 | 992 | if (typeof a === "object" && typeof b === "object") { 993 | return this.compareObjects_(a, b, mismatchKeys, mismatchValues); 994 | } 995 | 996 | //Straight check 997 | return (a === b); 998 | }; 999 | 1000 | jasmine.Env.prototype.contains_ = function(haystack, needle) { 1001 | if (jasmine.isArray_(haystack)) { 1002 | for (var i = 0; i < haystack.length; i++) { 1003 | if (this.equals_(haystack[i], needle)) return true; 1004 | } 1005 | return false; 1006 | } 1007 | return haystack.indexOf(needle) >= 0; 1008 | }; 1009 | 1010 | jasmine.Env.prototype.addEqualityTester = function(equalityTester) { 1011 | this.equalityTesters_.push(equalityTester); 1012 | }; 1013 | /** No-op base class for Jasmine reporters. 1014 | * 1015 | * @constructor 1016 | */ 1017 | jasmine.Reporter = function() { 1018 | }; 1019 | 1020 | //noinspection JSUnusedLocalSymbols 1021 | jasmine.Reporter.prototype.reportRunnerStarting = function(runner) { 1022 | }; 1023 | 1024 | //noinspection JSUnusedLocalSymbols 1025 | jasmine.Reporter.prototype.reportRunnerResults = function(runner) { 1026 | }; 1027 | 1028 | //noinspection JSUnusedLocalSymbols 1029 | jasmine.Reporter.prototype.reportSuiteResults = function(suite) { 1030 | }; 1031 | 1032 | //noinspection JSUnusedLocalSymbols 1033 | jasmine.Reporter.prototype.reportSpecStarting = function(spec) { 1034 | }; 1035 | 1036 | //noinspection JSUnusedLocalSymbols 1037 | jasmine.Reporter.prototype.reportSpecResults = function(spec) { 1038 | }; 1039 | 1040 | //noinspection JSUnusedLocalSymbols 1041 | jasmine.Reporter.prototype.log = function(str) { 1042 | }; 1043 | 1044 | /** 1045 | * Blocks are functions with executable code that make up a spec. 1046 | * 1047 | * @constructor 1048 | * @param {jasmine.Env} env 1049 | * @param {Function} func 1050 | * @param {jasmine.Spec} spec 1051 | */ 1052 | jasmine.Block = function(env, func, spec) { 1053 | this.env = env; 1054 | this.func = func; 1055 | this.spec = spec; 1056 | }; 1057 | 1058 | jasmine.Block.prototype.execute = function(onComplete) { 1059 | if (!jasmine.CATCH_EXCEPTIONS) { 1060 | this.func.apply(this.spec); 1061 | } 1062 | else { 1063 | try { 1064 | this.func.apply(this.spec); 1065 | } catch (e) { 1066 | this.spec.fail(e); 1067 | } 1068 | } 1069 | onComplete(); 1070 | }; 1071 | /** JavaScript API reporter. 1072 | * 1073 | * @constructor 1074 | */ 1075 | jasmine.JsApiReporter = function() { 1076 | this.started = false; 1077 | this.finished = false; 1078 | this.suites_ = []; 1079 | this.results_ = {}; 1080 | }; 1081 | 1082 | jasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) { 1083 | this.started = true; 1084 | var suites = runner.topLevelSuites(); 1085 | for (var i = 0; i < suites.length; i++) { 1086 | var suite = suites[i]; 1087 | this.suites_.push(this.summarize_(suite)); 1088 | } 1089 | }; 1090 | 1091 | jasmine.JsApiReporter.prototype.suites = function() { 1092 | return this.suites_; 1093 | }; 1094 | 1095 | jasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) { 1096 | var isSuite = suiteOrSpec instanceof jasmine.Suite; 1097 | var summary = { 1098 | id: suiteOrSpec.id, 1099 | name: suiteOrSpec.description, 1100 | type: isSuite ? 'suite' : 'spec', 1101 | children: [] 1102 | }; 1103 | 1104 | if (isSuite) { 1105 | var children = suiteOrSpec.children(); 1106 | for (var i = 0; i < children.length; i++) { 1107 | summary.children.push(this.summarize_(children[i])); 1108 | } 1109 | } 1110 | return summary; 1111 | }; 1112 | 1113 | jasmine.JsApiReporter.prototype.results = function() { 1114 | return this.results_; 1115 | }; 1116 | 1117 | jasmine.JsApiReporter.prototype.resultsForSpec = function(specId) { 1118 | return this.results_[specId]; 1119 | }; 1120 | 1121 | //noinspection JSUnusedLocalSymbols 1122 | jasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) { 1123 | this.finished = true; 1124 | }; 1125 | 1126 | //noinspection JSUnusedLocalSymbols 1127 | jasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) { 1128 | }; 1129 | 1130 | //noinspection JSUnusedLocalSymbols 1131 | jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) { 1132 | this.results_[spec.id] = { 1133 | messages: spec.results().getItems(), 1134 | result: spec.results().failedCount > 0 ? "failed" : "passed" 1135 | }; 1136 | }; 1137 | 1138 | //noinspection JSUnusedLocalSymbols 1139 | jasmine.JsApiReporter.prototype.log = function(str) { 1140 | }; 1141 | 1142 | jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){ 1143 | var results = {}; 1144 | for (var i = 0; i < specIds.length; i++) { 1145 | var specId = specIds[i]; 1146 | results[specId] = this.summarizeResult_(this.results_[specId]); 1147 | } 1148 | return results; 1149 | }; 1150 | 1151 | jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){ 1152 | var summaryMessages = []; 1153 | var messagesLength = result.messages.length; 1154 | for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) { 1155 | var resultMessage = result.messages[messageIndex]; 1156 | summaryMessages.push({ 1157 | text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined, 1158 | passed: resultMessage.passed ? resultMessage.passed() : true, 1159 | type: resultMessage.type, 1160 | message: resultMessage.message, 1161 | trace: { 1162 | stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined 1163 | } 1164 | }); 1165 | } 1166 | 1167 | return { 1168 | result : result.result, 1169 | messages : summaryMessages 1170 | }; 1171 | }; 1172 | 1173 | /** 1174 | * @constructor 1175 | * @param {jasmine.Env} env 1176 | * @param actual 1177 | * @param {jasmine.Spec} spec 1178 | */ 1179 | jasmine.Matchers = function(env, actual, spec, opt_isNot) { 1180 | this.env = env; 1181 | this.actual = actual; 1182 | this.spec = spec; 1183 | this.isNot = opt_isNot || false; 1184 | this.reportWasCalled_ = false; 1185 | }; 1186 | 1187 | // todo: @deprecated as of Jasmine 0.11, remove soon [xw] 1188 | jasmine.Matchers.pp = function(str) { 1189 | throw new Error("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!"); 1190 | }; 1191 | 1192 | // todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw] 1193 | jasmine.Matchers.prototype.report = function(result, failing_message, details) { 1194 | throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs"); 1195 | }; 1196 | 1197 | jasmine.Matchers.wrapInto_ = function(prototype, matchersClass) { 1198 | for (var methodName in prototype) { 1199 | if (methodName == 'report') continue; 1200 | var orig = prototype[methodName]; 1201 | matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig); 1202 | } 1203 | }; 1204 | 1205 | jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) { 1206 | return function() { 1207 | var matcherArgs = jasmine.util.argsToArray(arguments); 1208 | var result = matcherFunction.apply(this, arguments); 1209 | 1210 | if (this.isNot) { 1211 | result = !result; 1212 | } 1213 | 1214 | if (this.reportWasCalled_) return result; 1215 | 1216 | var message; 1217 | if (!result) { 1218 | if (this.message) { 1219 | message = this.message.apply(this, arguments); 1220 | if (jasmine.isArray_(message)) { 1221 | message = message[this.isNot ? 1 : 0]; 1222 | } 1223 | } else { 1224 | var englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); }); 1225 | message = "Expected " + jasmine.pp(this.actual) + (this.isNot ? " not " : " ") + englishyPredicate; 1226 | if (matcherArgs.length > 0) { 1227 | for (var i = 0; i < matcherArgs.length; i++) { 1228 | if (i > 0) message += ","; 1229 | message += " " + jasmine.pp(matcherArgs[i]); 1230 | } 1231 | } 1232 | message += "."; 1233 | } 1234 | } 1235 | var expectationResult = new jasmine.ExpectationResult({ 1236 | matcherName: matcherName, 1237 | passed: result, 1238 | expected: matcherArgs.length > 1 ? matcherArgs : matcherArgs[0], 1239 | actual: this.actual, 1240 | message: message 1241 | }); 1242 | this.spec.addMatcherResult(expectationResult); 1243 | return jasmine.undefined; 1244 | }; 1245 | }; 1246 | 1247 | 1248 | 1249 | 1250 | /** 1251 | * toBe: compares the actual to the expected using === 1252 | * @param expected 1253 | */ 1254 | jasmine.Matchers.prototype.toBe = function(expected) { 1255 | return this.actual === expected; 1256 | }; 1257 | 1258 | /** 1259 | * toNotBe: compares the actual to the expected using !== 1260 | * @param expected 1261 | * @deprecated as of 1.0. Use not.toBe() instead. 1262 | */ 1263 | jasmine.Matchers.prototype.toNotBe = function(expected) { 1264 | return this.actual !== expected; 1265 | }; 1266 | 1267 | /** 1268 | * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc. 1269 | * 1270 | * @param expected 1271 | */ 1272 | jasmine.Matchers.prototype.toEqual = function(expected) { 1273 | return this.env.equals_(this.actual, expected); 1274 | }; 1275 | 1276 | /** 1277 | * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual 1278 | * @param expected 1279 | * @deprecated as of 1.0. Use not.toEqual() instead. 1280 | */ 1281 | jasmine.Matchers.prototype.toNotEqual = function(expected) { 1282 | return !this.env.equals_(this.actual, expected); 1283 | }; 1284 | 1285 | /** 1286 | * Matcher that compares the actual to the expected using a regular expression. Constructs a RegExp, so takes 1287 | * a pattern or a String. 1288 | * 1289 | * @param expected 1290 | */ 1291 | jasmine.Matchers.prototype.toMatch = function(expected) { 1292 | return new RegExp(expected).test(this.actual); 1293 | }; 1294 | 1295 | /** 1296 | * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch 1297 | * @param expected 1298 | * @deprecated as of 1.0. Use not.toMatch() instead. 1299 | */ 1300 | jasmine.Matchers.prototype.toNotMatch = function(expected) { 1301 | return !(new RegExp(expected).test(this.actual)); 1302 | }; 1303 | 1304 | /** 1305 | * Matcher that compares the actual to jasmine.undefined. 1306 | */ 1307 | jasmine.Matchers.prototype.toBeDefined = function() { 1308 | return (this.actual !== jasmine.undefined); 1309 | }; 1310 | 1311 | /** 1312 | * Matcher that compares the actual to jasmine.undefined. 1313 | */ 1314 | jasmine.Matchers.prototype.toBeUndefined = function() { 1315 | return (this.actual === jasmine.undefined); 1316 | }; 1317 | 1318 | /** 1319 | * Matcher that compares the actual to null. 1320 | */ 1321 | jasmine.Matchers.prototype.toBeNull = function() { 1322 | return (this.actual === null); 1323 | }; 1324 | 1325 | /** 1326 | * Matcher that compares the actual to NaN. 1327 | */ 1328 | jasmine.Matchers.prototype.toBeNaN = function() { 1329 | this.message = function() { 1330 | return [ "Expected " + jasmine.pp(this.actual) + " to be NaN." ]; 1331 | }; 1332 | 1333 | return (this.actual !== this.actual); 1334 | }; 1335 | 1336 | /** 1337 | * Matcher that boolean not-nots the actual. 1338 | */ 1339 | jasmine.Matchers.prototype.toBeTruthy = function() { 1340 | return !!this.actual; 1341 | }; 1342 | 1343 | 1344 | /** 1345 | * Matcher that boolean nots the actual. 1346 | */ 1347 | jasmine.Matchers.prototype.toBeFalsy = function() { 1348 | return !this.actual; 1349 | }; 1350 | 1351 | 1352 | /** 1353 | * Matcher that checks to see if the actual, a Jasmine spy, was called. 1354 | */ 1355 | jasmine.Matchers.prototype.toHaveBeenCalled = function() { 1356 | if (arguments.length > 0) { 1357 | throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith'); 1358 | } 1359 | 1360 | if (!jasmine.isSpy(this.actual)) { 1361 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.'); 1362 | } 1363 | 1364 | this.message = function() { 1365 | return [ 1366 | "Expected spy " + this.actual.identity + " to have been called.", 1367 | "Expected spy " + this.actual.identity + " not to have been called." 1368 | ]; 1369 | }; 1370 | 1371 | return this.actual.wasCalled; 1372 | }; 1373 | 1374 | /** @deprecated Use expect(xxx).toHaveBeenCalled() instead */ 1375 | jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled; 1376 | 1377 | /** 1378 | * Matcher that checks to see if the actual, a Jasmine spy, was not called. 1379 | * 1380 | * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead 1381 | */ 1382 | jasmine.Matchers.prototype.wasNotCalled = function() { 1383 | if (arguments.length > 0) { 1384 | throw new Error('wasNotCalled does not take arguments'); 1385 | } 1386 | 1387 | if (!jasmine.isSpy(this.actual)) { 1388 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.'); 1389 | } 1390 | 1391 | this.message = function() { 1392 | return [ 1393 | "Expected spy " + this.actual.identity + " to not have been called.", 1394 | "Expected spy " + this.actual.identity + " to have been called." 1395 | ]; 1396 | }; 1397 | 1398 | return !this.actual.wasCalled; 1399 | }; 1400 | 1401 | /** 1402 | * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters. 1403 | * 1404 | * @example 1405 | * 1406 | */ 1407 | jasmine.Matchers.prototype.toHaveBeenCalledWith = function() { 1408 | var expectedArgs = jasmine.util.argsToArray(arguments); 1409 | if (!jasmine.isSpy(this.actual)) { 1410 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.'); 1411 | } 1412 | this.message = function() { 1413 | var invertedMessage = "Expected spy " + this.actual.identity + " not to have been called with " + jasmine.pp(expectedArgs) + " but it was."; 1414 | var positiveMessage = ""; 1415 | if (this.actual.callCount === 0) { 1416 | positiveMessage = "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but it was never called."; 1417 | } else { 1418 | positiveMessage = "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but actual calls were " + jasmine.pp(this.actual.argsForCall).replace(/^\[ | \]$/g, '') 1419 | } 1420 | return [positiveMessage, invertedMessage]; 1421 | }; 1422 | 1423 | return this.env.contains_(this.actual.argsForCall, expectedArgs); 1424 | }; 1425 | 1426 | /** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */ 1427 | jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith; 1428 | 1429 | /** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */ 1430 | jasmine.Matchers.prototype.wasNotCalledWith = function() { 1431 | var expectedArgs = jasmine.util.argsToArray(arguments); 1432 | if (!jasmine.isSpy(this.actual)) { 1433 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.'); 1434 | } 1435 | 1436 | this.message = function() { 1437 | return [ 1438 | "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was", 1439 | "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was" 1440 | ]; 1441 | }; 1442 | 1443 | return !this.env.contains_(this.actual.argsForCall, expectedArgs); 1444 | }; 1445 | 1446 | /** 1447 | * Matcher that checks that the expected item is an element in the actual Array. 1448 | * 1449 | * @param {Object} expected 1450 | */ 1451 | jasmine.Matchers.prototype.toContain = function(expected) { 1452 | return this.env.contains_(this.actual, expected); 1453 | }; 1454 | 1455 | /** 1456 | * Matcher that checks that the expected item is NOT an element in the actual Array. 1457 | * 1458 | * @param {Object} expected 1459 | * @deprecated as of 1.0. Use not.toContain() instead. 1460 | */ 1461 | jasmine.Matchers.prototype.toNotContain = function(expected) { 1462 | return !this.env.contains_(this.actual, expected); 1463 | }; 1464 | 1465 | jasmine.Matchers.prototype.toBeLessThan = function(expected) { 1466 | return this.actual < expected; 1467 | }; 1468 | 1469 | jasmine.Matchers.prototype.toBeGreaterThan = function(expected) { 1470 | return this.actual > expected; 1471 | }; 1472 | 1473 | /** 1474 | * Matcher that checks that the expected item is equal to the actual item 1475 | * up to a given level of decimal precision (default 2). 1476 | * 1477 | * @param {Number} expected 1478 | * @param {Number} precision, as number of decimal places 1479 | */ 1480 | jasmine.Matchers.prototype.toBeCloseTo = function(expected, precision) { 1481 | if (!(precision === 0)) { 1482 | precision = precision || 2; 1483 | } 1484 | return Math.abs(expected - this.actual) < (Math.pow(10, -precision) / 2); 1485 | }; 1486 | 1487 | /** 1488 | * Matcher that checks that the expected exception was thrown by the actual. 1489 | * 1490 | * @param {String} [expected] 1491 | */ 1492 | jasmine.Matchers.prototype.toThrow = function(expected) { 1493 | var result = false; 1494 | var exception; 1495 | if (typeof this.actual != 'function') { 1496 | throw new Error('Actual is not a function'); 1497 | } 1498 | try { 1499 | this.actual(); 1500 | } catch (e) { 1501 | exception = e; 1502 | } 1503 | if (exception) { 1504 | result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected)); 1505 | } 1506 | 1507 | var not = this.isNot ? "not " : ""; 1508 | 1509 | this.message = function() { 1510 | if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) { 1511 | return ["Expected function " + not + "to throw", expected ? expected.message || expected : "an exception", ", but it threw", exception.message || exception].join(' '); 1512 | } else { 1513 | return "Expected function to throw an exception."; 1514 | } 1515 | }; 1516 | 1517 | return result; 1518 | }; 1519 | 1520 | jasmine.Matchers.Any = function(expectedClass) { 1521 | this.expectedClass = expectedClass; 1522 | }; 1523 | 1524 | jasmine.Matchers.Any.prototype.jasmineMatches = function(other) { 1525 | if (this.expectedClass == String) { 1526 | return typeof other == 'string' || other instanceof String; 1527 | } 1528 | 1529 | if (this.expectedClass == Number) { 1530 | return typeof other == 'number' || other instanceof Number; 1531 | } 1532 | 1533 | if (this.expectedClass == Function) { 1534 | return typeof other == 'function' || other instanceof Function; 1535 | } 1536 | 1537 | if (this.expectedClass == Object) { 1538 | return typeof other == 'object'; 1539 | } 1540 | 1541 | return other instanceof this.expectedClass; 1542 | }; 1543 | 1544 | jasmine.Matchers.Any.prototype.jasmineToString = function() { 1545 | return ''; 1546 | }; 1547 | 1548 | jasmine.Matchers.ObjectContaining = function (sample) { 1549 | this.sample = sample; 1550 | }; 1551 | 1552 | jasmine.Matchers.ObjectContaining.prototype.jasmineMatches = function(other, mismatchKeys, mismatchValues) { 1553 | mismatchKeys = mismatchKeys || []; 1554 | mismatchValues = mismatchValues || []; 1555 | 1556 | var env = jasmine.getEnv(); 1557 | 1558 | var hasKey = function(obj, keyName) { 1559 | return obj != null && obj[keyName] !== jasmine.undefined; 1560 | }; 1561 | 1562 | for (var property in this.sample) { 1563 | if (!hasKey(other, property) && hasKey(this.sample, property)) { 1564 | mismatchKeys.push("expected has key '" + property + "', but missing from actual."); 1565 | } 1566 | else if (!env.equals_(this.sample[property], other[property], mismatchKeys, mismatchValues)) { 1567 | mismatchValues.push("'" + property + "' was '" + (other[property] ? jasmine.util.htmlEscape(other[property].toString()) : other[property]) + "' in expected, but was '" + (this.sample[property] ? jasmine.util.htmlEscape(this.sample[property].toString()) : this.sample[property]) + "' in actual."); 1568 | } 1569 | } 1570 | 1571 | return (mismatchKeys.length === 0 && mismatchValues.length === 0); 1572 | }; 1573 | 1574 | jasmine.Matchers.ObjectContaining.prototype.jasmineToString = function () { 1575 | return ""; 1576 | }; 1577 | // Mock setTimeout, clearTimeout 1578 | // Contributed by Pivotal Computer Systems, www.pivotalsf.com 1579 | 1580 | jasmine.FakeTimer = function() { 1581 | this.reset(); 1582 | 1583 | var self = this; 1584 | self.setTimeout = function(funcToCall, millis) { 1585 | self.timeoutsMade++; 1586 | self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false); 1587 | return self.timeoutsMade; 1588 | }; 1589 | 1590 | self.setInterval = function(funcToCall, millis) { 1591 | self.timeoutsMade++; 1592 | self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true); 1593 | return self.timeoutsMade; 1594 | }; 1595 | 1596 | self.clearTimeout = function(timeoutKey) { 1597 | self.scheduledFunctions[timeoutKey] = jasmine.undefined; 1598 | }; 1599 | 1600 | self.clearInterval = function(timeoutKey) { 1601 | self.scheduledFunctions[timeoutKey] = jasmine.undefined; 1602 | }; 1603 | 1604 | }; 1605 | 1606 | jasmine.FakeTimer.prototype.reset = function() { 1607 | this.timeoutsMade = 0; 1608 | this.scheduledFunctions = {}; 1609 | this.nowMillis = 0; 1610 | }; 1611 | 1612 | jasmine.FakeTimer.prototype.tick = function(millis) { 1613 | var oldMillis = this.nowMillis; 1614 | var newMillis = oldMillis + millis; 1615 | this.runFunctionsWithinRange(oldMillis, newMillis); 1616 | this.nowMillis = newMillis; 1617 | }; 1618 | 1619 | jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) { 1620 | var scheduledFunc; 1621 | var funcsToRun = []; 1622 | for (var timeoutKey in this.scheduledFunctions) { 1623 | scheduledFunc = this.scheduledFunctions[timeoutKey]; 1624 | if (scheduledFunc != jasmine.undefined && 1625 | scheduledFunc.runAtMillis >= oldMillis && 1626 | scheduledFunc.runAtMillis <= nowMillis) { 1627 | funcsToRun.push(scheduledFunc); 1628 | this.scheduledFunctions[timeoutKey] = jasmine.undefined; 1629 | } 1630 | } 1631 | 1632 | if (funcsToRun.length > 0) { 1633 | funcsToRun.sort(function(a, b) { 1634 | return a.runAtMillis - b.runAtMillis; 1635 | }); 1636 | for (var i = 0; i < funcsToRun.length; ++i) { 1637 | try { 1638 | var funcToRun = funcsToRun[i]; 1639 | this.nowMillis = funcToRun.runAtMillis; 1640 | funcToRun.funcToCall(); 1641 | if (funcToRun.recurring) { 1642 | this.scheduleFunction(funcToRun.timeoutKey, 1643 | funcToRun.funcToCall, 1644 | funcToRun.millis, 1645 | true); 1646 | } 1647 | } catch(e) { 1648 | } 1649 | } 1650 | this.runFunctionsWithinRange(oldMillis, nowMillis); 1651 | } 1652 | }; 1653 | 1654 | jasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) { 1655 | this.scheduledFunctions[timeoutKey] = { 1656 | runAtMillis: this.nowMillis + millis, 1657 | funcToCall: funcToCall, 1658 | recurring: recurring, 1659 | timeoutKey: timeoutKey, 1660 | millis: millis 1661 | }; 1662 | }; 1663 | 1664 | /** 1665 | * @namespace 1666 | */ 1667 | jasmine.Clock = { 1668 | defaultFakeTimer: new jasmine.FakeTimer(), 1669 | 1670 | reset: function() { 1671 | jasmine.Clock.assertInstalled(); 1672 | jasmine.Clock.defaultFakeTimer.reset(); 1673 | }, 1674 | 1675 | tick: function(millis) { 1676 | jasmine.Clock.assertInstalled(); 1677 | jasmine.Clock.defaultFakeTimer.tick(millis); 1678 | }, 1679 | 1680 | runFunctionsWithinRange: function(oldMillis, nowMillis) { 1681 | jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis); 1682 | }, 1683 | 1684 | scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) { 1685 | jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring); 1686 | }, 1687 | 1688 | useMock: function() { 1689 | if (!jasmine.Clock.isInstalled()) { 1690 | var spec = jasmine.getEnv().currentSpec; 1691 | spec.after(jasmine.Clock.uninstallMock); 1692 | 1693 | jasmine.Clock.installMock(); 1694 | } 1695 | }, 1696 | 1697 | installMock: function() { 1698 | jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer; 1699 | }, 1700 | 1701 | uninstallMock: function() { 1702 | jasmine.Clock.assertInstalled(); 1703 | jasmine.Clock.installed = jasmine.Clock.real; 1704 | }, 1705 | 1706 | real: { 1707 | setTimeout: jasmine.getGlobal().setTimeout, 1708 | clearTimeout: jasmine.getGlobal().clearTimeout, 1709 | setInterval: jasmine.getGlobal().setInterval, 1710 | clearInterval: jasmine.getGlobal().clearInterval 1711 | }, 1712 | 1713 | assertInstalled: function() { 1714 | if (!jasmine.Clock.isInstalled()) { 1715 | throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()"); 1716 | } 1717 | }, 1718 | 1719 | isInstalled: function() { 1720 | return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer; 1721 | }, 1722 | 1723 | installed: null 1724 | }; 1725 | jasmine.Clock.installed = jasmine.Clock.real; 1726 | 1727 | //else for IE support 1728 | jasmine.getGlobal().setTimeout = function(funcToCall, millis) { 1729 | if (jasmine.Clock.installed.setTimeout.apply) { 1730 | return jasmine.Clock.installed.setTimeout.apply(this, arguments); 1731 | } else { 1732 | return jasmine.Clock.installed.setTimeout(funcToCall, millis); 1733 | } 1734 | }; 1735 | 1736 | jasmine.getGlobal().setInterval = function(funcToCall, millis) { 1737 | if (jasmine.Clock.installed.setInterval.apply) { 1738 | return jasmine.Clock.installed.setInterval.apply(this, arguments); 1739 | } else { 1740 | return jasmine.Clock.installed.setInterval(funcToCall, millis); 1741 | } 1742 | }; 1743 | 1744 | jasmine.getGlobal().clearTimeout = function(timeoutKey) { 1745 | if (jasmine.Clock.installed.clearTimeout.apply) { 1746 | return jasmine.Clock.installed.clearTimeout.apply(this, arguments); 1747 | } else { 1748 | return jasmine.Clock.installed.clearTimeout(timeoutKey); 1749 | } 1750 | }; 1751 | 1752 | jasmine.getGlobal().clearInterval = function(timeoutKey) { 1753 | if (jasmine.Clock.installed.clearTimeout.apply) { 1754 | return jasmine.Clock.installed.clearInterval.apply(this, arguments); 1755 | } else { 1756 | return jasmine.Clock.installed.clearInterval(timeoutKey); 1757 | } 1758 | }; 1759 | 1760 | /** 1761 | * @constructor 1762 | */ 1763 | jasmine.MultiReporter = function() { 1764 | this.subReporters_ = []; 1765 | }; 1766 | jasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter); 1767 | 1768 | jasmine.MultiReporter.prototype.addReporter = function(reporter) { 1769 | this.subReporters_.push(reporter); 1770 | }; 1771 | 1772 | (function() { 1773 | var functionNames = [ 1774 | "reportRunnerStarting", 1775 | "reportRunnerResults", 1776 | "reportSuiteResults", 1777 | "reportSpecStarting", 1778 | "reportSpecResults", 1779 | "log" 1780 | ]; 1781 | for (var i = 0; i < functionNames.length; i++) { 1782 | var functionName = functionNames[i]; 1783 | jasmine.MultiReporter.prototype[functionName] = (function(functionName) { 1784 | return function() { 1785 | for (var j = 0; j < this.subReporters_.length; j++) { 1786 | var subReporter = this.subReporters_[j]; 1787 | if (subReporter[functionName]) { 1788 | subReporter[functionName].apply(subReporter, arguments); 1789 | } 1790 | } 1791 | }; 1792 | })(functionName); 1793 | } 1794 | })(); 1795 | /** 1796 | * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults 1797 | * 1798 | * @constructor 1799 | */ 1800 | jasmine.NestedResults = function() { 1801 | /** 1802 | * The total count of results 1803 | */ 1804 | this.totalCount = 0; 1805 | /** 1806 | * Number of passed results 1807 | */ 1808 | this.passedCount = 0; 1809 | /** 1810 | * Number of failed results 1811 | */ 1812 | this.failedCount = 0; 1813 | /** 1814 | * Was this suite/spec skipped? 1815 | */ 1816 | this.skipped = false; 1817 | /** 1818 | * @ignore 1819 | */ 1820 | this.items_ = []; 1821 | }; 1822 | 1823 | /** 1824 | * Roll up the result counts. 1825 | * 1826 | * @param result 1827 | */ 1828 | jasmine.NestedResults.prototype.rollupCounts = function(result) { 1829 | this.totalCount += result.totalCount; 1830 | this.passedCount += result.passedCount; 1831 | this.failedCount += result.failedCount; 1832 | }; 1833 | 1834 | /** 1835 | * Adds a log message. 1836 | * @param values Array of message parts which will be concatenated later. 1837 | */ 1838 | jasmine.NestedResults.prototype.log = function(values) { 1839 | this.items_.push(new jasmine.MessageResult(values)); 1840 | }; 1841 | 1842 | /** 1843 | * Getter for the results: message & results. 1844 | */ 1845 | jasmine.NestedResults.prototype.getItems = function() { 1846 | return this.items_; 1847 | }; 1848 | 1849 | /** 1850 | * Adds a result, tracking counts (total, passed, & failed) 1851 | * @param {jasmine.ExpectationResult|jasmine.NestedResults} result 1852 | */ 1853 | jasmine.NestedResults.prototype.addResult = function(result) { 1854 | if (result.type != 'log') { 1855 | if (result.items_) { 1856 | this.rollupCounts(result); 1857 | } else { 1858 | this.totalCount++; 1859 | if (result.passed()) { 1860 | this.passedCount++; 1861 | } else { 1862 | this.failedCount++; 1863 | } 1864 | } 1865 | } 1866 | this.items_.push(result); 1867 | }; 1868 | 1869 | /** 1870 | * @returns {Boolean} True if everything below passed 1871 | */ 1872 | jasmine.NestedResults.prototype.passed = function() { 1873 | return this.passedCount === this.totalCount; 1874 | }; 1875 | /** 1876 | * Base class for pretty printing for expectation results. 1877 | */ 1878 | jasmine.PrettyPrinter = function() { 1879 | this.ppNestLevel_ = 0; 1880 | }; 1881 | 1882 | /** 1883 | * Formats a value in a nice, human-readable string. 1884 | * 1885 | * @param value 1886 | */ 1887 | jasmine.PrettyPrinter.prototype.format = function(value) { 1888 | this.ppNestLevel_++; 1889 | try { 1890 | if (value === jasmine.undefined) { 1891 | this.emitScalar('undefined'); 1892 | } else if (value === null) { 1893 | this.emitScalar('null'); 1894 | } else if (value === jasmine.getGlobal()) { 1895 | this.emitScalar(''); 1896 | } else if (value.jasmineToString) { 1897 | this.emitScalar(value.jasmineToString()); 1898 | } else if (typeof value === 'string') { 1899 | this.emitString(value); 1900 | } else if (jasmine.isSpy(value)) { 1901 | this.emitScalar("spy on " + value.identity); 1902 | } else if (value instanceof RegExp) { 1903 | this.emitScalar(value.toString()); 1904 | } else if (typeof value === 'function') { 1905 | this.emitScalar('Function'); 1906 | } else if (typeof value.nodeType === 'number') { 1907 | this.emitScalar('HTMLNode'); 1908 | } else if (value instanceof Date) { 1909 | this.emitScalar('Date(' + value + ')'); 1910 | } else if (value.__Jasmine_been_here_before__) { 1911 | this.emitScalar(''); 1912 | } else if (jasmine.isArray_(value) || typeof value == 'object') { 1913 | value.__Jasmine_been_here_before__ = true; 1914 | if (jasmine.isArray_(value)) { 1915 | this.emitArray(value); 1916 | } else { 1917 | this.emitObject(value); 1918 | } 1919 | delete value.__Jasmine_been_here_before__; 1920 | } else { 1921 | this.emitScalar(value.toString()); 1922 | } 1923 | } finally { 1924 | this.ppNestLevel_--; 1925 | } 1926 | }; 1927 | 1928 | jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) { 1929 | for (var property in obj) { 1930 | if (!obj.hasOwnProperty(property)) continue; 1931 | if (property == '__Jasmine_been_here_before__') continue; 1932 | fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) !== jasmine.undefined && 1933 | obj.__lookupGetter__(property) !== null) : false); 1934 | } 1935 | }; 1936 | 1937 | jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_; 1938 | jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_; 1939 | jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_; 1940 | jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_; 1941 | 1942 | jasmine.StringPrettyPrinter = function() { 1943 | jasmine.PrettyPrinter.call(this); 1944 | 1945 | this.string = ''; 1946 | }; 1947 | jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter); 1948 | 1949 | jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) { 1950 | this.append(value); 1951 | }; 1952 | 1953 | jasmine.StringPrettyPrinter.prototype.emitString = function(value) { 1954 | this.append("'" + value + "'"); 1955 | }; 1956 | 1957 | jasmine.StringPrettyPrinter.prototype.emitArray = function(array) { 1958 | if (this.ppNestLevel_ > jasmine.MAX_PRETTY_PRINT_DEPTH) { 1959 | this.append("Array"); 1960 | return; 1961 | } 1962 | 1963 | this.append('[ '); 1964 | for (var i = 0; i < array.length; i++) { 1965 | if (i > 0) { 1966 | this.append(', '); 1967 | } 1968 | this.format(array[i]); 1969 | } 1970 | this.append(' ]'); 1971 | }; 1972 | 1973 | jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) { 1974 | if (this.ppNestLevel_ > jasmine.MAX_PRETTY_PRINT_DEPTH) { 1975 | this.append("Object"); 1976 | return; 1977 | } 1978 | 1979 | var self = this; 1980 | this.append('{ '); 1981 | var first = true; 1982 | 1983 | this.iterateObject(obj, function(property, isGetter) { 1984 | if (first) { 1985 | first = false; 1986 | } else { 1987 | self.append(', '); 1988 | } 1989 | 1990 | self.append(property); 1991 | self.append(' : '); 1992 | if (isGetter) { 1993 | self.append(''); 1994 | } else { 1995 | self.format(obj[property]); 1996 | } 1997 | }); 1998 | 1999 | this.append(' }'); 2000 | }; 2001 | 2002 | jasmine.StringPrettyPrinter.prototype.append = function(value) { 2003 | this.string += value; 2004 | }; 2005 | jasmine.Queue = function(env) { 2006 | this.env = env; 2007 | 2008 | // parallel to blocks. each true value in this array means the block will 2009 | // get executed even if we abort 2010 | this.ensured = []; 2011 | this.blocks = []; 2012 | this.running = false; 2013 | this.index = 0; 2014 | this.offset = 0; 2015 | this.abort = false; 2016 | }; 2017 | 2018 | jasmine.Queue.prototype.addBefore = function(block, ensure) { 2019 | if (ensure === jasmine.undefined) { 2020 | ensure = false; 2021 | } 2022 | 2023 | this.blocks.unshift(block); 2024 | this.ensured.unshift(ensure); 2025 | }; 2026 | 2027 | jasmine.Queue.prototype.add = function(block, ensure) { 2028 | if (ensure === jasmine.undefined) { 2029 | ensure = false; 2030 | } 2031 | 2032 | this.blocks.push(block); 2033 | this.ensured.push(ensure); 2034 | }; 2035 | 2036 | jasmine.Queue.prototype.insertNext = function(block, ensure) { 2037 | if (ensure === jasmine.undefined) { 2038 | ensure = false; 2039 | } 2040 | 2041 | this.ensured.splice((this.index + this.offset + 1), 0, ensure); 2042 | this.blocks.splice((this.index + this.offset + 1), 0, block); 2043 | this.offset++; 2044 | }; 2045 | 2046 | jasmine.Queue.prototype.start = function(onComplete) { 2047 | this.running = true; 2048 | this.onComplete = onComplete; 2049 | this.next_(); 2050 | }; 2051 | 2052 | jasmine.Queue.prototype.isRunning = function() { 2053 | return this.running; 2054 | }; 2055 | 2056 | jasmine.Queue.LOOP_DONT_RECURSE = true; 2057 | 2058 | jasmine.Queue.prototype.next_ = function() { 2059 | var self = this; 2060 | var goAgain = true; 2061 | 2062 | while (goAgain) { 2063 | goAgain = false; 2064 | 2065 | if (self.index < self.blocks.length && !(this.abort && !this.ensured[self.index])) { 2066 | var calledSynchronously = true; 2067 | var completedSynchronously = false; 2068 | 2069 | var onComplete = function () { 2070 | if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) { 2071 | completedSynchronously = true; 2072 | return; 2073 | } 2074 | 2075 | if (self.blocks[self.index].abort) { 2076 | self.abort = true; 2077 | } 2078 | 2079 | self.offset = 0; 2080 | self.index++; 2081 | 2082 | var now = new Date().getTime(); 2083 | if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) { 2084 | self.env.lastUpdate = now; 2085 | self.env.setTimeout(function() { 2086 | self.next_(); 2087 | }, 0); 2088 | } else { 2089 | if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) { 2090 | goAgain = true; 2091 | } else { 2092 | self.next_(); 2093 | } 2094 | } 2095 | }; 2096 | self.blocks[self.index].execute(onComplete); 2097 | 2098 | calledSynchronously = false; 2099 | if (completedSynchronously) { 2100 | onComplete(); 2101 | } 2102 | 2103 | } else { 2104 | self.running = false; 2105 | if (self.onComplete) { 2106 | self.onComplete(); 2107 | } 2108 | } 2109 | } 2110 | }; 2111 | 2112 | jasmine.Queue.prototype.results = function() { 2113 | var results = new jasmine.NestedResults(); 2114 | for (var i = 0; i < this.blocks.length; i++) { 2115 | if (this.blocks[i].results) { 2116 | results.addResult(this.blocks[i].results()); 2117 | } 2118 | } 2119 | return results; 2120 | }; 2121 | 2122 | 2123 | /** 2124 | * Runner 2125 | * 2126 | * @constructor 2127 | * @param {jasmine.Env} env 2128 | */ 2129 | jasmine.Runner = function(env) { 2130 | var self = this; 2131 | self.env = env; 2132 | self.queue = new jasmine.Queue(env); 2133 | self.before_ = []; 2134 | self.after_ = []; 2135 | self.suites_ = []; 2136 | }; 2137 | 2138 | jasmine.Runner.prototype.execute = function() { 2139 | var self = this; 2140 | if (self.env.reporter.reportRunnerStarting) { 2141 | self.env.reporter.reportRunnerStarting(this); 2142 | } 2143 | self.queue.start(function () { 2144 | self.finishCallback(); 2145 | }); 2146 | }; 2147 | 2148 | jasmine.Runner.prototype.beforeEach = function(beforeEachFunction) { 2149 | beforeEachFunction.typeName = 'beforeEach'; 2150 | this.before_.splice(0,0,beforeEachFunction); 2151 | }; 2152 | 2153 | jasmine.Runner.prototype.afterEach = function(afterEachFunction) { 2154 | afterEachFunction.typeName = 'afterEach'; 2155 | this.after_.splice(0,0,afterEachFunction); 2156 | }; 2157 | 2158 | 2159 | jasmine.Runner.prototype.finishCallback = function() { 2160 | this.env.reporter.reportRunnerResults(this); 2161 | }; 2162 | 2163 | jasmine.Runner.prototype.addSuite = function(suite) { 2164 | this.suites_.push(suite); 2165 | }; 2166 | 2167 | jasmine.Runner.prototype.add = function(block) { 2168 | if (block instanceof jasmine.Suite) { 2169 | this.addSuite(block); 2170 | } 2171 | this.queue.add(block); 2172 | }; 2173 | 2174 | jasmine.Runner.prototype.specs = function () { 2175 | var suites = this.suites(); 2176 | var specs = []; 2177 | for (var i = 0; i < suites.length; i++) { 2178 | specs = specs.concat(suites[i].specs()); 2179 | } 2180 | return specs; 2181 | }; 2182 | 2183 | jasmine.Runner.prototype.suites = function() { 2184 | return this.suites_; 2185 | }; 2186 | 2187 | jasmine.Runner.prototype.topLevelSuites = function() { 2188 | var topLevelSuites = []; 2189 | for (var i = 0; i < this.suites_.length; i++) { 2190 | if (!this.suites_[i].parentSuite) { 2191 | topLevelSuites.push(this.suites_[i]); 2192 | } 2193 | } 2194 | return topLevelSuites; 2195 | }; 2196 | 2197 | jasmine.Runner.prototype.results = function() { 2198 | return this.queue.results(); 2199 | }; 2200 | /** 2201 | * Internal representation of a Jasmine specification, or test. 2202 | * 2203 | * @constructor 2204 | * @param {jasmine.Env} env 2205 | * @param {jasmine.Suite} suite 2206 | * @param {String} description 2207 | */ 2208 | jasmine.Spec = function(env, suite, description) { 2209 | if (!env) { 2210 | throw new Error('jasmine.Env() required'); 2211 | } 2212 | if (!suite) { 2213 | throw new Error('jasmine.Suite() required'); 2214 | } 2215 | var spec = this; 2216 | spec.id = env.nextSpecId ? env.nextSpecId() : null; 2217 | spec.env = env; 2218 | spec.suite = suite; 2219 | spec.description = description; 2220 | spec.queue = new jasmine.Queue(env); 2221 | 2222 | spec.afterCallbacks = []; 2223 | spec.spies_ = []; 2224 | 2225 | spec.results_ = new jasmine.NestedResults(); 2226 | spec.results_.description = description; 2227 | spec.matchersClass = null; 2228 | }; 2229 | 2230 | jasmine.Spec.prototype.getFullName = function() { 2231 | return this.suite.getFullName() + ' ' + this.description + '.'; 2232 | }; 2233 | 2234 | 2235 | jasmine.Spec.prototype.results = function() { 2236 | return this.results_; 2237 | }; 2238 | 2239 | /** 2240 | * All parameters are pretty-printed and concatenated together, then written to the spec's output. 2241 | * 2242 | * Be careful not to leave calls to jasmine.log in production code. 2243 | */ 2244 | jasmine.Spec.prototype.log = function() { 2245 | return this.results_.log(arguments); 2246 | }; 2247 | 2248 | jasmine.Spec.prototype.runs = function (func) { 2249 | var block = new jasmine.Block(this.env, func, this); 2250 | this.addToQueue(block); 2251 | return this; 2252 | }; 2253 | 2254 | jasmine.Spec.prototype.addToQueue = function (block) { 2255 | if (this.queue.isRunning()) { 2256 | this.queue.insertNext(block); 2257 | } else { 2258 | this.queue.add(block); 2259 | } 2260 | }; 2261 | 2262 | /** 2263 | * @param {jasmine.ExpectationResult} result 2264 | */ 2265 | jasmine.Spec.prototype.addMatcherResult = function(result) { 2266 | this.results_.addResult(result); 2267 | }; 2268 | 2269 | jasmine.Spec.prototype.expect = function(actual) { 2270 | var positive = new (this.getMatchersClass_())(this.env, actual, this); 2271 | positive.not = new (this.getMatchersClass_())(this.env, actual, this, true); 2272 | return positive; 2273 | }; 2274 | 2275 | /** 2276 | * Waits a fixed time period before moving to the next block. 2277 | * 2278 | * @deprecated Use waitsFor() instead 2279 | * @param {Number} timeout milliseconds to wait 2280 | */ 2281 | jasmine.Spec.prototype.waits = function(timeout) { 2282 | var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this); 2283 | this.addToQueue(waitsFunc); 2284 | return this; 2285 | }; 2286 | 2287 | /** 2288 | * Waits for the latchFunction to return true before proceeding to the next block. 2289 | * 2290 | * @param {Function} latchFunction 2291 | * @param {String} optional_timeoutMessage 2292 | * @param {Number} optional_timeout 2293 | */ 2294 | jasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) { 2295 | var latchFunction_ = null; 2296 | var optional_timeoutMessage_ = null; 2297 | var optional_timeout_ = null; 2298 | 2299 | for (var i = 0; i < arguments.length; i++) { 2300 | var arg = arguments[i]; 2301 | switch (typeof arg) { 2302 | case 'function': 2303 | latchFunction_ = arg; 2304 | break; 2305 | case 'string': 2306 | optional_timeoutMessage_ = arg; 2307 | break; 2308 | case 'number': 2309 | optional_timeout_ = arg; 2310 | break; 2311 | } 2312 | } 2313 | 2314 | var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this); 2315 | this.addToQueue(waitsForFunc); 2316 | return this; 2317 | }; 2318 | 2319 | jasmine.Spec.prototype.fail = function (e) { 2320 | var expectationResult = new jasmine.ExpectationResult({ 2321 | passed: false, 2322 | message: e ? jasmine.util.formatException(e) : 'Exception', 2323 | trace: { stack: e.stack } 2324 | }); 2325 | this.results_.addResult(expectationResult); 2326 | }; 2327 | 2328 | jasmine.Spec.prototype.getMatchersClass_ = function() { 2329 | return this.matchersClass || this.env.matchersClass; 2330 | }; 2331 | 2332 | jasmine.Spec.prototype.addMatchers = function(matchersPrototype) { 2333 | var parent = this.getMatchersClass_(); 2334 | var newMatchersClass = function() { 2335 | parent.apply(this, arguments); 2336 | }; 2337 | jasmine.util.inherit(newMatchersClass, parent); 2338 | jasmine.Matchers.wrapInto_(matchersPrototype, newMatchersClass); 2339 | this.matchersClass = newMatchersClass; 2340 | }; 2341 | 2342 | jasmine.Spec.prototype.finishCallback = function() { 2343 | this.env.reporter.reportSpecResults(this); 2344 | }; 2345 | 2346 | jasmine.Spec.prototype.finish = function(onComplete) { 2347 | this.removeAllSpies(); 2348 | this.finishCallback(); 2349 | if (onComplete) { 2350 | onComplete(); 2351 | } 2352 | }; 2353 | 2354 | jasmine.Spec.prototype.after = function(doAfter) { 2355 | if (this.queue.isRunning()) { 2356 | this.queue.add(new jasmine.Block(this.env, doAfter, this), true); 2357 | } else { 2358 | this.afterCallbacks.unshift(doAfter); 2359 | } 2360 | }; 2361 | 2362 | jasmine.Spec.prototype.execute = function(onComplete) { 2363 | var spec = this; 2364 | if (!spec.env.specFilter(spec)) { 2365 | spec.results_.skipped = true; 2366 | spec.finish(onComplete); 2367 | return; 2368 | } 2369 | 2370 | this.env.reporter.reportSpecStarting(this); 2371 | 2372 | spec.env.currentSpec = spec; 2373 | 2374 | spec.addBeforesAndAftersToQueue(); 2375 | 2376 | spec.queue.start(function () { 2377 | spec.finish(onComplete); 2378 | }); 2379 | }; 2380 | 2381 | jasmine.Spec.prototype.addBeforesAndAftersToQueue = function() { 2382 | var runner = this.env.currentRunner(); 2383 | var i; 2384 | 2385 | for (var suite = this.suite; suite; suite = suite.parentSuite) { 2386 | for (i = 0; i < suite.before_.length; i++) { 2387 | this.queue.addBefore(new jasmine.Block(this.env, suite.before_[i], this)); 2388 | } 2389 | } 2390 | for (i = 0; i < runner.before_.length; i++) { 2391 | this.queue.addBefore(new jasmine.Block(this.env, runner.before_[i], this)); 2392 | } 2393 | for (i = 0; i < this.afterCallbacks.length; i++) { 2394 | this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this), true); 2395 | } 2396 | for (suite = this.suite; suite; suite = suite.parentSuite) { 2397 | for (i = 0; i < suite.after_.length; i++) { 2398 | this.queue.add(new jasmine.Block(this.env, suite.after_[i], this), true); 2399 | } 2400 | } 2401 | for (i = 0; i < runner.after_.length; i++) { 2402 | this.queue.add(new jasmine.Block(this.env, runner.after_[i], this), true); 2403 | } 2404 | }; 2405 | 2406 | jasmine.Spec.prototype.explodes = function() { 2407 | throw 'explodes function should not have been called'; 2408 | }; 2409 | 2410 | jasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) { 2411 | if (obj == jasmine.undefined) { 2412 | throw "spyOn could not find an object to spy upon for " + methodName + "()"; 2413 | } 2414 | 2415 | if (!ignoreMethodDoesntExist && obj[methodName] === jasmine.undefined) { 2416 | throw methodName + '() method does not exist'; 2417 | } 2418 | 2419 | if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) { 2420 | throw new Error(methodName + ' has already been spied upon'); 2421 | } 2422 | 2423 | var spyObj = jasmine.createSpy(methodName); 2424 | 2425 | this.spies_.push(spyObj); 2426 | spyObj.baseObj = obj; 2427 | spyObj.methodName = methodName; 2428 | spyObj.originalValue = obj[methodName]; 2429 | 2430 | obj[methodName] = spyObj; 2431 | 2432 | return spyObj; 2433 | }; 2434 | 2435 | jasmine.Spec.prototype.removeAllSpies = function() { 2436 | for (var i = 0; i < this.spies_.length; i++) { 2437 | var spy = this.spies_[i]; 2438 | spy.baseObj[spy.methodName] = spy.originalValue; 2439 | } 2440 | this.spies_ = []; 2441 | }; 2442 | 2443 | /** 2444 | * Internal representation of a Jasmine suite. 2445 | * 2446 | * @constructor 2447 | * @param {jasmine.Env} env 2448 | * @param {String} description 2449 | * @param {Function} specDefinitions 2450 | * @param {jasmine.Suite} parentSuite 2451 | */ 2452 | jasmine.Suite = function(env, description, specDefinitions, parentSuite) { 2453 | var self = this; 2454 | self.id = env.nextSuiteId ? env.nextSuiteId() : null; 2455 | self.description = description; 2456 | self.queue = new jasmine.Queue(env); 2457 | self.parentSuite = parentSuite; 2458 | self.env = env; 2459 | self.before_ = []; 2460 | self.after_ = []; 2461 | self.children_ = []; 2462 | self.suites_ = []; 2463 | self.specs_ = []; 2464 | }; 2465 | 2466 | jasmine.Suite.prototype.getFullName = function() { 2467 | var fullName = this.description; 2468 | for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) { 2469 | fullName = parentSuite.description + ' ' + fullName; 2470 | } 2471 | return fullName; 2472 | }; 2473 | 2474 | jasmine.Suite.prototype.finish = function(onComplete) { 2475 | this.env.reporter.reportSuiteResults(this); 2476 | this.finished = true; 2477 | if (typeof(onComplete) == 'function') { 2478 | onComplete(); 2479 | } 2480 | }; 2481 | 2482 | jasmine.Suite.prototype.beforeEach = function(beforeEachFunction) { 2483 | beforeEachFunction.typeName = 'beforeEach'; 2484 | this.before_.unshift(beforeEachFunction); 2485 | }; 2486 | 2487 | jasmine.Suite.prototype.afterEach = function(afterEachFunction) { 2488 | afterEachFunction.typeName = 'afterEach'; 2489 | this.after_.unshift(afterEachFunction); 2490 | }; 2491 | 2492 | jasmine.Suite.prototype.results = function() { 2493 | return this.queue.results(); 2494 | }; 2495 | 2496 | jasmine.Suite.prototype.add = function(suiteOrSpec) { 2497 | this.children_.push(suiteOrSpec); 2498 | if (suiteOrSpec instanceof jasmine.Suite) { 2499 | this.suites_.push(suiteOrSpec); 2500 | this.env.currentRunner().addSuite(suiteOrSpec); 2501 | } else { 2502 | this.specs_.push(suiteOrSpec); 2503 | } 2504 | this.queue.add(suiteOrSpec); 2505 | }; 2506 | 2507 | jasmine.Suite.prototype.specs = function() { 2508 | return this.specs_; 2509 | }; 2510 | 2511 | jasmine.Suite.prototype.suites = function() { 2512 | return this.suites_; 2513 | }; 2514 | 2515 | jasmine.Suite.prototype.children = function() { 2516 | return this.children_; 2517 | }; 2518 | 2519 | jasmine.Suite.prototype.execute = function(onComplete) { 2520 | var self = this; 2521 | this.queue.start(function () { 2522 | self.finish(onComplete); 2523 | }); 2524 | }; 2525 | jasmine.WaitsBlock = function(env, timeout, spec) { 2526 | this.timeout = timeout; 2527 | jasmine.Block.call(this, env, null, spec); 2528 | }; 2529 | 2530 | jasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block); 2531 | 2532 | jasmine.WaitsBlock.prototype.execute = function (onComplete) { 2533 | if (jasmine.VERBOSE) { 2534 | this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...'); 2535 | } 2536 | this.env.setTimeout(function () { 2537 | onComplete(); 2538 | }, this.timeout); 2539 | }; 2540 | /** 2541 | * A block which waits for some condition to become true, with timeout. 2542 | * 2543 | * @constructor 2544 | * @extends jasmine.Block 2545 | * @param {jasmine.Env} env The Jasmine environment. 2546 | * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true. 2547 | * @param {Function} latchFunction A function which returns true when the desired condition has been met. 2548 | * @param {String} message The message to display if the desired condition hasn't been met within the given time period. 2549 | * @param {jasmine.Spec} spec The Jasmine spec. 2550 | */ 2551 | jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) { 2552 | this.timeout = timeout || env.defaultTimeoutInterval; 2553 | this.latchFunction = latchFunction; 2554 | this.message = message; 2555 | this.totalTimeSpentWaitingForLatch = 0; 2556 | jasmine.Block.call(this, env, null, spec); 2557 | }; 2558 | jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block); 2559 | 2560 | jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10; 2561 | 2562 | jasmine.WaitsForBlock.prototype.execute = function(onComplete) { 2563 | if (jasmine.VERBOSE) { 2564 | this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen')); 2565 | } 2566 | var latchFunctionResult; 2567 | try { 2568 | latchFunctionResult = this.latchFunction.apply(this.spec); 2569 | } catch (e) { 2570 | this.spec.fail(e); 2571 | onComplete(); 2572 | return; 2573 | } 2574 | 2575 | if (latchFunctionResult) { 2576 | onComplete(); 2577 | } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) { 2578 | var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen'); 2579 | this.spec.fail({ 2580 | name: 'timeout', 2581 | message: message 2582 | }); 2583 | 2584 | this.abort = true; 2585 | onComplete(); 2586 | } else { 2587 | this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT; 2588 | var self = this; 2589 | this.env.setTimeout(function() { 2590 | self.execute(onComplete); 2591 | }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT); 2592 | } 2593 | }; 2594 | 2595 | jasmine.version_= { 2596 | "major": 1, 2597 | "minor": 3, 2598 | "build": 0, 2599 | "revision": 1354052693 2600 | }; 2601 | --------------------------------------------------------------------------------