test/unit/deprecated.js

   1 QUnit.module( "deprecated", { teardown: moduleTeardown } );
   2
   3
   4 QUnit.test( "bind/unbind", function( assert ) {
   5         assert.expect( 4 );
   6
   7         var markup = jQuery(
   8                 "<div><p><span><b>b</b></span></p></div>"
   9         );
  10
  11         markup
  12                 .find( "b" )
  13                 .bind( "click", { bindData: 19 }, function( e, trig ) {
  14                         assert.equal( e.type, "click", "correct event type" );
  15                         assert.equal( e.data.bindData, 19, "correct trigger data" );
  16                         assert.equal( trig, 42, "correct bind data" );
  17                         assert.equal( e.target.nodeName.toLowerCase(), "b", "correct element" );
  18                 } )
  19                 .trigger( "click", [ 42 ] )
  20                 .unbind( "click" )
  21                 .trigger( "click" )
  22                 .remove();
  23 } );
  24
  25 QUnit.test( "delegate/undelegate", function( assert ) {
  26         assert.expect( 2 );
  27
  28         var markup = jQuery(
  29                 "<div><p><span><b>b</b></span></p></div>"
  30         );
  31
  32         markup
  33                 .delegate( "b", "click", function( e ) {
  34                         assert.equal( e.type, "click", "correct event type" );
  35                         assert.equal( e.target.nodeName.toLowerCase(), "b", "correct element" );
  36                 } )
  37                 .find( "b" )
  38                         .trigger( "click" )
  39                         .end()
  40                 .undelegate( "b", "click" )
  41                 .remove();
  42 } );
  43
  44 QUnit.test( "jQuery.parseJSON", function( assert ) {
  45         assert.expect( 20 );
  46
  47         assert.strictEqual( jQuery.parseJSON( null ), null, "primitive null" );
  48         assert.strictEqual( jQuery.parseJSON( "0.88" ), 0.88, "Number" );
  49         assert.strictEqual(
  50                 jQuery.parseJSON( "\" \\\" \\\\ \\/ \\b \\f \\n \\r \\t \\u007E \\u263a \"" ),
  51                 " \" \\ / \b \f \n \r \t ~ \u263A ",
  52                 "String escapes"
  53         );
  54         assert.deepEqual( jQuery.parseJSON( "{}" ), {}, "Empty object" );
  55         assert.deepEqual( jQuery.parseJSON( "{\"test\":1}" ), { "test": 1 }, "Plain object" );
  56         assert.deepEqual( jQuery.parseJSON( "[0]" ), [ 0 ], "Simple array" );
  57
  58         assert.deepEqual(
  59                 jQuery.parseJSON( "[ \"string\", -4.2, 2.7180e0, 3.14E-1, {}, [], true, false, null ]" ),
  60                 [ "string", -4.2, 2.718, 0.314, {}, [], true, false, null ],
  61                 "Array of all data types"
  62         );
  63         assert.deepEqual(
  64                 jQuery.parseJSON( "{ \"string\": \"\", \"number\": 4.2e+1, \"object\": {}," +
  65                         "\"array\": [[]], \"boolean\": [ true, false ], \"null\": null }" ),
  66                 { string: "", number: 42, object: {}, array: [ [] ], "boolean": [ true, false ], "null": null },
  67                 "Dictionary of all data types"
  68         );
  69
  70         assert.deepEqual( jQuery.parseJSON( "\n{\"test\":1}\t" ), { "test": 1 },
  71                 "Leading and trailing whitespace are ignored" );
  72
  73         assert.throws( function() {
  74                 jQuery.parseJSON();
  75         }, null, "Undefined raises an error" );
  76         assert.throws( function() {
  77                 jQuery.parseJSON( "" );
  78         }, null, "Empty string raises an error" );
  79         assert.throws( function() {
  80                 jQuery.parseJSON( "''" );
  81         }, null, "Single-quoted string raises an error" );
  82
  83         assert.throws( function() {
  84                 var result = jQuery.parseJSON( "0101" );
  85
  86                 // Support: IE <=9 only
  87                 // Ensure base-10 interpretation on browsers that erroneously accept leading-zero numbers
  88                 if ( result === 101 ) {
  89                         throw new Error( "close enough" );
  90                 }
  91         }, null, "Leading-zero number raises an error or is parsed as decimal" );
  92         assert.throws( function() {
  93                 jQuery.parseJSON( "{a:1}" );
  94         }, null, "Unquoted property raises an error" );
  95         assert.throws( function() {
  96                 jQuery.parseJSON( "{'a':1}" );
  97         }, null, "Single-quoted property raises an error" );
  98         assert.throws( function() {
  99                 jQuery.parseJSON( "[,]" );
 100         }, null, "Array element elision raises an error" );
 101         assert.throws( function() {
 102                 jQuery.parseJSON( "{},[]" );
 103         }, null, "Comma expression raises an error" );
 104         assert.throws( function() {
 105                 jQuery.parseJSON( "[]\n,{}" );
 106         }, null, "Newline-containing comma expression raises an error" );
 107         assert.throws( function() {
 108                 jQuery.parseJSON( "\"\"\n\"\"" );
 109         }, null, "Automatic semicolon insertion raises an error" );
 110
 111         assert.strictEqual( jQuery.parseJSON( [ 0 ] ), 0, "Input cast to string" );
 112 } );
 113
 114 QUnit.test( "jQuery.isArray", function( assert ) {
 115         assert.expect( 1 );
 116
 117         assert.strictEqual( jQuery.isArray, Array.isArray, "Array.isArray equals jQuery.isArray" );
 118 } );
 119
 120 QUnit.test( "jQuery.nodeName", function( assert ) {
 121         assert.expect( 8 );
 122
 123         assert.strictEqual( typeof jQuery.nodeName, "function", "jQuery.nodeName is a function" );
 124
 125         assert.strictEqual(
 126                 jQuery.nodeName( document.createElement( "div" ), "div" ),
 127                 true,
 128                 "Basic usage (true)"
 129         );
 130
 131         assert.strictEqual(
 132                 jQuery.nodeName( document.createElement( "div" ), "span" ),
 133                 false,
 134                 "Basic usage (false)"
 135         );
 136
 137         assert.strictEqual(
 138                 jQuery.nodeName( document.createElement( "div" ), "DIV" ),
 139                 true,
 140                 "Ignores case in the name parameter"
 141         );
 142
 143         assert.strictEqual(
 144                 jQuery.nodeName( document.createElement( "section" ), "section" ),
 145                 true,
 146                 "Works on HTML5 tags (true)"
 147         );
 148
 149         assert.strictEqual(
 150                 jQuery.nodeName( document.createElement( "section" ), "article" ),
 151                 false,
 152                 "Works on HTML5 tags (false)"
 153         );
 154
 155         assert.strictEqual(
 156                 jQuery.nodeName( document.createElement( "custom-element" ), "custom-element" ),
 157                 true,
 158                 "Works on custom elements (true)"
 159         );
 160
 161         assert.strictEqual(
 162                 jQuery.nodeName( document.createElement( "custom-element" ), "my-element" ),
 163                 false,
 164                 "Works on custom elements (true)"
 165         );
 166 } );
 167
 168 QUnit.test( "jQuery.isWindow", function( assert ) {
 169         assert.expect( 14 );
 170
 171         assert.ok( jQuery.isWindow( window ), "window" );
 172         assert.ok( jQuery.isWindow( document.getElementsByTagName( "iframe" )[ 0 ].contentWindow ), "iframe.contentWindow" );
 173         assert.ok( !jQuery.isWindow(), "empty" );
 174         assert.ok( !jQuery.isWindow( null ), "null" );
 175         assert.ok( !jQuery.isWindow( undefined ), "undefined" );
 176         assert.ok( !jQuery.isWindow( document ), "document" );
 177         assert.ok( !jQuery.isWindow( document.documentElement ), "documentElement" );
 178         assert.ok( !jQuery.isWindow( "" ), "string" );
 179         assert.ok( !jQuery.isWindow( 1 ), "number" );
 180         assert.ok( !jQuery.isWindow( true ), "boolean" );
 181         assert.ok( !jQuery.isWindow( {} ), "object" );
 182         assert.ok( !jQuery.isWindow( { setInterval: function() {} } ), "fake window" );
 183         assert.ok( !jQuery.isWindow( /window/ ), "regexp" );
 184         assert.ok( !jQuery.isWindow( function() {} ), "function" );
 185 } );
 186
 187 QUnit.test( "jQuery.camelCase()", function( assert ) {
 188
 189         var tests = {
 190                 "foo-bar": "fooBar",
 191                 "foo-bar-baz": "fooBarBaz",
 192                 "girl-u-want": "girlUWant",
 193                 "the-4th-dimension": "the-4thDimension",
 194                 "-o-tannenbaum": "OTannenbaum",
 195                 "-moz-illa": "MozIlla",
 196                 "-ms-take": "msTake"
 197         };
 198
 199         assert.expect( 7 );
 200
 201         jQuery.each( tests, function( key, val ) {
 202                 assert.equal( jQuery.camelCase( key ), val, "Converts: " + key + " => " + val );
 203         } );
 204 } );
 205
 206 QUnit.test( "jQuery.now", function( assert ) {
 207         assert.expect( 1 );
 208
 209         assert.ok( typeof jQuery.now() === "number", "jQuery.now is a function" );
 210 } );