This is the equivalent of the '===' rule ("eqeqeq") in eslint core.
Change-Id: I1e6ea8bc1e86c6629ebe938f1b4a6bd288bcfcf7
"operator-linebreak": 0,
"quote-props": [ "error", "as-needed" ],
"valid-jsdoc": 0,
+ "qunit/no-assert-equal": "error",
"qunit/no-early-return": "error",
"qunit/no-negated-ok": "error",
"qunit/require-expect": 0,
QUnit.stop();
getMwLanguage( test.lang, function ( langClass ) {
var parser = new mw.jqueryMsg.Parser( { language: langClass } );
- assert.equal(
+ assert.strictEqual(
parser.parse( test.key, test.args ).html(),
test.result,
test.name
} ) );
QUnit.test( 'Setup', function ( assert ) {
- assert.equal( mw.html.escape( 'foo' ), 'mocked', 'setup() callback was ran.' );
- assert.equal( mw.config.get( 'testVar' ), 'foo', 'config object applied' );
- assert.equal( mw.messages.get( 'testMsg' ), 'Foo.', 'messages object applied' );
+ assert.strictEqual( mw.html.escape( 'foo' ), 'mocked', 'setup() callback was ran.' );
+ assert.strictEqual( mw.config.get( 'testVar' ), 'foo', 'config object applied' );
+ assert.strictEqual( mw.messages.get( 'testMsg' ), 'Foo.', 'messages object applied' );
mw.config.set( 'testVar', 'bar' );
mw.messages.set( 'testMsg', 'Bar.' );
} );
QUnit.test( 'Teardown', function ( assert ) {
- assert.equal( mw.config.get( 'testVar' ), 'foo', 'config object restored and re-applied after test()' );
- assert.equal( mw.messages.get( 'testMsg' ), 'Foo.', 'messages object restored and re-applied after test()' );
+ assert.strictEqual( mw.config.get( 'testVar' ), 'foo', 'config object restored and re-applied after test()' );
+ assert.strictEqual( mw.messages.get( 'testMsg' ), 'Foo.', 'messages object restored and re-applied after test()' );
} );
QUnit.test( 'Loader status', function ( assert ) {
QUnit.module( 'testrunner-after', QUnit.newMwEnvironment() );
QUnit.test( 'Teardown', function ( assert ) {
- assert.equal( mw.html.escape( '<' ), '<', 'teardown() callback was ran.' );
- assert.equal( mw.config.get( 'testVar' ), null, 'config object restored to live in next module()' );
- assert.equal( mw.messages.get( 'testMsg' ), null, 'messages object restored to live in next module()' );
+ assert.strictEqual( mw.html.escape( '<' ), '<', 'teardown() callback was ran.' );
+ assert.strictEqual( mw.config.get( 'testVar' ), null, 'config object restored to live in next module()' );
+ assert.strictEqual( mw.messages.get( 'testMsg' ), null, 'messages object restored to live in next module()' );
} );
QUnit.module( 'testrunner-each', {
mw.html = null;
} );
QUnit.test( 'afterEach', function ( assert ) {
- assert.equal( mw.html.escape( '<' ), '<', 'afterEach() ran' );
+ assert.strictEqual( mw.html.escape( '<' ), '<', 'afterEach() ran' );
} );
QUnit.module( 'testrunner-each-compat', {
mw.html = null;
} );
QUnit.test( 'teardown', function ( assert ) {
- assert.equal( mw.html.escape( '<' ), '<', 'teardown() ran' );
+ assert.strictEqual( mw.html.escape( '<' ), '<', 'teardown() ran' );
} );
// Regression test for 'this.sandbox undefined' error, fixed by
QUnit.test( 'getAccessKeyPrefix', function ( assert ) {
var i;
for ( i = 0; i < getAccessKeyPrefixTestData.length; i++ ) {
- assert.equal( $.fn.updateTooltipAccessKeys.getAccessKeyPrefix( {
+ assert.strictEqual( $.fn.updateTooltipAccessKeys.getAccessKeyPrefix( {
userAgent: getAccessKeyPrefixTestData[ i ][ 0 ],
platform: getAccessKeyPrefixTestData[ i ][ 1 ]
} ), getAccessKeyPrefixTestData[ i ][ 2 ], 'Correct prefix for ' + getAccessKeyPrefixTestData[ i ][ 0 ] );
$input = $( makeInput( oldTitle ) );
$( '#qunit-fixture' ).append( $input );
newTitle = $input.updateTooltipAccessKeys().prop( 'title' );
- assert.equal( newTitle, 'Title', 'title="' + oldTitle + '"' );
+ assert.strictEqual( newTitle, 'Title', 'title="' + oldTitle + '"' );
}
} );
$input = $( makeInput( oldTitle, 'a' ) );
$( '#qunit-fixture' ).append( $input );
newTitle = $input.updateTooltipAccessKeys().prop( 'title' );
- assert.equal( newTitle, 'Title [test-a]', 'title="' + oldTitle + '"' );
+ assert.strictEqual( newTitle, 'Title [test-a]', 'title="' + oldTitle + '"' );
}
$.fn.updateTooltipAccessKeys.setTestMode( false );
} );
$label = $( '#qunit-fixture label' );
$input = $( '#qunit-fixture input' );
$input.updateTooltipAccessKeys();
- assert.equal( $input.prop( 'title' ), '', 'No title attribute added to input element.' );
- assert.equal( $label.prop( 'title' ), 'Title [test-a]', 'title updated for associated label element.' );
+ assert.strictEqual( $input.prop( 'title' ), '', 'No title attribute added to input element.' );
+ assert.strictEqual( $label.prop( 'title' ), 'Title [test-a]', 'title updated for associated label element.' );
$.fn.updateTooltipAccessKeys.setTestMode( false );
} );
$label = $( '#qunit-fixture label' );
$input = $( '#qunit-fixture input' );
$input.updateTooltipAccessKeys();
- assert.equal( $input.prop( 'title' ), '', 'No title attribute added to input element.' );
- assert.equal( $label.prop( 'title' ), 'Title [test-a]', 'title updated for associated label element.' );
+ assert.strictEqual( $input.prop( 'title' ), '', 'No title attribute added to input element.' );
+ assert.strictEqual( $label.prop( 'title' ), 'Title [test-a]', 'title updated for associated label element.' );
$.fn.updateTooltipAccessKeys.setTestMode( false );
} );
QUnit.test( 'getColorBrightness', function ( assert ) {
var a, b;
a = $.colorUtil.getColorBrightness( 'red', +0.1 );
- assert.equal( a, 'rgb(255,50,50)', 'Start with named color "red", brighten 10%' );
+ assert.strictEqual( a, 'rgb(255,50,50)', 'Start with named color "red", brighten 10%' );
b = $.colorUtil.getColorBrightness( 'rgb(200,50,50)', -0.2 );
- assert.equal( b, 'rgb(118,29,29)', 'Start with rgb string "rgb(200,50,50)", darken 20%' );
+ assert.strictEqual( b, 'rgb(118,29,29)', 'Start with rgb string "rgb(200,50,50)", darken 20%' );
} );
}( jQuery ) );
QUnit.test( 'devicePixelRatio', function ( assert ) {
var devicePixelRatio = $.devicePixelRatio();
- assert.equal( typeof devicePixelRatio, 'number', '$.devicePixelRatio() returns a number' );
+ assert.strictEqual( typeof devicePixelRatio, 'number', '$.devicePixelRatio() returns a number' );
} );
QUnit.test( 'bracketedDevicePixelRatio', function ( assert ) {
var ratio = $.bracketedDevicePixelRatio();
- assert.equal( typeof ratio, 'number', '$.bracketedDevicePixelRatio() returns a number' );
+ assert.strictEqual( typeof ratio, 'number', '$.bracketedDevicePixelRatio() returns a number' );
} );
QUnit.test( 'bracketDevicePixelRatio', function ( assert ) {
- assert.equal( $.bracketDevicePixelRatio( 0.75 ), 1, '0.75 gives 1' );
- assert.equal( $.bracketDevicePixelRatio( 1 ), 1, '1 gives 1' );
- assert.equal( $.bracketDevicePixelRatio( 1.25 ), 1.5, '1.25 gives 1.5' );
- assert.equal( $.bracketDevicePixelRatio( 1.5 ), 1.5, '1.5 gives 1.5' );
- assert.equal( $.bracketDevicePixelRatio( 1.75 ), 2, '1.75 gives 2' );
- assert.equal( $.bracketDevicePixelRatio( 2 ), 2, '2 gives 2' );
- assert.equal( $.bracketDevicePixelRatio( 2.5 ), 2, '2.5 gives 2' );
- assert.equal( $.bracketDevicePixelRatio( 3 ), 2, '3 gives 2' );
+ assert.strictEqual( $.bracketDevicePixelRatio( 0.75 ), 1, '0.75 gives 1' );
+ assert.strictEqual( $.bracketDevicePixelRatio( 1 ), 1, '1 gives 1' );
+ assert.strictEqual( $.bracketDevicePixelRatio( 1.25 ), 1.5, '1.25 gives 1.5' );
+ assert.strictEqual( $.bracketDevicePixelRatio( 1.5 ), 1.5, '1.5 gives 1.5' );
+ assert.strictEqual( $.bracketDevicePixelRatio( 1.75 ), 2, '1.75 gives 2' );
+ assert.strictEqual( $.bracketDevicePixelRatio( 2 ), 2, '2 gives 2' );
+ assert.strictEqual( $.bracketDevicePixelRatio( 2.5 ), 2, '2.5 gives 2' );
+ assert.strictEqual( $.bracketDevicePixelRatio( 3 ), 2, '3 gives 2' );
} );
QUnit.test( 'matchSrcSet', function ( assert ) {
var srcset = 'onefive.png 1.5x, two.png 2x';
// Nice exact matches
- assert.equal( $.matchSrcSet( 1, srcset ), null, '1.0 gives no match' );
- assert.equal( $.matchSrcSet( 1.5, srcset ), 'onefive.png', '1.5 gives match' );
- assert.equal( $.matchSrcSet( 2, srcset ), 'two.png', '2 gives match' );
+ assert.strictEqual( $.matchSrcSet( 1, srcset ), null, '1.0 gives no match' );
+ assert.strictEqual( $.matchSrcSet( 1.5, srcset ), 'onefive.png', '1.5 gives match' );
+ assert.strictEqual( $.matchSrcSet( 2, srcset ), 'two.png', '2 gives match' );
// Non-exact matches; should return the next-biggest specified
- assert.equal( $.matchSrcSet( 1.25, srcset ), null, '1.25 gives no match' );
- assert.equal( $.matchSrcSet( 1.75, srcset ), 'onefive.png', '1.75 gives match to 1.5' );
- assert.equal( $.matchSrcSet( 2.25, srcset ), 'two.png', '2.25 gives match to 2' );
+ assert.strictEqual( $.matchSrcSet( 1.25, srcset ), null, '1.25 gives no match' );
+ assert.strictEqual( $.matchSrcSet( 1.75, srcset ), 'onefive.png', '1.75 gives match to 1.5' );
+ assert.strictEqual( $.matchSrcSet( 2.25, srcset ), 'two.png', '2.25 gives match to 2' );
} );
}( jQuery ) );
cases.forEach( function ( item ) {
$fixture = $( '<p>' ).text( item.text ).highlightText( item.highlight );
- assert.equal(
+ assert.strictEqual(
$fixture.html(),
// Re-parse to normalize
$( '<p>' ).html( item.expected ).html(),
// Simulate pressing keys for each of the sample characters
addChars( opt.$input, opt.sample );
- assert.equal(
+ assert.strictEqual(
opt.$input.val(),
opt.expected,
'New value matches the expected string'
$content = $collapsible.find( '.mw-collapsible-content' ),
$toggle = $collapsible.find( '.mw-collapsible-toggle' );
- assert.equal( $content.length, 1, 'content is present' );
- assert.equal( $content.find( $toggle ).length, 0, 'toggle is not a descendant of content' );
+ assert.strictEqual( $content.length, 1, 'content is present' );
+ assert.strictEqual( $content.find( $toggle ).length, 0, 'toggle is not a descendant of content' );
assert.assertTrue( $content.is( ':visible' ), 'content is visible' );
$contentRow = $collapsible.find( 'tr:last' ),
$toggle = $headerRow.find( 'td:last .mw-collapsible-toggle' );
- assert.equal( $toggle.length, 1, 'toggle is added to last cell of first row' );
+ assert.strictEqual( $toggle.length, 1, 'toggle is added to last cell of first row' );
assert.assertTrue( $headerRow.is( ':visible' ), 'headerRow is visible' );
assert.assertTrue( $contentRow.is( ':visible' ), 'contentRow is visible' );
$contentRow = $collapsible.find( 'tr:last' ),
$toggle = $caption.find( '.mw-collapsible-toggle' );
- assert.equal( $toggle.length, 1, 'toggle is added to the end of the caption' );
+ assert.strictEqual( $toggle.length, 1, 'toggle is added to the end of the caption' );
assert.assertTrue( $caption.is( ':visible' ), 'caption is visible' );
assert.assertTrue( $headerRow.is( ':visible' ), 'headerRow is visible' );
$contentItem = $collapsible.find( 'li:last' ),
$toggle = $toggleItem.find( '.mw-collapsible-toggle' );
- assert.equal( $toggle.length, 1, 'toggle is present, added inside new zeroth list item' );
+ assert.strictEqual( $toggle.length, 1, 'toggle is present, added inside new zeroth list item' );
assert.assertTrue( $toggleItem.is( ':visible' ), 'toggleItem is visible' );
assert.assertTrue( $contentItem.is( ':visible' ), 'contentItem is visible' );
'<div>' + loremIpsum + '</div>'
);
- assert.equal( $collapsible.data( 'mw-made-collapsible' ), true, 'mw-made-collapsible data present' );
+ assert.strictEqual( $collapsible.data( 'mw-made-collapsible' ), true, 'mw-made-collapsible data present' );
} );
QUnit.test( 'mw-collapsible added when missing', function ( assert ) {
),
$toggleText = $collapsible.find( '.mw-collapsible-text' );
- assert.equal( $toggleText.text(), 'Collapse me!', 'data-collapsetext is respected' );
+ assert.strictEqual( $toggleText.text(), 'Collapse me!', 'data-collapsetext is respected' );
$collapsible.on( 'afterCollapse.mw-collapsible', function () {
- assert.equal( $toggleText.text(), 'Expand me!', 'data-expandtext is respected' );
+ assert.strictEqual( $toggleText.text(), 'Expand me!', 'data-expandtext is respected' );
} );
$collapsible.find( '.mw-collapsible-toggle' ).trigger( 'click' );
),
$toggleText = $collapsible.find( '.mw-collapsible-text' );
- assert.equal( $toggleText.text(), 'Collapse me!', 'options.collapseText is respected' );
+ assert.strictEqual( $toggleText.text(), 'Collapse me!', 'options.collapseText is respected' );
$collapsible.on( 'afterCollapse.mw-collapsible', function () {
- assert.equal( $toggleText.text(), 'Expand me!', 'options.expandText is respected' );
+ assert.strictEqual( $toggleText.text(), 'Expand me!', 'options.expandText is respected' );
} );
$collapsible.find( '.mw-collapsible-toggle' ).trigger( 'click' );
),
$toggleText = $collapsible.find( '.mw-collapsible-text' );
- assert.equal( $toggleText.text(), 'Toggle', 'predefined text remains' );
+ assert.strictEqual( $toggleText.text(), 'Toggle', 'predefined text remains' );
$collapsible.on( 'afterCollapse.mw-collapsible', function () {
- assert.equal( $toggleText.text(), 'Show', 'predefined text is toggled' );
+ assert.strictEqual( $toggleText.text(), 'Show', 'predefined text is toggled' );
$collapsible.on( 'afterExpand.mw-collapsible', function () {
- assert.equal( $toggleText.text(), 'Hide', 'predefined text is toggled back' );
+ assert.strictEqual( $toggleText.text(), 'Hide', 'predefined text is toggled back' );
} );
$collapsible.find( '.mw-collapsible-toggle' ).trigger( 'click' );
);
$table.data( 'tablesorter' ).sort( [] );
- assert.equal(
+ assert.strictEqual(
$table.find( 'th.headerSortUp' ).length + $table.find( 'th.headerSortDown' ).length,
0,
'No sort specific sort classes addign to header cells'
);
- assert.equal(
+ assert.strictEqual(
$table.find( 'th' ).first().attr( 'title' ),
mw.msg( 'sort-ascending' ),
'First header cell has default title'
);
- assert.equal(
+ assert.strictEqual(
$table.find( 'th' ).first().attr( 'title' ),
$table.find( 'th' ).last().attr( 'title' ),
'Both header cells\' titles match'
$cell = $table.find( 'tr:eq(0) > th:eq(0)' );
$table.find( 'tr:eq(0) > th:eq(1)' ).click();
- assert.equal(
+ assert.strictEqual(
$cell.hasClass( 'headerSortUp' ) || $cell.hasClass( 'headerSortDown' ),
false,
'after sort: no class headerSortUp or headerSortDown'
);
- assert.equal(
+ assert.strictEqual(
$cell.attr( 'title' ),
undefined,
'after sort: no title tag added'
$table.tablesorter();
- assert.equal(
+ assert.strictEqual(
$table.find( 'tr:eq(2) td:eq(1)' ).prop( 'rowSpan' ),
3,
'Rowspan not exploded'
$table.tablesorter();
$table.find( '.headerSort:eq(0)' ).click();
- assert.equal(
+ assert.strictEqual(
$table.data( 'tablesorter' ).config.parsers[ 0 ].id,
'number',
'Correctly detected column content skipping sortbottom'
);
$table.tablesorter();
- assert.equal(
+ assert.strictEqual(
$table.children().get( 0 ).nodeName,
'CAPTION',
'First element after <thead> must be <caption> (T34047)'
);
$table.tablesorter();
- assert.equal(
+ assert.strictEqual(
$table.find( '> thead:eq(0) > tr > th.headerSort' ).length,
1,
'Child tables inside a headercell should not interfere with sortable headers (T34888)'
);
- assert.equal(
+ assert.strictEqual(
$( '#mw-bug-32888-2' ).find( 'th.headerSort' ).length,
0,
'The headers of child tables inside a headercell should not be sortable themselves (T34888)'
);
$table.tablesorter().find( '.headerSort:eq(0)' ).click();
- assert.equal(
+ assert.strictEqual(
$table.find( 'td' ).first().text(),
'1',
'Applied correct sorting order'
);
$table.tablesorter().find( '.headerSort:eq(0)' ).click();
- assert.equal(
+ assert.strictEqual(
$table.find( 'td' ).text(),
'CDEFCCA',
'Applied correct sorting order'
);
$table.tablesorter().find( '.headerSort:eq(0)' ).click();
- assert.equal(
+ assert.strictEqual(
$table.find( 'td' ).text(),
'4517',
'Applied correct sorting order'
);
$table.tablesorter();
- assert.equal(
+ assert.strictEqual(
$table.find( '#A1' ).attr( 'class' ),
'headerSort',
'The first column of the first row should be sortable'
);
- assert.equal(
+ assert.strictEqual(
$table.find( '#B2b' ).attr( 'class' ),
'headerSort',
'The th element of the 2nd row of the 2nd column should be sortable'
);
- assert.equal(
+ assert.strictEqual(
$table.find( '#C2b' ).attr( 'class' ),
'headerSort',
'The th element of the 2nd row of the 3rd column should be sortable'
);
$table.tablesorter();
- assert.equal(
+ assert.strictEqual(
$table.find( '#A1' ).attr( 'class' ),
'headerSort',
'The first column of the first row should be sortable'
);
- assert.equal(
+ assert.strictEqual(
$table.find( '#B2b' ).attr( 'class' ),
'headerSort',
'The th element of the 2nd row of the 2nd column should be sortable'
'</table>'
);
$table.tablesorter();
- assert.equal( $table.find( '#A2' ).data( 'headerIndex' ),
+ assert.strictEqual( $table.find( '#A2' ).data( 'headerIndex' ),
undefined,
'A2 should not be a sort header'
);
- assert.equal( $table.find( '#C1' ).data( 'headerIndex' ),
+ assert.strictEqual( $table.find( '#C1' ).data( 'headerIndex' ),
2,
'C1 should be a sort header'
);
'</table>'
);
$table.tablesorter();
- assert.equal( $table.find( '#C2' ).data( 'headerIndex' ),
+ assert.strictEqual( $table.find( '#C2' ).data( 'headerIndex' ),
2,
'C2 should be a sort header'
);
- assert.equal( $table.find( '#C1' ).data( 'headerIndex' ),
+ assert.strictEqual( $table.find( '#C1' ).data( 'headerIndex' ),
undefined,
'C1 should not be a sort header'
);
'</tbody></table>' );
$table.tablesorter();
- assert.equal( $table.find( 'tr:eq(1) th:eq(1)' ).data( 'headerIndex' ),
+ assert.strictEqual( $table.find( 'tr:eq(1) th:eq(1)' ).data( 'headerIndex' ),
2,
'Incorrect index of sort header'
);
parsers = $table.data( 'tablesorter' ).config.parsers;
- assert.equal(
+ assert.strictEqual(
parsers.length,
2,
'detectParserForColumn() detect 2 parsers'
);
- assert.equal(
+ assert.strictEqual(
parsers[ 1 ].id,
'number',
'detectParserForColumn() detect parser.id "number" for second column'
);
- assert.equal(
+ assert.strictEqual(
parsers[ 1 ].format( $table.find( 'tbody > tr > td:eq(1)' ).text() ),
-Infinity,
'empty cell is sorted as number -Infinity'
);
parsers = $table.data( 'tablesorter' ).config.parsers;
- assert.equal(
+ assert.strictEqual(
parsers[ 1 ].id,
'number',
'detectParserForColumn() detect parser.id "number" for second column'
);
parsers = $table.data( 'tablesorter' ).config.parsers;
- assert.equal(
+ assert.strictEqual(
parsers[ 0 ].id,
'number',
'detectParserForColumn() detect parser.id "number"'
text = $textarea.textSelection( 'getContents' ).replace( /\r\n/g, '\n' );
- assert.equal( text, opt.after.text, 'Checking full text after encapsulation' );
+ assert.strictEqual( text, opt.after.text, 'Checking full text after encapsulation' );
if ( opt.after.selected !== null ) {
selected = $textarea.textSelection( 'getSelection' );
- assert.equal( selected, opt.after.selected, 'Checking selected text after encapsulation.' );
+ assert.strictEqual( selected, opt.after.selected, 'Checking selected text after encapsulation.' );
}
} );
function among( actual, expected, message ) {
if ( Array.isArray( expected ) ) {
- assert.equal( expected.indexOf( actual ) !== -1, true, message + ' (got ' + actual + '; expected one of ' + expected.join( ', ' ) + ')' );
+ assert.strictEqual( expected.indexOf( actual ) !== -1, true, message + ' (got ' + actual + '; expected one of ' + expected.join( ', ' ) + ')' );
} else {
- assert.equal( actual, expected, message );
+ assert.strictEqual( actual, expected, message );
}
}
'{"batchcomplete":true}'
] );
return new mw.Api().isCategory( '' ).then( function ( response ) {
- assert.equal( response, false );
+ assert.strictEqual( response, false );
} );
} );
'{"batchcomplete":true,"query":{"normalized":[{"fromencoded":false,"from":"#","to":""}]}}'
] );
return new mw.Api().isCategory( '#' ).then( function ( response ) {
- assert.equal( response, false );
+ assert.strictEqual( response, false );
} );
} );
'{"batchcomplete":true,"query":{"interwiki":[{"title":"mw:","iw":"mw"}]}}'
] );
return new mw.Api().isCategory( 'mw:' ).then( function ( response ) {
- assert.equal( response, false );
+ assert.strictEqual( response, false );
} );
} );
'{"batchcomplete":true,"query":{"pages":[{"title":"|","invalidreason":"The requested page title contains invalid characters: \\"|\\".","invalid":true}]}}'
] );
return new mw.Api().isCategory( '|' ).then( function ( response ) {
- assert.equal( response, false );
+ assert.strictEqual( response, false );
} );
} );
'{"batchcomplete":true}'
] );
return new mw.Api().getCategories( '' ).then( function ( response ) {
- assert.equal( response, false );
+ assert.strictEqual( response, false );
} );
} );
'{"batchcomplete":true,"query":{"normalized":[{"fromencoded":false,"from":"#","to":""}]}}'
] );
return new mw.Api().getCategories( '#' ).then( function ( response ) {
- assert.equal( response, false );
+ assert.strictEqual( response, false );
} );
} );
'{"batchcomplete":true,"query":{"interwiki":[{"title":"mw:","iw":"mw"}]}}'
] );
return new mw.Api().getCategories( 'mw:' ).then( function ( response ) {
- assert.equal( response, false );
+ assert.strictEqual( response, false );
} );
} );
'{"batchcomplete":true,"query":{"pages":[{"title":"|","invalidreason":"The requested page title contains invalid characters: \\"|\\".","invalid":true}]}}'
] );
return new mw.Api().getCategories( '|' ).then( function ( response ) {
- assert.equal( response, false );
+ assert.strictEqual( response, false );
} );
} );
return revision.content.replace( 'Sand', 'Box' );
} )
.then( function ( edit ) {
- assert.equal( edit.newrevid, 13 );
+ assert.strictEqual( edit.newrevid, 13 );
} );
} );
return revision.content.replace( 'Sand', 'Box' );
} )
.then( function ( edit ) {
- assert.equal( edit.newrevid, 13 );
+ assert.strictEqual( edit.newrevid, 13 );
} );
} );
return $.Deferred().resolve( revision.content.replace( 'Async', 'Promise' ) );
} )
.then( function ( edit ) {
- assert.equal( edit.newrevid, 23 );
+ assert.strictEqual( edit.newrevid, 23 );
} );
} );
return { text: 'Content', summary: 'Sum' };
} )
.then( function ( edit ) {
- assert.equal( edit.newrevid, 33 );
+ assert.strictEqual( edit.newrevid, 33 );
} );
} );
.then( function () {
return $.Deferred().reject( 'Unexpected success' );
}, function ( reason ) {
- assert.equal( reason, 'invalidtitle' );
+ assert.strictEqual( reason, 'invalidtitle' );
} );
} );
return new mw.Api()
.create( 'Sandbox', { summary: 'Load sand particles.' }, 'Sand.' )
.then( function ( page ) {
- assert.equal( page.newrevid, 41 );
+ assert.strictEqual( page.newrevid, 41 );
} );
} );
] );
return new mw.Api().parse( '\'\'\'Hello world\'\'\'' ).done( function ( html ) {
- assert.
equal( html, '<p><b>Hello world</b></p>', 'Parse wikitext by string' );
+ assert.
strictEqual( html, '<p><b>Hello world</b></p>', 'Parse wikitext by string' );
} );
} );
return '\'\'\'Hello world\'\'\'';
}
} ).done( function ( html ) {
- assert.
equal( html, '<p><b>Hello world</b></p>', 'Parse wikitext by toString object' );
+ assert.
strictEqual( html, '<p><b>Hello world</b></p>', 'Parse wikitext by toString object' );
} );
} );
] );
return new mw.Api().parse( new mw.Title( 'Earth' ) ).done( function ( html ) {
- assert.
equal( html, '<p><b>Earth</b> is a planet.</p>', 'Parse page by Title object' );
+ assert.
strictEqual( html, '<p><b>Earth</b> is a planet.</p>', 'Parse page by Title object' );
} );
} );
}( mediaWiki ) );
api.get( { action: 'doesntexist' } )
.fail( function ( errorCode ) {
- assert.equal( errorCode, 'unknown_action', 'API error should reject the deferred' );
+ assert.strictEqual( errorCode, 'unknown_action', 'API error should reject the deferred' );
} )
.always( assert.async() );
} );
api.get( { action: 'doesntexist' } )
.fail( function ( errorCode ) {
- assert.equal( errorCode, 'unknown_action', 'API error should reject the deferred' );
+ assert.strictEqual( errorCode, 'unknown_action', 'API error should reject the deferred' );
} )
.always( assert.async() );
} );
assert.ok( request.requestBody instanceof FormData, 'Request uses FormData body' );
} else {
assert.notOk( request.url.match( /action=test/ ), 'Request has no query string' );
- assert.equal( request.requestBody, 'action=test&format=json', 'Request uses query string body' );
+ assert.strictEqual( request.requestBody, 'action=test&format=json', 'Request uses query string body' );
}
request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
} );
var api = new mw.Api();
this.server.respond( function ( request ) {
- assert.equal( match( request.url, /test=([^&]+)/ ), 'foo%7Cbar%7Cbaz', 'Pipe-separated value was submitted' );
+ assert.strictEqual( match( request.url, /test=([^&]+)/ ), 'foo%7Cbar%7Cbaz', 'Pipe-separated value was submitted' );
request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
} );
var api = new mw.Api();
this.server.respond( function ( request ) {
- assert.equal( match( request.url, /test=([^&]+)/ ), 'Foo%7CBar', 'Pipe-separated value was submitted' );
+ assert.strictEqual( match( request.url, /test=([^&]+)/ ), 'Foo%7CBar', 'Pipe-separated value was submitted' );
request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
} );
var api = new mw.Api();
this.server.respond( function ( request ) {
- assert.equal( match( request.url, /test=([^&]+)/ ), 'true%7Cfalse%7C%7C%7C0%7C1%2E2', 'Pipe-separated value was submitted' );
+ assert.strictEqual( match( request.url, /test=([^&]+)/ ), 'true%7Cfalse%7C%7C%7C0%7C1%2E2', 'Pipe-separated value was submitted' );
request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
} );
.then( function ( token ) {
assert.ok( token.length, 'Got a token' );
}, function ( err ) {
- assert.equal( err, '', 'API error' );
+ assert.strictEqual( err, '', 'API error' );
} )
.then( function () {
- assert.equal( test.server.requests.length, 0, 'Requests made' );
+ assert.strictEqual( test.server.requests.length, 0, 'Requests made' );
} );
} );
// be added to user.tokens, use a fake one instead.
api.getToken( 'testuncached' )
.done( function ( token ) {
- assert.equal( token, 'good', 'The token' );
+ assert.strictEqual( token, 'good', 'The token' );
} )
.fail( function ( err ) {
- assert.equal( err, '', 'API error' );
+ assert.strictEqual( err, '', 'API error' );
} )
.always( firstDone );
api.getToken( 'testuncached' )
.done( function ( token ) {
- assert.equal( token, 'good', 'The cached token' );
+ assert.strictEqual( token, 'good', 'The cached token' );
} )
.fail( function ( err ) {
- assert.equal( err, '', 'API error' );
+ assert.strictEqual( err, '', 'API error' );
} )
.always( secondDone );
- assert.equal( this.server.requests.length, 1, 'Requests made' );
+ assert.strictEqual( this.server.requests.length, 1, 'Requests made' );
} );
QUnit.test( 'getToken() - error', function ( assert ) {
// Don't cache error (T67268)
return api.getToken( 'testerror' )
.catch( function ( err ) {
- assert.equal( err, 'bite-me', 'Expected error' );
+ assert.strictEqual( err, 'bite-me', 'Expected error' );
return api.getToken( 'testerror' );
} )
.then( function ( token ) {
- assert.equal( token, 'good', 'The token' );
+ assert.strictEqual( token, 'good', 'The token' );
} );
} );
return api.getToken( 'testnoquery' )
.then( function () { assert.fail( 'Expected response missing a query to be rejected' ); } )
.catch( function ( err, rsp ) {
- assert.equal( err, 'query-missing', 'Expected no query error code' );
+ assert.strictEqual( err, 'query-missing', 'Expected no query error code' );
assert.deepEqual( rsp, serverRsp );
} );
} );
// Get a token of a type that is in the legacy map.
return api.getToken( 'email' )
.done( function ( token ) {
- assert.equal( token, 'csrfgood', 'Token' );
+ assert.strictEqual( token, 'csrfgood', 'Token' );
} )
.fail( function ( err ) {
- assert.equal( err, '', 'API error' );
+ assert.strictEqual( err, '', 'API error' );
} )
.always( function () {
- assert.equal( test.server.requests.length, 1, 'Requests made' );
+ assert.strictEqual( test.server.requests.length, 1, 'Requests made' );
} );
} );
return api.getToken( 'testbad' );
} )
.then( function ( token ) {
- assert.equal( token, 'good', 'The token' );
- assert.equal( test.server.requests.length, 2, 'Requests made' );
+ assert.strictEqual( token, 'good', 'The token' );
+ assert.strictEqual( test.server.requests.length, 2, 'Requests made' );
} );
} );
return api.getToken( 'options' );
} )
.then( function ( token ) {
- assert.equal( token, 'goodlegacy', 'The token' );
- assert.equal( test.server.requests.length, 2, 'Request made' );
+ assert.strictEqual( token, 'goodlegacy', 'The token' );
+ assert.strictEqual( test.server.requests.length, 2, 'Request made' );
} );
} );
.then( function () {
return $.Deferred().reject( 'Unexpected success' );
}, function ( errorCode ) {
- assert.equal( errorCode, 'assertuserfailed', 'getToken fails assert' );
+ assert.strictEqual( errorCode, 'assertuserfailed', 'getToken fails assert' );
return $.Deferred().resolve();
} )
.then( function () {
- assert.equal( test.server.requests.length, 1, 'Requests made' );
+ assert.strictEqual( test.server.requests.length, 1, 'Requests made' );
} );
} );
}
}
).then( function () {
- assert.equal( test.server.requests[ 0 ].requestHeaders[ 'X-Foo' ], 'Bar', 'Header sent' );
+ assert.strictEqual( test.server.requests[ 0 ].requestHeaders[ 'X-Foo' ], 'Bar', 'Header sent' );
return api.postWithToken( 'csrf',
{ action: 'example' },
}
);
} ).then( function ( data ) {
- assert.equal( data.example, 'quux' );
+ assert.strictEqual( data.example, 'quux' );
- assert.equal( test.server.requests.length, 2, 'Request made' );
+ assert.strictEqual( test.server.requests.length, 2, 'Request made' );
} );
} );
b: 2
} );
this.api.abort();
- assert.equal( this.requests.length, 2, 'Check both requests triggered' );
+ assert.strictEqual( this.requests.length, 2, 'Check both requests triggered' );
this.requests.forEach( function ( request, i ) {
assert.ok( request.abort.calledOnce, 'abort request number ' + i );
} );
} );
return new mw.Api().watch( 'Foo' ).done( function ( item ) {
- assert.equal( item.title, 'Foo' );
+ assert.strictEqual( item.title, 'Foo' );
} );
} );
} );
return new mw.Api().watch( [ 'Foo' ] ).done( function ( items ) {
- assert.equal( items[ 0 ].title, 'Foo' );
+ assert.strictEqual( items[ 0 ].title, 'Foo' );
} );
} );
} );
return new mw.Api().watch( [ 'Foo', 'Bar' ] ).done( function ( items ) {
- assert.equal( items[ 0 ].title, 'Foo' );
- assert.equal( items[ 1 ].title, 'Bar' );
+ assert.strictEqual( items[ 0 ].title, 'Foo' );
+ assert.strictEqual( items[ 1 ].title, 'Bar' );
} );
} );
QUnit.test( 'getVersion', function ( assert ) {
var uriProcessor = new mw.rcfilters.UriProcessor( new mw.rcfilters.dm.FiltersViewModel() );
- assert.equal(
+ assert.strictEqual(
uriProcessor.getVersion( { param1: 'foo', urlversion: '2' } ),
2,
'Retrieving the version from the URI query'
);
- assert.equal(
+ assert.strictEqual(
uriProcessor.getVersion( { param1: 'foo' } ),
1,
'Getting version 1 if no version is specified'
uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
cases.forEach( function ( testCase ) {
- assert.equal(
+ assert.strictEqual(
uriProcessor.isNewState( testCase.states.curr, testCase.states.new ),
testCase.result,
testCase.message
uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
cases.forEach( function ( testCase ) {
- assert.equal(
+ assert.strictEqual(
uriProcessor.doesQueryContainRecognizedParams( testCase.query ),
testCase.result,
testCase.message
}
);
- assert.equal(
+ assert.strictEqual(
uriProcessor._normalizeTargetInUri(
new mw.Uri( testCase.input )
).toString(),
group2 = new mw.rcfilters.dm.FilterGroup( 'group2' );
item = new mw.rcfilters.dm.FilterItem( 'filter1', group1 );
- assert.equal(
+ assert.strictEqual(
item.getName(),
'group1__filter1',
'Filter name is retained.'
);
- assert.equal(
+ assert.strictEqual(
item.getGroupName(),
'group1',
'Group name is retained.'
description: 'test description'
}
);
- assert.equal(
+ assert.strictEqual(
item.getLabel(),
'test label',
'Label information is retained.'
);
- assert.equal(
+ assert.strictEqual(
item.getLabel(),
'test label',
'Description information is retained.'
selected: true
}
);
- assert.equal(
+ assert.strictEqual(
item.isSelected(),
true,
'Item can be selected in the config.'
);
item.toggleSelected( true );
- assert.equal(
+ assert.strictEqual(
item.isSelected(),
true,
'Item can toggle its selected state.'
[ 'sub1', 'sub2', 'sub3' ],
'Subset information is retained.'
);
- assert.equal(
+ assert.strictEqual(
item.existsInSubset( 'sub1' ),
true,
'Specific item exists in subset.'
);
- assert.equal(
+ assert.strictEqual(
item.existsInSubset( 'sub10' ),
false,
'Specific item does not exists in subset.'
);
- assert.equal(
+ assert.strictEqual(
item.isIncluded(),
false,
'Initial state of "included" is false.'
);
item.toggleIncluded( true );
- assert.equal(
+ assert.strictEqual(
item.isIncluded(),
true,
'Item toggles its included state.'
},
'Conflict information is retained.'
);
- assert.equal(
+ assert.strictEqual(
item.existsInConflicts( new mw.rcfilters.dm.FilterItem( 'conflict1', group2 ) ),
true,
'Specific item exists in conflicts.'
);
- assert.equal(
+ assert.strictEqual(
item.existsInConflicts( new mw.rcfilters.dm.FilterItem( 'conflict10', group1 ) ),
false,
'Specific item does not exists in conflicts.'
);
- assert.equal(
+ assert.strictEqual(
item.isConflicted(),
false,
'Initial state of "conflicted" is false.'
);
item.toggleConflicted( true );
- assert.equal(
+ assert.strictEqual(
item.isConflicted(),
true,
'Item toggles its conflicted state.'
// Fully covered
item = new mw.rcfilters.dm.FilterItem( 'filter1', group1 );
- assert.equal(
+ assert.strictEqual(
item.isFullyCovered(),
false,
'Initial state of "full coverage" is false.'
);
item.toggleFullyCovered( true );
- assert.equal(
+ assert.strictEqual(
item.isFullyCovered(),
true,
'Item toggles its fully coverage state.'
item.setValue( '1' );
- assert.equal( item.getValue(), true, 'Value is coerced to boolean' );
+ assert.strictEqual( item.getValue(), true, 'Value is coerced to boolean' );
} );
QUnit.test( 'get/set any value', function ( assert ) {
item.setValue( '1' );
- assert.equal( item.getValue(), '1', 'Value is kept as-is' );
+ assert.strictEqual( item.getValue(), '1', 'Value is kept as-is' );
} );
}( mediaWiki ) );
model.initializeFilters( definition );
- assert.equal(
+ assert.strictEqual(
model.isHighlightEnabled(),
false,
'Initially, highlight is disabled.'
);
model.toggleHighlight( true );
- assert.equal(
+ assert.strictEqual(
model.isHighlightEnabled(),
true,
'Highlight is enabled on toggle.'
'Highlighted items are highlighted.'
);
- assert.equal(
+ assert.strictEqual(
model.getItemByName( 'group1__filter1' ).getHighlightColor(),
'color1',
'Item highlight color is set.'
);
model.setHighlightColor( 'group1__filter1', 'color1changed' );
- assert.equal(
+ assert.strictEqual(
model.getItemByName( 'group1__filter1' ).getHighlightColor(),
'color1changed',
'Item highlight color is changed on setHighlightColor.'
model.initializeFilters( shortFilterDefinition, null );
model.emptyAllFilters();
- assert.equal( model.areVisibleFiltersEmpty(), true );
+ assert.strictEqual( model.areVisibleFiltersEmpty(), true );
model.toggleFiltersSelected( {
group3__filter5: true // sticky
} );
- assert.equal( model.areVisibleFiltersEmpty(), true );
+ assert.strictEqual( model.areVisibleFiltersEmpty(), true );
model.toggleFiltersSelected( {
group1__filter1: true
} );
- assert.equal( model.areVisibleFiltersEmpty(), false );
+ assert.strictEqual( model.areVisibleFiltersEmpty(), false );
} );
}( mediaWiki, jQuery ) );
testCase.msg + ' (itemState)'
);
- assert.equal(
+ assert.strictEqual(
item.isDefault(),
testCase.result.isDefault,
testCase.msg + ' (isDefault)'
);
if ( testCase.result.id !== undefined ) {
- assert.equal(
+ assert.strictEqual(
item.getID(),
testCase.result.id,
testCase.msg + ' (item ID)'
);
item1 = queriesModel.getItemByID( id1 );
- assert.equal(
+ assert.strictEqual(
item1.getID(),
id1,
'Item created and its data retained successfully'
$.extend( true, {}, itemData )
);
- assert.equal(
+ assert.strictEqual(
model.getID(),
'randomID',
'Item ID is retained'
);
- assert.equal(
+ assert.strictEqual(
model.getLabel(),
'Some label',
'Item label is retained'
'Item data is retained'
);
- assert.equal(
+ assert.strictEqual(
model.isDefault(),
false,
'Item default state is retained.'
$.extend( true, {}, itemData )
);
- assert.equal(
+ assert.strictEqual(
model.isDefault(),
false,
'Default state represented when item initialized with default:false.'
);
model.toggleDefault( true );
- assert.equal(
+ assert.strictEqual(
model.isDefault(),
true,
'Default state toggles to true successfully'
);
model.toggleDefault( false );
- assert.equal(
+ assert.strictEqual(
model.isDefault(),
false,
'Default state toggles to false successfully'
{ default: true }
);
- assert.equal(
+ assert.strictEqual(
model.isDefault(),
true,
'Default state represented when item initialized with default:true.'
queue.get( 10 )
.then( function ( data ) {
// Check that we received all requested results
- assert.equal( data.length, 10, 'Query 1: Results received.' );
+ assert.strictEqual( data.length, 10, 'Query 1: Results received.' );
// We've asked for 10 items + 2 threshold from all providers.
// Provider 1 returned 12 results
// Provider 2 returned 0 results
// Provider 3 returned 1 results
// Overall 13 results. 10 were retrieved. 3 left in queue.
- assert.equal( queue.getQueueSize(), 3, 'Query 1: Remaining queue size.' );
+ assert.strictEqual( queue.getQueueSize(), 3, 'Query 1: Remaining queue size.' );
// Check if sources are depleted
- assert.equal( providers[ 0 ].isDepleted(), false, 'Query 1: Full provider not depleted.' );
- assert.equal( providers[ 1 ].isDepleted(), true, 'Query 1: Empty provider is depleted.' );
- assert.equal( providers[ 2 ].isDepleted(), true, 'Query 1: Single result provider is depleted.' );
+ assert.strictEqual( providers[ 0 ].isDepleted(), false, 'Query 1: Full provider not depleted.' );
+ assert.strictEqual( providers[ 1 ].isDepleted(), true, 'Query 1: Empty provider is depleted.' );
+ assert.strictEqual( providers[ 2 ].isDepleted(), true, 'Query 1: Single result provider is depleted.' );
// Ask for more results
return queue.get( 10 );
// * The queue queried provider #1 for 12 items
// * The queue returned 10 results as requested
// * 5 results are now left in the queue.
- assert.equal( data1.length, 10, 'Query 1: Second set of results received.' );
- assert.equal( queue.getQueueSize(), 5, 'Query 1: Remaining queue size.' );
+ assert.strictEqual( data1.length, 10, 'Query 1: Second set of results received.' );
+ assert.strictEqual( queue.getQueueSize(), 5, 'Query 1: Remaining queue size.' );
// Change the query
queue.setParams( { foo: 'baz' } );
// Check if sources are depleted
- assert.equal( providers[ 0 ].isDepleted(), false, 'Query 2: Full provider not depleted.' );
- assert.equal( providers[ 1 ].isDepleted(), false, 'Query 2: Empty provider not depleted.' );
- assert.equal( providers[ 2 ].isDepleted(), false, 'Query 2: Single result provider not depleted.' );
+ assert.strictEqual( providers[ 0 ].isDepleted(), false, 'Query 2: Full provider not depleted.' );
+ assert.strictEqual( providers[ 1 ].isDepleted(), false, 'Query 2: Empty provider not depleted.' );
+ assert.strictEqual( providers[ 2 ].isDepleted(), false, 'Query 2: Single result provider not depleted.' );
return queue.get( 10 );
} )
.then( function ( data2 ) {
// This should be the same as the very first result
- assert.equal( data2.length, 10, 'Query 2: Results received.' );
- assert.equal( queue.getQueueSize(), 3, 'Query 2: Remaining queue size.' );
+ assert.strictEqual( data2.length, 10, 'Query 2: Results received.' );
+ assert.strictEqual( queue.getQueueSize(), 3, 'Query 2: Remaining queue size.' );
// Check if sources are depleted
- assert.equal( providers[ 0 ].isDepleted(), false, 'Query 2: Full provider not depleted.' );
- assert.equal( providers[ 1 ].isDepleted(), true, 'Query 2: Empty provider is not depleted.' );
- assert.equal( providers[ 2 ].isDepleted(), true, 'Query 2: Single result provider is not depleted.' );
+ assert.strictEqual( providers[ 0 ].isDepleted(), false, 'Query 2: Full provider not depleted.' );
+ assert.strictEqual( providers[ 1 ].isDepleted(), true, 'Query 2: Empty provider is not depleted.' );
+ assert.strictEqual( providers[ 2 ].isDepleted(), true, 'Query 2: Single result provider is not depleted.' );
} )
// Finish the async test
.then( done );
biggerQueue.setParams( { foo: 'baz' } );
biggerQueue.get( 10 )
.then( function () {
- assert.equal( completed, false, 'Provider promises aborted.' );
+ assert.strictEqual( completed, false, 'Provider promises aborted.' );
} )
// Finish the async test
.then( done );
assert.propEqual( str.match( new RegExp( mw.RegExp.escape( str ) ) ), [ str ], 'Match ' + str );
} );
- assert.equal( mw.RegExp.escape( normal ), normal, 'Alphanumerals are left alone' );
+ assert.strictEqual( mw.RegExp.escape( normal ), normal, 'Alphanumerals are left alone' );
} );
}( mediaWiki ) );
x = '*',
space = ' ';
- assert.equal( byteLength( azLc ), 26, 'Lowercase a-z' );
- assert.equal( byteLength( azUc ), 26, 'Uppercase A-Z' );
- assert.equal( byteLength( num ), 10, 'Numbers 0-9' );
- assert.equal( byteLength( x ), 1, 'An asterisk' );
- assert.equal( byteLength( space ), 3, '3 spaces' );
+ assert.strictEqual( byteLength( azLc ), 26, 'Lowercase a-z' );
+ assert.strictEqual( byteLength( azUc ), 26, 'Uppercase A-Z' );
+ assert.strictEqual( byteLength( num ), 10, 'Numbers 0-9' );
+ assert.strictEqual( byteLength( x ), 1, 'An asterisk' );
+ assert.strictEqual( byteLength( space ), 3, '3 spaces' );
} );
QUnit.test( opt.description, function ( assert ) {
var res = trimByteLength( opt.initial, opt.sample, opt.limit, opt.fn );
- assert.equal(
+ assert.strictEqual(
res.newVal,
opt.expected,
'New value matches the expected string'
QUnit.test( 'newFromText', function ( assert ) {
var i;
for ( i = 0; i < cases.valid.length; i++ ) {
- assert.equal(
+ assert.strictEqual(
$.type( mw.Title.newFromText( cases.valid[ i ] ) ),
'object',
cases.valid[ i ]
);
}
for ( i = 0; i < cases.invalid.length; i++ ) {
- assert.equal(
+ assert.strictEqual(
$.type( mw.Title.newFromText( cases.invalid[ i ] ) ),
'null',
cases.invalid[ i ]
var title;
title = new mw.Title( 'File:Foo_bar.JPG' );
- assert.equal( title.getNamespaceId(), 6 );
- assert.equal( title.getNamespacePrefix(), 'File:' );
- assert.equal( title.getName(), 'Foo_bar' );
- assert.equal( title.getNameText(), 'Foo bar' );
- assert.equal( title.getExtension(), 'JPG' );
- assert.equal( title.getDotExtension(), '.JPG' );
- assert.equal( title.getMain(), 'Foo_bar.JPG' );
- assert.equal( title.getMainText(), 'Foo bar.JPG' );
- assert.equal( title.getPrefixedDb(), 'File:Foo_bar.JPG' );
- assert.equal( title.getPrefixedText(), 'File:Foo bar.JPG' );
+ assert.strictEqual( title.getNamespaceId(), 6 );
+ assert.strictEqual( title.getNamespacePrefix(), 'File:' );
+ assert.strictEqual( title.getName(), 'Foo_bar' );
+ assert.strictEqual( title.getNameText(), 'Foo bar' );
+ assert.strictEqual( title.getExtension(), 'JPG' );
+ assert.strictEqual( title.getDotExtension(), '.JPG' );
+ assert.strictEqual( title.getMain(), 'Foo_bar.JPG' );
+ assert.strictEqual( title.getMainText(), 'Foo bar.JPG' );
+ assert.strictEqual( title.getPrefixedDb(), 'File:Foo_bar.JPG' );
+ assert.strictEqual( title.getPrefixedText(), 'File:Foo bar.JPG' );
title = new mw.Title( 'Foo#bar' );
- assert.equal( title.getPrefixedText(), 'Foo' );
- assert.equal( title.getFragment(), 'bar' );
+ assert.strictEqual( title.getPrefixedText(), 'Foo' );
+ assert.strictEqual( title.getFragment(), 'bar' );
title = new mw.Title( '.foo' );
- assert.equal( title.getPrefixedText(), '.foo' );
- assert.equal( title.getName(), '' );
- assert.equal( title.getNameText(), '' );
- assert.equal( title.getExtension(), 'foo' );
- assert.equal( title.getDotExtension(), '.foo' );
- assert.equal( title.getMain(), '.foo' );
- assert.equal( title.getMainText(), '.foo' );
- assert.equal( title.getPrefixedDb(), '.foo' );
- assert.equal( title.getPrefixedText(), '.foo' );
+ assert.strictEqual( title.getPrefixedText(), '.foo' );
+ assert.strictEqual( title.getName(), '' );
+ assert.strictEqual( title.getNameText(), '' );
+ assert.strictEqual( title.getExtension(), 'foo' );
+ assert.strictEqual( title.getDotExtension(), '.foo' );
+ assert.strictEqual( title.getMain(), '.foo' );
+ assert.strictEqual( title.getMainText(), '.foo' );
+ assert.strictEqual( title.getPrefixedDb(), '.foo' );
+ assert.strictEqual( title.getPrefixedText(), '.foo' );
} );
QUnit.test( 'Transformation', function ( assert ) {
var title;
title = new mw.Title( 'File:quux pif.jpg' );
- assert.equal( title.getNameText(), 'Quux pif', 'First character of title' );
+ assert.strictEqual( title.getNameText(), 'Quux pif', 'First character of title' );
title = new mw.Title( 'File:Glarg_foo_glang.jpg' );
- assert.equal( title.getNameText(), 'Glarg foo glang', 'Underscores' );
+ assert.strictEqual( title.getNameText(), 'Glarg foo glang', 'Underscores' );
title = new mw.Title( 'User:ABC.DEF' );
- assert.equal( title.toText(), 'User:ABC.DEF', 'Round trip text' );
- assert.equal( title.getNamespaceId(), 2, 'Parse canonical namespace prefix' );
+ assert.strictEqual( title.toText(), 'User:ABC.DEF', 'Round trip text' );
+ assert.strictEqual( title.getNamespaceId(), 2, 'Parse canonical namespace prefix' );
title = new mw.Title( 'Image:quux pix.jpg' );
- assert.equal( title.getNamespacePrefix(), 'File:', 'Transform alias to canonical namespace' );
+ assert.strictEqual( title.getNamespacePrefix(), 'File:', 'Transform alias to canonical namespace' );
title = new mw.Title( 'uSEr:hAshAr' );
- assert.equal( title.toText(), 'User:HAshAr' );
- assert.equal( title.getNamespaceId(), 2, 'Case-insensitive namespace prefix' );
+ assert.strictEqual( title.toText(), 'User:HAshAr' );
+ assert.strictEqual( title.getNamespaceId(), 2, 'Case-insensitive namespace prefix' );
title = new mw.Title( 'Foo \u00A0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000 bar' );
- assert.equal( title.getMain(), 'Foo_bar', 'Merge multiple types of whitespace/underscores into a single underscore' );
+ assert.strictEqual( title.getMain(), 'Foo_bar', 'Merge multiple types of whitespace/underscores into a single underscore' );
title = new mw.Title( 'Foo\u200E\u200F\u202A\u202B\u202C\u202D\u202Ebar' );
- assert.equal( title.getMain(), 'Foobar', 'Strip Unicode bidi override characters' );
+ assert.strictEqual( title.getMain(), 'Foobar', 'Strip Unicode bidi override characters' );
// Regression test: Previously it would only detect an extension if there is no space after it
title = new mw.Title( 'Example.js ' );
- assert.equal( title.getExtension(), 'js', 'Space after an extension is stripped' );
+ assert.strictEqual( title.getExtension(), 'js', 'Space after an extension is stripped' );
title = new mw.Title( 'Example#foo' );
- assert.equal( title.getFragment(), 'foo', 'Fragment' );
+ assert.strictEqual( title.getFragment(), 'foo', 'Fragment' );
title = new mw.Title( 'Example#_foo_bar baz_' );
- assert.equal( title.getFragment(), ' foo bar baz', 'Fragment' );
+ assert.strictEqual( title.getFragment(), ' foo bar baz', 'Fragment' );
} );
QUnit.test( 'Namespace detection and conversion', function ( assert ) {
var title;
title = new mw.Title( 'File:User:Example' );
- assert.equal( title.getNamespaceId(), 6, 'Titles can contain namespace prefixes, which are otherwise ignored' );
+ assert.strictEqual( title.getNamespaceId(), 6, 'Titles can contain namespace prefixes, which are otherwise ignored' );
title = new mw.Title( 'Example', 6 );
- assert.equal( title.getNamespaceId(), 6, 'Default namespace passed is used' );
+ assert.strictEqual( title.getNamespaceId(), 6, 'Default namespace passed is used' );
title = new mw.Title( 'User:Example', 6 );
- assert.equal( title.getNamespaceId(), 2, 'Included namespace prefix overrides the given default' );
+ assert.strictEqual( title.getNamespaceId(), 2, 'Included namespace prefix overrides the given default' );
title = new mw.Title( ':Example', 6 );
- assert.equal( title.getNamespaceId(), 0, 'Colon forces main namespace' );
+ assert.strictEqual( title.getNamespaceId(), 0, 'Colon forces main namespace' );
title = new mw.Title( 'something.PDF', 6 );
- assert.equal( title.toString(), 'File:Something.PDF' );
+ assert.strictEqual( title.toString(), 'File:Something.PDF' );
title = new mw.Title( 'NeilK', 3 );
- assert.equal( title.toString(), 'User_talk:NeilK' );
- assert.equal( title.toText(), 'User talk:NeilK' );
+ assert.strictEqual( title.toString(), 'User_talk:NeilK' );
+ assert.strictEqual( title.toText(), 'User talk:NeilK' );
title = new mw.Title( 'Frobisher', 100 );
- assert.equal( title.toString(), 'Penguins:Frobisher' );
+ assert.strictEqual( title.toString(), 'Penguins:Frobisher' );
title = new mw.Title( 'antarctic_waterfowl:flightless_yet_cute.jpg' );
- assert.equal( title.toString(), 'Penguins:Flightless_yet_cute.jpg' );
+ assert.strictEqual( title.toString(), 'Penguins:Flightless_yet_cute.jpg' );
title = new mw.Title( 'Penguins:flightless_yet_cute.jpg' );
- assert.equal( title.toString(), 'Penguins:Flightless_yet_cute.jpg' );
+ assert.strictEqual( title.toString(), 'Penguins:Flightless_yet_cute.jpg' );
} );
QUnit.test( 'Throw error on invalid title', function ( assert ) {
mw.config.set( 'wgCaseSensitiveNamespaces', [] );
title = new mw.Title( 'article' );
- assert.equal( title.toString(), 'Article', 'Default config: No sensitive namespaces by default. First-letter becomes uppercase' );
+ assert.strictEqual( title.toString(), 'Article', 'Default config: No sensitive namespaces by default. First-letter becomes uppercase' );
title = new mw.Title( 'ß' );
- assert.equal( title.toString(), 'ß', 'Uppercasing matches PHP behaviour (ß -> ß, not SS)' );
+ assert.strictEqual( title.toString(), 'ß', 'Uppercasing matches PHP behaviour (ß -> ß, not SS)' );
title = new mw.Title( 'dž (digraph)' );
- assert.equal( title.toString(), 'Dž_(digraph)', 'Uppercasing matches PHP behaviour (dž -> Dž, not DŽ)' );
+ assert.strictEqual( title.toString(), 'Dž_(digraph)', 'Uppercasing matches PHP behaviour (dž -> Dž, not DŽ)' );
// $wgCapitalLinks = false;
mw.config.set( 'wgCaseSensitiveNamespaces', [ 0, -2, 1, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15 ] );
title = new mw.Title( 'article' );
- assert.equal( title.toString(), 'article', '$wgCapitalLinks=false: Article namespace is sensitive, first-letter case stays lowercase' );
+ assert.strictEqual( title.toString(), 'article', '$wgCapitalLinks=false: Article namespace is sensitive, first-letter case stays lowercase' );
title = new mw.Title( 'john', 2 );
- assert.equal( title.toString(), 'User:John', '$wgCapitalLinks=false: User namespace is insensitive, first-letter becomes uppercase' );
+ assert.strictEqual( title.toString(), 'User:John', '$wgCapitalLinks=false: User namespace is insensitive, first-letter becomes uppercase' );
} );
QUnit.test( 'toString / toText', function ( assert ) {
var title = new mw.Title( 'Some random page' );
- assert.equal( title.toString(), title.getPrefixedDb() );
- assert.equal( title.toText(), title.getPrefixedText() );
+ assert.strictEqual( title.toString(), title.getPrefixedDb() );
+ assert.strictEqual( title.toText(), title.getPrefixedText() );
} );
QUnit.test( 'getExtension', function ( assert ) {
function extTest( pagename, ext, description ) {
var title = new mw.Title( pagename );
- assert.equal( title.getExtension(), ext, description || pagename );
+ assert.strictEqual( title.getExtension(), ext, description || pagename );
}
extTest( 'MediaWiki:Vector.js', 'js' );
} );
title = new mw.Title( 'Foobar' );
- assert.equal( title.getUrl(), '/wiki/Foobar', 'Basic functionality, getUrl uses mw.util.getUrl' );
- assert.equal( title.getUrl( { action: 'edit' } ), '/w/index.php?title=Foobar&action=edit', 'Basic functionality, \'params\' parameter' );
+ assert.strictEqual( title.getUrl(), '/wiki/Foobar', 'Basic functionality, getUrl uses mw.util.getUrl' );
+ assert.strictEqual( title.getUrl( { action: 'edit' } ), '/w/index.php?title=Foobar&action=edit', 'Basic functionality, \'params\' parameter' );
title = new mw.Title( 'John Doe', 3 );
- assert.equal( title.getUrl(), '/wiki/User_talk:John_Doe', 'Escaping in title and namespace for urls' );
+ assert.strictEqual( title.getUrl(), '/wiki/User_talk:John_Doe', 'Escaping in title and namespace for urls' );
title = new mw.Title( 'John Cena#And_His_Name_Is', 3 );
- assert.equal( title.getUrl( { meme: true } ), '/w/index.php?title=User_talk:John_Cena&meme=true#And_His_Name_Is', 'title with fragment and query parameter' );
+ assert.strictEqual( title.getUrl( { meme: true } ), '/w/index.php?title=User_talk:John_Cena&meme=true#And_His_Name_Is', 'title with fragment and query parameter' );
} );
QUnit.test( 'newFromImg', function ( assert ) {
prefix = '[' + thisCase.typeOfUrl + ' URL] ';
assert.notStrictEqual( title, null, prefix + 'Parses successfully' );
- assert.equal( title.getNameText(), thisCase.nameText, prefix + 'Filename matches original' );
- assert.equal( title.getPrefixedText(), thisCase.prefixedText, prefix + 'File page title matches original' );
- assert.equal( title.getNamespaceId(), 6, prefix + 'Namespace ID matches File namespace' );
+ assert.strictEqual( title.getNameText(), thisCase.nameText, prefix + 'Filename matches original' );
+ assert.strictEqual( title.getPrefixedText(), thisCase.prefixedText, prefix + 'File page title matches original' );
+ assert.strictEqual( title.getNamespaceId(), 6, prefix + 'Namespace ID matches File namespace' );
} else {
assert.strictEqual( title, null, thisCase.typeOfUrl + ', should not produce an mw.Title object' );
}
thisCase = cases[ i ];
title = mw.Title.newFromText( thisCase.text );
- assert.equal( title.getRelativeText( thisCase.relativeTo ), thisCase.expectedResult );
+ assert.strictEqual( title.getRelativeText( thisCase.relativeTo ), thisCase.expectedResult );
}
} );
extension = mw.Title.normalizeExtension( thisCase.extension );
prefix = '[' + thisCase.description + '] ';
- assert.equal( extension, thisCase.expected, prefix + 'Extension as expected' );
+ assert.strictEqual( extension, thisCase.expected, prefix + 'Extension as expected' );
}
} );
prefix = '[' + thisCase.description + '] ';
assert.notStrictEqual( title, null, prefix + 'Parses successfully' );
- assert.equal( title.toText(), thisCase.expected, prefix + 'Title as expected' );
+ assert.strictEqual( title.toText(), thisCase.expected, prefix + 'Title as expected' );
} else {
assert.strictEqual( title, null, thisCase.description + ', should not produce an mw.Title object' );
}
prefix = '[' + thisCase.typeOfName + '] ';
assert.notStrictEqual( title, null, prefix + 'Parses successfully' );
- assert.equal( title.getNameText(), thisCase.nameText, prefix + 'Filename matches original' );
- assert.equal( title.getPrefixedText(), thisCase.prefixedText, prefix + 'File page title matches original' );
- assert.equal( title.getNamespaceId(), 6, prefix + 'Namespace ID matches File namespace' );
+ assert.strictEqual( title.getNameText(), thisCase.nameText, prefix + 'Filename matches original' );
+ assert.strictEqual( title.getPrefixedText(), thisCase.prefixedText, prefix + 'File page title matches original' );
+ assert.strictEqual( title.getNamespaceId(), 6, prefix + 'Namespace ID matches File namespace' );
} else {
assert.strictEqual( title, null, thisCase.typeOfName + ', should not produce an mw.Title object' );
}
uri = new mw.Uri( 'example.com/bar/baz', {
strictMode: false
} );
- assert.equal( uri.toString(), 'http://example.com/bar/baz', 'normalize URI without protocol or // in loose mode' );
+ assert.strictEqual( uri.toString(), 'http://example.com/bar/baz', 'normalize URI without protocol or // in loose mode' );
uri = new mw.Uri( 'http://example.com/index.php?key=key&hasOwnProperty=hasOwnProperty&constructor=constructor&watch=watch' );
assert.deepEqual(
host: 'www.foo.local',
path: '/this'
} );
- assert.equal( uri.toString(), 'http://www.foo.local/this', 'Basic properties' );
+ assert.strictEqual( uri.toString(), 'http://www.foo.local/this', 'Basic properties' );
uri = new mw.Uri( {
protocol: 'http',
query: { hi: 'there' },
fragment: 'blah'
} );
- assert.equal( uri.toString(), 'http://www.foo.local/this?hi=there#blah', 'More complex properties' );
+ assert.strictEqual( uri.toString(), 'http://www.foo.local/this?hi=there#blah', 'More complex properties' );
assert.throws(
function () {
MyUri = mw.UriRelative( testuri );
uri = new MyUri();
- assert.equal( uri.toString(), testuri, 'no arguments' );
+ assert.strictEqual( uri.toString(), testuri, 'no arguments' );
uri = new MyUri( undefined );
- assert.equal( uri.toString(), testuri, 'undefined' );
+ assert.strictEqual( uri.toString(), testuri, 'undefined' );
uri = new MyUri( null );
- assert.equal( uri.toString(), testuri, 'null' );
+ assert.strictEqual( uri.toString(), testuri, 'null' );
uri = new MyUri( '' );
- assert.equal( uri.toString(), testuri, 'empty string' );
+ assert.strictEqual( uri.toString(), testuri, 'empty string' );
uri = new MyUri( null, { overrideKeys: true } );
assert.deepEqual( uri.query, { a: '2' }, 'null, with options' );
uri = uriBase.clone();
uri.fragment = 'frag';
- assert.equal( uri.toString(), 'http://en.wiki.local/w/api.php#frag', 'add a fragment' );
+ assert.strictEqual( uri.toString(), 'http://en.wiki.local/w/api.php#frag', 'add a fragment' );
uri.fragment = 'café';
- assert.equal( uri.toString(), 'http://en.wiki.local/w/api.php#caf%C3%A9', 'fragment is url-encoded' );
+ assert.strictEqual( uri.toString(), 'http://en.wiki.local/w/api.php#caf%C3%A9', 'fragment is url-encoded' );
uri = uriBase.clone();
uri.host = 'fr.wiki.local';
uri.port = '8080';
- assert.equal( uri.toString(), 'http://fr.wiki.local:8080/w/api.php', 'change host and port' );
+ assert.strictEqual( uri.toString(), 'http://fr.wiki.local:8080/w/api.php', 'change host and port' );
uri = uriBase.clone();
uri.query.foo = 'bar';
- assert.equal( uri.toString(), 'http://en.wiki.local/w/api.php?foo=bar', 'add query arguments' );
+ assert.strictEqual( uri.toString(), 'http://en.wiki.local/w/api.php?foo=bar', 'add query arguments' );
delete uri.query.foo;
- assert.equal( uri.toString(), 'http://en.wiki.local/w/api.php', 'delete query arguments' );
+ assert.strictEqual( uri.toString(), 'http://en.wiki.local/w/api.php', 'delete query arguments' );
uri = uriBase.clone();
uri.query.foo = 'bar';
- assert.equal( uri.toString(), 'http://en.wiki.local/w/api.php?foo=bar', 'extend query arguments' );
+ assert.strictEqual( uri.toString(), 'http://en.wiki.local/w/api.php?foo=bar', 'extend query arguments' );
uri.extend( {
foo: 'quux',
pif: 'paf'
} );
- assert.equal( uri.toString().indexOf( 'foo=quux' ) !== -1, true, 'extend query arguments' );
- assert.equal( uri.toString().indexOf( 'foo=bar' ) !== -1, false, 'extend query arguments' );
- assert.equal( uri.toString().indexOf( 'pif=paf' ) !== -1, true, 'extend query arguments' );
+ assert.strictEqual( uri.toString().indexOf( 'foo=quux' ) !== -1, true, 'extend query arguments' );
+ assert.strictEqual( uri.toString().indexOf( 'foo=bar' ) !== -1, false, 'extend query arguments' );
+ assert.strictEqual( uri.toString().indexOf( 'pif=paf' ) !== -1, true, 'extend query arguments' );
} );
QUnit.test( '.getQueryString()', function ( assert ) {
);
uri = new mw.Uri( 'https://example.com/mw/index.php?title=Sandbox/7&other=Sandbox/7&foo' );
- assert.equal(
+ assert.strictEqual(
uri.getQueryString(),
'title=Sandbox/7&other=Sandbox%2F7&foo',
'title parameter is escaped the wiki-way'
clone = original.clone();
assert.deepEqual( clone, original, 'clone has equivalent properties' );
- assert.equal( original.toString(), clone.toString(), 'toString matches original' );
+ assert.strictEqual( original.toString(), clone.toString(), 'toString matches original' );
assert.notStrictEqual( clone, original, 'clone is a different object when compared by reference' );
// Verify parts and total length instead of entire string because order
// of iteration can vary.
- assert.equal( uri.toString().indexOf( 'm=bar' ) !== -1, true, 'toString preserves other values' );
- assert.equal( uri.toString().indexOf( 'n=x&n=y&n=z' ) !== -1, true, 'toString parameter includes all values of an array query parameter' );
- assert.equal( uri.toString().length, 'http://www.example.com/dir/?m=bar&n=x&n=y&n=z'.length, 'toString matches expected string' );
+ assert.strictEqual( uri.toString().indexOf( 'm=bar' ) !== -1, true, 'toString preserves other values' );
+ assert.strictEqual( uri.toString().indexOf( 'n=x&n=y&n=z' ) !== -1, true, 'toString parameter includes all values of an array query parameter' );
+ assert.strictEqual( uri.toString().length, 'http://www.example.com/dir/?m=bar&n=x&n=y&n=z'.length, 'toString matches expected string' );
uri = new mw.Uri( 'http://www.example.com/dir/?m=foo&m=bar&n=1', {
overrideKeys: false
// Verify parts and total length instead of entire string because order
// of iteration can vary.
- assert.equal( uri.toString().indexOf( 'm=foo&m=bar' ) !== -1, true, 'toString preserves other values' );
- assert.equal( uri.toString().indexOf( 'n=x&n=y&n=z' ) !== -1, true, 'toString parameter includes all values of an array query parameter' );
- assert.equal( uri.toString().length, 'http://www.example.com/dir/?m=foo&m=bar&n=x&n=y&n=z'.length, 'toString matches expected string' );
+ assert.strictEqual( uri.toString().indexOf( 'm=foo&m=bar' ) !== -1, true, 'toString preserves other values' );
+ assert.strictEqual( uri.toString().indexOf( 'n=x&n=y&n=z' ) !== -1, true, 'toString parameter includes all values of an array query parameter' );
+ assert.strictEqual( uri.toString().length, 'http://www.example.com/dir/?m=foo&m=bar&n=x&n=y&n=z'.length, 'toString matches expected string' );
// Remove query values
uri.query.m.splice( 0, 1 );
delete uri.query.n;
- assert.equal( uri.toString(), 'http://www.example.com/dir/?m=bar', 'deletion properties' );
+ assert.strictEqual( uri.toString(), 'http://www.example.com/dir/?m=bar', 'deletion properties' );
// Remove more query values, leaving an empty array
uri.query.m.splice( 0, 1 );
- assert.equal( uri.toString(), 'http://www.example.com/dir/', 'empty array value is ommitted' );
+ assert.strictEqual( uri.toString(), 'http://www.example.com/dir/', 'empty array value is ommitted' );
} );
QUnit.test( 'Variable defaultUri', function ( assert ) {
'basic object properties'
);
- assert.equal( uri.getUserInfo(), 'auth', 'user info' );
+ assert.strictEqual( uri.getUserInfo(), 'auth', 'user info' );
- assert.equal( uri.getAuthority(), 'auth@www.example.com:81', 'authority equal to auth@hostport' );
+ assert.strictEqual( uri.getAuthority(), 'auth@www.example.com:81', 'authority equal to auth@hostport' );
- assert.equal( uri.getHostPort(), 'www.example.com:81', 'hostport equal to host:port' );
+ assert.strictEqual( uri.getHostPort(), 'www.example.com:81', 'hostport equal to host:port' );
queryString = uri.getQueryString();
- assert.equal( queryString.indexOf( 'q1=0' ) !== -1, true, 'query param with numbers' );
- assert.equal( queryString.indexOf( 'test1' ) !== -1, true, 'query param with null value is included' );
- assert.equal( queryString.indexOf( 'test1=' ) !== -1, false, 'query param with null value does not generate equals sign' );
- assert.equal( queryString.indexOf( 'test2=value+%28escaped%29' ) !== -1, true, 'query param is url escaped' );
+ assert.strictEqual( queryString.indexOf( 'q1=0' ) !== -1, true, 'query param with numbers' );
+ assert.strictEqual( queryString.indexOf( 'test1' ) !== -1, true, 'query param with null value is included' );
+ assert.strictEqual( queryString.indexOf( 'test1=' ) !== -1, false, 'query param with null value does not generate equals sign' );
+ assert.strictEqual( queryString.indexOf( 'test2=value+%28escaped%29' ) !== -1, true, 'query param is url escaped' );
relativePath = uri.getRelativePath();
assert.ok( relativePath.indexOf( uri.path ) >= 0, 'path in relative path' );
UriRel = mw.UriRelative( 'glork://en.wiki.local/foo.php' );
uri = new UriRel( '//en.wiki.local/w/api.php' );
- assert.equal( uri.protocol, 'glork', 'create protocol-relative URLs with same protocol as document' );
+ assert.strictEqual( uri.protocol, 'glork', 'create protocol-relative URLs with same protocol as document' );
uri = new UriRel( '/foo.com' );
- assert.equal( uri.toString(), 'glork://en.wiki.local/foo.com', 'handle absolute paths by supplying protocol and host from document in loose mode' );
+ assert.strictEqual( uri.toString(), 'glork://en.wiki.local/foo.com', 'handle absolute paths by supplying protocol and host from document in loose mode' );
uri = new UriRel( 'http:/foo.com' );
- assert.equal( uri.toString(), 'http://en.wiki.local/foo.com', 'handle absolute paths by supplying host from document in loose mode' );
+ assert.strictEqual( uri.toString(), 'http://en.wiki.local/foo.com', 'handle absolute paths by supplying host from document in loose mode' );
uri = new UriRel( '/foo.com', true );
- assert.equal( uri.toString(), 'glork://en.wiki.local/foo.com', 'handle absolute paths by supplying protocol and host from document in strict mode' );
+ assert.strictEqual( uri.toString(), 'glork://en.wiki.local/foo.com', 'handle absolute paths by supplying protocol and host from document in strict mode' );
uri = new UriRel( 'http:/foo.com', true );
- assert.equal( uri.toString(), 'http://en.wiki.local/foo.com', 'handle absolute paths by supplying host from document in strict mode' );
+ assert.strictEqual( uri.toString(), 'http://en.wiki.local/foo.com', 'handle absolute paths by supplying host from document in strict mode' );
} );
QUnit.test( 'T37658', function ( assert ) {
UriClass = mw.UriRelative( testProtocol + testServer + '/some/path/index.html' );
uri = new UriClass( testPath );
href = uri.toString();
- assert.equal( href, testProtocol + testServer + testPath, 'Root-relative URL gets host & protocol supplied' );
+ assert.strictEqual( href, testProtocol + testServer + testPath, 'Root-relative URL gets host & protocol supplied' );
UriClass = mw.UriRelative( testProtocol + testServer + ':' + testPort + '/some/path.php' );
uri = new UriClass( testPath );
href = uri.toString();
- assert.equal( href, testProtocol + testServer + ':' + testPort + testPath, 'Root-relative URL gets host, protocol, and port supplied' );
+ assert.strictEqual( href, testProtocol + testServer + ':' + testPort + testPath, 'Root-relative URL gets host, protocol, and port supplied' );
} );
}( mediaWiki ) );
QUnit.test( 'Plural Test for ' + langCode, function ( assert ) {
var i;
for ( i = 0; i < tests.length; i++ ) {
- assert.equal(
+ assert.strictEqual(
mw.language.convertPlural( tests[ i ][ 0 ], tests[ i ][ 1 ] ),
tests[ i ][ 2 ],
tests[ i ][ 3 ]
var experiment = createExperiment(),
token = '123457890';
- assert.equal(
+ assert.strictEqual(
getBucket( experiment, token ),
getBucket( experiment, token ),
'It returns the same bucket for the same experiment-token pair.'
A: 0.314159265359
};
- assert.equal(
+ assert.strictEqual(
getBucket( experiment, token ),
'A',
'It returns the bucket if only one is defined.'
experiment = createExperiment();
experiment.enabled = false;
- assert.equal(
+ assert.strictEqual(
getBucket( experiment, token ),
'control',
'It returns "control" if the experiment is disabled.'
experiment = createExperiment();
experiment.buckets = {};
- assert.equal(
+ assert.strictEqual(
getBucket( experiment, token ),
'control',
'It returns "control" if the experiment doesn\'t have any buckets.'
'throw a TypeError if argument is not a string'
);
- assert.equal(
+ assert.strictEqual(
mw.html.escape( '<mw awesome="awesome" value=\'test\' />' ),
'<mw awesome="awesome" value='test' />',
'Escape special characters to html entities'
} );
QUnit.test( 'element()', function ( assert ) {
- assert.equal(
+ assert.strictEqual(
mw.html.element(),
'<undefined/>',
'return valid html even without arguments'
} );
QUnit.test( 'element( tagName )', function ( assert ) {
- assert.
equal( mw.html.element( 'div' ), '<div/>', 'DIV' );
+ assert.
strictEqual( mw.html.element( 'div' ), '<div/>', 'DIV' );
} );
QUnit.test( 'element( tagName, attrs )', function ( assert ) {
- assert.
equal( mw.html.element( 'div', {} ), '<div/>', 'DIV' );
+ assert.
strictEqual( mw.html.element( 'div', {} ), '<div/>', 'DIV' );
- assert.equal(
+ assert.strictEqual(
mw.html.element(
'div', {
id: 'foobar'
QUnit.test( 'element( tagName, attrs, content )', function ( assert ) {
- assert.
equal( mw.html.element( 'div', {}, '' ), '<div></div>', 'DIV with empty attributes and content' );
+ assert.
strictEqual( mw.html.element( 'div', {}, '' ), '<div></div>', 'DIV with empty attributes and content' );
- assert.
equal( mw.html.element( 'p', {}, 12 ), '<p>12</p>', 'numbers as content cast to strings' );
+ assert.
strictEqual( mw.html.element( 'p', {}, 12 ), '<p>12</p>', 'numbers as content cast to strings' );
- assert.
equal( mw.html.element( 'p', { title: 12 }, '' ), '<p title="12"></p>', 'number as attribute value' );
+ assert.
strictEqual( mw.html.element( 'p', { title: 12 }, '' ), '<p title="12"></p>', 'number as attribute value' );
- assert.equal(
+ assert.strictEqual(
mw.html.element(
'div',
{},
'unescaped content with mw.html.Raw'
);
- assert.equal(
+ assert.strictEqual(
mw.html.element(
'option',
{
'boolean true attribute value'
);
- assert.equal(
+ assert.strictEqual(
mw.html.element(
'option',
{
'boolean false attribute value'
);
- assert.equal(
+ assert.strictEqual(
mw.html.element( 'div', null, 'a' ),
'<div>a</div>',
'Skip attributes with null' );
- assert.equal(
+ assert.strictEqual(
mw.html.element( 'a', {
href: 'http://mediawiki.org/w/index.php?title=RL&action=history'
}, 'a' ),
);
return mw.loader.using( 'test.inspect.script' ).then( function () {
- assert.equal(
+ assert.strictEqual(
mw.inspect.getModuleSize( 'test.inspect.script' ),
// name, script function
43,
);
return mw.loader.using( 'test.inspect.both' ).then( function () {
- assert.equal(
+ assert.strictEqual(
mw.inspect.getModuleSize( 'test.inspect.both' ),
// name, script function, styles object
64,
);
return mw.loader.using( 'test.inspect.scriptmsg' ).then( function () {
- assert.equal(
+ assert.strictEqual(
mw.inspect.getModuleSize( 'test.inspect.scriptmsg' ),
// name, script function, empty styles object, messages object
74,
);
return mw.loader.using( 'test.inspect.all' ).then( function () {
- assert.equal(
+ assert.strictEqual(
mw.inspect.getModuleSize( 'test.inspect.all' ),
// name, script function, styles object, messages object, templates object
126,
// When the expected result is the same in both modes
function assertBothModes( assert, parserArguments, expectedResult, assertMessage ) {
- assert.equal( formatText.apply( null, parserArguments ), expectedResult, assertMessage + ' when format is \'text\'' );
- assert.equal( formatParse.apply( null, parserArguments ), expectedResult, assertMessage + ' when format is \'parse\'' );
+ assert.strictEqual( formatText.apply( null, parserArguments ), expectedResult, assertMessage + ' when format is \'text\'' );
+ assert.strictEqual( formatParse.apply( null, parserArguments ), expectedResult, assertMessage + ' when format is \'parse\'' );
}
QUnit.module( 'mediawiki.jqueryMsg', QUnit.newMwEnvironment( {
QUnit.test( 'Replace', function ( assert ) {
mw.messages.set( 'simple', 'Foo $1 baz $2' );
- assert.equal( formatParse( 'simple' ), 'Foo $1 baz $2', 'Replacements with no substitutes' );
- assert.equal( formatParse( 'simple', 'bar' ), 'Foo bar baz $2', 'Replacements with less substitutes' );
- assert.equal( formatParse( 'simple', 'bar', 'quux' ), 'Foo bar baz quux', 'Replacements with all substitutes' );
+ assert.strictEqual( formatParse( 'simple' ), 'Foo $1 baz $2', 'Replacements with no substitutes' );
+ assert.strictEqual( formatParse( 'simple', 'bar' ), 'Foo bar baz $2', 'Replacements with less substitutes' );
+ assert.strictEqual( formatParse( 'simple', 'bar', 'quux' ), 'Foo bar baz quux', 'Replacements with all substitutes' );
mw.messages.set( 'plain-input', '<foo foo="foo">x$1y<</foo>z' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'plain-input', 'bar' ),
'<foo foo="foo">xbary&lt;</foo>z',
'Input is not considered html'
mw.messages.set( 'plain-replace', 'Foo $1' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'plain-replace', '<bar bar="bar">></bar>' ),
'Foo <bar bar="bar">&gt;</bar>',
'Replacement is not considered html'
mw.messages.set( 'object-replace', 'Foo $1' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'object-replace', $( '<div class="bar">></div>' ) ),
'Foo <div class="bar">></div>',
'jQuery objects are preserved as raw html'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'object-replace', $( '<div class="bar">></div>' ).get( 0 ) ),
'Foo <div class="bar">></div>',
'HTMLElement objects are preserved as raw html'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'object-replace', $( '<div class="bar">></div>' ).toArray() ),
'Foo <div class="bar">></div>',
'HTMLElement[] arrays are preserved as raw html'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'external-link-replace', 'http://example.org/?x=y&z' ),
'Foo <a href="http://example.org/?x=y&z">bar</a>',
'Href is not double-escaped in wikilink function'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'external-link-plural', 1, 'http://example.org' ),
'Foo is <a href="http://example.org">one</a> things.',
'Link is expanded inside plural and is not escaped html'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'external-link-plural', 2, 'http://example.org' ),
'Foo <a href="http://example.org">two</a> things.',
'Link is expanded inside an explicit plural form and is not escaped html'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'external-link-plural', 3 ),
'Foo three things.',
'A simple explicit plural form co-existing with complex explicit plural forms'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'external-link-plural', 4, 'http://example.org' ),
'Foo a=b things.',
'Only first equal sign is used as delimiter for explicit plural form. Repeated equal signs does not create issue'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'external-link-plural', 6, 'http://example.org' ),
'Foo are <a href="http://example.org">some</a> things.',
'Plural fallback to the "other" plural form'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'plural-only-explicit-forms', 2 ),
'It is a double room.',
'Plural with explicit forms alone.'
} );
QUnit.test( 'Plural', function ( assert ) {
- assert.equal( formatParse( 'plural-msg', 0 ), 'Found 0 items', 'Plural test for english with zero as count' );
- assert.equal( formatParse( 'plural-msg', 1 ), 'Found 1 item', 'Singular test for english' );
- assert.equal( formatParse( 'plural-msg', 2 ), 'Found 2 items', 'Plural test for english' );
- assert.equal( formatParse( 'plural-msg-explicit-forms-nested', 6 ), 'Found 6 results', 'Plural message with explicit plural forms' );
- assert.equal( formatParse( 'plural-msg-explicit-forms-nested', 0 ), 'Found no results in Wiki', 'Plural message with explicit plural forms, with nested {{SITENAME}}' );
- assert.equal( formatParse( 'plural-msg-explicit-forms-nested', 1 ), 'Found 1 result', 'Plural message with explicit plural forms with placeholder nested' );
- assert.equal( formatParse( 'plural-empty-explicit-form', 0 ), 'There is me.' );
- assert.equal( formatParse( 'plural-empty-explicit-form', 1 ), 'There is me and other people.' );
- assert.equal( formatParse( 'plural-empty-explicit-form', 2 ), 'There is me and other people.' );
+ assert.strictEqual( formatParse( 'plural-msg', 0 ), 'Found 0 items', 'Plural test for english with zero as count' );
+ assert.strictEqual( formatParse( 'plural-msg', 1 ), 'Found 1 item', 'Singular test for english' );
+ assert.strictEqual( formatParse( 'plural-msg', 2 ), 'Found 2 items', 'Plural test for english' );
+ assert.strictEqual( formatParse( 'plural-msg-explicit-forms-nested', 6 ), 'Found 6 results', 'Plural message with explicit plural forms' );
+ assert.strictEqual( formatParse( 'plural-msg-explicit-forms-nested', 0 ), 'Found no results in Wiki', 'Plural message with explicit plural forms, with nested {{SITENAME}}' );
+ assert.strictEqual( formatParse( 'plural-msg-explicit-forms-nested', 1 ), 'Found 1 result', 'Plural message with explicit plural forms with placeholder nested' );
+ assert.strictEqual( formatParse( 'plural-empty-explicit-form', 0 ), 'There is me.' );
+ assert.strictEqual( formatParse( 'plural-empty-explicit-form', 1 ), 'There is me and other people.' );
+ assert.strictEqual( formatParse( 'plural-empty-explicit-form', 2 ), 'There is me and other people.' );
} );
QUnit.test( 'Gender', function ( assert ) {
// TODO: These tests should be for mw.msg once mw.msg integrated with mw.jqueryMsg
// TODO: English may not be the best language for these tests. Use a language like Arabic or Russian
mw.user.options.set( 'gender', 'male' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg', 'Bob', 'male' ),
'Bob: blue',
'Masculine from string "male"'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg', 'Bob', mw.user ),
'Bob: blue',
'Masculine from mw.user object'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg-currentuser' ),
'blue',
'Masculine for current user'
);
mw.user.options.set( 'gender', 'female' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg', 'Alice', 'female' ),
'Alice: pink',
'Feminine from string "female"' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg', 'Alice', mw.user ),
'Alice: pink',
'Feminine from mw.user object'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg-currentuser' ),
'pink',
'Feminine for current user'
);
mw.user.options.set( 'gender', 'unknown' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg', 'Foo', mw.user ),
'Foo: green',
'Neutral from mw.user object' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg', 'User' ),
'User: green',
'Neutral when no parameter given' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg', 'User', 'unknown' ),
'User: green',
'Neutral from string "unknown"'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg-currentuser' ),
'green',
'Neutral for current user'
mw.messages.set( 'gender-msg-one-form', '{{GENDER:$1|User}}: $2 {{PLURAL:$2|edit|edits}}' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg-one-form', 'male', 10 ),
'User: 10 edits',
'Gender neutral and plural form'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg-one-form', 'female', 1 ),
'User: 1 edit',
'Gender neutral and singular form'
);
mw.messages.set( 'gender-msg-lowercase', '{{gender:$1|he|she}} is awesome' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg-lowercase', 'male' ),
'he is awesome',
'Gender masculine'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg-lowercase', 'female' ),
'she is awesome',
'Gender feminine'
);
mw.messages.set( 'gender-msg-wrong', '{{gender}} test' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'gender-msg-wrong', 'female' ),
' test',
'Invalid syntax should result in {{gender}} simply being stripped away'
QUnit.test( 'Case changing', function ( assert ) {
mw.messages.set( 'to-lowercase', '{{lc:thIS hAS MEsSed uP CapItaliZatiON}}' );
- assert.equal( formatParse( 'to-lowercase' ), 'this has messed up capitalization', 'To lowercase' );
+ assert.strictEqual( formatParse( 'to-lowercase' ), 'this has messed up capitalization', 'To lowercase' );
mw.messages.set( 'to-caps', '{{uc:thIS hAS MEsSed uP CapItaliZatiON}}' );
- assert.equal( formatParse( 'to-caps' ), 'THIS HAS MESSED UP CAPITALIZATION', 'To caps' );
+ assert.strictEqual( formatParse( 'to-caps' ), 'THIS HAS MESSED UP CAPITALIZATION', 'To caps' );
mw.messages.set( 'uc-to-lcfirst', '{{lcfirst:THis hAS MEsSed uP CapItaliZatiON}}' );
mw.messages.set( 'lc-to-lcfirst', '{{lcfirst:thIS hAS MEsSed uP CapItaliZatiON}}' );
- assert.equal( formatParse( 'uc-to-lcfirst' ), 'tHis hAS MEsSed uP CapItaliZatiON', 'Lcfirst caps' );
- assert.equal( formatParse( 'lc-to-lcfirst' ), 'thIS hAS MEsSed uP CapItaliZatiON', 'Lcfirst lowercase' );
+ assert.strictEqual( formatParse( 'uc-to-lcfirst' ), 'tHis hAS MEsSed uP CapItaliZatiON', 'Lcfirst caps' );
+ assert.strictEqual( formatParse( 'lc-to-lcfirst' ), 'thIS hAS MEsSed uP CapItaliZatiON', 'Lcfirst lowercase' );
mw.messages.set( 'uc-to-ucfirst', '{{ucfirst:THis hAS MEsSed uP CapItaliZatiON}}' );
mw.messages.set( 'lc-to-ucfirst', '{{ucfirst:thIS hAS MEsSed uP CapItaliZatiON}}' );
- assert.equal( formatParse( 'uc-to-ucfirst' ), 'THis hAS MEsSed uP CapItaliZatiON', 'Ucfirst caps' );
- assert.equal( formatParse( 'lc-to-ucfirst' ), 'ThIS hAS MEsSed uP CapItaliZatiON', 'Ucfirst lowercase' );
+ assert.strictEqual( formatParse( 'uc-to-ucfirst' ), 'THis hAS MEsSed uP CapItaliZatiON', 'Ucfirst caps' );
+ assert.strictEqual( formatParse( 'lc-to-ucfirst' ), 'ThIS hAS MEsSed uP CapItaliZatiON', 'Ucfirst lowercase' );
mw.messages.set( 'mixed-to-sentence', '{{ucfirst:{{lc:thIS hAS MEsSed uP CapItaliZatiON}}}}' );
- assert.equal( formatParse( 'mixed-to-sentence' ), 'This has messed up capitalization', 'To sentence case' );
+ assert.strictEqual( formatParse( 'mixed-to-sentence' ), 'This has messed up capitalization', 'To sentence case' );
mw.messages.set( 'all-caps-except-first', '{{lcfirst:{{uc:thIS hAS MEsSed uP CapItaliZatiON}}}}' );
- assert.equal( formatParse( 'all-caps-except-first' ), 'tHIS HAS MESSED UP CAPITALIZATION', 'To opposite sentence case' );
+ assert.strictEqual( formatParse( 'all-caps-except-first' ), 'tHIS HAS MESSED UP CAPITALIZATION', 'To opposite sentence case' );
} );
QUnit.test( 'Grammar', function ( assert ) {
- assert.equal( formatParse( 'grammar-msg' ), 'Przeszukaj Wiki', 'Grammar Test with sitename' );
+ assert.strictEqual( formatParse( 'grammar-msg' ), 'Przeszukaj Wiki', 'Grammar Test with sitename' );
mw.messages.set( 'grammar-msg-wrong-syntax', 'Przeszukaj {{GRAMMAR:grammar_case_xyz}}' );
- assert.equal( formatParse( 'grammar-msg-wrong-syntax' ), 'Przeszukaj ', 'Grammar Test with wrong grammar template syntax' );
+ assert.strictEqual( formatParse( 'grammar-msg-wrong-syntax' ), 'Przeszukaj ', 'Grammar Test with wrong grammar template syntax' );
} );
QUnit.test( 'Match PHP parser', function ( assert ) {
var parser;
mw.config.set( 'wgUserLanguage', test.lang );
parser = new mw.jqueryMsg.Parser( { language: langClass } );
- assert.equal(
+ assert.strictEqual(
parser.parse( test.key, test.args ).html(),
test.result,
test.name
mw.messages.set( 'reverse-pipe-trick', '[[|Tampa, Florida]]' );
mw.messages.set( 'empty-link', '[[]]' );
this.suppressWarnings();
- assert.equal(
+ assert.strictEqual(
formatParse( 'pipe-trick' ),
'[[Tampa, Florida|]]',
'Pipe trick should not be parsed.'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'reverse-pipe-trick' ),
'[[|Tampa, Florida]]',
'Reverse pipe trick should not be parsed.'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'empty-link' ),
'[[]]',
'Empty link should not be parsed.'
// Test non-{{ wikitext, where behavior differs
// Wikilink
- assert.equal(
+ assert.strictEqual(
formatText( 'jquerymsg-test-statistics-users' ),
mw.messages.get( 'jquerymsg-test-statistics-users' ),
'Internal link message unchanged when format is \'text\''
);
// External link
- assert.equal(
+ assert.strictEqual(
formatText( 'jquerymsg-test-version-entrypoints-index-php' ),
mw.messages.get( 'jquerymsg-test-version-entrypoints-index-php' ),
'External link message unchanged when format is \'text\''
);
// External link with parameter
- assert.equal(
+ assert.strictEqual(
formatText( 'external-link-replace', 'http://example.com' ),
'Foo [http://example.com bar]',
'External link message only substitutes parameter when format is \'text\''
'Link with nested message'
);
- assert.equal(
+ assert.strictEqual(
formatParse( 'see-portal-url' ),
'Project:Community portal is an important community page.',
'Nested message'
mw.messages.set( 'uses-missing-int', '{{int:doesnt-exist}}' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'uses-missing-int' ),
'⧼doesnt-exist⧽',
'int: where nested message does not exist'
QUnit.test( 'Ns', function ( assert ) {
mw.messages.set( 'ns-template-talk', '{{ns:Template talk}}' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'ns-template-talk' ),
'Dyskusja szablonu',
'ns: returns localised namespace when used with a canonical namespace name'
);
mw.messages.set( 'ns-10', '{{ns:10}}' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'ns-10' ),
'Szablon',
'ns: returns localised namespace when used with a namespace number'
);
mw.messages.set( 'ns-unknown', '{{ns:doesnt-exist}}' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'ns-unknown' ),
'',
'ns: returns empty string for unknown namespace name'
);
mw.messages.set( 'ns-in-a-link', '[[{{ns:template}}:Foo]]' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'ns-in-a-link' ),
'<a title="Szablon:Foo" href="/wiki/Szablon:Foo">Szablon:Foo</a>',
'ns: works when used inside a wikilink'
{
lang: 'ar',
number: '٩٨٧٦٥٤٣٢١٫٦٥٤٣٢١',
- result: 987654321,
+ result: '987654321',
integer: true,
description: 'formatnum test for Arabic, with decimal separator, reverse'
},
{
lang: 'ar',
number: '-١٢٫٨٩',
- result: -12,
+ result: '-12',
integer: true,
description: 'formatnum test for Arabic, negative number, reverse'
},
var parser;
mw.config.set( 'wgUserLanguage', test.lang );
parser = new mw.jqueryMsg.Parser( { language: langClass } );
- assert.equal(
+ assert.strictEqual(
parser.parse( test.integer ? 'formatnum-msg-int' : 'formatnum-msg',
[ test.number ] ).html(),
test.result,
'Italics with link inside in parse mode'
);
- assert.equal(
+ assert.strictEqual(
formatText( 'jquerymsg-italics-with-link' ),
mw.messages.get( 'jquerymsg-italics-with-link' ),
'Italics with link unchanged in text mode'
'Tag outside whitelist escaped in parse mode'
);
- assert.equal(
+ assert.strictEqual(
formatText( 'jquerymsg-script-msg' ),
mw.messages.get( 'jquerymsg-script-msg' ),
'Tag outside whitelist unchanged in text mode'
// Intentionally not using htmlEqual for the quote tests
mw.messages.set( 'jquerymsg-double-quotes-preserved', '<i id="double">Double</i>' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'jquerymsg-double-quotes-preserved' ),
mw.messages.get( 'jquerymsg-double-quotes-preserved' ),
'Attributes with double quotes are preserved as such'
);
mw.messages.set( 'jquerymsg-single-quotes-normalized-to-double', '<i id=\'single\'>Single</i>' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'jquerymsg-single-quotes-normalized-to-double' ),
'<i id="single">Single</i>',
'Attributes with single quotes are normalized to double'
QUnit.test( 'Nowiki', function ( assert ) {
mw.messages.set( 'jquerymsg-nowiki-link', 'Foo <nowiki>[[bar]]</nowiki> baz.' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'jquerymsg-nowiki-link' ),
'Foo [[bar]] baz.',
'Link inside nowiki is not parsed'
);
mw.messages.set( 'jquerymsg-nowiki-htmltag', 'Foo <nowiki><b>bar</b></nowiki> baz.' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'jquerymsg-nowiki-htmltag' ),
'Foo <b>bar</b> baz.',
'HTML inside nowiki is not parsed and escaped'
);
mw.messages.set( 'jquerymsg-nowiki-template', 'Foo <nowiki>{{bar}}</nowiki> baz.' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'jquerymsg-nowiki-template' ),
'Foo {{bar}} baz.',
'Template inside nowiki is not parsed and does not cause a parse error'
this.suppressWarnings();
logSpy = this.sandbox.spy( mw.log, 'warn' );
- assert.equal(
+ assert.strictEqual(
formatParse( 'invalid-wikitext' ),
'<b>{{FAIL}}</b>',
'Invalid wikitext: \'parse\' format'
);
- assert.equal(
+ assert.strictEqual(
formatText( 'invalid-wikitext' ),
'<b>{{FAIL}}</b>',
'Invalid wikitext: \'text\' format'
);
- assert.equal( logSpy.callCount, 2, 'mw.log.warn calls' );
+ assert.strictEqual( logSpy.callCount, 2, 'mw.log.warn calls' );
} );
QUnit.test( 'Integration', function ( assert ) {
expected = '<b><a title="Bold" href="/wiki/Bold">Bold</a>!</b>';
mw.messages.set( 'integration-test', '<b>[[Bold]]!</b>' );
- assert.equal(
+ assert.strictEqual(
mw.message( 'integration-test' ).parse(),
expected,
'mw.message().parse() works correctly'
);
- assert.equal(
+ assert.strictEqual(
$( '<span>' ).msg( 'integration-test' ).html(),
expected,
'jQuery plugin $.fn.msg() works correctly'
$( '<a>' ).attr( 'href', 'http://example.com/' )
);
msg.parse(); // Not a no-op
- assert.equal(
+ assert.strictEqual(
msg.parse(),
'<a href="http://example.com/">Link</a>',
'Calling .parse() multiple times does not duplicate link contents'
expected = repeat( '\n', n ) + 'some text';
$textarea = $( '<textarea>\n' + expected + '</textarea>' );
- assert.equal( $textarea.val(), expected, 'Expecting ' + n + ' newlines (HTML contained ' + ( n + 1 ) + ')' );
+ assert.strictEqual( $textarea.val(), expected, 'Expecting ' + n + ' newlines (HTML contained ' + ( n + 1 ) + ')' );
$textarea = $( '<textarea>' ).val( expected );
- assert.equal( $textarea.val(), expected, 'Expecting ' + n + ' newlines (from DOM set with ' + n + ')' );
+ assert.strictEqual( $textarea.val(), expected, 'Expecting ' + n + ' newlines (from DOM set with ' + n + ')' );
}
} );
}( jQuery ) );
QUnit.test( 'mw.language getData and setData', function ( assert ) {
mw.language.setData( 'en', 'testkey', 'testvalue' );
- assert.equal( mw.language.getData( 'en', 'testkey' ), 'testvalue', 'Getter setter test for mw.language' );
- assert.equal( mw.language.getData( 'en', 'invalidkey' ), undefined, 'Getter setter test for mw.language with invalid key' );
+ assert.strictEqual( mw.language.getData( 'en', 'testkey' ), 'testvalue', 'Getter setter test for mw.language' );
+ assert.strictEqual( mw.language.getData( 'en', 'invalidkey' ), null, 'Getter setter test for mw.language with invalid key' );
+ assert.strictEqual( mw.language.getData( 'xx', 'invalidLang' ), undefined, 'Getter setter test for mw.language with invalid lang' );
mw.language.setData( 'en-us', 'testkey', 'testvalue' );
- assert.equal( mw.language.getData( 'en-US', 'testkey' ), 'testvalue', 'Case insensitive test for mw.language' );
+ assert.strictEqual( mw.language.getData( 'en-US', 'testkey' ), 'testvalue', 'Case insensitive test for mw.language' );
} );
QUnit.test( 'mw.language.commafy test', function ( assert ) {
mw.config.set( 'wgUserLanguage', 'en' );
// Number grouping patterns are as per http://cldr.unicode.org/translation/number-patterns
- assert.equal( mw.language.commafy( 1234.567, '###0.#####' ), '1234.567', 'Pattern with no digit grouping separator defined' );
- assert.equal( mw.language.commafy( 123456789.567, '###0.#####' ), '123456789.567', 'Pattern with no digit grouping separator defined, bigger decimal part' );
- assert.equal( mw.language.commafy( 0.567, '###0.#####' ), '0.567', 'Decimal part 0' );
- assert.equal( mw.language.commafy( '.567', '###0.#####' ), '0.567', 'Decimal part missing. replace with zero' );
- assert.equal( mw.language.commafy( 1234, '##,#0.#####' ), '12,34', 'Pattern with no fractional part' );
- assert.equal( mw.language.commafy( -1234.567, '###0.#####' ), '-1234.567', 'Negative number' );
- assert.equal( mw.language.commafy( -1234.567, '#,###.00' ), '-1,234.56', 'Fractional part bigger than pattern.' );
- assert.equal( mw.language.commafy( 123456789.567, '###,##0.00' ), '123,456,789.56', 'Decimal part as group of 3' );
- assert.equal( mw.language.commafy( 123456789.567, '###,###,#0.00' ), '1,234,567,89.56', 'Decimal part as group of 3 and last one 2' );
+ assert.strictEqual( mw.language.commafy( 1234.567, '###0.#####' ), '1234.567', 'Pattern with no digit grouping separator defined' );
+ assert.strictEqual( mw.language.commafy( 123456789.567, '###0.#####' ), '123456789.567', 'Pattern with no digit grouping separator defined, bigger decimal part' );
+ assert.strictEqual( mw.language.commafy( 0.567, '###0.#####' ), '0.567', 'Decimal part 0' );
+ assert.strictEqual( mw.language.commafy( '.567', '###0.#####' ), '0.567', 'Decimal part missing. replace with zero' );
+ assert.strictEqual( mw.language.commafy( 1234, '##,#0.#####' ), '12,34', 'Pattern with no fractional part' );
+ assert.strictEqual( mw.language.commafy( -1234.567, '###0.#####' ), '-1234.567', 'Negative number' );
+ assert.strictEqual( mw.language.commafy( -1234.567, '#,###.00' ), '-1,234.56', 'Fractional part bigger than pattern.' );
+ assert.strictEqual( mw.language.commafy( 123456789.567, '###,##0.00' ), '123,456,789.56', 'Decimal part as group of 3' );
+ assert.strictEqual( mw.language.commafy( 123456789.567, '###,###,#0.00' ), '1,234,567,89.56', 'Decimal part as group of 3 and last one 2' );
} );
QUnit.test( 'mw.language.convertNumber', function ( assert ) {
mw.config.set( 'wgUserLanguage', 'en' );
mw.config.set( 'wgTranslateNumerals', true );
- assert.equal( mw.language.convertNumber( 180 ), '180', 'formatting 3-digit' );
- assert.equal( mw.language.convertNumber( 1800 ), '1.800', 'formatting 4-digit' );
- assert.equal( mw.language.convertNumber( 18000 ), '18.000', 'formatting 5-digit' );
+ assert.strictEqual( mw.language.convertNumber( 180 ), '180', 'formatting 3-digit' );
+ assert.strictEqual( mw.language.convertNumber( 1800 ), '1.800', 'formatting 4-digit' );
+ assert.strictEqual( mw.language.convertNumber( 18000 ), '18.000', 'formatting 5-digit' );
- assert.equal( mw.language.convertNumber( '1.800', true ), '1800', 'unformatting' );
+ assert.strictEqual( mw.language.convertNumber( '1.800', true ), 1800, 'unformatting' );
mw.language.setData( 'en', 'minimumGroupingDigits', 2 );
- assert.equal( mw.language.convertNumber( 180 ), '180', 'formatting 3-digit with minimumGroupingDigits=2' );
- assert.equal( mw.language.convertNumber( 1800 ), '1800', 'formatting 4-digit with minimumGroupingDigits=2' );
- assert.equal( mw.language.convertNumber( 18000 ), '18.000', 'formatting 5-digit with minimumGroupingDigits=2' );
+ assert.strictEqual( mw.language.convertNumber( 180 ), '180', 'formatting 3-digit with minimumGroupingDigits=2' );
+ assert.strictEqual( mw.language.convertNumber( 1800 ), '1800', 'formatting 4-digit with minimumGroupingDigits=2' );
+ assert.strictEqual( mw.language.convertNumber( 18000 ), '18.000', 'formatting 5-digit with minimumGroupingDigits=2' );
} );
QUnit.test( 'mw.language.convertNumber - digitTransformTable', function ( assert ) {
2: '२'
} );
- assert.equal( mw.language.convertNumber( 1200 ), '१.२००', 'format' );
- assert.equal( mw.language.convertNumber( '१.२००', true ), '1200', 'unformat from digit transform' );
- assert.equal( mw.language.convertNumber( '1.200', true ), '1200', 'unformat plain' );
+ assert.strictEqual( mw.language.convertNumber( 1200 ), '१.२००', 'format' );
+ assert.strictEqual( mw.language.convertNumber( '१.२००', true ), 1200, 'unformat from digit transform' );
+ assert.strictEqual( mw.language.convertNumber( '1.200', true ), 1200, 'unformat plain' );
mw.config.set( 'wgTranslateNumerals', false );
- assert.equal( mw.language.convertNumber( 1200 ), '1.200', 'format (digit transform disabled)' );
- assert.equal( mw.language.convertNumber( '१.२००', true ), '1200', 'unformat from digit transform (when disabled)' );
- assert.equal( mw.language.convertNumber( '1.200', true ), '1200', 'unformat plain (digit transform disabled)' );
+ assert.strictEqual( mw.language.convertNumber( 1200 ), '1.200', 'format (digit transform disabled)' );
+ assert.strictEqual( mw.language.convertNumber( '१.२००', true ), 1200, 'unformat from digit transform (when disabled)' );
+ assert.strictEqual( mw.language.convertNumber( '1.200', true ), 1200, 'unformat plain (digit transform disabled)' );
} );
function grammarTest( langCode, test ) {
QUnit.test( 'Grammar test for lang=' + langCode, function ( assert ) {
var i;
for ( i = 0; i < test.length; i++ ) {
- assert.equal(
+ assert.strictEqual(
mw.language.convertGrammar( test[ i ].word, test[ i ].grammarForm ),
test[ i ].expected,
test[ i ].description
} );
QUnit.test( 'List to text test', function ( assert ) {
- assert.equal( mw.language.listToText( [] ), '', 'Blank list' );
- assert.equal( mw.language.listToText( [ 'a' ] ), 'a', 'Single item' );
- assert.equal( mw.language.listToText( [ 'a', 'b' ] ), 'a and b', 'Two items' );
- assert.equal( mw.language.listToText( [ 'a', 'b', 'c' ] ), 'a, b and c', 'More than two items' );
+ assert.strictEqual( mw.language.listToText( [] ), '', 'Blank list' );
+ assert.strictEqual( mw.language.listToText( [ 'a' ] ), 'a', 'Single item' );
+ assert.strictEqual( mw.language.listToText( [ 'a', 'b' ] ), 'a and b', 'Two items' );
+ assert.strictEqual( mw.language.listToText( [ 'a', 'b', 'c' ] ), 'a, b and c', 'More than two items' );
} );
bcp47Tests = [
bcp47Tests.forEach( function ( data ) {
var input = data[ 0 ],
expected = data[ 1 ];
- assert.equal( mw.language.bcp47( input ), expected );
+ assert.strictEqual( mw.language.bcp47( input ), expected );
} );
} );
}( mediaWiki, jQuery ) );
var styleTestSince = new Date().getTime() - styleTestStart;
// If it is passing or if we timed out, run the real test and stop the loop
if ( isCssImportApplied() || styleTestSince > styleTestTimeout ) {
- assert.equal( $element.css( prop ), val,
+ assert.strictEqual( $element.css( prop ), val,
'style "' + prop + ': ' + val + '" from url is applied (after ' + styleTestSince + 'ms)'
);
mw.loader.implement(
'test.implement.a',
function () {
- assert.equal(
+ assert.strictEqual(
$element.css( 'float' ),
'right',
'style is applied'
mw.loader.implement(
'test.implement.c',
function () {
- assert.equal(
+ assert.strictEqual(
$element.css( 'float' ),
'right',
'style is applied'
mw.loader.implement(
'test.implement.order',
function () {
- assert.equal( mw.loader.getState( 'test.implement.order' ), 'executing', 'state during script execution' );
- assert.equal( mw.msg( 'test-foobar' ), 'Hello Foobar, $1!', 'messages load before script execution' );
+ assert.strictEqual( mw.loader.getState( 'test.implement.order' ), 'executing', 'state during script execution' );
+ assert.strictEqual( mw.msg( 'test-foobar' ), 'Hello Foobar, $1!', 'messages load before script execution' );
},
{},
{
);
return mw.loader.using( 'test.implement.order' ).then( function () {
- assert.equal( mw.loader.getState( 'test.implement.order' ), 'ready', 'final success state' );
+ assert.strictEqual( mw.loader.getState( 'test.implement.order' ), 'ready', 'final success state' );
} );
} );
$element = $( '<div class="mw-test-implement-import">Foo bar</div>' ).appendTo( '#qunit-fixture' );
assertStyleAsync( assert, $element, 'float', 'right', function () {
- assert.equal( $element.css( 'text-align' ), 'center',
+ assert.strictEqual( $element.css( 'text-align' ), 'center',
'CSS styles after the @import rule are working'
);
mw.loader.implement(
'test.implement.e',
function () {
- assert.equal(
+ assert.strictEqual(
$element.css( 'float' ),
'right',
'Depending module\'s style is applied'
mw.loader.implement(
'test.implement.e2',
function () {
- assert.equal(
+ assert.strictEqual(
$element2.css( 'float' ),
'left',
'Dependency\'s style is applied'
] );
function verifyModuleStates() {
- assert.equal( mw.loader.getState( 'testMissing' ), 'missing', 'Module "testMissing" state' );
- assert.equal( mw.loader.getState( 'testUsesMissing' ), 'error', 'Module "testUsesMissing" state' );
- assert.equal( mw.loader.getState( 'testUsesNestedMissing' ), 'error', 'Module "testUsesNestedMissing" state' );
+ assert.strictEqual( mw.loader.getState( 'testMissing' ), 'missing', 'Module "testMissing" state' );
+ assert.strictEqual( mw.loader.getState( 'testUsesMissing' ), 'error', 'Module "testUsesMissing" state' );
+ assert.strictEqual( mw.loader.getState( 'testUsesNestedMissing' ), 'error', 'Module "testUsesNestedMissing" state' );
}
mw.loader.using( [ 'testUsesNestedMissing' ],
return mw.loader.using( [ 'testUsesSkippable' ] ).then(
function () {
- assert.equal( mw.loader.getState( 'testSkipped' ), 'ready', 'Skipped module' );
- assert.equal( mw.loader.getState( 'testNotSkipped' ), 'ready', 'Regular module' );
- assert.equal( mw.loader.getState( 'testUsesSkippable' ), 'ready', 'Regular module with skippable dependency' );
+ assert.strictEqual( mw.loader.getState( 'testSkipped' ), 'ready', 'Skipped module' );
+ assert.strictEqual( mw.loader.getState( 'testNotSkipped' ), 'ready', 'Regular module' );
+ assert.strictEqual( mw.loader.getState( 'testUsesSkippable' ), 'ready', 'Regular module with skippable dependency' );
},
function ( e, badmodules ) {
// Should not fail and QUnit would already catch this,
);
// Ensure a protocol-relative URL for this test
target = target.replace( /https?:/, '' );
- assert.equal( target.slice( 0, 2 ), '//', 'URL is protocol-relative' );
+ assert.strictEqual( target.slice( 0, 2 ), '//', 'URL is protocol-relative' );
mw.loader.testCallback = function () {
// Ensure once, delete now
// URL to the callback script
target = QUnit.fixurl( mw.config.get( 'wgScriptPath' ) + '/tests/qunit/data/mwLoaderTestCallback.js' );
- assert.equal( target.slice( 0, 1 ), '/', 'URL is relative to document root' );
+ assert.strictEqual( target.slice( 0, 1 ), '/', 'URL is relative to document root' );
mw.loader.testCallback = function () {
// Ensure once, delete now
try {
assert.strictEqual( cb.later(), 'Defined.', 'require works asynchrously in debug mode' );
} catch ( e ) {
- assert.equal( String( e ), null, 'require works asynchrously in debug mode' );
+ assert.strictEqual( String( e ), null, 'require works asynchrously in debug mode' );
}
} );
} );
} );
QUnit.test( 'mw.format', function ( assert ) {
- assert.equal(
+ assert.strictEqual(
mw.format( 'Format $1 $2', 'foo', 'bar' ),
'Format foo bar',
'Simple parameters'
);
- assert.equal(
+ assert.strictEqual(
mw.format( 'Format $1 $2' ),
'Format $1 $2',
'Missing parameters'
} );
QUnit.test( 'mw.now', function ( assert ) {
- assert.equal( typeof mw.now(), 'number', 'Return a number' );
- assert.equal(
+ assert.strictEqual( typeof mw.now(), 'number', 'Return a number' );
+ assert.strictEqual(
String( Math.round( mw.now() ) ).length,
String( +new Date() ).length,
'Match size of current timestamp'
// Single get and set
assert.strictEqual( conf.set( 'foo', 'Bar' ), true, 'Map.set returns boolean true if a value was set for a valid key string' );
- assert.equal( conf.get( 'foo' ), 'Bar', 'Map.get returns a single value value correctly' );
+ assert.strictEqual( conf.get( 'foo' ), 'Bar', 'Map.get returns a single value value correctly' );
assert.strictEqual( conf.get( 'example' ), null, 'Map.get returns null if selection was a string and the key was not found' );
assert.strictEqual( conf.get( 'example', arry ), arry, 'Map.get returns fallback by reference if the key was not found' );
assert.strictEqual( conf.set( 'undef' ), false, 'Map.set requires explicit value (no undefined default)' );
assert.strictEqual( conf.set( 'undef', undefined ), true, 'Map.set allows setting value to `undefined`' );
- assert.equal( conf.get( 'undef', 'fallback' ), undefined, 'Map.get supports retreiving value of `undefined`' );
+ assert.strictEqual( conf.get( 'undef', 'fallback' ), undefined, 'Map.get supports retreiving value of `undefined`' );
assert.strictEqual( conf.set( funky, 'Funky' ), false, 'Map.set returns boolean false if key was invalid (Function)' );
assert.strictEqual( conf.set( arry, 'Arry' ), false, 'Map.set returns boolean false if key was invalid (Array)' );
// Interacting with globals
conf.set( 'globalMapChecker', 'Hi' );
- assert.equal( 'globalMapChecker' in window, false, 'Map does not its store values in the window object by default' );
+ assert.strictEqual( 'globalMapChecker' in window, false, 'Map does not its store values in the window object by default' );
globalConf = new mw.Map( true );
globalConf.set( 'anotherGlobalMapChecker', 'Hello' );
assert.ok( 'anotherGlobalMapChecker' in window, 'global Map stores its values in the window object' );
- assert.equal( globalConf.get( 'anotherGlobalMapChecker' ), 'Hello', 'get value from global Map via get()' );
+ assert.strictEqual( globalConf.get( 'anotherGlobalMapChecker' ), 'Hello', 'get value from global Map via get()' );
this.suppressWarnings();
- assert.equal( window.anotherGlobalMapChecker, 'Hello', 'get value from global Map via window object' );
+ assert.strictEqual( window.anotherGlobalMapChecker, 'Hello', 'get value from global Map via window object' );
this.restoreWarnings();
// Change value via global Map
globalConf.set( 'anotherGlobalMapChecker', 'Again' );
- assert.equal( globalConf.get( 'anotherGlobalMapChecker' ), 'Again', 'Change in global Map reflected via get()' );
+ assert.strictEqual( globalConf.get( 'anotherGlobalMapChecker' ), 'Again', 'Change in global Map reflected via get()' );
this.suppressWarnings();
- assert.equal( window.anotherGlobalMapChecker, 'Again', 'Change in global Map reflected window object' );
+ assert.strictEqual( window.anotherGlobalMapChecker, 'Again', 'Change in global Map reflected window object' );
this.restoreWarnings();
// Change value via window object
this.suppressWarnings();
window.anotherGlobalMapChecker = 'World';
- assert.equal( window.anotherGlobalMapChecker, 'World', 'Change in window object works' );
+ assert.strictEqual( window.anotherGlobalMapChecker, 'World', 'Change in window object works' );
this.restoreWarnings();
- assert.equal( globalConf.get( 'anotherGlobalMapChecker' ), 'Again', 'Change in window object not reflected in global Map' );
+ assert.strictEqual( globalConf.get( 'anotherGlobalMapChecker' ), 'Again', 'Change in window object not reflected in global Map' );
// Whitelist this global variable for QUnit's 'noglobal' mode
if ( QUnit.config.noglobals ) {
for ( i = 0; i < len; i++ ) {
format = formats[ i ];
- assert.equal( mw.message.apply( null, messageArguments )[ format ](), expectedResult, assertMessage + ' when format is ' + format );
+ assert.strictEqual( mw.message.apply( null, messageArguments )[ format ](), expectedResult, assertMessage + ' when format is ' + format );
}
}
hello = mw.message( 'hello' );
// https://phabricator.wikimedia.org/T46459
- assert.equal( hello.format, 'text', 'Message property "format" defaults to "text"' );
+ assert.strictEqual( hello.format, 'text', 'Message property "format" defaults to "text"' );
assert.strictEqual( hello.map, mw.messages, 'Message property "map" defaults to the global instance in mw.messages' );
- assert.equal( hello.key, 'hello', 'Message property "key" (currect key)' );
+ assert.strictEqual( hello.key, 'hello', 'Message property "key" (currect key)' );
assert.deepEqual( hello.parameters, [], 'Message property "parameters" defaults to an empty array' );
// TODO
assert.ok( hello.params, 'Message prototype "params"' );
hello.format = 'plain';
- assert.equal( hello.toString(), 'Hello <b>awesome</b> world', 'Message.toString returns the message as a string with the current "format"' );
+ assert.strictEqual( hello.toString(), 'Hello <b>awesome</b> world', 'Message.toString returns the message as a string with the current "format"' );
- assert.equal( hello.escaped(), 'Hello <b>awesome</b> world', 'Message.escaped returns the escaped message' );
- assert.equal( hello.format, 'escaped', 'Message.escaped correctly updated the "format" property' );
+ assert.strictEqual( hello.escaped(), 'Hello <b>awesome</b> world', 'Message.escaped returns the escaped message' );
+ assert.strictEqual( hello.format, 'escaped', 'Message.escaped correctly updated the "format" property' );
assert.ok( mw.messages.set( 'multiple-curly-brace', '"{{SITENAME}}" is the home of {{int:other-message}}' ), 'mw.messages.set: Register' );
assertMultipleFormats( [ 'multiple-curly-brace' ], [ 'text', 'parse' ], '"' + siteName + '" is the home of Other Message', 'Curly brace format works correctly' );
- assert.equal( mw.message( 'multiple-curly-brace' ).plain(), mw.messages.get( 'multiple-curly-brace' ), 'Plain format works correctly for curly brace message' );
- assert.equal( mw.message( 'multiple-curly-brace' ).escaped(), mw.html.escape( '"' + siteName + '" is the home of Other Message' ), 'Escaped format works correctly for curly brace message' );
+ assert.strictEqual( mw.message( 'multiple-curly-brace' ).plain(), mw.messages.get( 'multiple-curly-brace' ), 'Plain format works correctly for curly brace message' );
+ assert.strictEqual( mw.message( 'multiple-curly-brace' ).escaped(), mw.html.escape( '"' + siteName + '" is the home of Other Message' ), 'Escaped format works correctly for curly brace message' );
assert.ok( mw.messages.set( 'multiple-square-brackets-and-ampersand', 'Visit the [[Project:Community portal|community portal]] & [[Project:Help desk|help desk]]' ), 'mw.messages.set: Register' );
assertMultipleFormats( [ 'multiple-square-brackets-and-ampersand' ], [ 'plain', 'text' ], mw.messages.get( 'multiple-square-brackets-and-ampersand' ), 'Square bracket message is not processed' );
- assert.equal( mw.message( 'multiple-square-brackets-and-ampersand' ).escaped(), 'Visit the [[Project:Community portal|community portal]] & [[Project:Help desk|help desk]]', 'Escaped format works correctly for square bracket message' );
+ assert.strictEqual( mw.message( 'multiple-square-brackets-and-ampersand' ).escaped(), 'Visit the [[Project:Community portal|community portal]] & [[Project:Help desk|help desk]]', 'Escaped format works correctly for square bracket message' );
assert.htmlEqual( mw.message( 'multiple-square-brackets-and-ampersand' ).parse(), 'Visit the ' +
'<a title="Project:Community portal" href="/wiki/Project:Community_portal">community portal</a>' +
' & <a title="Project:Help desk" href="/wiki/Project:Help_desk">help desk</a>', 'Internal links work with parse' );
assert.htmlEqual( mw.message( 'mediawiki-test-version-entrypoints-index-php' ).parse(), '<a href="https://www.mediawiki.org/wiki/Manual:index.php">index.php</a>', 'External link works correctly in parse mode' );
assertMultipleFormats( [ 'external-link-replace', 'http://example.org/?x=y&z' ], [ 'plain', 'text' ], 'Foo [http://example.org/?x=y&z bar]', 'Parameters are substituted but external link is not processed' );
- assert.equal( mw.message( 'external-link-replace', 'http://example.org/?x=y&z' ).escaped(), 'Foo [http://example.org/?x=y&z bar]', 'In escaped mode, parameters are substituted and ampersand is escaped, but external link is not processed' );
+ assert.strictEqual( mw.message( 'external-link-replace', 'http://example.org/?x=y&z' ).escaped(), 'Foo [http://example.org/?x=y&z bar]', 'In escaped mode, parameters are substituted and ampersand is escaped, but external link is not processed' );
assert.htmlEqual( mw.message( 'external-link-replace', 'http://example.org/?x=y&z' ).parse(), 'Foo <a href="http://example.org/?x=y&z">bar</a>', 'External link with replacement works in parse mode without double-escaping' );
hello.parse();
- assert.equal( hello.format, 'parse', 'Message.parse correctly updated the "format" property' );
+ assert.strictEqual( hello.format, 'parse', 'Message.parse correctly updated the "format" property' );
hello.plain();
- assert.equal( hello.format, 'plain', 'Message.plain correctly updated the "format" property' );
+ assert.strictEqual( hello.format, 'plain', 'Message.plain correctly updated the "format" property' );
hello.text();
- assert.equal( hello.format, 'text', 'Message.text correctly updated the "format" property' );
+ assert.strictEqual( hello.format, 'text', 'Message.text correctly updated the "format" property' );
assert.strictEqual( hello.exists(), true, 'Message.exists returns true for existing messages' );
assert.ok( mw.messages.set( 'plural-test-msg', 'There {{PLURAL:$1|is|are}} $1 {{PLURAL:$1|result|results}}' ), 'mw.messages.set: Register' );
assertMultipleFormats( [ 'plural-test-msg', 6 ], [ 'text', 'parse', 'escaped' ], 'There are 6 results', 'plural get resolved' );
- assert.equal( mw.message( 'plural-test-msg', 6 ).plain(), 'There {{PLURAL:6|is|are}} 6 {{PLURAL:6|result|results}}', 'Parameter is substituted but plural is not resolved in plain' );
+ assert.strictEqual( mw.message( 'plural-test-msg', 6 ).plain(), 'There {{PLURAL:6|is|are}} 6 {{PLURAL:6|result|results}}', 'Parameter is substituted but plural is not resolved in plain' );
assert.ok( mw.messages.set( 'plural-test-msg-explicit', 'There {{plural:$1|is one car|are $1 cars|0=are no cars|12=are a dozen cars}}' ), 'mw.messages.set: Register message with explicit plural forms' );
assertMultipleFormats( [ 'plural-test-msg-explicit', 12 ], [ 'text', 'parse', 'escaped' ], 'There are a dozen cars', 'explicit plural get resolved' );
assertMultipleFormats( [ 'mediawiki-test-pagetriage-del-talk-page-notify-summary', specialCharactersPageName ], [ 'plain', 'text' ], 'Notifying author of deletion nomination for [[' + specialCharactersPageName + ']]', 'Double square brackets with one parameter' );
- assert.equal( mw.message( 'mediawiki-test-pagetriage-del-talk-page-notify-summary', specialCharactersPageName ).escaped(), 'Notifying author of deletion nomination for [[' + mw.html.escape( specialCharactersPageName ) + ']]', 'Double square brackets with one parameter, when escaped' );
+ assert.strictEqual( mw.message( 'mediawiki-test-pagetriage-del-talk-page-notify-summary', specialCharactersPageName ).escaped(), 'Notifying author of deletion nomination for [[' + mw.html.escape( specialCharactersPageName ) + ']]', 'Double square brackets with one parameter, when escaped' );
assert.ok( mw.messages.set( 'mediawiki-test-categorytree-collapse-bullet', '[<b>−</b>]' ), 'mw.messages.set: Register' );
- assert.equal( mw.message( 'mediawiki-test-categorytree-collapse-bullet' ).plain(), mw.messages.get( 'mediawiki-test-categorytree-collapse-bullet' ), 'Single square brackets unchanged in plain mode' );
+ assert.strictEqual( mw.message( 'mediawiki-test-categorytree-collapse-bullet' ).plain(), mw.messages.get( 'mediawiki-test-categorytree-collapse-bullet' ), 'Single square brackets unchanged in plain mode' );
assert.ok( mw.messages.set( 'mediawiki-test-wikieditor-toolbar-help-content-signature-result', '<a href=\'#\' title=\'{{#special:mypage}}\'>Username</a> (<a href=\'#\' title=\'{{#special:mytalk}}\'>talk</a>)' ), 'mw.messages.set: Register' );
- assert.equal( mw.message( 'mediawiki-test-wikieditor-toolbar-help-content-signature-result' ).plain(), mw.messages.get( 'mediawiki-test-wikieditor-toolbar-help-content-signature-result' ), 'HTML message with curly braces is not changed in plain mode' );
+ assert.strictEqual( mw.message( 'mediawiki-test-wikieditor-toolbar-help-content-signature-result' ).plain(), mw.messages.get( 'mediawiki-test-wikieditor-toolbar-help-content-signature-result' ), 'HTML message with curly braces is not changed in plain mode' );
assertMultipleFormats( [ 'gender-plural-msg', 'male', 1 ], [ 'text', 'parse', 'escaped' ], 'he is awesome', 'Gender and plural are resolved' );
- assert.equal( mw.message( 'gender-plural-msg', 'male', 1 ).plain(), '{{GENDER:male|he|she|they}} {{PLURAL:1|is|are}} awesome', 'Parameters are substituted, but gender and plural are not resolved in plain mode' );
+ assert.strictEqual( mw.message( 'gender-plural-msg', 'male', 1 ).plain(), '{{GENDER:male|he|she|they}} {{PLURAL:1|is|are}} awesome', 'Parameters are substituted, but gender and plural are not resolved in plain mode' );
- assert.equal( mw.message( 'grammar-msg' ).plain(), mw.messages.get( 'grammar-msg' ), 'Grammar is not resolved in plain mode' );
+ assert.strictEqual( mw.message( 'grammar-msg' ).plain(), mw.messages.get( 'grammar-msg' ), 'Grammar is not resolved in plain mode' );
assertMultipleFormats( [ 'grammar-msg' ], [ 'text', 'parse' ], 'Przeszukaj ' + siteName, 'Grammar is resolved' );
- assert.equal( mw.message( 'grammar-msg' ).escaped(), 'Przeszukaj ' + siteName, 'Grammar is resolved in escaped mode' );
+ assert.strictEqual( mw.message( 'grammar-msg' ).escaped(), 'Przeszukaj ' + siteName, 'Grammar is resolved in escaped mode' );
assertMultipleFormats( [ 'formatnum-msg', '987654321.654321' ], [ 'text', 'parse', 'escaped' ], '987,654,321.654', 'formatnum is resolved' );
- assert.equal( mw.message( 'formatnum-msg' ).plain(), mw.messages.get( 'formatnum-msg' ), 'formatnum is not resolved in plain mode' );
+ assert.strictEqual( mw.message( 'formatnum-msg' ).plain(), mw.messages.get( 'formatnum-msg' ), 'formatnum is not resolved in plain mode' );
assertMultipleFormats( [ 'int-msg' ], [ 'text', 'parse', 'escaped' ], 'Some Other Message', 'int is resolved' );
- assert.equal( mw.message( 'int-msg' ).plain(), mw.messages.get( 'int-msg' ), 'int is not resolved in plain mode' );
+ assert.strictEqual( mw.message( 'int-msg' ).plain(), mw.messages.get( 'int-msg' ), 'int is not resolved in plain mode' );
assert.ok( mw.messages.set( 'mediawiki-italics-msg', '<i>Very</i> important' ), 'mw.messages.set: Register' );
assertMultipleFormats( [ 'mediawiki-italics-msg' ], [ 'plain', 'text', 'parse' ], mw.messages.get( 'mediawiki-italics-msg' ), 'Simple italics unchanged' );
QUnit.test( 'mw.msg', function ( assert ) {
assert.ok( mw.messages.set( 'hello', 'Hello <b>awesome</b> world' ), 'mw.messages.set: Register' );
- assert.equal( mw.msg( 'hello' ), 'Hello <b>awesome</b> world', 'Gets message with default options (existing message)' );
- assert.equal( mw.msg( 'goodbye' ), '⧼goodbye⧽', 'Gets message with default options (nonexistent message)' );
+ assert.strictEqual( mw.msg( 'hello' ), 'Hello <b>awesome</b> world', 'Gets message with default options (existing message)' );
+ assert.strictEqual( mw.msg( 'goodbye' ), '⧼goodbye⧽', 'Gets message with default options (nonexistent message)' );
assert.ok( mw.messages.set( 'plural-item', 'Found $1 {{PLURAL:$1|item|items}}' ), 'mw.messages.set: Register' );
- assert.equal( mw.msg( 'plural-item', 5 ), 'Found 5 items', 'Apply plural for count 5' );
- assert.equal( mw.msg( 'plural-item', 0 ), 'Found 0 items', 'Apply plural for count 0' );
- assert.equal( mw.msg( 'plural-item', 1 ), 'Found 1 item', 'Apply plural for count 1' );
+ assert.strictEqual( mw.msg( 'plural-item', 5 ), 'Found 5 items', 'Apply plural for count 5' );
+ assert.strictEqual( mw.msg( 'plural-item', 0 ), 'Found 0 items', 'Apply plural for count 0' );
+ assert.strictEqual( mw.msg( 'plural-item', 1 ), 'Found 1 item', 'Apply plural for count 1' );
- assert.equal( mw.msg( 'mediawiki-test-pagetriage-del-talk-page-notify-summary', specialCharactersPageName ), 'Notifying author of deletion nomination for [[' + specialCharactersPageName + ']]', 'Double square brackets in mw.msg one parameter' );
+ assert.strictEqual( mw.msg( 'mediawiki-test-pagetriage-del-talk-page-notify-summary', specialCharactersPageName ), 'Notifying author of deletion nomination for [[' + specialCharactersPageName + ']]', 'Double square brackets in mw.msg one parameter' );
- assert.equal( mw.msg( 'gender-plural-msg', 'male', 1 ), 'he is awesome', 'Gender test for male, plural count 1' );
- assert.equal( mw.msg( 'gender-plural-msg', 'female', '1' ), 'she is awesome', 'Gender test for female, plural count 1' );
- assert.equal( mw.msg( 'gender-plural-msg', 'unknown', 10 ), 'they are awesome', 'Gender test for neutral, plural count 10' );
+ assert.strictEqual( mw.msg( 'gender-plural-msg', 'male', 1 ), 'he is awesome', 'Gender test for male, plural count 1' );
+ assert.strictEqual( mw.msg( 'gender-plural-msg', 'female', '1' ), 'she is awesome', 'Gender test for female, plural count 1' );
+ assert.strictEqual( mw.msg( 'gender-plural-msg', 'unknown', 10 ), 'they are awesome', 'Gender test for neutral, plural count 10' );
- assert.equal( mw.msg( 'grammar-msg' ), 'Przeszukaj ' + siteName, 'Grammar is resolved' );
+ assert.strictEqual( mw.msg( 'grammar-msg' ), 'Przeszukaj ' + siteName, 'Grammar is resolved' );
- assert.equal( mw.msg( 'formatnum-msg', '987654321.654321' ), '987,654,321.654', 'formatnum is resolved' );
+ assert.strictEqual( mw.msg( 'formatnum-msg', '987654321.654321' ), '987,654,321.654', 'formatnum is resolved' );
- assert.equal( mw.msg( 'int-msg' ), 'Some Other Message', 'int is resolved' );
+ assert.strictEqual( mw.msg( 'int-msg' ), 'Some Other Message', 'int is resolved' );
} );
QUnit.test( 'mw.hook', function ( assert ) {
mw.hook( 'hasOwnProperty' ).fire();
mw.hook( 'test.hook.data' ).add( function ( data1, data2 ) {
- assert.equal( data1, 'example', 'Fire with data (string param)' );
+ assert.strictEqual( data1, 'example', 'Fire with data (string param)' );
assert.deepEqual( data2, [ 'two' ], 'Fire with data (array param)' );
} );
mw.hook( 'test.hook.data' ).fire( 'example', [ 'two' ] );
} )
.fire( 'x' ).fire( 'y' ).fire( 'z' )
.add( function ( chr ) {
- assert.equal( chr, 'z', 'Adding callback later invokes right away with last data' );
+ assert.strictEqual( chr, 'z', 'Adding callback later invokes right away with last data' );
} );
assert.deepEqual( chars, [ 'x', 'y', 'z' ], 'Multiple callbacks with multiple fires' );
mw.config.set( 'wgUserName', 'John' );
mw.config.set( 'wgUserId', 123 );
- assert.equal( mw.user.getName(), 'John', 'getName()' );
+ assert.strictEqual( mw.user.getName(), 'John', 'getName()' );
assert.strictEqual( mw.user.isAnon(), false, 'isAnon()' );
assert.strictEqual( mw.user.getId(), 123, 'getId()' );
- assert.equal( mw.user.id(), 'John', 'user.id()' );
+ assert.strictEqual( mw.user.id(), 'John', 'user.id()' );
} );
QUnit.test( 'getUserInfo', function ( assert ) {
var result, result2;
result = mw.user.generateRandomSessionId();
- assert.equal( typeof result, 'string', 'type' );
- assert.equal( $.trim( result ), result, 'no whitespace at beginning or end' );
- assert.equal( result.length, 16, 'size' );
+ assert.strictEqual( typeof result, 'string', 'type' );
+ assert.strictEqual( $.trim( result ), result, 'no whitespace at beginning or end' );
+ assert.strictEqual( result.length, 16, 'size' );
result2 = mw.user.generateRandomSessionId();
assert.notEqual( result, result2, 'different when called multiple times' );
}
result = mw.user.generateRandomSessionId();
- assert.equal( typeof result, 'string', 'type' );
- assert.equal( $.trim( result ), result, 'no whitespace at beginning or end' );
- assert.equal( result.length, 16, 'size' );
+ assert.strictEqual( typeof result, 'string', 'type' );
+ assert.strictEqual( $.trim( result ), result, 'no whitespace at beginning or end' );
+ assert.strictEqual( result.length, 16, 'size' );
result2 = mw.user.generateRandomSessionId();
assert.notEqual( result, result2, 'different when called multiple times' );
QUnit.test( 'stickyRandomId', function ( assert ) {
var result = mw.user.stickyRandomId(),
result2 = mw.user.stickyRandomId();
- assert.equal( typeof result, 'string', 'type' );
+ assert.strictEqual( typeof result, 'string', 'type' );
assert.strictEqual( /^[a-f0-9]{16}$/.test( result ), true, '16 HEX symbols string' );
- assert.equal( result2, result, 'sticky' );
+ assert.strictEqual( result2, result, 'sticky' );
} );
QUnit.test( 'sessionId', function ( assert ) {
var result = mw.user.sessionId(),
result2 = mw.user.sessionId();
- assert.equal( typeof result, 'string', 'type' );
- assert.equal( $.trim( result ), result, 'no leading or trailing whitespace' );
- assert.equal( result2, result, 'retained' );
+ assert.strictEqual( typeof result, 'string', 'type' );
+ assert.strictEqual( $.trim( result ), result, 'no leading or trailing whitespace' );
+ assert.strictEqual( result2, result, 'retained' );
} );
}( mediaWiki, jQuery ) );
} ) );
QUnit.test( 'rawurlencode', function ( assert ) {
- assert.equal( util.rawurlencode( 'Test:A & B/Here' ), 'Test%3AA%20%26%20B%2FHere' );
+ assert.strictEqual( util.rawurlencode( 'Test:A & B/Here' ), 'Test%3AA%20%26%20B%2FHere' );
} );
QUnit.test( 'escapeIdForAttribute', function ( assert ) {
].forEach( function ( testCase ) {
mw.config.set( 'wgFragmentMode', testCase[ 0 ] );
- assert.equal( util.escapeIdForAttribute( testCase[ 1 ] ), testCase[ 2 ] );
+ assert.strictEqual( util.escapeIdForAttribute( testCase[ 1 ] ), testCase[ 2 ] );
} );
} );
].forEach( function ( testCase ) {
mw.config.set( 'wgFragmentMode', testCase[ 0 ] );
- assert.equal( util.escapeIdForLink( testCase[ 1 ] ), testCase[ 2 ] );
+ assert.strictEqual( util.escapeIdForLink( testCase[ 1 ] ), testCase[ 2 ] );
} );
} );
QUnit.test( 'wikiUrlencode', function ( assert ) {
- assert.equal( util.wikiUrlencode( 'Test:A & B/Here' ), 'Test:A_%26_B/Here' );
+ assert.strictEqual( util.wikiUrlencode( 'Test:A & B/Here' ), 'Test:A_%26_B/Here' );
// See also wfUrlencodeTest.php#provideURLS
$.each( {
'+': '%2B',
'<>': '%3C%3E',
'\'': '%27'
}, function ( input, output ) {
- assert.equal( util.wikiUrlencode( input ), output );
+ assert.strictEqual( util.wikiUrlencode( input ), output );
} );
} );
} );
href = util.getUrl( 'Sandbox' );
- assert.equal( href, '/wiki/Sandbox', 'simple title' );
+ assert.strictEqual( href, '/wiki/Sandbox', 'simple title' );
href = util.getUrl( 'Foo:Sandbox? 5+5=10! (test)/sub ' );
- assert.equal( href, '/wiki/Foo:Sandbox%3F_5%2B5%3D10!_(test)/sub_', 'complex title' );
+ assert.strictEqual( href, '/wiki/Foo:Sandbox%3F_5%2B5%3D10!_(test)/sub_', 'complex title' );
// T149767
href = util.getUrl( 'My$$test$$$$$title' );
- assert.equal( href, '/wiki/My$$test$$$$$title', 'title with multiple consecutive dollar signs' );
+ assert.strictEqual( href, '/wiki/My$$test$$$$$title', 'title with multiple consecutive dollar signs' );
href = util.getUrl();
- assert.equal( href, '/wiki/Foobar', 'default title' );
+ assert.strictEqual( href, '/wiki/Foobar', 'default title' );
href = util.getUrl( null, { action: 'edit' } );
- assert.equal( href, '/w/index.php?title=Foobar&action=edit', 'default title with query string' );
+ assert.strictEqual( href, '/w/index.php?title=Foobar&action=edit', 'default title with query string' );
href = util.getUrl( 'Sandbox', { action: 'edit' } );
- assert.equal( href, '/w/index.php?title=Sandbox&action=edit', 'simple title with query string' );
+ assert.strictEqual( href, '/w/index.php?title=Sandbox&action=edit', 'simple title with query string' );
// Test fragments
href = util.getUrl( 'Foo:Sandbox#Fragment', { action: 'edit' } );
- assert.equal( href, '/w/index.php?title=Foo:Sandbox&action=edit#Fragment', 'namespaced title with query string and fragment' );
+ assert.strictEqual( href, '/w/index.php?title=Foo:Sandbox&action=edit#Fragment', 'namespaced title with query string and fragment' );
href = util.getUrl( 'Sandbox#', { action: 'edit' } );
- assert.equal( href, '/w/index.php?title=Sandbox&action=edit', 'title with query string and empty fragment' );
+ assert.strictEqual( href, '/w/index.php?title=Sandbox&action=edit', 'title with query string and empty fragment' );
href = util.getUrl( 'Sandbox', {} );
- assert.equal( href, '/wiki/Sandbox', 'title with empty query string' );
+ assert.strictEqual( href, '/wiki/Sandbox', 'title with empty query string' );
href = util.getUrl( '#Fragment' );
- assert.equal( href, '/wiki/#Fragment', 'empty title with fragment' );
+ assert.strictEqual( href, '/wiki/#Fragment', 'empty title with fragment' );
href = util.getUrl( '#Fragment', { action: 'edit' } );
- assert.equal( href, '/w/index.php?action=edit#Fragment', 'empty title with query string and fragment' );
+ assert.strictEqual( href, '/w/index.php?action=edit#Fragment', 'empty title with query string and fragment' );
mw.config.set( 'wgFragmentMode', [ 'legacy' ] );
href = util.getUrl( 'Foo:Sandbox \xC4#Fragment \xC4', { action: 'edit' } );
- assert.equal( href, '/w/index.php?title=Foo:Sandbox_%C3%84&action=edit#Fragment_.C3.84', 'title with query string, fragment, and special characters' );
+ assert.strictEqual( href, '/w/index.php?title=Foo:Sandbox_%C3%84&action=edit#Fragment_.C3.84', 'title with query string, fragment, and special characters' );
mw.config.set( 'wgFragmentMode', [ 'html5' ] );
href = util.getUrl( 'Foo:Sandbox \xC4#Fragment \xC4', { action: 'edit' } );
- assert.equal( href, '/w/index.php?title=Foo:Sandbox_%C3%84&action=edit#Fragment_Ä', 'title with query string, fragment, and special characters' );
+ assert.strictEqual( href, '/w/index.php?title=Foo:Sandbox_%C3%84&action=edit#Fragment_Ä', 'title with query string, fragment, and special characters' );
href = util.getUrl( 'Foo:%23#Fragment', { action: 'edit' } );
- assert.equal( href, '/w/index.php?title=Foo:%2523&action=edit#Fragment', 'title containing %23 (#), fragment, and a query string' );
+ assert.strictEqual( href, '/w/index.php?title=Foo:%2523&action=edit#Fragment', 'title containing %23 (#), fragment, and a query string' );
mw.config.set( 'wgFragmentMode', [ 'legacy' ] );
href = util.getUrl( '#+&=:;@$-_.!*/[]<>\'§', { action: 'edit' } );
- assert.equal( href, '/w/index.php?action=edit#.2B.26.3D:.3B.40.24-_..21.2A.2F.5B.5D.3C.3E.27.C2.A7', 'fragment with various characters' );
+ assert.strictEqual( href, '/w/index.php?action=edit#.2B.26.3D:.3B.40.24-_..21.2A.2F.5B.5D.3C.3E.27.C2.A7', 'fragment with various characters' );
mw.config.set( 'wgFragmentMode', [ 'html5' ] );
href = util.getUrl( '#+&=:;@$-_.!*/[]<>\'§', { action: 'edit' } );
- assert.equal( href, '/w/index.php?action=edit#+&=:;@$-_.!*/[]<>\'§', 'fragment with various characters' );
+ assert.strictEqual( href, '/w/index.php?action=edit#+&=:;@$-_.!*/[]<>\'§', 'fragment with various characters' );
} );
QUnit.test( 'wikiScript', function ( assert ) {
wgScriptPath: '/w'
} );
- assert.equal( util.wikiScript(), mw.config.get( 'wgScript' ),
+ assert.strictEqual( util.wikiScript(), mw.config.get( 'wgScript' ),
'wikiScript() returns wgScript'
);
- assert.equal( util.wikiScript( 'index' ), mw.config.get( 'wgScript' ),
+ assert.strictEqual( util.wikiScript( 'index' ), mw.config.get( 'wgScript' ),
'wikiScript( index ) returns wgScript'
);
- assert.equal( util.wikiScript( 'load' ), mw.config.get( 'wgLoadScript' ),
+ assert.strictEqual( util.wikiScript( 'load' ), mw.config.get( 'wgLoadScript' ),
'wikiScript( load ) returns wgLoadScript'
);
- assert.equal( util.wikiScript( 'api' ), '/w/api.php', 'API path' );
+ assert.strictEqual( util.wikiScript( 'api' ), '/w/api.php', 'API path' );
} );
QUnit.test( 'addCSS', function ( assert ) {
$el = $( '<div>' ).attr( 'id', 'mw-addcsstest' ).appendTo( '#qunit-fixture' );
style = util.addCSS( '#mw-addcsstest { visibility: hidden; }' );
- assert.equal( typeof style, 'object', 'addCSS returned an object' );
+ assert.strictEqual( typeof style, 'object', 'addCSS returned an object' );
assert.strictEqual( style.disabled, false, 'property "disabled" is available and set to false' );
- assert.equal( $el.css( 'visibility' ), 'hidden', 'Added style properties are in effect' );
+ assert.strictEqual( $el.css( 'visibility' ), 'hidden', 'Added style properties are in effect' );
// Clean up
$( style.ownerNode ).remove();
var url;
url = 'http://example.org/?foo=wrong&foo=right#&foo=bad';
- assert.equal( util.getParamValue( 'foo', url ), 'right', 'Use latest one, ignore hash' );
+ assert.strictEqual( util.getParamValue( 'foo', url ), 'right', 'Use latest one, ignore hash' );
assert.strictEqual( util.getParamValue( 'bar', url ), null, 'Return null when not found' );
url = 'http://example.org/#&foo=bad';
'Validate attributes of anchor tag in created element'
);
- assert.equal( $tbMW.closest( '.portlet' ).attr( 'id' ), 'p-test-tb', 'Link was inserted within correct portlet' );
+ assert.strictEqual( $tbMW.closest( '.portlet' ).attr( 'id' ), 'p-test-tb', 'Link was inserted within correct portlet' );
assert.strictEqual( $tbMW.next()[ 0 ], tbRL, 'Link is in the correct position (nextnode as Node object)' );
cuQuux = util.addPortletLink( 'p-test-custom', '#', 'Quux', null, 'Example [shift-x]', 'q' );
$cuQuux = $( cuQuux );
- assert.equal( $cuQuux.find( 'a' ).attr( 'title' ), 'Example [test-q]', 'Existing accesskey is stripped and updated' );
+ assert.strictEqual( $cuQuux.find( 'a' ).attr( 'title' ), 'Example [test-q]', 'Existing accesskey is stripped and updated' );
- assert.equal(
+ assert.strictEqual(
$( '#p-test-custom #c-barmenu ul li' ).length,
1,
'addPortletLink did not add the item to all <ul> elements in the portlet (T37082)'
tbRLDMnonexistentid = util.addPortletLink( 'p-test-tb', '//mediawiki.org/wiki/RL/DM',
'Default modules', 't-rldm-nonexistent', 'List of all default modules ', 'd', '#t-rl-nonexistent' );
- assert.equal( tbRLDMnonexistentid, $( '#p-test-tb li:last' )[ 0 ], 'Fallback to adding at the end (nextnode non-matching CSS selector)' );
+ assert.strictEqual( tbRLDMnonexistentid, $( '#p-test-tb li:last' )[ 0 ], 'Fallback to adding at the end (nextnode non-matching CSS selector)' );
// test case - empty jquery object as next node
tbRLDMemptyjquery = util.addPortletLink( 'p-test-tb', '//mediawiki.org/wiki/RL/DM',
'Default modules', 't-rldm-empty-jquery', 'List of all default modules ', 'd', $( '#t-rl-nonexistent' ) );
- assert.equal( tbRLDMemptyjquery, $( '#p-test-tb li:last' )[ 0 ], 'Fallback to adding at the end (nextnode as empty jQuery object)' );
+ assert.strictEqual( tbRLDMemptyjquery, $( '#p-test-tb li:last' )[ 0 ], 'Fallback to adding at the end (nextnode as empty jQuery object)' );
} );
QUnit.test( 'validateEmail', function ( assert ) {
dépôts / lhc / web / wiklou.git / commitdiff