2015-08-16 06:59:58 +00:00
QUnit . module ( "core" , { teardown : moduleTeardown } ) ;
2015-08-16 03:45:28 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "Basic requirements" , function ( assert ) {
assert . expect ( 7 ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( Array . prototype . push , "Array.push()" ) ;
assert . ok ( Function . prototype . apply , "Function.apply()" ) ;
assert . ok ( document . getElementById , "getElementById" ) ;
assert . ok ( document . getElementsByTagName , "getElementsByTagName" ) ;
assert . ok ( RegExp , "RegExp" ) ;
assert . ok ( jQuery , "jQuery" ) ;
assert . ok ( $ , "$" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery()" , function ( assert ) {
2008-12-19 05:43:37 +00:00
2012-06-07 15:24:35 +00:00
var elem , i ,
2015-08-16 06:59:58 +00:00
obj = jQuery ( "div" ) ,
code = jQuery ( "<code/>" ) ,
img = jQuery ( "<img/>" ) ,
div = jQuery ( "<div/><hr/><code/><b/>" ) ,
2012-06-07 15:24:35 +00:00
exec = false ,
2015-04-10 19:57:18 +00:00
expected = 23 ,
2012-06-07 15:24:35 +00:00
attrObj = {
2012-07-05 19:52:13 +00:00
"text" : "test" ,
2012-06-07 15:24:35 +00:00
"class" : "test2" ,
2012-07-05 19:52:13 +00:00
"id" : "test3"
2012-06-07 15:24:35 +00:00
} ;
2009-07-16 07:31:47 +00:00
2012-07-05 21:21:58 +00:00
// The $(html, props) signature can stealth-call any $.fn method, check for a
// few here but beware of modular builds where these methods may be excluded.
2013-01-27 04:48:59 +00:00
if ( jQuery . fn . click ) {
expected ++ ;
2015-09-08 00:26:29 +00:00
attrObj [ "click" ] = function ( ) { assert . ok ( exec , "Click executed." ) ; } ;
2013-01-27 04:48:59 +00:00
}
2012-06-07 15:24:35 +00:00
if ( jQuery . fn . width ) {
expected ++ ;
2015-08-16 06:59:58 +00:00
attrObj [ "width" ] = 10 ;
2012-06-07 15:24:35 +00:00
}
2015-11-13 11:54:33 +00:00
if ( jQuery . fn . offset ) {
expected ++ ;
2015-11-13 13:02:32 +00:00
attrObj [ "offset" ] = { "top" : 1 , "left" : 1 } ;
2015-11-13 11:54:33 +00:00
}
2012-07-05 21:21:58 +00:00
if ( jQuery . fn . css ) {
2012-06-11 01:54:16 +00:00
expected += 2 ;
2015-08-16 06:59:58 +00:00
attrObj [ "css" ] = { "paddingLeft" : 1 , "paddingRight" : 1 } ;
2012-06-11 01:54:16 +00:00
}
2012-07-05 21:21:58 +00:00
if ( jQuery . fn . attr ) {
expected ++ ;
attrObj . attr = { "desired" : "very" } ;
}
2012-06-11 01:54:16 +00:00
2015-08-16 03:45:28 +00:00
assert . expect ( expected ) ;
2012-06-07 15:24:35 +00:00
// Basic constructor's behavior
2015-08-16 03:45:28 +00:00
assert . equal ( jQuery ( ) . length , 0 , "jQuery() === jQuery([])" ) ;
2015-11-13 13:27:18 +00:00
assert . equal ( jQuery ( undefined ) . length , 0 , "jQuery(undefined) === jQuery([])" ) ;
assert . equal ( jQuery ( null ) . length , 0 , "jQuery(null) === jQuery([])" ) ;
assert . equal ( jQuery ( "" ) . length , 0 , "jQuery('') === jQuery([])" ) ;
2015-11-13 13:47:41 +00:00
assert . equal ( jQuery ( "#" ) . length , 0 , "jQuery('#') === jQuery([])" ) ;
2009-07-17 17:33:44 +00:00
2015-11-13 13:47:41 +00:00
assert . equal ( jQuery ( obj ) . selector , "div" , "jQuery(jQueryObj) == jQueryObj" ) ;
2014-12-03 19:51:24 +00:00
2012-06-07 15:24:35 +00:00
// can actually yield more than one, when iframes are included, the window is an array as well
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery ( window ) . length , 1 , "Correct number of elements generated for jQuery(window)" ) ;
2009-07-16 07:31:47 +00:00
2008-12-19 05:43:37 +00:00
/ *
// disabled since this test was doing nothing. i tried to fix it but i'm not sure
// what the expected behavior should even be. FF returns "\n" for the text node
// make sure this is handled
var crlfContainer = jQuery ( '<p>\r\n</p>' ) ;
var x = crlfContainer . contents ( ) . get ( 0 ) . nodeValue ;
2015-08-16 03:45:28 +00:00
assert . equal ( x , what ? ? ? , "Check for \\r and \\n in jQuery()" ) ;
2008-12-19 05:43:37 +00:00
* /
/* / / Disabled until we add this functionality in
var pass = true ;
try {
jQuery ( "<div>Testing</div>" ) . appendTo ( document . getElementById ( "iframe" ) . contentDocument . body ) ;
} catch ( e ) {
pass = false ;
}
2015-08-16 03:45:28 +00:00
assert . ok ( pass , "jQuery('<tag>') needs optional document parameter to ease cross-frame DOM wrangling, see #968" ) ; * /
2008-12-19 05:43:37 +00:00
2015-08-16 03:45:28 +00:00
assert . equal ( code . length , 1 , "Correct number of elements generated for code" ) ;
assert . equal ( code . parent ( ) . length , 0 , "Make sure that the generated HTML has no parent." ) ;
2012-06-07 15:24:35 +00:00
2015-08-16 03:45:28 +00:00
assert . equal ( img . length , 1 , "Correct number of elements generated for img" ) ;
assert . equal ( img . parent ( ) . length , 0 , "Make sure that the generated HTML has no parent." ) ;
2012-06-07 15:24:35 +00:00
2015-08-16 03:45:28 +00:00
assert . equal ( div . length , 4 , "Correct number of elements generated for div hr code b" ) ;
assert . equal ( div . parent ( ) . length , 0 , "Make sure that the generated HTML has no parent." ) ;
2008-12-19 05:43:37 +00:00
2015-11-13 13:02:32 +00:00
assert . equal ( jQuery ( [ 1 , 2 , 3 ] ) . get ( 1 ) , 2 , "Test passing an array to the factory" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery ( document . body ) . get ( 0 ) , jQuery ( "body" ) . get ( 0 ) , "Test passing an html node to the factory" ) ;
2009-12-18 17:41:53 +00:00
2015-08-16 06:59:58 +00:00
elem = jQuery ( " <em>hello</em>" ) [ 0 ] ;
2015-08-16 03:45:28 +00:00
assert . equal ( elem . nodeName . toLowerCase ( ) , "em" , "leading space" ) ;
2013-05-09 01:07:41 +00:00
2015-08-16 06:59:58 +00:00
elem = jQuery ( "\n\n<em>world</em>" ) [ 0 ] ;
2015-08-16 03:45:28 +00:00
assert . equal ( elem . nodeName . toLowerCase ( ) , "em" , "leading newlines" ) ;
2013-05-09 01:07:41 +00:00
2015-11-13 13:02:32 +00:00
elem = jQuery ( "<div/>" , attrObj ) ;
2012-06-05 20:38:18 +00:00
if ( jQuery . fn . width ) {
2015-08-16 06:59:58 +00:00
assert . equal ( elem [ 0 ] . style . width , "10px" , "jQuery() quick setter width" ) ;
2012-06-07 15:24:35 +00:00
}
2012-06-05 20:38:18 +00:00
2015-11-13 11:54:33 +00:00
if ( jQuery . fn . offset ) {
2015-11-13 13:02:32 +00:00
assert . equal ( elem [ 0 ] . style . top , "1px" , "jQuery() quick setter offset" ) ;
2015-11-13 11:54:33 +00:00
}
2012-07-05 21:21:58 +00:00
if ( jQuery . fn . css ) {
2015-08-16 06:59:58 +00:00
assert . equal ( elem [ 0 ] . style . paddingLeft , "1px" , "jQuery quick setter css" ) ;
assert . equal ( elem [ 0 ] . style . paddingRight , "1px" , "jQuery quick setter css" ) ;
2012-06-11 01:54:16 +00:00
}
2012-07-05 21:21:58 +00:00
if ( jQuery . fn . attr ) {
2015-08-16 06:59:58 +00:00
assert . equal ( elem [ 0 ] . getAttribute ( "desired" ) , "very" , "jQuery quick setter attr" ) ;
2012-07-05 21:21:58 +00:00
}
2015-08-16 06:59:58 +00:00
assert . equal ( elem [ 0 ] . childNodes . length , 1 , "jQuery quick setter text" ) ;
assert . equal ( elem [ 0 ] . firstChild . nodeValue , "test" , "jQuery quick setter text" ) ;
assert . equal ( elem [ 0 ] . className , "test2" , "jQuery() quick setter class" ) ;
assert . equal ( elem [ 0 ] . id , "test3" , "jQuery() quick setter id" ) ;
2010-01-13 02:54:06 +00:00
exec = true ;
2015-08-16 06:59:58 +00:00
elem . trigger ( "click" ) ;
2011-01-10 00:38:44 +00:00
2011-01-09 21:58:47 +00:00
// manually clean up detached elements
elem . remove ( ) ;
2011-01-17 21:31:43 +00:00
2012-06-07 15:24:35 +00:00
for ( i = 0 ; i < 3 ; ++ i ) {
2015-08-16 06:59:58 +00:00
elem = jQuery ( "<input type='text' value='TEST' />" ) ;
2011-01-10 00:38:44 +00:00
}
2015-08-16 06:59:58 +00:00
assert . equal ( elem [ 0 ] . defaultValue , "TEST" , "Ensure cached nodes are cloned properly (Bug #6655)" ) ;
2011-01-17 21:31:43 +00:00
2015-04-10 19:57:18 +00:00
elem = jQuery ( "<input type='hidden'>" , { } ) ;
2015-08-16 03:45:28 +00:00
assert . strictEqual ( elem [ 0 ] . ownerDocument , document ,
2015-04-10 19:57:18 +00:00
"Empty attributes object is not interpreted as a document (trac-8950)" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2008-12-19 04:37:10 +00:00
2015-11-10 18:26:15 +00:00
QUnit [ jQuery . find . compile ? "test" : "skip" ] ( "jQuery(selector, context)" , function ( assert ) {
2015-08-16 06:59:58 +00:00
assert . expect ( 3 ) ;
assert . deepEqual ( jQuery ( "div p" , "#qunit-fixture" ) . get ( ) , q ( "sndp" , "en" , "sap" ) , "Basic selector with string as context" ) ;
assert . deepEqual ( jQuery ( "div p" , q ( "qunit-fixture" ) [ 0 ] ) . get ( ) , q ( "sndp" , "en" , "sap" ) , "Basic selector with element as context" ) ;
assert . deepEqual ( jQuery ( "div p" , jQuery ( "#qunit-fixture" ) ) . get ( ) , q ( "sndp" , "en" , "sap" ) , "Basic selector with jQuery object as context" ) ;
} ) ;
2013-02-19 04:52:29 +00:00
2015-08-16 03:45:28 +00:00
QUnit . test ( "globalEval" , function ( assert ) {
assert . expect ( 3 ) ;
2015-08-16 06:59:58 +00:00
Globals . register ( "globalEvalTest" ) ;
2011-04-07 04:47:15 +00:00
2015-08-16 06:59:58 +00:00
jQuery . globalEval ( "globalEvalTest = 1;" ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( window . globalEvalTest , 1 , "Test variable assignments are global" ) ;
2011-04-07 04:47:15 +00:00
2015-08-16 06:59:58 +00:00
jQuery . globalEval ( "var globalEvalTest = 2;" ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( window . globalEvalTest , 2 , "Test variable declarations are global" ) ;
2011-04-07 04:47:15 +00:00
2015-08-16 06:59:58 +00:00
jQuery . globalEval ( "this.globalEvalTest = 3;" ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( window . globalEvalTest , 3 , "Test context (this) is the window object" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2011-04-07 04:47:15 +00:00
2015-11-13 13:27:18 +00:00
2015-08-16 03:45:28 +00:00
QUnit . test ( "globalEval with 'use strict'" , function ( assert ) {
assert . expect ( 1 ) ;
2015-08-16 06:59:58 +00:00
Globals . register ( "strictEvalTest" ) ;
2013-04-03 15:26:07 +00:00
2015-08-16 06:59:58 +00:00
jQuery . globalEval ( "'use strict'; var strictEvalTest = 1;" ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( window . strictEvalTest , 1 , "Test variable declarations are global (strict mode)" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2013-04-03 15:26:07 +00:00
2014-12-09 20:39:24 +00:00
// This is not run in AMD mode
2014-12-10 14:48:55 +00:00
if ( jQuery . noConflict ) {
2015-08-16 06:59:58 +00:00
QUnit . test ( "noConflict" , function ( assert ) {
assert . expect ( 7 ) ;
2008-12-19 05:43:37 +00:00
2014-12-09 20:39:24 +00:00
var $$ = jQuery ;
2008-12-19 05:43:37 +00:00
2015-08-16 03:45:28 +00:00
assert . strictEqual ( jQuery , jQuery . noConflict ( ) , "noConflict returned the jQuery object" ) ;
2015-08-16 06:59:58 +00:00
assert . strictEqual ( window [ "jQuery" ] , $$ , "Make sure jQuery wasn't touched." ) ;
assert . strictEqual ( window [ "$" ] , original$ , "Make sure $ was reverted." ) ;
2008-12-19 05:43:37 +00:00
2014-12-09 20:39:24 +00:00
jQuery = $ = $$ ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . strictEqual ( jQuery . noConflict ( true ) , $$ , "noConflict returned the jQuery object" ) ;
assert . strictEqual ( window [ "jQuery" ] , originaljQuery , "Make sure jQuery was reverted." ) ;
assert . strictEqual ( window [ "$" ] , original$ , "Make sure $ was reverted." ) ;
assert . ok ( $$ ( ) . pushStack ( [ ] ) , "Make sure that jQuery still works." ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
window [ "jQuery" ] = jQuery = $$ ;
} ) ;
2014-12-09 20:39:24 +00:00
}
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "trim" , function ( assert ) {
assert . expect ( 13 ) ;
2009-11-30 18:21:56 +00:00
2015-08-16 06:59:58 +00:00
var nbsp = String . fromCharCode ( 160 ) ;
2009-11-30 18:21:56 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . trim ( "hello " ) , "hello" , "trailing space" ) ;
assert . equal ( jQuery . trim ( " hello" ) , "hello" , "leading space" ) ;
assert . equal ( jQuery . trim ( " hello " ) , "hello" , "space on both sides" ) ;
assert . equal ( jQuery . trim ( " " + nbsp + "hello " + nbsp + " " ) , "hello" , " " ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( jQuery . trim ( ) , "" , "Nothing in." ) ;
assert . equal ( jQuery . trim ( undefined ) , "" , "Undefined" ) ;
assert . equal ( jQuery . trim ( null ) , "" , "Null" ) ;
assert . equal ( jQuery . trim ( 5 ) , "5" , "Number" ) ;
assert . equal ( jQuery . trim ( false ) , "false" , "Boolean" ) ;
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . trim ( " " ) , "" , "space should be trimmed" ) ;
assert . equal ( jQuery . trim ( "ipad\xA0" ) , "ipad" , "nbsp should be trimmed" ) ;
assert . equal ( jQuery . trim ( "\uFEFF" ) , "" , "zwsp should be trimmed" ) ;
assert . equal ( jQuery . trim ( "\uFEFF \xA0! | \uFEFF" ) , "! |" , "leading/trailing should be trimmed" ) ;
} ) ;
2009-11-30 18:21:56 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "type" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 28 ) ;
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . type ( null ) , "null" , "null" ) ;
assert . equal ( jQuery . type ( undefined ) , "undefined" , "undefined" ) ;
assert . equal ( jQuery . type ( true ) , "boolean" , "Boolean" ) ;
assert . equal ( jQuery . type ( false ) , "boolean" , "Boolean" ) ;
assert . equal ( jQuery . type ( Boolean ( true ) ) , "boolean" , "Boolean" ) ;
assert . equal ( jQuery . type ( 0 ) , "number" , "Number" ) ;
assert . equal ( jQuery . type ( 1 ) , "number" , "Number" ) ;
assert . equal ( jQuery . type ( Number ( 1 ) ) , "number" , "Number" ) ;
assert . equal ( jQuery . type ( "" ) , "string" , "String" ) ;
assert . equal ( jQuery . type ( "a" ) , "string" , "String" ) ;
assert . equal ( jQuery . type ( String ( "a" ) ) , "string" , "String" ) ;
assert . equal ( jQuery . type ( { } ) , "object" , "Object" ) ;
assert . equal ( jQuery . type ( /foo/ ) , "regexp" , "RegExp" ) ;
assert . equal ( jQuery . type ( new RegExp ( "asdf" ) ) , "regexp" , "RegExp" ) ;
assert . equal ( jQuery . type ( [ 1 ] ) , "array" , "Array" ) ;
assert . equal ( jQuery . type ( new Date ( ) ) , "date" , "Date" ) ;
assert . equal ( jQuery . type ( new Function ( "return;" ) ) , "function" , "Function" ) ;
assert . equal ( jQuery . type ( function ( ) { } ) , "function" , "Function" ) ;
assert . equal ( jQuery . type ( new Error ( ) ) , "error" , "Error" ) ;
assert . equal ( jQuery . type ( window ) , "object" , "Window" ) ;
assert . equal ( jQuery . type ( document ) , "object" , "Document" ) ;
assert . equal ( jQuery . type ( document . body ) , "object" , "Element" ) ;
assert . equal ( jQuery . type ( document . createTextNode ( "foo" ) ) , "object" , "TextNode" ) ;
assert . equal ( jQuery . type ( document . getElementsByTagName ( "*" ) ) , "object" , "NodeList" ) ;
2012-12-18 15:33:32 +00:00
// Avoid Lint complaints
2013-04-09 15:45:09 +00:00
var MyString = String ,
MyNumber = Number ,
MyBoolean = Boolean ,
MyObject = Object ;
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . type ( new MyBoolean ( true ) ) , "boolean" , "Boolean" ) ;
assert . equal ( jQuery . type ( new MyNumber ( 1 ) ) , "number" , "Number" ) ;
assert . equal ( jQuery . type ( new MyString ( "a" ) ) , "string" , "String" ) ;
assert . equal ( jQuery . type ( new MyObject ( ) ) , "object" , "Object" ) ;
} ) ;
2010-08-27 13:10:52 +00:00
2015-10-02 22:28:34 +00:00
QUnit . test ( "type for `Symbol`" , function ( assert ) {
2015-11-13 13:02:32 +00:00
2015-10-02 22:28:34 +00:00
// Prevent reference errors
2015-11-13 13:02:32 +00:00
if ( typeof Symbol !== "function" ) {
2015-10-02 22:28:34 +00:00
assert . expect ( 0 ) ;
2015-10-12 22:22:57 +00:00
return ;
2015-10-02 22:28:34 +00:00
}
assert . expect ( 2 ) ;
assert . equal ( jQuery . type ( Symbol ( ) ) , "symbol" , "Symbol" ) ;
assert . equal ( jQuery . type ( Object ( Symbol ( ) ) ) , "symbol" , "Symbol" ) ;
2015-11-13 13:02:32 +00:00
} ) ;
2015-10-02 22:28:34 +00:00
2015-08-16 06:59:58 +00:00
QUnit . asyncTest ( "isPlainObject" , function ( assert ) {
assert . expect ( 15 ) ;
2009-12-02 19:57:13 +00:00
2013-03-06 20:11:20 +00:00
var pass , iframe , doc ,
2012-11-03 04:06:50 +00:00
fn = function ( ) { } ;
2009-12-02 19:57:13 +00:00
// The use case that we want to match
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery . isPlainObject ( { } ) , "{}" ) ;
2011-01-05 21:41:23 +00:00
2009-12-18 16:34:20 +00:00
// Not objects shouldn't be matched
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isPlainObject ( "" ) , "string" ) ;
assert . ok ( ! jQuery . isPlainObject ( 0 ) && ! jQuery . isPlainObject ( 1 ) , "number" ) ;
assert . ok ( ! jQuery . isPlainObject ( true ) && ! jQuery . isPlainObject ( false ) , "boolean" ) ;
assert . ok ( ! jQuery . isPlainObject ( null ) , "null" ) ;
assert . ok ( ! jQuery . isPlainObject ( undefined ) , "undefined" ) ;
2011-01-05 21:41:23 +00:00
2009-12-18 16:34:20 +00:00
// Arrays shouldn't be matched
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isPlainObject ( [ ] ) , "array" ) ;
2011-01-05 21:41:23 +00:00
2009-12-02 19:57:13 +00:00
// Instantiated objects shouldn't be matched
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isPlainObject ( new Date ( ) ) , "new Date" ) ;
2011-01-05 21:41:23 +00:00
2009-12-02 19:57:13 +00:00
// Functions shouldn't be matched
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isPlainObject ( fn ) , "fn" ) ;
2011-01-05 21:41:23 +00:00
2009-12-02 19:57:13 +00:00
// Again, instantiated objects shouldn't be matched
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isPlainObject ( new fn ( ) ) , "new fn (no methods)" ) ;
2011-01-05 21:41:23 +00:00
2009-12-02 19:57:13 +00:00
// Makes the function a little more realistic
// (and harder to detect, incidentally)
2015-08-16 06:59:58 +00:00
fn . prototype [ "someMethod" ] = function ( ) { } ;
2011-01-05 21:41:23 +00:00
2009-12-02 19:57:13 +00:00
// Again, instantiated objects shouldn't be matched
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isPlainObject ( new fn ( ) ) , "new fn" ) ;
2009-12-02 19:57:13 +00:00
// DOM Element
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isPlainObject ( document . createElement ( "div" ) ) , "DOM Element" ) ;
2011-01-05 21:41:23 +00:00
2009-12-18 16:34:20 +00:00
// Window
2015-08-16 03:45:28 +00:00
assert . ok ( ! jQuery . isPlainObject ( window ) , "window" ) ;
2009-12-02 19:57:13 +00:00
2012-11-03 04:06:50 +00:00
pass = false ;
2011-07-25 21:06:38 +00:00
try {
jQuery . isPlainObject ( window . location ) ;
2012-11-03 04:06:50 +00:00
pass = true ;
} catch ( e ) { }
2015-08-16 03:45:28 +00:00
assert . ok ( pass , "Does not throw exceptions on host objects" ) ;
2012-11-03 04:06:50 +00:00
// Objects from other windows should be matched
2015-08-16 06:59:58 +00:00
Globals . register ( "iframeDone" ) ;
2013-09-03 13:55:32 +00:00
window . iframeDone = function ( otherObject , detail ) {
window . iframeDone = undefined ;
2012-11-03 04:06:50 +00:00
iframe . parentNode . removeChild ( iframe ) ;
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery . isPlainObject ( new otherObject ( ) ) , "new otherObject" + ( detail ? " - " + detail : "" ) ) ;
2015-08-16 03:45:28 +00:00
QUnit . start ( ) ;
2012-11-03 04:06:50 +00:00
} ;
2011-07-25 21:06:38 +00:00
2010-08-23 19:38:55 +00:00
try {
2015-08-16 06:59:58 +00:00
iframe = jQuery ( "#qunit-fixture" ) [ 0 ] . appendChild ( document . createElement ( "iframe" ) ) ;
2012-11-03 04:06:50 +00:00
doc = iframe . contentDocument || iframe . contentWindow . document ;
2010-08-23 19:38:55 +00:00
doc . open ( ) ;
2015-08-16 06:59:58 +00:00
doc . write ( "<body onload='window.parent.iframeDone(Object);'>" ) ;
2010-08-23 19:38:55 +00:00
doc . close ( ) ;
2015-08-16 06:59:58 +00:00
} catch ( e ) {
2012-11-03 04:06:50 +00:00
window . iframeDone ( Object , "iframes not supported" ) ;
2010-08-23 19:38:55 +00:00
}
2015-08-16 06:59:58 +00:00
} ) ;
2009-12-02 19:57:13 +00:00
2015-10-18 19:00:38 +00:00
//
QUnit [ typeof Symbol === "function" ? "test" : "skip" ] ( "isPlainObject(Symbol)" , function ( assert ) {
assert . expect ( 2 ) ;
assert . equal ( jQuery . isPlainObject ( Symbol ( ) ) , false , "Symbol" ) ;
assert . equal ( jQuery . isPlainObject ( Object ( Symbol ( ) ) ) , false , "Symbol inside an object" ) ;
} ) ;
2015-08-16 06:59:58 +00:00
QUnit . test ( "isFunction" , function ( assert ) {
assert . expect ( 19 ) ;
2008-12-19 05:43:37 +00:00
2013-04-09 15:45:09 +00:00
var mystr , myarr , myfunction , fn , obj , nodes , first , input , a ;
2008-12-19 05:43:37 +00:00
// Make sure that false values return false
2015-08-16 03:45:28 +00:00
assert . ok ( ! jQuery . isFunction ( ) , "No Value" ) ;
assert . ok ( ! jQuery . isFunction ( null ) , "null Value" ) ;
assert . ok ( ! jQuery . isFunction ( undefined ) , "undefined Value" ) ;
assert . ok ( ! jQuery . isFunction ( "" ) , "Empty String Value" ) ;
assert . ok ( ! jQuery . isFunction ( 0 ) , "0 Value" ) ;
2008-12-19 05:43:37 +00:00
// Check built-ins
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery . isFunction ( String ) , "String Function(" + String + ")" ) ;
assert . ok ( jQuery . isFunction ( Array ) , "Array Function(" + Array + ")" ) ;
assert . ok ( jQuery . isFunction ( Object ) , "Object Function(" + Object + ")" ) ;
assert . ok ( jQuery . isFunction ( Function ) , "Function Function(" + Function + ")" ) ;
2008-12-19 05:43:37 +00:00
// When stringified, this could be misinterpreted
2013-04-09 15:45:09 +00:00
mystr = "function" ;
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isFunction ( mystr ) , "Function String" ) ;
2008-12-19 05:43:37 +00:00
// When stringified, this could be misinterpreted
2013-04-09 15:45:09 +00:00
myarr = [ "function" ] ;
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isFunction ( myarr ) , "Function Array" ) ;
2008-12-19 05:43:37 +00:00
// When stringified, this could be misinterpreted
2013-04-09 15:45:09 +00:00
myfunction = { "function" : "test" } ;
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isFunction ( myfunction ) , "Function Object" ) ;
2008-12-19 05:43:37 +00:00
// Make sure normal functions still work
2015-08-16 06:59:58 +00:00
fn = function ( ) { } ;
assert . ok ( jQuery . isFunction ( fn ) , "Normal Function" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
obj = document . createElement ( "object" ) ;
2008-12-19 05:43:37 +00:00
// Firefox says this is a function
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isFunction ( obj ) , "Object Element" ) ;
2008-12-19 05:43:37 +00:00
// Since 1.3, this isn't supported (#2968)
//ok( jQuery.isFunction(obj.getAttribute), "getAttribute Function" );
2013-04-09 15:45:09 +00:00
nodes = document . body . childNodes ;
2008-12-19 05:43:37 +00:00
// Safari says this is a function
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isFunction ( nodes ) , "childNodes Property" ) ;
2008-12-19 05:43:37 +00:00
2013-04-09 15:45:09 +00:00
first = document . body . firstChild ;
2008-12-19 05:43:37 +00:00
// Normal elements are reported ok everywhere
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isFunction ( first ) , "A normal DOM Element" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
input = document . createElement ( "input" ) ;
2008-12-19 05:43:37 +00:00
input . type = "text" ;
document . body . appendChild ( input ) ;
// Since 1.3, this isn't supported (#2968)
//ok( jQuery.isFunction(input.focus), "A default function property" );
document . body . removeChild ( input ) ;
2015-08-16 06:59:58 +00:00
a = document . createElement ( "a" ) ;
2008-12-19 05:43:37 +00:00
a . href = "some-function" ;
document . body . appendChild ( a ) ;
// This serializes with the word 'function' in it
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isFunction ( a ) , "Anchor Element" ) ;
2008-12-19 05:43:37 +00:00
document . body . removeChild ( a ) ;
// Recursive function calls have lengths and array-like properties
2015-08-16 06:59:58 +00:00
function callme ( callback ) {
function fn ( response ) {
callback ( response ) ;
2008-12-19 05:43:37 +00:00
}
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery . isFunction ( fn ) , "Recursive Function Call" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
fn ( { some : "data" } ) ;
2012-06-21 19:30:24 +00:00
}
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
callme ( function ( ) {
callme ( function ( ) { } ) ;
} ) ;
} ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 03:45:28 +00:00
QUnit . test ( "isNumeric" , function ( assert ) {
assert . expect ( 38 ) ;
2011-11-07 16:25:51 +00:00
var t = jQuery . isNumeric ,
2014-06-07 18:33:36 +00:00
ToString = function ( value ) {
this . toString = function ( ) {
return String ( value ) ;
2011-11-07 16:25:51 +00:00
} ;
2014-06-07 18:33:36 +00:00
} ;
2015-08-16 03:45:28 +00:00
assert . ok ( t ( "-10" ) , "Negative integer string" ) ;
assert . ok ( t ( "0" ) , "Zero string" ) ;
assert . ok ( t ( "5" ) , "Positive integer string" ) ;
assert . ok ( t ( - 16 ) , "Negative integer number" ) ;
assert . ok ( t ( 0 ) , "Zero integer number" ) ;
assert . ok ( t ( 32 ) , "Positive integer number" ) ;
assert . ok ( t ( "040" ) , "Octal integer literal string" ) ;
assert . ok ( t ( "0xFF" ) , "Hexadecimal integer literal string" ) ;
assert . ok ( t ( 0xFFF ) , "Hexadecimal integer literal" ) ;
assert . ok ( t ( "-1.6" ) , "Negative floating point string" ) ;
assert . ok ( t ( "4.536" ) , "Positive floating point string" ) ;
assert . ok ( t ( - 2.6 ) , "Negative floating point number" ) ;
assert . ok ( t ( 3.1415 ) , "Positive floating point number" ) ;
assert . ok ( t ( 1.5999999999999999 ) , "Very precise floating point number" ) ;
assert . ok ( t ( 8e5 ) , "Exponential notation" ) ;
assert . ok ( t ( "123e-2" ) , "Exponential notation string" ) ;
2015-12-09 15:41:41 +00:00
assert . ok ( t ( new ToString ( "42" ) ) , "Custom .toString returning number" ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( t ( "" ) , false , "Empty string" ) ;
assert . equal ( t ( " " ) , false , "Whitespace characters string" ) ;
assert . equal ( t ( "\t\t" ) , false , "Tab characters string" ) ;
assert . equal ( t ( "abcdefghijklm1234567890" ) , false , "Alphanumeric character string" ) ;
assert . equal ( t ( "xabcdefx" ) , false , "Non-numeric character string" ) ;
assert . equal ( t ( true ) , false , "Boolean true literal" ) ;
assert . equal ( t ( false ) , false , "Boolean false literal" ) ;
assert . equal ( t ( "bcfed5.2" ) , false , "Number with preceding non-numeric characters" ) ;
assert . equal ( t ( "7.2acdgs" ) , false , "Number with trailling non-numeric characters" ) ;
assert . equal ( t ( undefined ) , false , "Undefined value" ) ;
assert . equal ( t ( null ) , false , "Null value" ) ;
assert . equal ( t ( NaN ) , false , "NaN value" ) ;
assert . equal ( t ( Infinity ) , false , "Infinity primitive" ) ;
assert . equal ( t ( Number . POSITIVE _INFINITY ) , false , "Positive Infinity" ) ;
assert . equal ( t ( Number . NEGATIVE _INFINITY ) , false , "Negative Infinity" ) ;
assert . equal ( t ( new ToString ( "Devo" ) ) , false , "Custom .toString returning non-number" ) ;
assert . equal ( t ( { } ) , false , "Empty object" ) ;
assert . equal ( t ( [ ] ) , false , "Empty array" ) ;
assert . equal ( t ( [ 42 ] ) , false , "Array with one number" ) ;
2015-08-16 06:59:58 +00:00
assert . equal ( t ( function ( ) { } ) , false , "Instance of a function" ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( t ( new Date ( ) ) , false , "Instance of a Date" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2011-10-12 01:04:22 +00:00
2015-10-17 20:48:57 +00:00
QUnit [ typeof Symbol === "function" ? "test" : "skip" ] ( "isNumeric(Symbol)" , function ( assert ) {
assert . expect ( 2 ) ;
assert . equal ( jQuery . isNumeric ( Symbol ( ) ) , false , "Symbol" ) ;
assert . equal ( jQuery . isNumeric ( Object ( Symbol ( ) ) ) , false , "Symbol inside an object" ) ;
} ) ;
2015-08-16 06:59:58 +00:00
QUnit . test ( "isXMLDoc - HTML" , function ( assert ) {
assert . expect ( 4 ) ;
2009-07-27 13:02:41 +00:00
2015-08-16 03:45:28 +00:00
assert . ok ( ! jQuery . isXMLDoc ( document ) , "HTML document" ) ;
assert . ok ( ! jQuery . isXMLDoc ( document . documentElement ) , "HTML documentElement" ) ;
assert . ok ( ! jQuery . isXMLDoc ( document . body ) , "HTML Body Element" ) ;
2009-07-27 13:02:41 +00:00
2013-04-09 15:45:09 +00:00
var body ,
2015-08-16 06:59:58 +00:00
iframe = document . createElement ( "iframe" ) ;
2009-07-27 13:02:41 +00:00
document . body . appendChild ( iframe ) ;
try {
2015-08-16 06:59:58 +00:00
body = jQuery ( iframe ) . contents ( ) [ 0 ] ;
2010-08-23 19:38:55 +00:00
try {
2015-08-16 03:45:28 +00:00
assert . ok ( ! jQuery . isXMLDoc ( body ) , "Iframe body element" ) ;
2015-08-16 06:59:58 +00:00
} catch ( e ) {
2015-08-16 03:45:28 +00:00
assert . ok ( false , "Iframe body element exception" ) ;
2010-08-23 19:38:55 +00:00
}
2015-08-16 06:59:58 +00:00
} catch ( e ) {
2015-08-16 03:45:28 +00:00
assert . ok ( true , "Iframe body element - iframe not working correctly" ) ;
2009-07-27 13:02:41 +00:00
}
document . body . removeChild ( iframe ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2009-07-27 13:02:41 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "XSS via location.hash" , function ( assert ) {
assert . expect ( 1 ) ;
2011-11-14 17:13:25 +00:00
2015-08-16 03:45:28 +00:00
QUnit . stop ( ) ;
2015-08-16 06:59:58 +00:00
jQuery [ "_check9521" ] = function ( x ) {
2015-08-16 03:45:28 +00:00
assert . ok ( x , "script called from #id-like selector with inline handler" ) ;
2015-08-16 06:59:58 +00:00
jQuery ( "#check9521" ) . remove ( ) ;
delete jQuery [ "_check9521" ] ;
2015-08-16 03:45:28 +00:00
QUnit . start ( ) ;
2011-08-23 12:25:11 +00:00
} ;
try {
2015-08-16 06:59:58 +00:00
2011-08-23 12:25:11 +00:00
// This throws an error because it's processed like an id
2015-08-16 06:59:58 +00:00
jQuery ( "#<img id='check9521' src='no-such-.gif' onerror='jQuery._check9521(false)'>" ) . appendTo ( "#qunit-fixture" ) ;
} catch ( err ) {
jQuery [ "_check9521" ] ( true ) ;
2012-04-15 21:41:54 +00:00
}
2015-08-16 06:59:58 +00:00
} ) ;
2011-08-23 12:25:11 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "isXMLDoc - XML" , function ( assert ) {
assert . expect ( 3 ) ;
2012-04-15 21:52:48 +00:00
var xml = createDashboardXML ( ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( jQuery . isXMLDoc ( xml ) , "XML document" ) ;
assert . ok ( jQuery . isXMLDoc ( xml . documentElement ) , "XML documentElement" ) ;
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery . isXMLDoc ( jQuery ( "tab" , xml ) [ 0 ] ) , "XML Tab Element" ) ;
} ) ;
2009-07-27 13:02:41 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "isWindow" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 14 ) ;
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery . isWindow ( window ) , "window" ) ;
assert . ok ( jQuery . isWindow ( document . getElementsByTagName ( "iframe" ) [ 0 ] . contentWindow ) , "iframe.contentWindow" ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( ! jQuery . isWindow ( ) , "empty" ) ;
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery . isWindow ( null ) , "null" ) ;
assert . ok ( ! jQuery . isWindow ( undefined ) , "undefined" ) ;
assert . ok ( ! jQuery . isWindow ( document ) , "document" ) ;
assert . ok ( ! jQuery . isWindow ( document . documentElement ) , "documentElement" ) ;
assert . ok ( ! jQuery . isWindow ( "" ) , "string" ) ;
assert . ok ( ! jQuery . isWindow ( 1 ) , "number" ) ;
assert . ok ( ! jQuery . isWindow ( true ) , "boolean" ) ;
assert . ok ( ! jQuery . isWindow ( { } ) , "object" ) ;
assert . ok ( ! jQuery . isWindow ( { setInterval : function ( ) { } } ) , "fake window" ) ;
assert . ok ( ! jQuery . isWindow ( /window/ ) , "regexp" ) ;
assert . ok ( ! jQuery . isWindow ( function ( ) { } ) , "function" ) ;
} ) ;
QUnit . test ( "jQuery('html')" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 18 ) ;
2008-12-19 05:43:37 +00:00
2013-04-09 15:45:09 +00:00
var s , div , j ;
2015-08-16 06:59:58 +00:00
jQuery [ "foo" ] = false ;
s = jQuery ( "<script>jQuery.foo='test';</script>" ) [ 0 ] ;
2015-08-16 03:45:28 +00:00
assert . ok ( s , "Creating a script" ) ;
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery [ "foo" ] , "Make sure the script wasn't executed prematurely" ) ;
jQuery ( "body" ) . append ( "<script>jQuery.foo='test';</script>" ) ;
assert . ok ( jQuery [ "foo" ] , "Executing a scripts contents in the right context" ) ;
2008-12-19 05:43:37 +00:00
2009-07-27 20:47:32 +00:00
// Test multi-line HTML
2015-08-16 06:59:58 +00:00
div = jQuery ( "<div>\r\nsome text\n<p>some p</p>\nmore text\r\n</div>" ) [ 0 ] ;
2015-08-16 03:45:28 +00:00
assert . equal ( div . nodeName . toUpperCase ( ) , "DIV" , "Make sure we're getting a div." ) ;
assert . equal ( div . firstChild . nodeType , 3 , "Text node." ) ;
assert . equal ( div . lastChild . nodeType , 3 , "Text node." ) ;
2015-08-16 06:59:58 +00:00
assert . equal ( div . childNodes [ 1 ] . nodeType , 1 , "Paragraph." ) ;
assert . equal ( div . childNodes [ 1 ] . firstChild . nodeType , 3 , "Paragraph text." ) ;
2009-07-27 20:47:32 +00:00
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery ( "<link rel='stylesheet'/>" ) [ 0 ] , "Creating a link" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery ( "<script/>" ) [ 0 ] . parentNode , "Create a script" ) ;
2009-01-03 00:51:07 +00:00
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery ( "<input/>" ) . attr ( "type" , "hidden" ) , "Create an input and set the type." ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
j = jQuery ( "<span>hi</span> there <!-- mon ami -->" ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( j . length >= 2 , "Check node,textnode,comment creation (some browsers delete comments)" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . ok ( ! jQuery ( "<option>test</option>" ) [ 0 ] . selected , "Make sure that options are auto-selected #2050" ) ;
2009-11-11 18:49:29 +00:00
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery ( "<div></div>" ) [ 0 ] , "Create a div with closing tag." ) ;
assert . ok ( jQuery ( "<table></table>" ) [ 0 ] , "Create a table with closing tag." ) ;
2011-01-19 23:37:31 +00:00
2015-08-16 03:45:28 +00:00
assert . equal ( jQuery ( "element[attribute='<div></div>']" ) . length , 0 ,
2013-09-07 00:46:55 +00:00
"When html is within brackets, do not recognize as html." ) ;
2015-08-16 06:59:58 +00:00
2013-09-07 00:46:55 +00:00
//equal( jQuery( "element[attribute=<div></div>]" ).length, 0,
// "When html is within brackets, do not recognize as html." );
2015-11-10 18:26:15 +00:00
if ( jQuery . find . compile ) {
assert . equal ( jQuery ( "element:not(<div></div>)" ) . length , 0 ,
"When html is within parens, do not recognize as html." ) ;
} else {
assert . ok ( "skip" , "Complex :not not supported in selector-native" ) ;
}
2015-08-16 03:45:28 +00:00
assert . equal ( jQuery ( "\\<div\\>" ) . length , 0 , "Ignore escaped html characters" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2012-10-10 00:06:02 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery(tag-hyphenated elements) gh-1987" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 17 ) ;
2015-01-04 22:48:35 +00:00
2015-08-16 06:59:58 +00:00
jQuery . each ( "thead tbody tfoot colgroup caption tr th td" . split ( " " ) , function ( i , name ) {
var j = jQuery ( "<" + name + "-d></" + name + "-d>" ) ;
assert . ok ( j [ 0 ] , "Create a tag-hyphenated elements" ) ;
assert . ok ( jQuery . nodeName ( j [ 0 ] , name . toUpperCase ( ) + "-D" ) , "Tag-hyphenated element has expected node name" ) ;
} ) ;
2015-01-04 22:48:35 +00:00
2015-08-16 06:59:58 +00:00
var j = jQuery ( "<tr-multiple-hyphens></tr-multiple-hyphens>" ) ;
assert . ok ( jQuery . nodeName ( j [ 0 ] , "TR-MULTIPLE-HYPHENS" ) , "Element with multiple hyphens in its tag has expected node name" ) ;
} ) ;
2015-01-04 22:48:35 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery('massive html #7990')" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 3 ) ;
2012-06-19 15:35:45 +00:00
2013-04-09 15:45:09 +00:00
var i ,
li = "<li>very very very very large html string</li>" ,
2015-08-16 06:59:58 +00:00
html = [ "<ul>" ] ;
2013-04-09 15:45:09 +00:00
2012-10-10 00:06:02 +00:00
for ( i = 0 ; i < 30000 ; i += 1 ) {
2015-08-16 06:59:58 +00:00
html [ html . length ] = li ;
2011-01-19 23:37:31 +00:00
}
2015-08-16 06:59:58 +00:00
html [ html . length ] = "</ul>" ;
html = jQuery ( html . join ( "" ) ) [ 0 ] ;
assert . equal ( html . nodeName . toLowerCase ( ) , "ul" ) ;
assert . equal ( html . firstChild . nodeName . toLowerCase ( ) , "li" ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( html . childNodes . length , 30000 ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery('html', context)" , function ( assert ) {
assert . expect ( 1 ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
var $div = jQuery ( "<div/>" ) [ 0 ] ,
$span = jQuery ( "<span/>" , $div ) ;
assert . equal ( $span . length , 1 , "verify a span created with a div context works, #1763" ) ;
} ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery(selector, xml).text(str) - loaded via xml document" , function ( assert ) {
assert . expect ( 2 ) ;
2012-04-15 21:41:54 +00:00
2013-04-09 15:45:09 +00:00
var xml = createDashboardXML ( ) ,
2015-08-16 06:59:58 +00:00
2013-04-09 15:45:09 +00:00
// tests for #1419 where ie was a problem
2015-08-16 06:59:58 +00:00
tab = jQuery ( "tab" , xml ) . eq ( 0 ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( tab . text ( ) , "blabla" , "verify initial text correct" ) ;
2015-08-16 06:59:58 +00:00
tab . text ( "newtext" ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( tab . text ( ) , "newtext" , "verify new text correct" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "end()" , function ( assert ) {
assert . expect ( 3 ) ;
assert . equal ( "Yahoo" , jQuery ( "#yahoo" ) . parent ( ) . end ( ) . text ( ) , "check for end" ) ;
assert . ok ( jQuery ( "#yahoo" ) . end ( ) , "check for end with nothing to end" ) ;
2009-12-10 17:25:25 +00:00
2015-08-16 06:59:58 +00:00
var x = jQuery ( "#yahoo" ) ;
2009-12-10 17:25:25 +00:00
x . parent ( ) ;
2015-08-16 06:59:58 +00:00
assert . equal ( "Yahoo" , jQuery ( "#yahoo" ) . text ( ) , "check for non-destructive behaviour" ) ;
} ) ;
QUnit . test ( "length" , function ( assert ) {
assert . expect ( 1 ) ;
assert . equal ( jQuery ( "#qunit-fixture p" ) . length , 6 , "Get Number of Elements Found" ) ;
} ) ;
QUnit . test ( "get()" , function ( assert ) {
assert . expect ( 1 ) ;
assert . deepEqual ( jQuery ( "#qunit-fixture p" ) . get ( ) , q ( "firstp" , "ap" , "sndp" , "en" , "sap" , "first" ) , "Get All Elements" ) ;
} ) ;
QUnit . test ( "toArray()" , function ( assert ) {
assert . expect ( 1 ) ;
assert . deepEqual ( jQuery ( "#qunit-fixture p" ) . toArray ( ) ,
q ( "firstp" , "ap" , "sndp" , "en" , "sap" , "first" ) ,
2012-06-21 19:30:24 +00:00
"Convert jQuery object to an Array" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2009-07-16 07:31:32 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "inArray()" , function ( assert ) {
assert . expect ( 19 ) ;
2011-05-28 16:00:28 +00:00
var selections = {
2015-08-16 06:59:58 +00:00
p : q ( "firstp" , "sap" , "ap" , "first" ) ,
em : q ( "siblingnext" , "siblingfirst" ) ,
div : q ( "qunit-testrunner-toolbar" , "nothiddendiv" , "nothiddendivchild" , "foo" ) ,
a : q ( "mark" , "groups" , "google" , "simon1" ) ,
2011-05-28 16:00:28 +00:00
empty : [ ]
} ,
tests = {
2015-08-16 06:59:58 +00:00
p : { elem : jQuery ( "#ap" ) [ 0 ] , index : 2 } ,
em : { elem : jQuery ( "#siblingfirst" ) [ 0 ] , index : 1 } ,
div : { elem : jQuery ( "#nothiddendiv" ) [ 0 ] , index : 1 } ,
a : { elem : jQuery ( "#simon1" ) [ 0 ] , index : 3 }
2011-05-28 16:00:28 +00:00
} ,
falseTests = {
2015-08-16 06:59:58 +00:00
p : jQuery ( "#liveSpan1" ) [ 0 ] ,
em : jQuery ( "#nothiddendiv" ) [ 0 ] ,
2011-05-28 16:00:28 +00:00
empty : ""
} ;
jQuery . each ( tests , function ( key , obj ) {
2015-08-16 03:45:28 +00:00
assert . equal ( jQuery . inArray ( obj . elem , selections [ key ] ) , obj . index , "elem is in the array of selections of its tag" ) ;
2015-08-16 06:59:58 +00:00
2011-05-28 16:00:28 +00:00
// Third argument (fromIndex)
2015-08-16 03:45:28 +00:00
assert . equal ( ! ! ~ jQuery . inArray ( obj . elem , selections [ key ] , 5 ) , false , "elem is NOT in the array of selections given a starting index greater than its position" ) ;
assert . equal ( ! ! ~ jQuery . inArray ( obj . elem , selections [ key ] , 1 ) , true , "elem is in the array of selections given a starting index less than or equal to its position" ) ;
assert . equal ( ! ! ~ jQuery . inArray ( obj . elem , selections [ key ] , - 3 ) , true , "elem is in the array of selections given a negative index" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2011-05-28 16:00:28 +00:00
jQuery . each ( falseTests , function ( key , elem ) {
2015-08-16 03:45:28 +00:00
assert . equal ( ! ! ~ jQuery . inArray ( elem , selections [ key ] ) , false , "elem is NOT in the array of selections" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2011-05-28 16:00:28 +00:00
2015-08-16 06:59:58 +00:00
} ) ;
2011-05-28 16:00:28 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "get(Number)" , function ( assert ) {
assert . expect ( 2 ) ;
assert . equal ( jQuery ( "#qunit-fixture p" ) . get ( 0 ) , document . getElementById ( "firstp" ) , "Get A Single Element" ) ;
assert . strictEqual ( jQuery ( "#firstp" ) . get ( 1 ) , undefined , "Try get with index larger elements count" ) ;
} ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "get(-Number)" , function ( assert ) {
assert . expect ( 2 ) ;
assert . equal ( jQuery ( "p" ) . get ( - 1 ) , document . getElementById ( "first" ) , "Get a single element with negative index" ) ;
assert . strictEqual ( jQuery ( "#firstp" ) . get ( - 2 ) , undefined , "Try get with index negative index larger then elements count" ) ;
} ) ;
2009-07-16 07:31:41 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "each(Function)" , function ( assert ) {
assert . expect ( 1 ) ;
2013-04-09 15:45:09 +00:00
var div , pass , i ;
2015-08-16 06:59:58 +00:00
div = jQuery ( "div" ) ;
div . each ( function ( ) { this . foo = "zoo" ; } ) ;
2013-04-09 15:45:09 +00:00
pass = true ;
for ( i = 0 ; i < div . length ; i ++ ) {
2015-08-16 06:59:58 +00:00
if ( div . get ( i ) . foo !== "zoo" ) {
2012-06-21 19:30:24 +00:00
pass = false ;
}
2008-12-19 05:43:37 +00:00
}
2015-08-16 03:45:28 +00:00
assert . ok ( pass , "Execute a function, Relative" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "slice()" , function ( assert ) {
assert . expect ( 7 ) ;
2009-12-10 17:25:25 +00:00
2015-08-16 06:59:58 +00:00
var $links = jQuery ( "#ap a" ) ;
2009-07-16 07:32:17 +00:00
2015-08-16 06:59:58 +00:00
assert . deepEqual ( $links . slice ( 1 , 2 ) . get ( ) , q ( "groups" ) , "slice(1,2)" ) ;
assert . deepEqual ( $links . slice ( 1 ) . get ( ) , q ( "groups" , "anchor1" , "mark" ) , "slice(1)" ) ;
assert . deepEqual ( $links . slice ( 0 , 3 ) . get ( ) , q ( "google" , "groups" , "anchor1" ) , "slice(0,3)" ) ;
assert . deepEqual ( $links . slice ( - 1 ) . get ( ) , q ( "mark" ) , "slice(-1)" ) ;
2009-12-10 17:25:25 +00:00
2015-08-16 06:59:58 +00:00
assert . deepEqual ( $links . eq ( 1 ) . get ( ) , q ( "groups" ) , "eq(1)" ) ;
assert . deepEqual ( $links . eq ( "2" ) . get ( ) , q ( "anchor1" ) , "eq('2')" ) ;
assert . deepEqual ( $links . eq ( - 1 ) . get ( ) , q ( "mark" ) , "eq(-1)" ) ;
} ) ;
2009-07-16 07:32:17 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "first()/last()" , function ( assert ) {
assert . expect ( 4 ) ;
2009-12-10 17:25:25 +00:00
2015-08-16 06:59:58 +00:00
var $links = jQuery ( "#ap a" ) , $none = jQuery ( "asdf" ) ;
2009-12-10 17:25:25 +00:00
2015-08-16 06:59:58 +00:00
assert . deepEqual ( $links . first ( ) . get ( ) , q ( "google" ) , "first()" ) ;
assert . deepEqual ( $links . last ( ) . get ( ) , q ( "mark" ) , "last()" ) ;
2009-12-10 17:25:25 +00:00
2015-08-16 03:45:28 +00:00
assert . deepEqual ( $none . first ( ) . get ( ) , [ ] , "first() none" ) ;
assert . deepEqual ( $none . last ( ) . get ( ) , [ ] , "last() none" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2009-12-10 17:25:25 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "map()" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 2 ) ;
2009-12-10 17:25:25 +00:00
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2015-08-16 06:59:58 +00:00
jQuery ( "#ap" ) . map ( function ( ) {
return jQuery ( this ) . find ( "a" ) . get ( ) ;
} ) . get ( ) ,
2012-12-10 18:52:02 +00:00
q ( "google" , "groups" , "anchor1" , "mark" ) ,
2009-12-10 17:25:25 +00:00
"Array Map"
) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2015-08-16 06:59:58 +00:00
jQuery ( "#ap > a" ) . map ( function ( ) {
2009-12-10 17:25:25 +00:00
return this . parentNode ;
2015-08-16 06:59:58 +00:00
} ) . get ( ) ,
q ( "ap" , "ap" , "ap" ) ,
2009-12-10 17:25:25 +00:00
"Single Map"
) ;
2015-08-16 06:59:58 +00:00
} ) ;
2012-12-10 18:52:02 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.map" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 25 ) ;
2009-12-10 17:25:25 +00:00
2012-12-10 18:52:02 +00:00
var i , label , result , callback ;
result = jQuery . map ( [ 3 , 4 , 5 ] , function ( v , k ) {
2009-12-10 17:25:25 +00:00
return k ;
2015-08-16 06:59:58 +00:00
} ) ;
assert . equal ( result . join ( "" ) , "012" , "Map the keys from an array" ) ;
2009-12-10 17:25:25 +00:00
2013-04-09 15:45:09 +00:00
result = jQuery . map ( [ 3 , 4 , 5 ] , function ( v ) {
2009-12-10 17:25:25 +00:00
return v ;
2015-08-16 06:59:58 +00:00
} ) ;
assert . equal ( result . join ( "" ) , "345" , "Map the values from an array" ) ;
2012-12-10 18:52:02 +00:00
result = jQuery . map ( { a : 1 , b : 2 } , function ( v , k ) {
return k ;
2015-08-16 06:59:58 +00:00
} ) ;
assert . equal ( result . join ( "" ) , "ab" , "Map the keys from an object" ) ;
2009-12-10 17:25:25 +00:00
2013-04-09 15:45:09 +00:00
result = jQuery . map ( { a : 1 , b : 2 } , function ( v ) {
2011-03-21 19:12:31 +00:00
return v ;
2015-08-16 06:59:58 +00:00
} ) ;
assert . equal ( result . join ( "" ) , "12" , "Map the values from an object" ) ;
2009-12-10 17:25:25 +00:00
2013-04-09 15:45:09 +00:00
result = jQuery . map ( [ "a" , undefined , null , "b" ] , function ( v ) {
2009-12-10 17:25:25 +00:00
return v ;
2015-08-16 06:59:58 +00:00
} ) ;
assert . equal ( result . join ( "" ) , "ab" , "Array iteration does not include undefined/null results" ) ;
2009-12-10 17:25:25 +00:00
2013-04-09 15:45:09 +00:00
result = jQuery . map ( { a : "a" , b : undefined , c : null , d : "b" } , function ( v ) {
2011-05-02 17:25:53 +00:00
return v ;
2015-08-16 06:59:58 +00:00
} ) ;
assert . equal ( result . join ( "" ) , "ab" , "Object iteration does not include undefined/null results" ) ;
2012-12-10 18:52:02 +00:00
result = {
Zero : function ( ) { } ,
2013-04-09 15:45:09 +00:00
One : function ( a ) { a = a ; } ,
Two : function ( a , b ) { a = a ; b = b ; }
2012-12-10 18:52:02 +00:00
} ;
callback = function ( v , k ) {
2015-08-16 03:45:28 +00:00
assert . equal ( k , "foo" , label + "-argument function treated like object" ) ;
2012-12-10 18:52:02 +00:00
} ;
for ( i in result ) {
label = i ;
result [ i ] . foo = "bar" ;
jQuery . map ( result [ i ] , callback ) ;
}
result = {
"undefined" : undefined ,
"null" : null ,
"false" : false ,
"true" : true ,
"empty string" : "" ,
"nonempty string" : "string" ,
"string \"0\"" : "0" ,
"negative" : - 1 ,
"excess" : 1
} ;
callback = function ( v , k ) {
2015-08-16 03:45:28 +00:00
assert . equal ( k , "length" , "Object with " + label + " length treated like object" ) ;
2012-12-10 18:52:02 +00:00
} ;
for ( i in result ) {
label = i ;
jQuery . map ( { length : result [ i ] } , callback ) ;
}
result = {
"sparse Array" : Array ( 4 ) ,
"length: 1 plain object" : { length : 1 , "0" : true } ,
"length: 2 plain object" : { length : 2 , "0" : true , "1" : true } ,
2015-08-16 06:59:58 +00:00
NodeList : document . getElementsByTagName ( "html" )
2012-12-10 18:52:02 +00:00
} ;
callback = function ( v , k ) {
if ( result [ label ] ) {
delete result [ label ] ;
2015-08-16 03:45:28 +00:00
assert . equal ( k , "0" , label + " treated like array" ) ;
2012-12-10 18:52:02 +00:00
}
} ;
for ( i in result ) {
label = i ;
jQuery . map ( result [ i ] , callback ) ;
}
result = false ;
2013-04-09 15:45:09 +00:00
jQuery . map ( { length : 0 } , function ( ) {
2012-12-10 18:52:02 +00:00
result = true ;
2015-08-16 06:59:58 +00:00
} ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( ! result , "length: 0 plain object treated like array" ) ;
2012-12-10 18:52:02 +00:00
result = false ;
2015-08-16 06:59:58 +00:00
jQuery . map ( document . getElementsByTagName ( "asdf" ) , function ( ) {
2012-12-10 18:52:02 +00:00
result = true ;
2015-08-16 06:59:58 +00:00
} ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( ! result , "empty NodeList treated like array" ) ;
2011-05-02 17:25:53 +00:00
2015-08-16 06:59:58 +00:00
result = jQuery . map ( Array ( 4 ) , function ( v , k ) {
2015-11-13 13:02:32 +00:00
return k % 2 ? k : [ k , k , k ] ;
2015-08-16 06:59:58 +00:00
} ) ;
assert . equal ( result . join ( "" ) , "00012223" , "Array results flattened (#2616)" ) ;
} ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.merge()" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 10 ) ;
2009-05-02 19:22:55 +00:00
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2013-09-03 05:24:01 +00:00
jQuery . merge ( [ ] , [ ] ) ,
[ ] ,
"Empty arrays"
) ;
2009-05-02 19:22:55 +00:00
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2013-09-03 05:24:01 +00:00
jQuery . merge ( [ 1 ] , [ 2 ] ) ,
[ 1 , 2 ] ,
"Basic (single-element)"
) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2013-09-03 05:24:01 +00:00
jQuery . merge ( [ 1 , 2 ] , [ 3 , 4 ] ) ,
[ 1 , 2 , 3 , 4 ] ,
"Basic (multiple-element)"
) ;
2009-05-02 19:22:55 +00:00
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2013-09-03 05:24:01 +00:00
jQuery . merge ( [ 1 , 2 ] , [ ] ) ,
[ 1 , 2 ] ,
"Second empty"
) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2013-09-03 05:24:01 +00:00
jQuery . merge ( [ ] , [ 1 , 2 ] ) ,
[ 1 , 2 ] ,
"First empty"
) ;
2009-05-02 19:22:55 +00:00
2008-12-25 19:25:30 +00:00
// Fixed at [5998], #3641
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2013-09-03 05:24:01 +00:00
jQuery . merge ( [ - 2 , - 1 ] , [ 0 , 1 , 2 ] ) ,
2015-08-16 06:59:58 +00:00
[ - 2 , - 1 , 0 , 1 , 2 ] ,
2013-09-03 05:24:01 +00:00
"Second array including a zero (falsy)"
) ;
2011-01-05 21:41:23 +00:00
2009-11-18 02:26:42 +00:00
// After fixing #5527
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2013-09-03 05:24:01 +00:00
jQuery . merge ( [ ] , [ null , undefined ] ) ,
[ null , undefined ] ,
"Second array including null and undefined values"
) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2013-09-03 05:24:01 +00:00
jQuery . merge ( { length : 0 } , [ 1 , 2 ] ) ,
{ length : 2 , 0 : 1 , 1 : 2 } ,
"First array like"
) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2013-09-03 05:24:01 +00:00
jQuery . merge ( [ 1 , 2 ] , { length : 1 , 0 : 3 } ) ,
[ 1 , 2 , 3 ] ,
"Second array like"
) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2015-08-16 06:59:58 +00:00
jQuery . merge ( [ ] , document . getElementById ( "lengthtest" ) . getElementsByTagName ( "input" ) ) ,
[ document . getElementById ( "length" ) , document . getElementById ( "idTest" ) ] ,
2013-09-03 05:24:01 +00:00
"Second NodeList"
) ;
2015-08-16 06:59:58 +00:00
} ) ;
2008-12-25 19:25:30 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.grep()" , function ( assert ) {
assert . expect ( 8 ) ;
2013-09-12 16:18:36 +00:00
var searchCriterion = function ( value ) {
return value % 2 === 0 ;
} ;
2015-08-16 03:45:28 +00:00
assert . deepEqual ( jQuery . grep ( [ ] , searchCriterion ) , [ ] , "Empty array" ) ;
2015-08-16 06:59:58 +00:00
assert . deepEqual ( jQuery . grep ( new Array ( 4 ) , searchCriterion ) , [ ] , "Sparse array" ) ;
2013-09-12 16:18:36 +00:00
2015-09-20 23:05:50 +00:00
assert . deepEqual (
jQuery . grep ( [ 1 , 2 , 3 , 4 , 5 , 6 ] , searchCriterion ) ,
[ 2 , 4 , 6 ] ,
"Satisfying elements present"
) ;
assert . deepEqual (
jQuery . grep ( [ 1 , 3 , 5 , 7 ] , searchCriterion ) ,
[ ] ,
"Satisfying elements absent"
) ;
2013-09-12 16:18:36 +00:00
2015-09-20 23:05:50 +00:00
assert . deepEqual (
jQuery . grep ( [ 1 , 2 , 3 , 4 , 5 , 6 ] , searchCriterion , true ) ,
[ 1 , 3 , 5 ] ,
"Satisfying elements present and grep inverted"
) ;
assert . deepEqual (
jQuery . grep ( [ 1 , 3 , 5 , 7 ] , searchCriterion , true ) ,
[ 1 , 3 , 5 , 7 ] ,
"Satisfying elements absent and grep inverted"
) ;
2013-09-12 16:18:36 +00:00
2015-09-20 23:05:50 +00:00
assert . deepEqual (
jQuery . grep ( [ 1 , 2 , 3 , 4 , 5 , 6 ] , searchCriterion , false ) ,
[ 2 , 4 , 6 ] ,
"Satisfying elements present but grep explicitly uninverted"
) ;
assert . deepEqual (
jQuery . grep ( [ 1 , 3 , 5 , 7 ] , searchCriterion , false ) ,
[ ] ,
"Satisfying elements absent and grep explicitly uninverted"
) ;
2015-08-16 06:59:58 +00:00
} ) ;
2013-09-12 16:18:36 +00:00
2015-09-20 23:05:50 +00:00
QUnit . test ( "jQuery.grep(Array-like)" , function ( assert ) {
assert . expect ( 7 ) ;
var searchCriterion = function ( value ) {
return value % 2 === 0 ;
} ;
assert . deepEqual ( jQuery . grep ( { length : 0 } , searchCriterion ) , [ ] , "Empty array-like" ) ;
assert . deepEqual (
jQuery . grep ( { 0 : 1 , 1 : 2 , 2 : 3 , 3 : 4 , 4 : 5 , 5 : 6 , length : 6 } , searchCriterion ) ,
[ 2 , 4 , 6 ] ,
"Satisfying elements present and array-like object used"
) ;
assert . deepEqual (
jQuery . grep ( { 0 : 1 , 1 : 3 , 2 : 5 , 3 : 7 , length : 4 } , searchCriterion ) ,
[ ] ,
"Satisfying elements absent and Array-like object used"
) ;
assert . deepEqual (
jQuery . grep ( { 0 : 1 , 1 : 2 , 2 : 3 , 3 : 4 , 4 : 5 , 5 : 6 , length : 6 } , searchCriterion , true ) ,
[ 1 , 3 , 5 ] ,
"Satisfying elements present, array-like object used, and grep inverted"
) ;
assert . deepEqual (
jQuery . grep ( { 0 : 1 , 1 : 3 , 2 : 5 , 3 : 7 , length : 4 } , searchCriterion , true ) ,
[ 1 , 3 , 5 , 7 ] ,
"Satisfying elements absent, array-like object used, and grep inverted"
) ;
assert . deepEqual (
jQuery . grep ( { 0 : 1 , 1 : 2 , 2 : 3 , 3 : 4 , 4 : 5 , 5 : 6 , length : 6 } , searchCriterion , false ) ,
[ 2 , 4 , 6 ] ,
"Satisfying elements present, Array-like object used, but grep explicitly uninverted"
) ;
assert . deepEqual (
jQuery . grep ( { 0 : 1 , 1 : 3 , 2 : 5 , 3 : 7 , length : 4 } , searchCriterion , false ) ,
[ ] ,
"Satisfying elements absent, Array-like object used, and grep explicitly uninverted"
) ;
2015-11-13 13:02:32 +00:00
} ) ;
2015-09-20 23:05:50 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.extend(Object, Object)" , function ( assert ) {
assert . expect ( 28 ) ;
2008-12-19 05:43:37 +00:00
2013-04-09 15:45:09 +00:00
var empty , optionsWithLength , optionsWithDate , myKlass ,
customObject , optionsWithCustomObject , MyNumber , ret ,
nullUndef , target , recursive , obj ,
defaults , defaultsCopy , options1 , options1Copy , options2 , options2Copy , merged2 ,
settings = { "xnumber1" : 5 , "xnumber2" : 7 , "xstring1" : "peter" , "xstring2" : "pan" } ,
2012-07-05 19:52:13 +00:00
options = { "xnumber2" : 1 , "xstring2" : "x" , "xxx" : "newstring" } ,
optionsCopy = { "xnumber2" : 1 , "xstring2" : "x" , "xxx" : "newstring" } ,
merged = { "xnumber1" : 5 , "xnumber2" : 1 , "xstring1" : "peter" , "xstring2" : "x" , "xxx" : "newstring" } ,
deep1 = { "foo" : { "bar" : true } } ,
deep2 = { "foo" : { "baz" : true } , "foo2" : document } ,
deep2copy = { "foo" : { "baz" : true } , "foo2" : document } ,
deepmerged = { "foo" : { "bar" : true , "baz" : true } , "foo2" : document } ,
2015-08-16 06:59:58 +00:00
arr = [ 1 , 2 , 3 ] ,
2012-07-05 19:52:13 +00:00
nestedarray = { "arr" : arr } ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
jQuery . extend ( settings , options ) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual ( settings , merged , "Check if extended: settings must be extended" ) ;
assert . deepEqual ( options , optionsCopy , "Check if not modified: options must not be modified" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
jQuery . extend ( settings , null , options ) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual ( settings , merged , "Check if extended: settings must be extended" ) ;
assert . deepEqual ( options , optionsCopy , "Check if not modified: options must not be modified" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
jQuery . extend ( true , deep1 , deep2 ) ;
assert . deepEqual ( deep1 [ "foo" ] , deepmerged [ "foo" ] , "Check if foo: settings must be extended" ) ;
assert . deepEqual ( deep2 [ "foo" ] , deep2copy [ "foo" ] , "Check if not deep2: options must not be modified" ) ;
assert . equal ( deep1 [ "foo2" ] , document , "Make sure that a deep clone was not attempted on the document" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery . extend ( true , { } , nestedarray ) [ "arr" ] !== arr , "Deep extend of object must clone child array" ) ;
2011-01-05 21:41:23 +00:00
2010-02-04 21:54:53 +00:00
// #5991
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery . isArray ( jQuery . extend ( true , { "arr" : { } } , nestedarray ) [ "arr" ] ) , "Cloned array have to be an Array" ) ;
assert . ok ( jQuery . isPlainObject ( jQuery . extend ( true , { "arr" : arr } , { "arr" : { } } ) [ "arr" ] ) , "Cloned object have to be an plain object" ) ;
2010-01-04 21:25:14 +00:00
2013-04-09 15:45:09 +00:00
empty = { } ;
optionsWithLength = { "foo" : { "length" : - 1 } } ;
2015-08-16 06:59:58 +00:00
jQuery . extend ( true , empty , optionsWithLength ) ;
assert . deepEqual ( empty [ "foo" ] , optionsWithLength [ "foo" ] , "The length property must copy correctly" ) ;
2009-07-16 07:31:55 +00:00
2009-07-16 07:32:03 +00:00
empty = { } ;
2013-04-09 15:45:09 +00:00
optionsWithDate = { "foo" : { "date" : new Date ( ) } } ;
2015-08-16 06:59:58 +00:00
jQuery . extend ( true , empty , optionsWithDate ) ;
assert . deepEqual ( empty [ "foo" ] , optionsWithDate [ "foo" ] , "Dates copy correctly" ) ;
2009-07-16 07:32:03 +00:00
2012-07-05 19:52:13 +00:00
/** @constructor */
2013-04-09 15:45:09 +00:00
myKlass = function ( ) { } ;
customObject = new myKlass ( ) ;
optionsWithCustomObject = { "foo" : { "date" : customObject } } ;
2009-11-12 04:50:40 +00:00
empty = { } ;
2015-08-16 06:59:58 +00:00
jQuery . extend ( true , empty , optionsWithCustomObject ) ;
assert . ok ( empty [ "foo" ] && empty [ "foo" ] [ "date" ] === customObject , "Custom objects copy correctly (no methods)" ) ;
2011-01-05 21:41:23 +00:00
2009-11-09 10:55:25 +00:00
// Makes the class a little more realistic
2015-08-16 06:59:58 +00:00
myKlass . prototype = { "someMethod" : function ( ) { } } ;
2009-07-16 07:32:03 +00:00
empty = { } ;
2015-08-16 06:59:58 +00:00
jQuery . extend ( true , empty , optionsWithCustomObject ) ;
assert . ok ( empty [ "foo" ] && empty [ "foo" ] [ "date" ] === customObject , "Custom objects copy correctly" ) ;
2011-01-05 21:41:23 +00:00
2013-04-09 15:45:09 +00:00
MyNumber = Number ;
2015-08-16 06:59:58 +00:00
ret = jQuery . extend ( true , { "foo" : 4 } , { "foo" : new MyNumber ( 5 ) } ) ;
assert . ok ( parseInt ( ret . foo , 10 ) === 5 , "Wrapped numbers copy correctly" ) ;
2009-07-16 07:32:03 +00:00
2013-04-09 15:45:09 +00:00
nullUndef ;
2015-08-16 06:59:58 +00:00
nullUndef = jQuery . extend ( { } , options , { "xnumber2" : null } ) ;
assert . ok ( nullUndef [ "xnumber2" ] === null , "Check to make sure null values are copied" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
nullUndef = jQuery . extend ( { } , options , { "xnumber2" : undefined } ) ;
assert . ok ( nullUndef [ "xnumber2" ] === options [ "xnumber2" ] , "Check to make sure undefined values are not copied" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
nullUndef = jQuery . extend ( { } , options , { "xnumber0" : null } ) ;
assert . ok ( nullUndef [ "xnumber0" ] === null , "Check to make sure null values are inserted" ) ;
2008-12-19 05:43:37 +00:00
2013-04-09 15:45:09 +00:00
target = { } ;
recursive = { foo : target , bar : 5 } ;
2015-08-16 06:59:58 +00:00
jQuery . extend ( true , target , recursive ) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual ( target , { bar : 5 } , "Check to make sure a recursive obj doesn't go never-ending loop by not copying it over" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
ret = jQuery . extend ( true , { foo : [ ] } , { foo : [ 0 ] } ) ; // 1907
2015-08-16 03:45:28 +00:00
assert . equal ( ret . foo . length , 1 , "Check to make sure a value with coercion 'false' copies over when necessary to fix #1907" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
ret = jQuery . extend ( true , { foo : "1,2,3" } , { foo : [ 1 , 2 , 3 ] } ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( typeof ret . foo !== "string" , "Check to make sure values equal with coercion (but not actually equal) overwrite correctly" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
ret = jQuery . extend ( true , { foo : "bar" } , { foo : null } ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( typeof ret . foo !== "undefined" , "Make sure a null value doesn't crash with deep extend, for #1908" ) ;
2008-12-19 05:43:37 +00:00
2013-04-09 15:45:09 +00:00
obj = { foo : null } ;
2015-08-16 06:59:58 +00:00
jQuery . extend ( true , obj , { foo : "notnull" } ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( obj . foo , "notnull" , "Make sure a null value can be overwritten" ) ;
2008-12-19 05:43:37 +00:00
function func ( ) { }
2015-08-16 06:59:58 +00:00
jQuery . extend ( func , { key : "value" } ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( func . key , "value" , "Verify a function can be extended" ) ;
2008-12-19 05:43:37 +00:00
2013-04-09 15:45:09 +00:00
defaults = { xnumber1 : 5 , xnumber2 : 7 , xstring1 : "peter" , xstring2 : "pan" } ;
defaultsCopy = { xnumber1 : 5 , xnumber2 : 7 , xstring1 : "peter" , xstring2 : "pan" } ;
options1 = { xnumber2 : 1 , xstring2 : "x" } ;
options1Copy = { xnumber2 : 1 , xstring2 : "x" } ;
options2 = { xstring2 : "xx" , xxx : "newstringx" } ;
options2Copy = { xstring2 : "xx" , xxx : "newstringx" } ;
merged2 = { xnumber1 : 5 , xnumber2 : 1 , xstring1 : "peter" , xstring2 : "xx" , xxx : "newstringx" } ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
settings = jQuery . extend ( { } , defaults , options1 , options2 ) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual ( settings , merged2 , "Check if extended: settings must be extended" ) ;
assert . deepEqual ( defaults , defaultsCopy , "Check if not modified: options1 must not be modified" ) ;
assert . deepEqual ( options1 , options1Copy , "Check if not modified: options1 must not be modified" ) ;
assert . deepEqual ( options2 , options2Copy , "Check if not modified: options2 must not be modified" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2008-12-19 05:43:37 +00:00
2015-09-25 19:02:53 +00:00
QUnit . test ( "jQuery.extend(Object, Object {created with \"defineProperties\"})" , function ( assert ) {
assert . expect ( 2 ) ;
2015-11-13 13:02:32 +00:00
var definedObj = Object . defineProperties ( { } , {
2015-09-25 19:02:53 +00:00
"enumerableProp" : {
2015-11-13 13:02:32 +00:00
get : function ( ) {
2015-09-25 19:02:53 +00:00
return true ;
} ,
enumerable : true
} ,
"nonenumerableProp" : {
2015-11-13 13:02:32 +00:00
get : function ( ) {
2015-09-25 19:02:53 +00:00
return true ;
}
}
2015-11-13 13:02:32 +00:00
} ) ,
2015-09-25 19:02:53 +00:00
accessorObj = { } ;
jQuery . extend ( accessorObj , definedObj ) ;
assert . equal ( accessorObj . enumerableProp , true , "Verify that getters are transferred" ) ;
assert . equal ( accessorObj . nonenumerableProp , undefined , "Verify that non-enumerable getters are ignored" ) ;
} ) ;
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.extend(true,{},{a:[], o:{}}); deep copy with array, followed by object" , function ( assert ) {
assert . expect ( 2 ) ;
2013-02-03 17:51:54 +00:00
var result , initial = {
2015-08-16 06:59:58 +00:00
2013-02-03 17:51:54 +00:00
// This will make "copyIsArray" true
array : [ 1 , 2 , 3 , 4 ] ,
2015-08-16 06:59:58 +00:00
2013-02-03 17:51:54 +00:00
// If "copyIsArray" doesn't get reset to false, the check
// will evaluate true and enter the array copy block
// instead of the object copy block. Since the ternary in the
// "copyIsArray" block will will evaluate to false
// (check if operating on an array with ), this will be
// replaced by an empty array.
object : { }
} ;
result = jQuery . extend ( true , { } , initial ) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual ( result , initial , "The [result] and [initial] have equal shape and values" ) ;
assert . ok ( ! jQuery . isArray ( result . object ) , "result.object wasn't paved with an empty array" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2013-02-03 17:51:54 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.each(Object,Function)" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 23 ) ;
2012-12-10 18:52:02 +00:00
var i , label , seen , callback ;
2008-12-19 05:43:37 +00:00
2012-12-10 18:52:02 +00:00
seen = { } ;
jQuery . each ( [ 3 , 4 , 5 ] , function ( k , v ) {
seen [ k ] = v ;
2015-08-16 06:59:58 +00:00
} ) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual ( seen , { "0" : 3 , "1" : 4 , "2" : 5 } , "Array iteration" ) ;
2008-12-19 05:43:37 +00:00
2012-12-10 18:52:02 +00:00
seen = { } ;
jQuery . each ( { name : "name" , lang : "lang" } , function ( k , v ) {
seen [ k ] = v ;
2015-08-16 06:59:58 +00:00
} ) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual ( seen , { name : "name" , lang : "lang" } , "Object iteration" ) ;
2008-12-19 05:43:37 +00:00
2012-12-10 18:52:02 +00:00
seen = [ ] ;
jQuery . each ( [ 1 , 2 , 3 ] , function ( k , v ) {
seen . push ( v ) ;
if ( k === 1 ) {
2012-06-21 19:30:24 +00:00
return false ;
}
2015-08-16 06:59:58 +00:00
} ) ;
assert . deepEqual ( seen , [ 1 , 2 ] , "Broken array iteration" ) ;
2012-12-10 18:52:02 +00:00
seen = [ ] ;
2015-11-13 13:02:32 +00:00
jQuery . each ( { "a" : 1 , "b" : 2 , "c" : 3 } , function ( k , v ) {
2012-12-10 18:52:02 +00:00
seen . push ( v ) ;
return false ;
2015-08-16 06:59:58 +00:00
} ) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual ( seen , [ 1 ] , "Broken object iteration" ) ;
2012-12-10 18:52:02 +00:00
seen = {
Zero : function ( ) { } ,
2013-04-09 15:45:09 +00:00
One : function ( a ) { a = a ; } ,
Two : function ( a , b ) { a = a ; b = b ; }
2012-12-10 18:52:02 +00:00
} ;
2013-04-09 15:45:09 +00:00
callback = function ( k ) {
2015-08-16 03:45:28 +00:00
assert . equal ( k , "foo" , label + "-argument function treated like object" ) ;
2012-12-10 18:52:02 +00:00
} ;
for ( i in seen ) {
label = i ;
seen [ i ] . foo = "bar" ;
jQuery . each ( seen [ i ] , callback ) ;
}
seen = {
"undefined" : undefined ,
"null" : null ,
"false" : false ,
"true" : true ,
"empty string" : "" ,
"nonempty string" : "string" ,
"string \"0\"" : "0" ,
"negative" : - 1 ,
"excess" : 1
} ;
2013-04-09 15:45:09 +00:00
callback = function ( k ) {
2015-08-16 03:45:28 +00:00
assert . equal ( k , "length" , "Object with " + label + " length treated like object" ) ;
2012-12-10 18:52:02 +00:00
} ;
for ( i in seen ) {
label = i ;
jQuery . each ( { length : seen [ i ] } , callback ) ;
}
seen = {
"sparse Array" : Array ( 4 ) ,
"length: 1 plain object" : { length : 1 , "0" : true } ,
"length: 2 plain object" : { length : 2 , "0" : true , "1" : true } ,
2015-08-16 06:59:58 +00:00
NodeList : document . getElementsByTagName ( "html" )
2012-12-10 18:52:02 +00:00
} ;
2013-04-09 15:45:09 +00:00
callback = function ( k ) {
2012-12-10 18:52:02 +00:00
if ( seen [ label ] ) {
delete seen [ label ] ;
2015-08-16 03:45:28 +00:00
assert . equal ( k , "0" , label + " treated like array" ) ;
2012-12-10 18:52:02 +00:00
return false ;
}
} ;
for ( i in seen ) {
label = i ;
jQuery . each ( seen [ i ] , callback ) ;
}
seen = false ;
2013-04-09 15:45:09 +00:00
jQuery . each ( { length : 0 } , function ( ) {
2012-12-10 18:52:02 +00:00
seen = true ;
2015-08-16 06:59:58 +00:00
} ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( ! seen , "length: 0 plain object treated like array" ) ;
2011-07-23 01:26:36 +00:00
2012-12-10 18:52:02 +00:00
seen = false ;
2015-08-16 06:59:58 +00:00
jQuery . each ( document . getElementsByTagName ( "asdf" ) , function ( ) {
2012-12-10 18:52:02 +00:00
seen = true ;
2015-08-16 06:59:58 +00:00
} ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( ! seen , "empty NodeList treated like array" ) ;
2011-03-30 17:17:48 +00:00
2012-12-10 18:52:02 +00:00
i = 0 ;
jQuery . each ( document . styleSheets , function ( ) {
i ++ ;
2015-08-16 06:59:58 +00:00
} ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( i , document . styleSheets . length , "Iteration over document.styleSheets" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.each/map(undefined/null,Function)" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 1 ) ;
2015-07-29 15:10:04 +00:00
2015-06-25 04:18:04 +00:00
try {
jQuery . each ( undefined , jQuery . noop ) ;
jQuery . each ( null , jQuery . noop ) ;
jQuery . map ( undefined , jQuery . noop ) ;
jQuery . map ( null , jQuery . noop ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( true , "jQuery.each/map( undefined/null, function() {} );" ) ;
2015-06-25 04:18:04 +00:00
} catch ( e ) {
2015-08-16 03:45:28 +00:00
assert . ok ( false , "each/map must accept null and undefined values" ) ;
2015-06-25 04:18:04 +00:00
}
2015-08-16 06:59:58 +00:00
} ) ;
2015-06-25 04:18:04 +00:00
2015-08-16 03:45:28 +00:00
QUnit . test ( "JIT compilation does not interfere with length retrieval (gh-2145)" , function ( assert ) {
assert . expect ( 4 ) ;
2015-04-04 19:34:07 +00:00
var i ;
// Trigger JIT compilation of jQuery.each – and therefore isArraylike – in iOS.
// Convince JSC to use one of its optimizing compilers
// by providing code which can be LICM'd into nothing.
for ( i = 0 ; i < 1000 ; i ++ ) {
jQuery . each ( [ ] ) ;
}
i = 0 ;
jQuery . each ( { 1 : "1" , 2 : "2" , 3 : "3" } , function ( index ) {
2015-08-16 03:45:28 +00:00
assert . equal ( ++ i , index , "Iteration over object with solely " +
2015-04-04 19:34:07 +00:00
"numeric indices (gh-2145 JIT iOS 8 bug)" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( i , 3 , "Iteration over object with solely " +
2015-04-04 19:34:07 +00:00
"numeric indices (gh-2145 JIT iOS 8 bug)" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2015-04-04 19:34:07 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.makeArray" , function ( assert ) {
assert . expect ( 15 ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . makeArray ( jQuery ( "html>*" ) ) [ 0 ] . nodeName . toUpperCase ( ) , "HEAD" , "Pass makeArray a jQuery object" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . makeArray ( document . getElementsByName ( "PWD" ) ) . slice ( 0 , 1 ) [ 0 ] . name , "PWD" , "Pass makeArray a nodelist" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( ( function ( ) { return jQuery . makeArray ( arguments ) ; } ) ( 1 , 2 ) . join ( "" ) , "12" , "Pass makeArray an arguments array" ) ;
2008-12-19 05:43:37 +00:00
2015-11-13 13:02:32 +00:00
assert . equal ( jQuery . makeArray ( [ 1 , 2 , 3 ] ) . join ( "" ) , "123" , "Pass makeArray a real array" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 03:45:28 +00:00
assert . equal ( jQuery . makeArray ( ) . length , 0 , "Pass nothing to makeArray and expect an empty array" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . makeArray ( 0 ) [ 0 ] , 0 , "Pass makeArray a number" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . makeArray ( "foo" ) [ 0 ] , "foo" , "Pass makeArray a string" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . makeArray ( true ) [ 0 ] . constructor , Boolean , "Pass makeArray a boolean" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . makeArray ( document . createElement ( "div" ) ) [ 0 ] . nodeName . toUpperCase ( ) , "DIV" , "Pass makeArray a single node" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . makeArray ( { length : 2 , 0 : "a" , 1 : "b" } ) . join ( "" ) , "ab" , "Pass makeArray an array like map (with length)" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . ok ( ! ! jQuery . makeArray ( document . documentElement . childNodes ) . slice ( 0 , 1 ) [ 0 ] . nodeName , "Pass makeArray a childNodes array" ) ;
2008-12-19 05:43:37 +00:00
// function, is tricky as it has length
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . makeArray ( function ( ) { return 1 ; } ) [ 0 ] ( ) , 1 , "Pass makeArray a function" ) ;
2009-05-02 19:22:55 +00:00
2008-12-19 05:43:37 +00:00
//window, also has length
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . makeArray ( window ) [ 0 ] , window , "Pass makeArray the window" ) ;
2008-12-19 05:43:37 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . makeArray ( /a/ ) [ 0 ] . constructor , RegExp , "Pass makeArray a regex" ) ;
2008-12-19 05:43:37 +00:00
2012-12-11 01:19:26 +00:00
// Some nodes inherit traits of nodelists
2015-08-16 06:59:58 +00:00
assert . ok ( jQuery . makeArray ( document . getElementById ( "form" ) ) . length >= 13 ,
2012-12-11 01:19:26 +00:00
"Pass makeArray a form (treat as elements)" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2009-07-16 15:16:44 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.inArray" , function ( assert ) {
assert . expect ( 3 ) ;
2011-08-17 14:56:21 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . inArray ( 0 , false ) , - 1 , "Search in 'false' as array returns -1 and doesn't throw exception" ) ;
2011-08-17 14:56:21 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . inArray ( 0 , null ) , - 1 , "Search in 'null' as array returns -1 and doesn't throw exception" ) ;
2011-08-17 14:56:21 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( jQuery . inArray ( 0 , undefined ) , - 1 , "Search in 'undefined' as array returns -1 and doesn't throw exception" ) ;
} ) ;
2011-08-17 14:56:21 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.isEmptyObject" , function ( assert ) {
assert . expect ( 2 ) ;
2011-01-05 21:41:23 +00:00
2015-08-16 06:59:58 +00:00
assert . equal ( true , jQuery . isEmptyObject ( { } ) , "isEmptyObject on empty object literal" ) ;
assert . equal ( false , jQuery . isEmptyObject ( { a : 1 } ) , "isEmptyObject on non-empty object literal" ) ;
2011-01-05 21:41:23 +00:00
2010-12-09 18:07:44 +00:00
// What about this ?
2011-11-06 20:27:42 +00:00
// equal(true, jQuery.isEmptyObject(null), "isEmptyObject on null" );
2015-08-16 06:59:58 +00:00
} ) ;
2009-12-31 20:17:52 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.proxy" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 9 ) ;
2009-12-31 20:17:52 +00:00
2013-04-09 15:45:09 +00:00
var test2 , test3 , test4 , fn , cb ,
2015-09-08 00:26:29 +00:00
test = function ( ) {
assert . equal ( this , thisObject , "Make sure that scope is set properly." ) ;
} ,
2013-04-09 15:45:09 +00:00
thisObject = { foo : "bar" , method : test } ;
2009-12-31 20:17:52 +00:00
// Make sure normal works
test . call ( thisObject ) ;
// Basic scoping
jQuery . proxy ( test , thisObject ) ( ) ;
2011-04-17 21:11:40 +00:00
// Another take on it
jQuery . proxy ( thisObject , "method" ) ( ) ;
2009-12-31 20:17:52 +00:00
// Make sure it doesn't freak out
2015-08-16 03:45:28 +00:00
assert . equal ( jQuery . proxy ( null , thisObject ) , undefined , "Make sure no function was returned." ) ;
2009-12-31 20:17:52 +00:00
2012-05-18 17:28:50 +00:00
// Partial application
2015-09-08 00:26:29 +00:00
test2 = function ( a ) {
assert . equal ( a , "pre-applied" , "Ensure arguments can be pre-applied." ) ;
} ;
2012-05-18 17:28:50 +00:00
jQuery . proxy ( test2 , null , "pre-applied" ) ( ) ;
2010-12-15 02:53:04 +00:00
2012-05-18 17:28:50 +00:00
// Partial application w/ normal arguments
2015-09-08 00:26:29 +00:00
test3 = function ( a , b ) {
assert . equal ( b , "normal" , "Ensure arguments can be pre-applied and passed as usual." ) ;
} ;
2012-05-18 17:28:50 +00:00
jQuery . proxy ( test3 , null , "pre-applied" ) ( "normal" ) ;
2011-01-21 15:33:50 +00:00
// Test old syntax
2015-09-08 00:26:29 +00:00
test4 = { "meth" : function ( a ) {
assert . equal ( a , "boom" , "Ensure old syntax works." ) ;
} } ;
2011-01-21 15:33:50 +00:00
jQuery . proxy ( test4 , "meth" ) ( "boom" ) ;
2012-12-10 18:52:02 +00:00
2012-07-19 15:54:14 +00:00
// jQuery 1.9 improved currying with `this` object
2013-04-09 15:45:09 +00:00
fn = function ( ) {
2015-08-16 03:45:28 +00:00
assert . equal ( Array . prototype . join . call ( arguments , "," ) , "arg1,arg2,arg3" , "args passed" ) ;
assert . equal ( this . foo , "bar" , "this-object passed" ) ;
2012-07-19 15:54:14 +00:00
} ;
2013-04-09 15:45:09 +00:00
cb = jQuery . proxy ( fn , null , "arg1" , "arg2" ) ;
2012-07-19 15:54:14 +00:00
cb . call ( thisObject , "arg3" ) ;
2015-08-16 06:59:58 +00:00
} ) ;
2010-01-23 22:08:26 +00:00
2015-11-13 13:21:08 +00:00
QUnit . test ( "jQuery.parseHTML" , function ( assert ) {
assert . expect ( 18 ) ;
2012-12-11 21:12:23 +00:00
var html , nodes ;
2012-06-21 19:28:57 +00:00
2015-11-13 13:21:08 +00:00
assert . equal ( jQuery . parseHTML ( ) , null , "Nothing in, null out." ) ;
assert . equal ( jQuery . parseHTML ( null ) , null , "Null in, null out." ) ;
assert . equal ( jQuery . parseHTML ( "" ) , null , "Empty string in, null out." ) ;
2015-11-13 13:39:32 +00:00
assert . throws ( function ( ) {
2015-11-13 13:21:08 +00:00
jQuery . parseHTML ( "<div></div>" , document . getElementById ( "form" ) ) ;
} , "Passing an element as the context raises an exception (context should be a document)" ) ;
nodes = jQuery . parseHTML ( jQuery ( "body" ) [ 0 ] . innerHTML ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( nodes . length > 4 , "Parse a large html string" ) ;
assert . equal ( jQuery . type ( nodes ) , "array" , "parseHTML returns an array rather than a nodelist" ) ;
2012-06-21 19:28:57 +00:00
2012-12-11 21:12:23 +00:00
html = "<script>undefined()</script>" ;
2015-08-16 03:45:28 +00:00
assert . equal ( jQuery . parseHTML ( html ) . length , 0 , "Ignore scripts by default" ) ;
2015-11-13 13:21:08 +00:00
assert . equal ( jQuery . parseHTML ( html , true ) [ 0 ] . nodeName . toLowerCase ( ) , "script" , "Preserve scripts when requested" ) ;
2012-06-21 19:28:57 +00:00
2012-12-11 21:12:23 +00:00
html += "<div></div>" ;
2015-11-13 13:21:08 +00:00
assert . equal ( jQuery . parseHTML ( html ) [ 0 ] . nodeName . toLowerCase ( ) , "div" , "Preserve non-script nodes" ) ;
assert . equal ( jQuery . parseHTML ( html , true ) [ 0 ] . nodeName . toLowerCase ( ) , "script" , "Preserve script position" ) ;
2012-06-21 19:28:57 +00:00
2015-11-13 13:21:08 +00:00
assert . equal ( jQuery . parseHTML ( "text" ) [ 0 ] . nodeType , 3 , "Parsing text returns a text node" ) ;
assert . equal ( jQuery . parseHTML ( "\t<div></div>" ) [ 0 ] . nodeValue , "\t" , "Preserve leading whitespace" ) ;
2012-06-20 15:19:24 +00:00
2015-11-13 13:21:08 +00:00
assert . equal ( jQuery . parseHTML ( " <div/> " ) [ 0 ] . nodeType , 3 , "Leading spaces are treated as text nodes (#11290)" ) ;
2013-01-07 14:38:21 +00:00
html = jQuery . parseHTML ( "<div>test div</div>" ) ;
2015-08-16 03:45:28 +00:00
assert . equal ( html [ 0 ] . parentNode . nodeType , 11 , "parentNode should be documentFragment" ) ;
assert . equal ( html [ 0 ] . innerHTML , "test div" , "Content should be preserved" ) ;
2013-01-07 14:38:21 +00:00
2015-11-13 13:21:08 +00:00
assert . equal ( jQuery . parseHTML ( "<span><span>" ) . length , 1 , "Incorrect html-strings should not break anything" ) ;
assert . equal ( jQuery . parseHTML ( "<td><td>" ) [ 1 ] . parentNode . nodeType , 11 ,
2013-01-07 19:21:42 +00:00
"parentNode should be documentFragment for wrapMap (variable in manipulation module) elements too" ) ;
2015-11-13 13:21:08 +00:00
assert . ok ( jQuery . parseHTML ( "<#if><tr><p>This is a test.</p></tr><#/if>" ) || true , "Garbage input should not cause error" ) ;
} ) ;
2012-06-21 19:28:57 +00:00
2016-01-06 22:00:50 +00:00
if ( jQuery . support . createHTMLDocument && ! /opera.*version\/12\.1/i . test ( navigator . userAgent ) ) {
2015-08-16 06:59:58 +00:00
QUnit . asyncTest ( "jQuery.parseHTML" , function ( assert ) {
2015-09-08 00:28:56 +00:00
assert . expect ( 1 ) ;
2014-12-10 14:48:55 +00:00
2015-08-16 06:59:58 +00:00
Globals . register ( "parseHTMLError" ) ;
2014-12-10 14:48:55 +00:00
2015-08-16 06:59:58 +00:00
jQuery . globalEval ( "parseHTMLError = false;" ) ;
2014-12-10 14:48:55 +00:00
jQuery . parseHTML ( "<img src=x onerror='parseHTMLError = true'>" ) ;
2015-08-16 06:59:58 +00:00
window . setTimeout ( function ( ) {
2015-08-16 03:45:28 +00:00
QUnit . start ( ) ;
assert . equal ( window . parseHTMLError , false , "onerror eventhandler has not been called." ) ;
2015-08-16 06:59:58 +00:00
} , 2000 ) ;
} ) ;
2014-12-10 14:48:55 +00:00
}
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.parseJSON" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 20 ) ;
2013-11-05 04:36:15 +00:00
2015-08-16 03:45:28 +00:00
assert . strictEqual ( jQuery . parseJSON ( null ) , null , "primitive null" ) ;
2015-08-16 06:59:58 +00:00
assert . strictEqual ( jQuery . parseJSON ( "0.88" ) , 0.88 , "Number" ) ;
2015-08-16 03:45:28 +00:00
assert . strictEqual (
2015-08-16 06:59:58 +00:00
jQuery . parseJSON ( "\" \\\" \\\\ \\/ \\b \\f \\n \\r \\t \\u007E \\u263a \"" ) ,
2013-11-05 04:36:15 +00:00
" \" \\ / \b \f \n \r \t ~ \u263A " ,
"String escapes"
) ;
2015-08-16 06:59:58 +00:00
assert . deepEqual ( jQuery . parseJSON ( "{}" ) , { } , "Empty object" ) ;
assert . deepEqual ( jQuery . parseJSON ( "{\"test\":1}" ) , { "test" : 1 } , "Plain object" ) ;
assert . deepEqual ( jQuery . parseJSON ( "[0]" ) , [ 0 ] , "Simple array" ) ;
2013-11-05 04:36:15 +00:00
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2015-08-16 06:59:58 +00:00
jQuery . parseJSON ( "[ \"string\", -4.2, 2.7180e0, 3.14E-1, {}, [], true, false, null ]" ) ,
2013-11-05 04:36:15 +00:00
[ "string" , - 4.2 , 2.718 , 0.314 , { } , [ ] , true , false , null ] ,
"Array of all data types"
) ;
2015-08-16 03:45:28 +00:00
assert . deepEqual (
2013-11-05 04:36:15 +00:00
jQuery . parseJSON ( "{ \"string\": \"\", \"number\": 4.2e+1, \"object\": {}," +
2015-08-16 06:59:58 +00:00
"\"array\": [[]], \"boolean\": [ true, false ], \"null\": null }" ) ,
{ string : "" , number : 42 , object : { } , array : [ [ ] ] , "boolean" : [ true , false ] , "null" : null } ,
2013-11-05 04:36:15 +00:00
"Dictionary of all data types"
) ;
2015-08-16 06:59:58 +00:00
assert . deepEqual ( jQuery . parseJSON ( "\n{\"test\":1}\t" ) , { "test" : 1 } ,
2013-11-05 04:36:15 +00:00
"Leading and trailing whitespace are ignored" ) ;
2011-01-05 21:41:23 +00:00
2015-08-16 06:59:58 +00:00
assert . throws ( function ( ) {
2012-10-16 18:51:54 +00:00
jQuery . parseJSON ( ) ;
2012-10-20 01:59:33 +00:00
} , null , "Undefined raises an error" ) ;
2015-08-16 06:59:58 +00:00
assert . throws ( function ( ) {
2012-10-16 18:51:54 +00:00
jQuery . parseJSON ( "" ) ;
2012-10-20 01:59:33 +00:00
} , null , "Empty string raises an error" ) ;
2015-08-16 06:59:58 +00:00
assert . throws ( function ( ) {
jQuery . parseJSON ( "''" ) ;
2012-10-20 01:59:33 +00:00
} , null , "Single-quoted string raises an error" ) ;
2013-11-05 04:36:15 +00:00
/ *
// Broken on IE8
2015-08-16 03:45:28 +00:00
assert . throws ( function ( ) {
2013-11-05 04:36:15 +00:00
jQuery . parseJSON ( "\" \\a \"" ) ;
} , null , "Invalid string escape raises an error" ) ;
// Broken on IE8, Safari 5.1 Windows
2015-08-16 03:45:28 +00:00
assert . throws ( function ( ) {
2013-11-05 04:36:15 +00:00
jQuery . parseJSON ( "\"\t\"" ) ;
} , null , "Unescaped control character raises an error" ) ;
// Broken on IE8
2015-08-16 03:45:28 +00:00
assert . throws ( function ( ) {
2013-11-05 04:36:15 +00:00
jQuery . parseJSON ( ".123" ) ;
} , null , "Number with no integer component raises an error" ) ;
* /
2015-08-16 06:59:58 +00:00
assert . throws ( function ( ) {
var result = jQuery . parseJSON ( "0101" ) ;
2013-11-05 04:36:15 +00:00
// Support: IE9+
// Ensure base-10 interpretation on browsers that erroneously accept leading-zero numbers
if ( result === 101 ) {
2015-08-16 06:59:58 +00:00
throw new Error ( "close enough" ) ;
2013-11-05 04:36:15 +00:00
}
} , null , "Leading-zero number raises an error or is parsed as decimal" ) ;
2015-08-16 06:59:58 +00:00
assert . throws ( function ( ) {
jQuery . parseJSON ( "{a:1}" ) ;
2012-10-20 01:59:33 +00:00
} , null , "Unquoted property raises an error" ) ;
2015-08-16 06:59:58 +00:00
assert . throws ( function ( ) {
jQuery . parseJSON ( "{'a':1}" ) ;
2012-10-20 01:59:33 +00:00
} , null , "Single-quoted property raises an error" ) ;
2015-08-16 06:59:58 +00:00
assert . throws ( function ( ) {
jQuery . parseJSON ( "[,]" ) ;
2013-11-05 04:36:15 +00:00
} , null , "Array element elision raises an error" ) ;
2015-08-16 06:59:58 +00:00
assert . throws ( function ( ) {
jQuery . parseJSON ( "{},[]" ) ;
2013-11-05 04:36:15 +00:00
} , null , "Comma expression raises an error" ) ;
2015-08-16 06:59:58 +00:00
assert . throws ( function ( ) {
jQuery . parseJSON ( "[]\n,{}" ) ;
2013-11-05 04:36:15 +00:00
} , null , "Newline-containing comma expression raises an error" ) ;
2015-08-16 06:59:58 +00:00
assert . throws ( function ( ) {
jQuery . parseJSON ( "\"\"\n\"\"" ) ;
2013-11-05 04:36:15 +00:00
} , null , "Automatic semicolon insertion raises an error" ) ;
2015-08-16 06:59:58 +00:00
assert . strictEqual ( jQuery . parseJSON ( [ 0 ] ) , 0 , "Input cast to string" ) ;
} ) ;
2010-12-20 18:09:15 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.parseXML" , function ( assert ) {
2015-08-16 03:45:28 +00:00
assert . expect ( 8 ) ;
2015-07-29 15:10:04 +00:00
2011-07-23 01:26:36 +00:00
var xml , tmp ;
try {
xml = jQuery . parseXML ( "<p>A <b>well-formed</b> xml string</p>" ) ;
tmp = xml . getElementsByTagName ( "p" ) [ 0 ] ;
2015-08-16 03:45:28 +00:00
assert . ok ( ! ! tmp , "<p> present in document" ) ;
2011-07-23 01:26:36 +00:00
tmp = tmp . getElementsByTagName ( "b" ) [ 0 ] ;
2015-08-16 03:45:28 +00:00
assert . ok ( ! ! tmp , "<b> present in document" ) ;
assert . strictEqual ( tmp . childNodes [ 0 ] . nodeValue , "well-formed" , "<b> text is as expected" ) ;
2015-08-16 06:59:58 +00:00
} catch ( e ) {
2015-08-16 03:45:28 +00:00
assert . strictEqual ( e , undefined , "unexpected error" ) ;
2011-07-23 01:26:36 +00:00
}
try {
xml = jQuery . parseXML ( "<p>Not a <<b>well-formed</b> xml string</p>" ) ;
2015-08-16 03:45:28 +00:00
assert . ok ( false , "invalid xml not detected" ) ;
2015-08-16 06:59:58 +00:00
} catch ( e ) {
2015-08-16 03:45:28 +00:00
assert . strictEqual ( e . message , "Invalid XML: <p>Not a <<b>well-formed</b> xml string</p>" , "invalid xml detected" ) ;
2011-07-23 01:26:36 +00:00
}
2012-03-07 16:37:14 +00:00
try {
xml = jQuery . parseXML ( "" ) ;
2015-08-16 03:45:28 +00:00
assert . strictEqual ( xml , null , "empty string => null document" ) ;
2012-03-07 16:37:14 +00:00
xml = jQuery . parseXML ( ) ;
2015-08-16 03:45:28 +00:00
assert . strictEqual ( xml , null , "undefined string => null document" ) ;
2012-03-07 16:37:14 +00:00
xml = jQuery . parseXML ( null ) ;
2015-08-16 03:45:28 +00:00
assert . strictEqual ( xml , null , "null string => null document" ) ;
2012-03-07 16:37:14 +00:00
xml = jQuery . parseXML ( true ) ;
2015-08-16 03:45:28 +00:00
assert . strictEqual ( xml , null , "non-string => null document" ) ;
2015-08-16 06:59:58 +00:00
} catch ( e ) {
2015-08-16 03:45:28 +00:00
assert . ok ( false , "empty input throws exception" ) ;
2012-03-07 16:37:14 +00:00
}
2015-08-16 06:59:58 +00:00
} ) ;
2011-07-23 01:26:36 +00:00
2015-08-16 06:59:58 +00:00
QUnit . test ( "jQuery.camelCase()" , function ( assert ) {
2011-05-25 19:10:49 +00:00
var tests = {
2011-07-23 01:26:36 +00:00
"foo-bar" : "fooBar" ,
2011-08-17 21:30:31 +00:00
"foo-bar-baz" : "fooBarBaz" ,
"girl-u-want" : "girlUWant" ,
2015-11-13 12:18:49 +00:00
"the-4th-dimension" : "the4thDimension" ,
2011-08-17 21:30:31 +00:00
"-o-tannenbaum" : "OTannenbaum" ,
"-moz-illa" : "MozIlla" ,
"-ms-take" : "msTake"
2011-05-25 19:10:49 +00:00
} ;
2015-08-16 06:59:58 +00:00
assert . expect ( 7 ) ;
2011-05-25 19:10:49 +00:00
jQuery . each ( tests , function ( key , val ) {
2015-08-16 03:45:28 +00:00
assert . equal ( jQuery . camelCase ( key ) , val , "Converts: " + key + " => " + val ) ;
2015-08-16 06:59:58 +00:00
} ) ;
} ) ;
2013-08-15 18:15:49 +00:00
2015-08-16 03:45:28 +00:00
testIframeWithCallback (
"Conditional compilation compatibility (#13274)" ,
"core/cc_on.html" ,
function ( cc _on , errors , $ , assert ) {
assert . expect ( 3 ) ;
assert . ok ( true , "JScript conditional compilation " + ( cc _on ? "supported" : "not supported" ) ) ;
assert . deepEqual ( errors , [ ] , "No errors" ) ;
assert . ok ( $ ( ) , "jQuery executes" ) ;
}
) ;
2013-08-15 18:15:49 +00:00
2014-03-17 17:13:00 +00:00
// iOS7 doesn't fire the load event if the long-loading iframe gets its source reset to about:blank.
// This makes this test fail but it doesn't seem to cause any real-life problems so blacklisting
// this test there is preferred to complicating the hard-to-test core/ready code further.
if ( ! /iphone os 7_/i . test ( navigator . userAgent ) ) {
2015-08-16 03:45:28 +00:00
testIframeWithCallback (
"document ready when jQuery loaded asynchronously (#13655)" ,
"core/dynamic_ready.html" ,
function ( ready , assert ) {
assert . expect ( 1 ) ;
assert . equal ( true , ready , "document ready correctly fired when jQuery is loaded after DOMContentLoaded" ) ;
}
) ;
2014-03-17 17:13:00 +00:00
}
2013-09-18 13:41:07 +00:00
2015-08-16 03:45:28 +00:00
testIframeWithCallback (
"Tolerating alias-masked DOM properties (#14074)" ,
"core/aliased.html" ,
function ( errors , assert ) {
assert . expect ( 1 ) ;
assert . deepEqual ( errors , [ ] , "jQuery loaded" ) ;
2013-09-18 13:41:07 +00:00
}
) ;
2014-03-04 03:04:23 +00:00
2015-08-16 03:45:28 +00:00
testIframeWithCallback (
"Don't call window.onready (#14802)" ,
"core/onready.html" ,
function ( error , assert ) {
assert . expect ( 1 ) ;
assert . equal ( error , false , "no call to user-defined onready" ) ;
2014-03-04 03:04:23 +00:00
}
) ;
2015-06-01 21:25:38 +00:00
2015-08-16 03:45:28 +00:00
QUnit . test ( "Iterability of jQuery objects (gh-1693)" , function ( assert ) {
2015-06-01 21:25:38 +00:00
/* jshint unused: false */
2015-08-16 03:45:28 +00:00
assert . expect ( 1 ) ;
2015-06-01 21:25:38 +00:00
var i , elem , result ;
if ( typeof Symbol === "function" ) {
elem = jQuery ( "<div></div><span></span><a></a>" ) ;
result = "" ;
try {
eval ( "for ( i of elem ) { result += i.nodeName; }" ) ;
} catch ( e ) { }
2015-08-16 03:45:28 +00:00
assert . equal ( result , "DIVSPANA" , "for-of works on jQuery objects" ) ;
2015-06-01 21:25:38 +00:00
} else {
2015-08-16 03:45:28 +00:00
assert . ok ( true , "The browser doesn't support Symbols" ) ;
2015-06-01 21:25:38 +00:00
}
} ) ;