Dotclear


Ignore:
Timestamp:
07/09/14 15:03:41 (11 years ago)
Author:
Nicolas <nikrou77@…>
Branch:
default
Message:

Upgrade jasmine to version 2.0.0
Major change : all spies have a single "and" attribute.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • tests/functional/lib/jasmine-jquery.js

    r1602 r2726  
    11/*! 
    2  Jasmine-jQuery: a set of jQuery helpers for Jasmine tests. 
    3  
    4  Version 1.5.8 
    5  
    6  https://github.com/velesin/jasmine-jquery 
    7  
    8  Copyright (c) 2010-2013 Wojciech Zawistowski, Travis Jeffery 
    9  
    10  Permission is hereby granted, free of charge, to any person obtaining 
    11  a copy of this software and associated documentation files (the 
    12  "Software"), to deal in the Software without restriction, including 
    13  without limitation the rights to use, copy, modify, merge, publish, 
    14  distribute, sublicense, and/or sell copies of the Software, and to 
    15  permit persons to whom the Software is furnished to do so, subject to 
    16  the following conditions: 
    17  
    18  The above copyright notice and this permission notice shall be 
    19  included in all copies or substantial portions of the Software. 
    20  
    21  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
    22  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
    23  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
    24  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
    25  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
    26  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
    27  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
     2Jasmine-jQuery: a set of jQuery helpers for Jasmine tests. 
     3 
     4Version 2.0.5 
     5 
     6https://github.com/velesin/jasmine-jquery 
     7 
     8Copyright (c) 2010-2014 Wojciech Zawistowski, Travis Jeffery 
     9 
     10Permission is hereby granted, free of charge, to any person obtaining 
     11a copy of this software and associated documentation files (the 
     12"Software"), to deal in the Software without restriction, including 
     13without limitation the rights to use, copy, modify, merge, publish, 
     14distribute, sublicense, and/or sell copies of the Software, and to 
     15permit persons to whom the Software is furnished to do so, subject to 
     16the following conditions: 
     17 
     18The above copyright notice and this permission notice shall be 
     19included in all copies or substantial portions of the Software. 
     20 
     21THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
     22EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
     23MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
     24NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
     25LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
     26OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
     27WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
    2828*/ 
    29 var readFixtures = function() { 
    30   return jasmine.getFixtures().proxyCallTo_('read', arguments) 
    31 } 
    32  
    33 var preloadFixtures = function() { 
    34   jasmine.getFixtures().proxyCallTo_('preload', arguments) 
    35 } 
    36  
    37 var loadFixtures = function() { 
    38   jasmine.getFixtures().proxyCallTo_('load', arguments) 
    39 } 
    40  
    41 var appendLoadFixtures = function() { 
    42   jasmine.getFixtures().proxyCallTo_('appendLoad', arguments) 
    43 } 
    44  
    45 var setFixtures = function(html) { 
    46   return jasmine.getFixtures().proxyCallTo_('set', arguments) 
    47 } 
    48  
    49 var appendSetFixtures = function() { 
    50   jasmine.getFixtures().proxyCallTo_('appendSet', arguments) 
    51 } 
    52  
    53 var sandbox = function(attributes) { 
    54   return jasmine.getFixtures().sandbox(attributes) 
    55 } 
    56  
    57 var spyOnEvent = function(selector, eventName) { 
    58   return jasmine.JQuery.events.spyOn(selector, eventName) 
    59 } 
    60  
    61 var preloadStyleFixtures = function() { 
    62   jasmine.getStyleFixtures().proxyCallTo_('preload', arguments) 
    63 } 
    64  
    65 var loadStyleFixtures = function() { 
    66   jasmine.getStyleFixtures().proxyCallTo_('load', arguments) 
    67 } 
    68  
    69 var appendLoadStyleFixtures = function() { 
    70   jasmine.getStyleFixtures().proxyCallTo_('appendLoad', arguments) 
    71 } 
    72  
    73 var setStyleFixtures = function(html) { 
    74   jasmine.getStyleFixtures().proxyCallTo_('set', arguments) 
    75 } 
    76  
    77 var appendSetStyleFixtures = function(html) { 
    78   jasmine.getStyleFixtures().proxyCallTo_('appendSet', arguments) 
    79 } 
    80  
    81 var loadJSONFixtures = function() { 
    82   return jasmine.getJSONFixtures().proxyCallTo_('load', arguments) 
    83 } 
    84  
    85 var getJSONFixture = function(url) { 
    86   return jasmine.getJSONFixtures().proxyCallTo_('read', arguments)[url] 
    87 } 
    88  
    89 jasmine.spiedEventsKey = function (selector, eventName) { 
    90   return [$(selector).selector, eventName].toString() 
    91 } 
    92  
    93 jasmine.getFixtures = function() { 
    94   return jasmine.currentFixtures_ = jasmine.currentFixtures_ || new jasmine.Fixtures() 
    95 } 
    96  
    97 jasmine.getStyleFixtures = function() { 
    98   return jasmine.currentStyleFixtures_ = jasmine.currentStyleFixtures_ || new jasmine.StyleFixtures() 
    99 } 
    100  
    101 jasmine.Fixtures = function() { 
    102   this.containerId = 'jasmine-fixtures' 
    103   this.fixturesCache_ = {} 
    104   this.fixturesPath = 'spec/javascripts/fixtures' 
    105 } 
    106  
    107 jasmine.Fixtures.prototype.set = function(html) { 
    108   this.cleanUp() 
    109   return this.createContainer_(html) 
    110 } 
    111  
    112 jasmine.Fixtures.prototype.appendSet= function(html) { 
    113   this.addToContainer_(html) 
    114 } 
    115  
    116 jasmine.Fixtures.prototype.preload = function() { 
    117   this.read.apply(this, arguments) 
    118 } 
    119  
    120 jasmine.Fixtures.prototype.load = function() { 
    121   this.cleanUp() 
    122   this.createContainer_(this.read.apply(this, arguments)) 
    123 } 
    124  
    125 jasmine.Fixtures.prototype.appendLoad = function() { 
    126   this.addToContainer_(this.read.apply(this, arguments)) 
    127 } 
    128  
    129 jasmine.Fixtures.prototype.read = function() { 
    130   var htmlChunks = [] 
    131  
    132   var fixtureUrls = arguments 
    133   for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) { 
    134     htmlChunks.push(this.getFixtureHtml_(fixtureUrls[urlIndex])) 
    135   } 
    136  
    137   return htmlChunks.join('') 
    138 } 
    139  
    140 jasmine.Fixtures.prototype.clearCache = function() { 
    141   this.fixturesCache_ = {} 
    142 } 
    143  
    144 jasmine.Fixtures.prototype.cleanUp = function() { 
    145   $('#' + this.containerId).remove() 
    146 } 
    147  
    148 jasmine.Fixtures.prototype.sandbox = function(attributes) { 
    149   var attributesToSet = attributes || {} 
    150   return $('<div id="sandbox" />').attr(attributesToSet) 
    151 } 
    152  
    153 jasmine.Fixtures.prototype.createContainer_ = function(html) { 
    154   var container = $('<div>') 
     29 
     30+function (window, jasmine, $) { "use strict"; 
     31 
     32  jasmine.spiedEventsKey = function (selector, eventName) { 
     33    return [$(selector).selector, eventName].toString() 
     34  } 
     35 
     36  jasmine.getFixtures = function () { 
     37    return jasmine.currentFixtures_ = jasmine.currentFixtures_ || new jasmine.Fixtures() 
     38  } 
     39 
     40  jasmine.getStyleFixtures = function () { 
     41    return jasmine.currentStyleFixtures_ = jasmine.currentStyleFixtures_ || new jasmine.StyleFixtures() 
     42  } 
     43 
     44  jasmine.Fixtures = function () { 
     45    this.containerId = 'jasmine-fixtures' 
     46    this.fixturesCache_ = {} 
     47    this.fixturesPath = 'spec/javascripts/fixtures' 
     48  } 
     49 
     50  jasmine.Fixtures.prototype.set = function (html) { 
     51    this.cleanUp() 
     52    return this.createContainer_(html) 
     53  } 
     54 
     55  jasmine.Fixtures.prototype.appendSet= function (html) { 
     56    this.addToContainer_(html) 
     57  } 
     58 
     59  jasmine.Fixtures.prototype.preload = function () { 
     60    this.read.apply(this, arguments) 
     61  } 
     62 
     63  jasmine.Fixtures.prototype.load = function () { 
     64    this.cleanUp() 
     65    this.createContainer_(this.read.apply(this, arguments)) 
     66  } 
     67 
     68  jasmine.Fixtures.prototype.appendLoad = function () { 
     69    this.addToContainer_(this.read.apply(this, arguments)) 
     70  } 
     71 
     72  jasmine.Fixtures.prototype.read = function () { 
     73    var htmlChunks = [] 
     74      , fixtureUrls = arguments 
     75 
     76    for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) { 
     77      htmlChunks.push(this.getFixtureHtml_(fixtureUrls[urlIndex])) 
     78    } 
     79 
     80    return htmlChunks.join('') 
     81  } 
     82 
     83  jasmine.Fixtures.prototype.clearCache = function () { 
     84    this.fixturesCache_ = {} 
     85  } 
     86 
     87  jasmine.Fixtures.prototype.cleanUp = function () { 
     88    $('#' + this.containerId).remove() 
     89  } 
     90 
     91  jasmine.Fixtures.prototype.sandbox = function (attributes) { 
     92    var attributesToSet = attributes || {} 
     93    return $('<div id="sandbox" />').attr(attributesToSet) 
     94  } 
     95 
     96  jasmine.Fixtures.prototype.createContainer_ = function (html) { 
     97    var container = $('<div>') 
    15598    .attr('id', this.containerId) 
    156     .html(html); 
    157   $(document.body).append(container) 
    158   return container 
    159 } 
    160  
    161 jasmine.Fixtures.prototype.addToContainer_ = function(html){ 
    162   var container = $(document.body).find('#'+this.containerId).append(html) 
    163   if(!container.length){ 
    164     this.createContainer_(html) 
    165   } 
    166 } 
    167  
    168 jasmine.Fixtures.prototype.getFixtureHtml_ = function(url) { 
    169   if (typeof this.fixturesCache_[url] === 'undefined') { 
    170     this.loadFixtureIntoCache_(url) 
    171   } 
    172   return this.fixturesCache_[url] 
    173 } 
    174  
    175 jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function(relativeUrl) { 
    176   var url = this.makeFixtureUrl_(relativeUrl) 
    177   var request = $.ajax({ 
    178     type: "GET", 
    179     url: url + "?" + new Date().getTime(), 
    180     async: false 
    181   }) 
    182   this.fixturesCache_[relativeUrl] = request.responseText 
    183 } 
    184  
    185 jasmine.Fixtures.prototype.makeFixtureUrl_ = function(relativeUrl){ 
    186   return this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl 
    187 } 
    188  
    189 jasmine.Fixtures.prototype.proxyCallTo_ = function(methodName, passedArguments) { 
    190   return this[methodName].apply(this, passedArguments) 
    191 } 
    192  
    193  
    194 jasmine.StyleFixtures = function() { 
    195   this.fixturesCache_ = {} 
    196   this.fixturesNodes_ = [] 
    197   this.fixturesPath = 'spec/javascripts/fixtures' 
    198 } 
    199  
    200 jasmine.StyleFixtures.prototype.set = function(css) { 
    201   this.cleanUp() 
    202   this.createStyle_(css) 
    203 } 
    204  
    205 jasmine.StyleFixtures.prototype.appendSet = function(css) { 
    206   this.createStyle_(css) 
    207 } 
    208  
    209 jasmine.StyleFixtures.prototype.preload = function() { 
    210   this.read_.apply(this, arguments) 
    211 } 
    212  
    213 jasmine.StyleFixtures.prototype.load = function() { 
    214   this.cleanUp() 
    215   this.createStyle_(this.read_.apply(this, arguments)) 
    216 } 
    217  
    218 jasmine.StyleFixtures.prototype.appendLoad = function() { 
    219   this.createStyle_(this.read_.apply(this, arguments)) 
    220 } 
    221  
    222 jasmine.StyleFixtures.prototype.cleanUp = function() { 
    223   while(this.fixturesNodes_.length) { 
    224     this.fixturesNodes_.pop().remove() 
    225   } 
    226 } 
    227  
    228 jasmine.StyleFixtures.prototype.createStyle_ = function(html) { 
    229   var styleText = $('<div></div>').html(html).text(), 
    230     style = $('<style>' + styleText + '</style>') 
    231  
    232   this.fixturesNodes_.push(style) 
    233  
    234   $('head').append(style) 
    235 } 
    236  
    237 jasmine.StyleFixtures.prototype.clearCache = jasmine.Fixtures.prototype.clearCache 
    238  
    239 jasmine.StyleFixtures.prototype.read_ = jasmine.Fixtures.prototype.read 
    240  
    241 jasmine.StyleFixtures.prototype.getFixtureHtml_ = jasmine.Fixtures.prototype.getFixtureHtml_ 
    242  
    243 jasmine.StyleFixtures.prototype.loadFixtureIntoCache_ = jasmine.Fixtures.prototype.loadFixtureIntoCache_ 
    244  
    245 jasmine.StyleFixtures.prototype.makeFixtureUrl_ = jasmine.Fixtures.prototype.makeFixtureUrl_ 
    246  
    247 jasmine.StyleFixtures.prototype.proxyCallTo_ = jasmine.Fixtures.prototype.proxyCallTo_ 
    248  
    249 jasmine.getJSONFixtures = function() { 
    250   return jasmine.currentJSONFixtures_ = jasmine.currentJSONFixtures_ || new jasmine.JSONFixtures() 
    251 } 
    252  
    253 jasmine.JSONFixtures = function() { 
    254   this.fixturesCache_ = {} 
    255   this.fixturesPath = 'spec/javascripts/fixtures/json' 
    256 } 
    257  
    258 jasmine.JSONFixtures.prototype.load = function() { 
    259   this.read.apply(this, arguments) 
    260   return this.fixturesCache_ 
    261 } 
    262  
    263 jasmine.JSONFixtures.prototype.read = function() { 
    264   var fixtureUrls = arguments 
    265   for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) { 
    266     this.getFixtureData_(fixtureUrls[urlIndex]) 
    267   } 
    268   return this.fixturesCache_ 
    269 } 
    270  
    271 jasmine.JSONFixtures.prototype.clearCache = function() { 
    272   this.fixturesCache_ = {} 
    273 } 
    274  
    275 jasmine.JSONFixtures.prototype.getFixtureData_ = function(url) { 
    276   this.loadFixtureIntoCache_(url) 
    277   return this.fixturesCache_[url] 
    278 } 
    279  
    280 jasmine.JSONFixtures.prototype.loadFixtureIntoCache_ = function(relativeUrl) { 
    281   var self = this 
    282   var url = this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl 
    283   $.ajax({ 
    284     async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded 
    285     cache: false, 
    286     dataType: 'json', 
    287     url: url, 
    288     success: function(data) { 
    289       self.fixturesCache_[relativeUrl] = data 
    290     }, 
    291     error: function(jqXHR, status, errorThrown) { 
    292         throw Error('JSONFixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + errorThrown.message + ')') 
     99    .html(html) 
     100 
     101    $(document.body).append(container) 
     102    return container 
     103  } 
     104 
     105  jasmine.Fixtures.prototype.addToContainer_ = function (html){ 
     106    var container = $(document.body).find('#'+this.containerId).append(html) 
     107 
     108    if (!container.length) { 
     109      this.createContainer_(html) 
    293110    } 
    294   }) 
    295 } 
    296  
    297 jasmine.JSONFixtures.prototype.proxyCallTo_ = function(methodName, passedArguments) { 
    298   return this[methodName].apply(this, passedArguments) 
    299 } 
    300  
    301 jasmine.JQuery = function() {} 
    302  
    303 jasmine.JQuery.browserTagCaseIndependentHtml = function(html) { 
    304   return $('<div/>').append(html).html() 
    305 } 
    306  
    307 jasmine.JQuery.elementToString = function(element) { 
    308   var domEl = $(element).get(0) 
    309   if (domEl == undefined || domEl.cloneNode) 
    310     return $('<div />').append($(element).clone()).html() 
    311   else 
    312     return element.toString() 
    313 } 
    314  
    315 jasmine.JQuery.matchersClass = {} 
    316  
    317 !function(namespace) { 
     111  } 
     112 
     113  jasmine.Fixtures.prototype.getFixtureHtml_ = function (url) { 
     114    if (typeof this.fixturesCache_[url] === 'undefined') { 
     115      this.loadFixtureIntoCache_(url) 
     116    } 
     117    return this.fixturesCache_[url] 
     118  } 
     119 
     120  jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function (relativeUrl) { 
     121    var self = this 
     122      , url = this.makeFixtureUrl_(relativeUrl) 
     123      , htmlText = '' 
     124      , request = $.ajax({ 
     125        async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded 
     126        cache: false, 
     127        url: url, 
     128        success: function (data, status, $xhr) { 
     129          htmlText = $xhr.responseText 
     130        } 
     131      }).fail(function ($xhr, status, err) { 
     132          throw new Error('Fixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + err.message + ')') 
     133      }) 
     134 
     135      var scripts = $($.parseHTML(htmlText, true)).find('script[src]') || []; 
     136 
     137      scripts.each(function(){ 
     138        $.ajax({ 
     139            async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded 
     140            cache: false, 
     141            dataType: 'script', 
     142            url: $(this).attr('src'), 
     143            success: function (data, status, $xhr) { 
     144                htmlText += '<script>' + $xhr.responseText + '</script>' 
     145            }, 
     146            error: function ($xhr, status, err) { 
     147                throw new Error('Script could not be loaded: ' + scriptSrc + ' (status: ' + status + ', message: ' + err.message + ')') 
     148            } 
     149        }); 
     150      }) 
     151 
     152      self.fixturesCache_[relativeUrl] = htmlText; 
     153  } 
     154 
     155  jasmine.Fixtures.prototype.makeFixtureUrl_ = function (relativeUrl){ 
     156    return this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl 
     157  } 
     158 
     159  jasmine.Fixtures.prototype.proxyCallTo_ = function (methodName, passedArguments) { 
     160    return this[methodName].apply(this, passedArguments) 
     161  } 
     162 
     163 
     164  jasmine.StyleFixtures = function () { 
     165    this.fixturesCache_ = {} 
     166    this.fixturesNodes_ = [] 
     167    this.fixturesPath = 'spec/javascripts/fixtures' 
     168  } 
     169 
     170  jasmine.StyleFixtures.prototype.set = function (css) { 
     171    this.cleanUp() 
     172    this.createStyle_(css) 
     173  } 
     174 
     175  jasmine.StyleFixtures.prototype.appendSet = function (css) { 
     176    this.createStyle_(css) 
     177  } 
     178 
     179  jasmine.StyleFixtures.prototype.preload = function () { 
     180    this.read_.apply(this, arguments) 
     181  } 
     182 
     183  jasmine.StyleFixtures.prototype.load = function () { 
     184    this.cleanUp() 
     185    this.createStyle_(this.read_.apply(this, arguments)) 
     186  } 
     187 
     188  jasmine.StyleFixtures.prototype.appendLoad = function () { 
     189    this.createStyle_(this.read_.apply(this, arguments)) 
     190  } 
     191 
     192  jasmine.StyleFixtures.prototype.cleanUp = function () { 
     193    while(this.fixturesNodes_.length) { 
     194      this.fixturesNodes_.pop().remove() 
     195    } 
     196  } 
     197 
     198  jasmine.StyleFixtures.prototype.createStyle_ = function (html) { 
     199    var styleText = $('<div></div>').html(html).text() 
     200      , style = $('<style>' + styleText + '</style>') 
     201 
     202    this.fixturesNodes_.push(style) 
     203    $('head').append(style) 
     204  } 
     205 
     206  jasmine.StyleFixtures.prototype.clearCache = jasmine.Fixtures.prototype.clearCache 
     207  jasmine.StyleFixtures.prototype.read_ = jasmine.Fixtures.prototype.read 
     208  jasmine.StyleFixtures.prototype.getFixtureHtml_ = jasmine.Fixtures.prototype.getFixtureHtml_ 
     209  jasmine.StyleFixtures.prototype.loadFixtureIntoCache_ = jasmine.Fixtures.prototype.loadFixtureIntoCache_ 
     210  jasmine.StyleFixtures.prototype.makeFixtureUrl_ = jasmine.Fixtures.prototype.makeFixtureUrl_ 
     211  jasmine.StyleFixtures.prototype.proxyCallTo_ = jasmine.Fixtures.prototype.proxyCallTo_ 
     212 
     213  jasmine.getJSONFixtures = function () { 
     214    return jasmine.currentJSONFixtures_ = jasmine.currentJSONFixtures_ || new jasmine.JSONFixtures() 
     215  } 
     216 
     217  jasmine.JSONFixtures = function () { 
     218    this.fixturesCache_ = {} 
     219    this.fixturesPath = 'spec/javascripts/fixtures/json' 
     220  } 
     221 
     222  jasmine.JSONFixtures.prototype.load = function () { 
     223    this.read.apply(this, arguments) 
     224    return this.fixturesCache_ 
     225  } 
     226 
     227  jasmine.JSONFixtures.prototype.read = function () { 
     228    var fixtureUrls = arguments 
     229 
     230    for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) { 
     231      this.getFixtureData_(fixtureUrls[urlIndex]) 
     232    } 
     233 
     234    return this.fixturesCache_ 
     235  } 
     236 
     237  jasmine.JSONFixtures.prototype.clearCache = function () { 
     238    this.fixturesCache_ = {} 
     239  } 
     240 
     241  jasmine.JSONFixtures.prototype.getFixtureData_ = function (url) { 
     242    if (!this.fixturesCache_[url]) this.loadFixtureIntoCache_(url) 
     243    return this.fixturesCache_[url] 
     244  } 
     245 
     246  jasmine.JSONFixtures.prototype.loadFixtureIntoCache_ = function (relativeUrl) { 
     247    var self = this 
     248      , url = this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl 
     249 
     250    $.ajax({ 
     251      async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded 
     252      cache: false, 
     253      dataType: 'json', 
     254      url: url, 
     255      success: function (data) { 
     256        self.fixturesCache_[relativeUrl] = data 
     257      }, 
     258      error: function ($xhr, status, err) { 
     259        throw new Error('JSONFixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + err.message + ')') 
     260      } 
     261    }) 
     262  } 
     263 
     264  jasmine.JSONFixtures.prototype.proxyCallTo_ = function (methodName, passedArguments) { 
     265    return this[methodName].apply(this, passedArguments) 
     266  } 
     267 
     268  jasmine.jQuery = function () {} 
     269 
     270  jasmine.jQuery.browserTagCaseIndependentHtml = function (html) { 
     271    return $('<div/>').append(html).html() 
     272  } 
     273 
     274  jasmine.jQuery.elementToString = function (element) { 
     275    return $(element).map(function () { return this.outerHTML; }).toArray().join(', ') 
     276  } 
     277 
    318278  var data = { 
    319     spiedEvents: {}, 
    320     handlers:    [] 
    321   } 
    322  
    323   namespace.events = { 
    324     spyOn: function(selector, eventName) { 
    325       var handler = function(e) { 
     279      spiedEvents: {} 
     280    , handlers:    [] 
     281  } 
     282 
     283  jasmine.jQuery.events = { 
     284    spyOn: function (selector, eventName) { 
     285      var handler = function (e) { 
    326286        data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)] = jasmine.util.argsToArray(arguments) 
    327287      } 
     288 
    328289      $(selector).on(eventName, handler) 
    329290      data.handlers.push(handler) 
     291 
    330292      return { 
    331293        selector: selector, 
    332294        eventName: eventName, 
    333295        handler: handler, 
    334         reset: function(){ 
     296        reset: function (){ 
    335297          delete data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)] 
    336298        } 
    … …  
    338300    }, 
    339301 
    340     args: function(selector, eventName) { 
    341       var actualArgs = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]; 
     302    args: function (selector, eventName) { 
     303      var actualArgs = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)] 
    342304 
    343305      if (!actualArgs) { 
    344         throw "There is no spy for " + eventName + " on " + selector.toString() + ". Make sure to create a spy using spyOnEvent."; 
     306        throw "There is no spy for " + eventName + " on " + selector.toString() + ". Make sure to create a spy using spyOnEvent." 
    345307      } 
    346308 
    347       return actualArgs; 
     309      return actualArgs 
    348310    }, 
    349311 
    350     wasTriggered: function(selector, eventName) { 
     312    wasTriggered: function (selector, eventName) { 
    351313      return !!(data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)]) 
    352314    }, 
    353315 
    354     wasTriggeredWith: function(selector, eventName, expectedArgs, env) { 
    355       var actualArgs = jasmine.JQuery.events.args(selector, eventName).slice(1); 
    356       if (Object.prototype.toString.call(expectedArgs) !== '[object Array]') { 
    357         actualArgs = actualArgs[0]; 
    358       } 
    359       return env.equals_(expectedArgs, actualArgs); 
     316    wasTriggeredWith: function (selector, eventName, expectedArgs, util, customEqualityTesters) { 
     317      var actualArgs = jasmine.jQuery.events.args(selector, eventName).slice(1) 
     318 
     319      if (Object.prototype.toString.call(expectedArgs) !== '[object Array]') 
     320        actualArgs = actualArgs[0] 
     321 
     322      return util.equals(expectedArgs, actualArgs, customEqualityTesters) 
    360323    }, 
    361324 
    362     wasPrevented: function(selector, eventName) { 
    363       var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)], 
    364           e = args ? args[0] : undefined; 
     325    wasPrevented: function (selector, eventName) { 
     326      var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)] 
     327        , e = args ? args[0] : undefined 
     328 
    365329      return e && e.isDefaultPrevented() 
    366330    }, 
    367331 
    368     wasStopped: function(selector, eventName) { 
    369       var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)], 
    370           e = args ? args[0] : undefined; 
     332    wasStopped: function (selector, eventName) { 
     333      var args = data.spiedEvents[jasmine.spiedEventsKey(selector, eventName)] 
     334        , e = args ? args[0] : undefined 
    371335      return e && e.isPropagationStopped() 
    372336    }, 
    373337 
    374     cleanUp: function() { 
     338    cleanUp: function () { 
    375339      data.spiedEvents = {} 
    376340      data.handlers    = [] 
    377341    } 
    378342  } 
    379 }(jasmine.JQuery) 
    380  
    381 !function(){ 
    382   var jQueryMatchers = { 
    383     toHaveClass: function(className) { 
    384       return this.actual.hasClass(className) 
    385     }, 
    386  
    387     toHaveCss: function(css){ 
    388       for (var prop in css){ 
    389         if (this.actual.css(prop) !== css[prop]) return false 
     343 
     344  var hasProperty = function (actualValue, expectedValue) { 
     345    if (expectedValue === undefined) 
     346      return actualValue !== undefined 
     347 
     348    return actualValue === expectedValue 
     349  } 
     350 
     351  beforeEach(function () { 
     352    jasmine.addMatchers({ 
     353      toHaveClass: function () { 
     354        return { 
     355          compare: function (actual, className) { 
     356            return { pass: $(actual).hasClass(className) } 
     357          } 
     358        } 
     359      }, 
     360 
     361      toHaveCss: function () { 
     362        return { 
     363          compare: function (actual, css) { 
     364            for (var prop in css){ 
     365              var value = css[prop] 
     366              // see issue #147 on gh 
     367              ;if (value === 'auto' && $(actual).get(0).style[prop] === 'auto') continue 
     368              if ($(actual).css(prop) !== value) return { pass: false } 
     369            } 
     370            return { pass: true } 
     371          } 
     372        } 
     373      }, 
     374 
     375      toBeVisible: function () { 
     376        return { 
     377          compare: function (actual) { 
     378            return { pass: $(actual).is(':visible') } 
     379          } 
     380        } 
     381      }, 
     382 
     383      toBeHidden: function () { 
     384        return { 
     385          compare: function (actual) { 
     386            return { pass: $(actual).is(':hidden') } 
     387          } 
     388        } 
     389      }, 
     390 
     391      toBeSelected: function () { 
     392        return { 
     393          compare: function (actual) { 
     394            return { pass: $(actual).is(':selected') } 
     395          } 
     396        } 
     397      }, 
     398 
     399      toBeChecked: function () { 
     400        return { 
     401          compare: function (actual) { 
     402            return { pass: $(actual).is(':checked') } 
     403          } 
     404        } 
     405      }, 
     406 
     407      toBeEmpty: function () { 
     408        return { 
     409          compare: function (actual) { 
     410            return { pass: $(actual).is(':empty') } 
     411          } 
     412        } 
     413      }, 
     414 
     415      toBeInDOM: function () { 
     416        return { 
     417          compare: function (actual) { 
     418            return { pass: $.contains(document.documentElement, $(actual)[0]) } 
     419          } 
     420        } 
     421      }, 
     422 
     423      toExist: function () { 
     424        return { 
     425          compare: function (actual) { 
     426            return { pass: $(actual).length } 
     427          } 
     428        } 
     429      }, 
     430 
     431      toHaveLength: function () { 
     432        return { 
     433          compare: function (actual, length) { 
     434            return { pass: $(actual).length === length } 
     435          } 
     436        } 
     437      }, 
     438 
     439      toHaveAttr: function () { 
     440        return { 
     441          compare: function (actual, attributeName, expectedAttributeValue) { 
     442            return { pass: hasProperty($(actual).attr(attributeName), expectedAttributeValue) } 
     443          } 
     444        } 
     445      }, 
     446 
     447      toHaveProp: function () { 
     448        return { 
     449          compare: function (actual, propertyName, expectedPropertyValue) { 
     450            return { pass: hasProperty($(actual).prop(propertyName), expectedPropertyValue) } 
     451          } 
     452        } 
     453      }, 
     454 
     455      toHaveId: function () { 
     456        return { 
     457          compare: function (actual, id) { 
     458            return { pass: $(actual).attr('id') == id } 
     459          } 
     460        } 
     461      }, 
     462 
     463      toHaveHtml: function () { 
     464        return { 
     465          compare: function (actual, html) { 
     466            return { pass: $(actual).html() == jasmine.jQuery.browserTagCaseIndependentHtml(html) } 
     467          } 
     468        } 
     469      }, 
     470 
     471      toContainHtml: function () { 
     472        return { 
     473          compare: function (actual, html) { 
     474            var actualHtml = $(actual).html() 
     475              , expectedHtml = jasmine.jQuery.browserTagCaseIndependentHtml(html) 
     476 
     477            return { pass: (actualHtml.indexOf(expectedHtml) >= 0) } 
     478          } 
     479        } 
     480      }, 
     481 
     482      toHaveText: function () { 
     483        return { 
     484          compare: function (actual, text) { 
     485            var actualText = $(actual).text() 
     486            var trimmedText = $.trim(actualText) 
     487 
     488            if (text && $.isFunction(text.test)) { 
     489              return { pass: text.test(actualText) || text.test(trimmedText) } 
     490            } else { 
     491              return { pass: (actualText == text || trimmedText == text) } 
     492            } 
     493          } 
     494        } 
     495      }, 
     496 
     497      toContainText: function () { 
     498        return { 
     499          compare: function (actual, text) { 
     500            var trimmedText = $.trim($(actual).text()) 
     501 
     502            if (text && $.isFunction(text.test)) { 
     503              return { pass: text.test(trimmedText) } 
     504            } else { 
     505              return { pass: trimmedText.indexOf(text) != -1 } 
     506            } 
     507          } 
     508        } 
     509      }, 
     510 
     511      toHaveValue: function () { 
     512        return { 
     513          compare: function (actual, value) { 
     514            return { pass: $(actual).val() === value } 
     515          } 
     516        } 
     517      }, 
     518 
     519      toHaveData: function () { 
     520        return { 
     521          compare: function (actual, key, expectedValue) { 
     522            return { pass: hasProperty($(actual).data(key), expectedValue) } 
     523          } 
     524        } 
     525      }, 
     526 
     527      toContainElement: function () { 
     528        return { 
     529          compare: function (actual, selector) { 
     530            if (window.debug) debugger 
     531            return { pass: $(actual).find(selector).length } 
     532          } 
     533        } 
     534      }, 
     535 
     536      toBeMatchedBy: function () { 
     537        return { 
     538          compare: function (actual, selector) { 
     539            return { pass: $(actual).filter(selector).length } 
     540          } 
     541        } 
     542      }, 
     543 
     544      toBeDisabled: function () { 
     545        return { 
     546          compare: function (actual, selector) { 
     547            return { pass: $(actual).is(':disabled') } 
     548          } 
     549        } 
     550      }, 
     551 
     552      toBeFocused: function (selector) { 
     553        return { 
     554          compare: function (actual, selector) { 
     555            return { pass: $(actual)[0] === $(actual)[0].ownerDocument.activeElement } 
     556          } 
     557        } 
     558      }, 
     559 
     560      toHandle: function () { 
     561        return { 
     562          compare: function (actual, event) { 
     563            var events = $._data($(actual).get(0), "events") 
     564 
     565            if (!events || !event || typeof event !== "string") { 
     566              return { pass: false } 
     567            } 
     568 
     569            var namespaces = event.split(".") 
     570              , eventType = namespaces.shift() 
     571              , sortedNamespaces = namespaces.slice(0).sort() 
     572              , namespaceRegExp = new RegExp("(^|\\.)" + sortedNamespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") 
     573 
     574            if (events[eventType] && namespaces.length) { 
     575              for (var i = 0; i < events[eventType].length; i++) { 
     576                var namespace = events[eventType][i].namespace 
     577 
     578                if (namespaceRegExp.test(namespace)) 
     579                  return { pass: true } 
     580              } 
     581            } else { 
     582              return { pass: (events[eventType] && events[eventType].length > 0) } 
     583            } 
     584 
     585            return { pass: false } 
     586          } 
     587        } 
     588      }, 
     589 
     590      toHandleWith: function () { 
     591        return { 
     592          compare: function (actual, eventName, eventHandler) { 
     593            var normalizedEventName = eventName.split('.')[0] 
     594              , stack = $._data($(actual).get(0), "events")[normalizedEventName] 
     595 
     596            for (var i = 0; i < stack.length; i++) { 
     597              if (stack[i].handler == eventHandler) return { pass: true } 
     598            } 
     599 
     600            return { pass: false } 
     601          } 
     602        } 
     603      }, 
     604 
     605      toHaveBeenTriggeredOn: function () { 
     606        return { 
     607          compare: function (actual, selector) { 
     608            var result = { pass: jasmine.jQuery.events.wasTriggered(selector, actual) } 
     609 
     610            result.message = result.pass ? 
     611              "Expected event " + $(actual) + " not to have been triggered on " + selector : 
     612              "Expected event " + $(actual) + " to have been triggered on " + selector 
     613 
     614            return result; 
     615          } 
     616        } 
     617      }, 
     618 
     619      toHaveBeenTriggered: function (){ 
     620        return { 
     621          compare: function (actual) { 
     622            var eventName = actual.eventName 
     623              , selector = actual.selector 
     624              , result = { pass: jasmine.jQuery.events.wasTriggered(selector, eventName) } 
     625 
     626            result.message = result.pass ? 
     627            "Expected event " + eventName + " not to have been triggered on " + selector : 
     628              "Expected event " + eventName + " to have been triggered on " + selector 
     629 
     630            return result 
     631          } 
     632        } 
     633      }, 
     634 
     635      toHaveBeenTriggeredOnAndWith: function (j$, customEqualityTesters) { 
     636        return { 
     637          compare: function (actual, selector, expectedArgs) { 
     638            var wasTriggered = jasmine.jQuery.events.wasTriggered(selector, actual) 
     639              , result = { pass: wasTriggered && jasmine.jQuery.events.wasTriggeredWith(selector, actual, expectedArgs, j$, customEqualityTesters) } 
     640 
     641              if (wasTriggered) { 
     642                var actualArgs = jasmine.jQuery.events.args(selector, actual, expectedArgs)[1] 
     643                result.message = result.pass ? 
     644                  "Expected event " + actual + " not to have been triggered with " + jasmine.pp(expectedArgs) + " but it was triggered with " + jasmine.pp(actualArgs) : 
     645                  "Expected event " + actual + " to have been triggered with " + jasmine.pp(expectedArgs) + "  but it was triggered with " + jasmine.pp(actualArgs) 
     646 
     647              } else { 
     648                // todo check on this 
     649                result.message = result.pass ? 
     650                  "Expected event " + actual + " not to have been triggered on " + selector : 
     651                  "Expected event " + actual + " to have been triggered on " + selector 
     652              } 
     653 
     654              return result 
     655          } 
     656        } 
     657      }, 
     658 
     659      toHaveBeenPreventedOn: function () { 
     660        return { 
     661          compare: function (actual, selector) { 
     662            var result = { pass: jasmine.jQuery.events.wasPrevented(selector, actual) } 
     663 
     664            result.message = result.pass ? 
     665              "Expected event " + actual + " not to have been prevented on " + selector : 
     666              "Expected event " + actual + " to have been prevented on " + selector 
     667 
     668            return result 
     669          } 
     670        } 
     671      }, 
     672 
     673      toHaveBeenPrevented: function () { 
     674        return { 
     675          compare: function (actual) { 
     676            var eventName = actual.eventName 
     677              , selector = actual.selector 
     678              , result = { pass: jasmine.jQuery.events.wasPrevented(selector, eventName) } 
     679 
     680            result.message = result.pass ? 
     681              "Expected event " + eventName + " not to have been prevented on " + selector : 
     682              "Expected event " + eventName + " to have been prevented on " + selector 
     683 
     684            return result 
     685          } 
     686        } 
     687      }, 
     688 
     689      toHaveBeenStoppedOn: function () { 
     690        return { 
     691          compare: function (actual, selector) { 
     692            var result = { pass: jasmine.jQuery.events.wasStopped(selector, actual) } 
     693 
     694            result.message = result.pass ? 
     695              "Expected event " + actual + " not to have been stopped on " + selector : 
     696              "Expected event " + actual + " to have been stopped on " + selector 
     697 
     698            return result; 
     699          } 
     700        } 
     701      }, 
     702 
     703      toHaveBeenStopped: function () { 
     704        return { 
     705          compare: function (actual) { 
     706            var eventName = actual.eventName 
     707              , selector = actual.selector 
     708              , result = { pass: jasmine.jQuery.events.wasStopped(selector, eventName) } 
     709 
     710            result.message = result.pass ? 
     711              "Expected event " + eventName + " not to have been stopped on " + selector : 
     712              "Expected event " + eventName + " to have been stopped on " + selector 
     713 
     714            return result 
     715          } 
     716        } 
    390717      } 
    391       return true 
    392     }, 
    393  
    394     toBeVisible: function() { 
    395       return this.actual.is(':visible') 
    396     }, 
    397  
    398     toBeHidden: function() { 
    399       return this.actual.is(':hidden') 
    400     }, 
    401  
    402     toBeSelected: function() { 
    403       return this.actual.is(':selected') 
    404     }, 
    405  
    406     toBeChecked: function() { 
    407       return this.actual.is(':checked') 
    408     }, 
    409  
    410     toBeEmpty: function() { 
    411       return this.actual.is(':empty') 
    412     }, 
    413  
    414     toExist: function() { 
    415       return $(document).find(this.actual).length 
    416     }, 
    417  
    418     toHaveLength: function(length) { 
    419       return this.actual.length === length 
    420     }, 
    421  
    422     toHaveAttr: function(attributeName, expectedAttributeValue) { 
    423       return hasProperty(this.actual.attr(attributeName), expectedAttributeValue) 
    424     }, 
    425  
    426     toHaveProp: function(propertyName, expectedPropertyValue) { 
    427       return hasProperty(this.actual.prop(propertyName), expectedPropertyValue) 
    428     }, 
    429  
    430     toHaveId: function(id) { 
    431       return this.actual.attr('id') == id 
    432     }, 
    433  
    434     toHaveHtml: function(html) { 
    435       return this.actual.html() == jasmine.JQuery.browserTagCaseIndependentHtml(html) 
    436     }, 
    437  
    438     toContainHtml: function(html){ 
    439       var actualHtml = this.actual.html() 
    440       var expectedHtml = jasmine.JQuery.browserTagCaseIndependentHtml(html) 
    441       return (actualHtml.indexOf(expectedHtml) >= 0) 
    442     }, 
    443  
    444     toHaveText: function(text) { 
    445       var trimmedText = $.trim(this.actual.text()) 
    446       if (text && $.isFunction(text.test)) { 
    447         return text.test(trimmedText) 
    448       } else { 
    449         return trimmedText == text 
    450       } 
    451     }, 
    452  
    453     toContainText: function(text) { 
    454       var trimmedText = $.trim(this.actual.text()) 
    455       if (text && $.isFunction(text.test)) { 
    456         return text.test(trimmedText) 
    457       } else { 
    458         return trimmedText.indexOf(text) != -1; 
    459       } 
    460     }, 
    461  
    462     toHaveValue: function(value) { 
    463       return this.actual.val() === value 
    464     }, 
    465  
    466     toHaveData: function(key, expectedValue) { 
    467       return hasProperty(this.actual.data(key), expectedValue) 
    468     }, 
    469  
    470     toBe: function(selector) { 
    471       return this.actual.is(selector) 
    472     }, 
    473  
    474     toContain: function(selector) { 
    475       return this.actual.find(selector).length 
    476     }, 
    477      
    478     toBeMatchedBy: function(selector) { 
    479       return this.actual.filter(selector).length 
    480     }, 
    481  
    482     toBeDisabled: function(selector){ 
    483       return this.actual.is(':disabled') 
    484     }, 
    485  
    486     toBeFocused: function(selector) { 
    487       return this.actual[0] === this.actual[0].ownerDocument.activeElement 
    488     }, 
    489  
    490     toHandle: function(event) { 
    491  
    492       var events = $._data(this.actual.get(0), "events") 
    493  
    494       if(!events || !event || typeof event !== "string") { 
    495         return false 
    496       } 
    497  
    498       var namespaces = event.split(".") 
    499       var eventType = namespaces.shift() 
    500       var sortedNamespaces = namespaces.slice(0).sort() 
    501       var namespaceRegExp = new RegExp("(^|\\.)" + sortedNamespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") 
    502  
    503       if(events[eventType] && namespaces.length) { 
    504         for(var i = 0; i < events[eventType].length; i++) { 
    505           var namespace = events[eventType][i].namespace 
    506           if(namespaceRegExp.test(namespace)) { 
    507             return true 
    508           } 
    509         } 
    510       } else { 
    511         return events[eventType] && events[eventType].length > 0 
    512       } 
    513     }, 
    514  
    515     // tests the existence of a specific event binding + handler 
    516     toHandleWith: function(eventName, eventHandler) { 
    517       var normalizedEventName = eventName.split('.')[0]; 
    518       var stack = $._data(this.actual.get(0), "events")[normalizedEventName] 
    519       for (var i = 0; i < stack.length; i++) { 
    520         if (stack[i].handler == eventHandler) return true 
    521       } 
    522       return false 
    523     } 
    524   } 
    525  
    526   var hasProperty = function(actualValue, expectedValue) { 
    527     if (expectedValue === undefined) return actualValue !== undefined 
    528     return actualValue == expectedValue 
    529   } 
    530  
    531   var bindMatcher = function(methodName) { 
    532     var builtInMatcher = jasmine.Matchers.prototype[methodName] 
    533  
    534     jasmine.JQuery.matchersClass[methodName] = function() { 
    535       if (this.actual 
    536         && (this.actual instanceof $ 
    537           || jasmine.isDomNode(this.actual))) { 
    538             this.actual = $(this.actual) 
    539             var result = jQueryMatchers[methodName].apply(this, arguments) 
    540             var element 
    541             if (this.actual.get && (element = this.actual.get()[0]) && !$.isWindow(element) && element.tagName !== "HTML") 
    542               this.actual = jasmine.JQuery.elementToString(this.actual) 
    543             return result 
    544           } 
    545  
    546           if (builtInMatcher) { 
    547             return builtInMatcher.apply(this, arguments) 
    548           } 
    549  
    550           return false 
    551     } 
    552   } 
    553  
    554   for(var methodName in jQueryMatchers) { 
    555     bindMatcher(methodName) 
    556   } 
    557 }() 
    558  
    559 beforeEach(function() { 
    560   this.addMatchers(jasmine.JQuery.matchersClass) 
    561   this.addMatchers({ 
    562     toHaveBeenTriggeredOn: function(selector) { 
    563       this.message = function() { 
    564         return [ 
    565           "Expected event " + this.actual + " to have been triggered on " + selector, 
    566           "Expected event " + this.actual + " not to have been triggered on " + selector 
    567         ] 
    568       } 
    569       return jasmine.JQuery.events.wasTriggered(selector, this.actual) 
    570     } 
     718    }) 
     719 
     720    jasmine.getEnv().addCustomEqualityTester(function(a, b) { 
     721     if (a && b) { 
     722       if (a instanceof $ || jasmine.isDomNode(a)) { 
     723         var $a = $(a) 
     724 
     725         if (b instanceof $) 
     726           return $a.length == b.length && a.is(b) 
     727 
     728         return $a.is(b); 
     729       } 
     730 
     731       if (b instanceof $ || jasmine.isDomNode(b)) { 
     732         var $b = $(b) 
     733 
     734         if (a instanceof $) 
     735           return a.length == $b.length && $b.is(a) 
     736 
     737         return $(b).is(a); 
     738       } 
     739     } 
     740    }) 
     741 
     742    jasmine.getEnv().addCustomEqualityTester(function (a, b) { 
     743     if (a instanceof $ && b instanceof $ && a.size() == b.size()) 
     744        return a.is(b) 
     745    }) 
    571746  }) 
    572   this.addMatchers({ 
    573     toHaveBeenTriggered: function(){ 
    574       var eventName = this.actual.eventName, 
    575           selector = this.actual.selector 
    576       this.message = function() { 
    577         return [ 
    578           "Expected event " + eventName + " to have been triggered on " + selector, 
    579           "Expected event " + eventName + " not to have been triggered on " + selector 
    580         ] 
    581       } 
    582       return jasmine.JQuery.events.wasTriggered(selector, eventName) 
    583      } 
     747 
     748  afterEach(function () { 
     749    jasmine.getFixtures().cleanUp() 
     750    jasmine.getStyleFixtures().cleanUp() 
     751    jasmine.jQuery.events.cleanUp() 
    584752  }) 
    585   this.addMatchers({ 
    586     toHaveBeenTriggeredOnAndWith: function() { 
    587       var selector = arguments[0], 
    588           expectedArgs = arguments[1], 
    589           wasTriggered = jasmine.JQuery.events.wasTriggered(selector, this.actual); 
    590       this.message = function() { 
    591         if (wasTriggered) { 
    592           var actualArgs = jasmine.JQuery.events.args(selector, this.actual, expectedArgs)[1]; 
    593           return [ 
    594             "Expected event " + this.actual + " to have been triggered with " + jasmine.pp(expectedArgs) + "  but it was triggered with " + jasmine.pp(actualArgs), 
    595             "Expected event " + this.actual + " not to have been triggered with " + jasmine.pp(expectedArgs) + " but it was triggered with " + jasmine.pp(actualArgs) 
    596           ] 
    597         } else { 
    598           return [ 
    599             "Expected event " + this.actual + " to have been triggered on " + selector, 
    600             "Expected event " + this.actual + " not to have been triggered on " + selector 
    601           ] 
    602         } 
    603       } 
    604       return wasTriggered && jasmine.JQuery.events.wasTriggeredWith(selector, this.actual, expectedArgs, this.env); 
    605     } 
    606   }) 
    607   this.addMatchers({ 
    608     toHaveBeenPreventedOn: function(selector) { 
    609       this.message = function() { 
    610         return [ 
    611           "Expected event " + this.actual + " to have been prevented on " + selector, 
    612           "Expected event " + this.actual + " not to have been prevented on " + selector 
    613         ] 
    614       } 
    615       return jasmine.JQuery.events.wasPrevented(selector, this.actual) 
    616     } 
    617   }) 
    618   this.addMatchers({ 
    619     toHaveBeenPrevented: function() { 
    620       var eventName = this.actual.eventName, 
    621           selector = this.actual.selector 
    622       this.message = function() { 
    623         return [ 
    624           "Expected event " + eventName + " to have been prevented on " + selector, 
    625           "Expected event " + eventName + " not to have been prevented on " + selector 
    626         ] 
    627       } 
    628       return jasmine.JQuery.events.wasPrevented(selector, eventName) 
    629     } 
    630   }) 
    631   this.addMatchers({ 
    632     toHaveBeenStoppedOn: function(selector) { 
    633       this.message = function() { 
    634         return [ 
    635           "Expected event " + this.actual + " to have been stopped on " + selector, 
    636           "Expected event " + this.actual + " not to have been stopped on " + selector 
    637         ] 
    638       } 
    639       return jasmine.JQuery.events.wasStopped(selector, this.actual) 
    640     } 
    641   }) 
    642   this.addMatchers({ 
    643     toHaveBeenStopped: function() { 
    644       var eventName = this.actual.eventName, 
    645           selector = this.actual.selector 
    646       this.message = function() { 
    647         return [ 
    648           "Expected event " + eventName + " to have been stopped on " + selector, 
    649           "Expected event " + eventName + " not to have been stopped on " + selector 
    650         ] 
    651       } 
    652       return jasmine.JQuery.events.wasStopped(selector, eventName) 
    653     } 
    654   }) 
    655   jasmine.getEnv().addEqualityTester(function(a, b) { 
    656     if(a instanceof jQuery && b instanceof jQuery) { 
    657       if(a.size() != b.size()) { 
    658         return jasmine.undefined; 
    659       } 
    660       else if(a.is(b)) { 
    661         return true; 
    662       } 
    663     } 
    664     return jasmine.undefined; 
    665      
    666   }) 
    667 }) 
    668  
    669 afterEach(function() { 
    670   jasmine.getFixtures().cleanUp() 
    671   jasmine.getStyleFixtures().cleanUp() 
    672   jasmine.JQuery.events.cleanUp() 
    673 }) 
     753 
     754  window.readFixtures = function () { 
     755    return jasmine.getFixtures().proxyCallTo_('read', arguments) 
     756  } 
     757 
     758  window.preloadFixtures = function () { 
     759    jasmine.getFixtures().proxyCallTo_('preload', arguments) 
     760  } 
     761 
     762  window.loadFixtures = function () { 
     763    jasmine.getFixtures().proxyCallTo_('load', arguments) 
     764  } 
     765 
     766  window.appendLoadFixtures = function () { 
     767    jasmine.getFixtures().proxyCallTo_('appendLoad', arguments) 
     768  } 
     769 
     770  window.setFixtures = function (html) { 
     771    return jasmine.getFixtures().proxyCallTo_('set', arguments) 
     772  } 
     773 
     774  window.appendSetFixtures = function () { 
     775    jasmine.getFixtures().proxyCallTo_('appendSet', arguments) 
     776  } 
     777 
     778  window.sandbox = function (attributes) { 
     779    return jasmine.getFixtures().sandbox(attributes) 
     780  } 
     781 
     782  window.spyOnEvent = function (selector, eventName) { 
     783    return jasmine.jQuery.events.spyOn(selector, eventName) 
     784  } 
     785 
     786  window.preloadStyleFixtures = function () { 
     787    jasmine.getStyleFixtures().proxyCallTo_('preload', arguments) 
     788  } 
     789 
     790  window.loadStyleFixtures = function () { 
     791    jasmine.getStyleFixtures().proxyCallTo_('load', arguments) 
     792  } 
     793 
     794  window.appendLoadStyleFixtures = function () { 
     795    jasmine.getStyleFixtures().proxyCallTo_('appendLoad', arguments) 
     796  } 
     797 
     798  window.setStyleFixtures = function (html) { 
     799    jasmine.getStyleFixtures().proxyCallTo_('set', arguments) 
     800  } 
     801 
     802  window.appendSetStyleFixtures = function (html) { 
     803    jasmine.getStyleFixtures().proxyCallTo_('appendSet', arguments) 
     804  } 
     805 
     806  window.loadJSONFixtures = function () { 
     807    return jasmine.getJSONFixtures().proxyCallTo_('load', arguments) 
     808  } 
     809 
     810  window.getJSONFixture = function (url) { 
     811    return jasmine.getJSONFixtures().proxyCallTo_('read', arguments)[url] 
     812  } 
     813}(window, window.jasmine, window.jQuery); 
Note: See TracChangeset for help on using the changeset viewer.

Sites map