WordPress.org

Make WordPress Core

Changeset 40399


Ignore:
Timestamp:
04/09/17 23:10:15 (3 months ago)
Author:
azaozz
Message:

TinyMCE: update the tests for version 4.5.6. Remove default plugins tests, it is quite pointless to keep repeating them at this point.

See #40305.

Location:
trunk/tests/qunit/editor
Files:
15 added
1 deleted
27 edited

Legend:

Unmodified
Added
Removed
  • trunk/tests/qunit/editor/index.html

    r38773 r40399  
    4141    <script src="tinymce/caret/LineWalker.js"></script> 
    4242 
     43    <!-- tinymce.content.* --> 
     44    <script src="tinymce/content/LinkTargets.js"></script> 
     45 
    4346    <!-- tinymce.geom.* --> 
    4447    <script src="tinymce/geom/Rect.js"></script> 
     
    5255    <!-- tinymce.fmt.* --> 
    5356    <script src="tinymce/fmt/Hooks.js"></script> 
     57    <script src="tinymce/fmt/Preview.js"></script> 
     58    <script src="tinymce/fmt/FontInfo.js"></script> 
    5459 
    5560    <!-- tinymce.text.* --> 
     
    8792    <script src="tinymce/ui/ColorButton.js"></script> 
    8893    <script src="tinymce/ui/Control.js"></script> 
     94<!--<script src="tinymce/ui/FilePicker.js"></script>--> 
    8995    <script src="tinymce/ui/FitLayout.js"></script> 
    9096    <script src="tinymce/ui/FlexLayout.js"></script> 
     
    97103    <script src="tinymce/ui/TextBox.js"></script> 
    98104    <script src="tinymce/ui/Window.js"></script> 
     105 
     106    <!-- tinymce.undo.* --> 
     107    <script src="tinymce/undo/Diff.js"></script> 
     108    <script src="tinymce/undo/Fragments.js"></script> 
     109    <script src="tinymce/undo/Levels.js"></script> 
     110    <script src="tinymce/undo/ForcedRootBlock.js"></script> 
    99111 
    100112    <!-- tinymce.util.* --> 
     
    116128    <!-- tinymce.* --> 
    117129    <script src="tinymce/AddOnManager.js"></script> 
     130    <script src="tinymce/options.js"></script> 
    118131    <script src="tinymce/Editor.js"></script> 
    119132    <script src="tinymce/Editor_rtl.js"></script> 
     133    <script src="tinymce/EditorCustomTheme.js"></script> 
    120134    <script src="tinymce/EditorUpload.js"></script> 
    121135    <script src="tinymce/EditorCommands.js"></script> 
    122136    <script src="tinymce/EditorManager.js"></script> 
    123137    <script src="tinymce/EnterKey.js"></script> 
     138    <script src="tinymce/FocusManager.js"></script> 
    124139    <script src="tinymce/ForceBlocks.js"></script> 
    125140    <script src="tinymce/Formatter_apply.js"></script> 
     
    131146    <script src="tinymce/WindowManager.js"></script> 
    132147    <script src="tinymce/InsertContent.js"></script> 
     148    <script src="tinymce/InsertContentForcedRootFalse.js"></script> 
    133149    <script src="tinymce/InsertList.js"></script> 
     150    <script src="tinymce/NotificationManager.js"></script> 
    134151 
    135152    <!-- tinymce.plugins.* --> 
    136 <!--<script src="plugins/autolink.js"></script>--> 
    137     <script src="plugins/charmap.js"></script> 
    138 <!--<script src="plugins/autosave.js"></script>--> 
    139 <!--<script src="plugins/fullpage.js"></script>--> 
    140     <script src="plugins/image.js"></script> 
    141 <!--<script src="plugins/importcss.js"></script>--> 
    142 <!--<script src="plugins/jquery_plugin.js"></script>--> 
    143 <!--<script src="plugins/jquery_initialization.js"></script>--> 
    144 <!--<script src="plugins/legacyoutput.js"></script>--> 
    145 <!--<script src="plugins/link.js"></script>--> 
    146     <script src="plugins/lists.js"></script> 
    147     <script src="plugins/media.js"></script> 
    148 <!--<script src="plugins/noneditable.js"></script> --> 
    149     <script src="plugins/paste.js"></script> 
    150     <script src="plugins/paste_images.js"></script> 
    151     <script src="plugins/paste_smart.js"></script> 
    152 <!--<script src="plugins/searchreplace.js"></script>--> 
    153 <!--<script src="plugins/spellchecker.js"></script>--> 
    154 <!--<script src="plugins/table.js"></script>--> 
    155 <!--<script src="plugins/textpattern.js"></script>--> 
    156 <!--<script src="plugins/wordcount.js"></script>--> 
     153 
    157154</body> 
    158155</html> 
  • trunk/tests/qunit/editor/js/init.js

    r29203 r40399  
    55    QUnit.config.hidepassed = true; 
    66 
    7     window.editor = window.inlineEditor = null;  
     7    window.editor = window.inlineEditor = null; 
    88 
    99    var oldModule = module; 
     
    2424    // Sauce labs 
    2525    QUnit.testStart(function(testDetails) { 
    26         QUnit.log = function(details) { 
     26        QUnit.log(function(details) { 
    2727            if (!details.result) { 
    2828                details.name = currentModule + ':' + testDetails.name; 
    2929                log.push(details); 
    3030            } 
    31         }; 
     31        }); 
    3232    }); 
    3333 
  • trunk/tests/qunit/editor/js/qunit/qunit.js

    r27679 r40399  
    570570if ( !defined.document || document.readyState === "complete" ) { 
    571571    config.autorun = true; 
     572} 
     573 
     574if (document.location.search.indexOf('bedrock') !== -1) { 
     575    config.autorun = false; 
     576    config.autostart = false; 
    572577} 
    573578 
  • trunk/tests/qunit/editor/js/tinymce_loader.js

    r36352 r40399  
    55            'fullscreen wordpress wpautoresize wpeditimage wpgallery wplink wpdialogs wpview'; 
    66 
     7var $ = window.jQuery; 
     8 
    79getUserSetting = setUserSetting = function() {} 
  • trunk/tests/qunit/editor/tinymce/Editor.js

    r38773 r40399  
    493493}); 
    494494 
     495test('Treat some paragraphs as empty contents', function() { 
     496    editor.setContent('<p><br /></p>'); 
     497    equal(editor.getContent(), ''); 
     498 
     499    editor.setContent('<p>\u00a0</p>'); 
     500    equal(editor.getContent(), ''); 
     501}); 
     502 
    495503test('kamer word bounderies', function() { 
    496504    editor.setContent('<p>!\u200b!\u200b!</p>'); 
    497505    equal(editor.getContent(), '<p>!\u200b!\u200b!</p>'); 
    498506}); 
     507 
     508test('Padd empty elements with br', function() { 
     509    editor.settings.padd_empty_with_br = true; 
     510    editor.setContent('<p>a</p><p></p>'); 
     511    equal(editor.getContent(), '<p>a</p><p><br /></p>'); 
     512    delete editor.settings.padd_empty_with_br; 
     513}); 
     514 
     515test('Padd empty elements with br on insert at caret', function() { 
     516    editor.settings.padd_empty_with_br = true; 
     517    editor.setContent('<p>a</p>'); 
     518    Utils.setSelection('p', 1); 
     519    editor.insertContent('<p>b</p><p></p>'); 
     520    equal(editor.getContent(), '<p>a</p><p>b</p><p><br /></p>'); 
     521    delete editor.settings.padd_empty_with_br; 
     522}); 
     523 
     524test('Preserve whitespace pre elements', function() { 
     525    editor.setContent('<pre> </pre>'); 
     526    equal(editor.getContent(), '<pre> </pre>'); 
     527}); 
  • trunk/tests/qunit/editor/tinymce/EditorCommands.js

    r38034 r40399  
    751751}); 
    752752 
     753test('unlink - unselected a[href] with childNodes', function() { 
     754    editor.setContent('<p><a href="test"><strong><em>test</em></strong></a></p>'); 
     755    Utils.setSelection('em', 0); 
     756    editor.execCommand('unlink'); 
     757    equal(editor.getContent(), '<p><strong><em>test</em></strong></p>'); 
     758}); 
     759 
    753760test('subscript/superscript', function() { 
    754761    expect(4); 
     
    802809    editor.execCommand('Outdent'); 
    803810    equal(editor.getContent(), '<p>test 123</p>'); 
     811}); 
     812 
     813test('indent/outdent table always uses margin', function () { 
     814    expect(4); 
     815 
     816    editor.setContent('<table><tbody><tr><td>test</td></tr></tbody></table>'); 
     817    editor.execCommand('SelectAll'); 
     818    editor.execCommand('Indent'); 
     819    equal(editor.getContent(), '<table style="margin-left: 30px;"><tbody><tr><td>test</td></tr></tbody></table>'); 
     820 
     821    editor.setContent('<table><tbody><tr><td>test</td></tr></tbody></table>'); 
     822    editor.execCommand('SelectAll'); 
     823    editor.execCommand('Indent'); 
     824    editor.execCommand('Indent'); 
     825    equal(editor.getContent(), '<table style="margin-left: 60px;"><tbody><tr><td>test</td></tr></tbody></table>'); 
     826 
     827    editor.setContent('<table><tbody><tr><td>test</td></tr></tbody></table>'); 
     828    editor.execCommand('SelectAll'); 
     829    editor.execCommand('Indent'); 
     830    editor.execCommand('Indent'); 
     831    editor.execCommand('Outdent'); 
     832    equal(editor.getContent(), '<table style="margin-left: 30px;"><tbody><tr><td>test</td></tr></tbody></table>'); 
     833 
     834    editor.setContent('<table><tbody><tr><td>test</td></tr></tbody></table>'); 
     835    editor.execCommand('SelectAll'); 
     836    editor.execCommand('Outdent'); 
     837    equal(editor.getContent(), '<table><tbody><tr><td>test</td></tr></tbody></table>'); 
    804838}); 
    805839 
     
    827861    equal(editor.getContent(), '<p>dfn tag code tag samp tag kbd tag var tag cite tag mark tag q tag</p>'); 
    828862}); 
     863 
     864if (tinymce.Env.ceFalse) { 
     865    test('SelectAll', function() { 
     866        editor.setContent('<p>a</p><div contenteditable="false"><div contenteditable="true">b</div><p>c</p>'); 
     867        Utils.setSelection('div div', 0); 
     868        editor.execCommand('SelectAll'); 
     869        equal(editor.selection.getStart().nodeName, 'DIV'); 
     870        equal(editor.selection.getEnd().nodeName, 'DIV'); 
     871        equal(editor.selection.isCollapsed(), false); 
     872    }); 
     873} 
    829874 
    830875test('InsertLineBreak', function() { 
  • trunk/tests/qunit/editor/tinymce/EditorManager.js

    r38034 r40399  
    9999 
    100100asyncTest('Init editor async with proper editors state', function() { 
    101     var unloadTheme = function(name) { 
    102         var url = tinymce.baseURI.toAbsolute('themes/' + name + '/theme.js'); 
     101    var unloadUrl = function (url) { 
    103102        tinymce.dom.ScriptLoader.ScriptLoader.remove(url); 
    104103        tinymce.ThemeManager.remove(name); 
     104    }; 
     105 
     106    var unloadTheme = function(name) { 
     107        unloadUrl(tinymce.baseURI.toAbsolute('themes/' + name + '/theme.min.js')); 
     108        unloadUrl(tinymce.baseURI.toAbsolute('themes/' + name + '/theme.js')); 
    105109    }; 
    106110 
     
    142146            "plugina": "//domain/plugina.js", 
    143147            "pluginb": "//domain/pluginb.js" 
     148        }, 
     149        plugin_base_urls: { 
     150            testplugin: 'http://custom.ephox.com/dir/testplugin' 
    144151        } 
    145152    }); 
     
    149156    strictEqual(tinymce.suffix, "x"); 
    150157    strictEqual(new tinymce.Editor('ed1', {}, tinymce).settings.test, 42); 
     158    strictEqual(tinymce.PluginManager.urls.testplugin, 'http://custom.ephox.com/dir/testplugin'); 
    151159 
    152160    deepEqual(new tinymce.Editor('ed2', { 
     
    154162            "plugina": "//domain/plugina2.js", 
    155163            "pluginc": "//domain/pluginc.js" 
     164        }, 
     165        plugin_base_urls: { 
     166            testplugin: 'http://custom.ephox.com/dir/testplugin' 
    156167        } 
    157168    }, tinymce).settings.external_plugins, { 
  • trunk/tests/qunit/editor/tinymce/EditorUpload.js

    r38034 r40399  
    236236            if (callCount == 2) { 
    237237                QUnit.start(); 
    238                 equal(uploadCount, 1, 'Should only be one upload.'); 
     238                // This is in exact since the status of the image can be pending or failed meaing it should try again 
     239                ok(uploadCount >= 1, 'Should at least be one.'); 
    239240            } 
    240241 
  • trunk/tests/qunit/editor/tinymce/EnterKey.js

    r37000 r40399  
    10991099    }); 
    11001100} 
     1101 
     1102if (tinymce.Env.ceFalse) { 
     1103    test('Enter before cE=false div', function() { 
     1104        editor.getBody().innerHTML = '<div contenteditable="false">x</div>'; 
     1105        editor.selection.select(editor.dom.select('div')[0]); 
     1106        editor.selection.collapse(true); 
     1107        Utils.pressEnter(); 
     1108        equal(Utils.cleanHtml(editor.getBody().innerHTML), '<p><br data-mce-bogus="1"></p><div contenteditable="false">x</div>'); 
     1109        equal(editor.selection.getNode().nodeName, 'P'); 
     1110    }); 
     1111 
     1112    test('Enter after cE=false div', function() { 
     1113        editor.getBody().innerHTML = '<div contenteditable="false">x</div>'; 
     1114        editor.selection.select(editor.dom.select('div')[0]); 
     1115        editor.selection.collapse(false); 
     1116        Utils.pressEnter(); 
     1117        equal(Utils.cleanHtml(editor.getBody().innerHTML), '<div contenteditable="false">x</div><p><br data-mce-bogus="1"></p>'); 
     1118        equal(editor.selection.getNode().nodeName, 'P'); 
     1119    }); 
     1120} 
     1121 
  • trunk/tests/qunit/editor/tinymce/Formatter_apply.js

    r38773 r40399  
    11module("tinymce.Formatter - Apply", { 
    22    setupModule: function() { 
    3         document.getElementById('view').innerHTML = '<textarea id="elm1"></textarea><div id="elm2"></div>'; 
     3        document.getElementById('view').innerHTML = '<textarea id="elm1"></textarea><div id="elm2"></div><textarea id="elm3"></textarea>'; 
    44        QUnit.stop(); 
    55 
     
    1919            }, 
    2020            init_instance_callback: function(ed) { 
     21                QUnit.start(); 
    2122                window.editor = ed; 
    22  
    23                 if (inlineEditor) { 
    24                     QUnit.start(); 
    25                 } 
    26             } 
    27         }); 
    28  
    29         tinymce.init({ 
    30             selector: "#elm2", 
    31             inline: true, 
    32             add_unload_trigger: false, 
    33             skin: false, 
    34             indent: false, 
    35             convert_fonts_to_spans: false, 
    36             disable_nodechange: true, 
    37             entities: 'raw', 
    38             valid_styles: { 
    39                 '*': 'color,font-size,font-family,background-color,font-weight,font-style,text-decoration,float,margin,margin-top,margin-right,margin-bottom,margin-left,display,text-align' 
    40             }, 
    41             init_instance_callback: function(ed) { 
    42                 window.inlineEditor = ed; 
    43  
    44                 if (editor) { 
    45                     QUnit.start(); 
    46                 } 
    4723            } 
    4824        }); 
     
    12901266    editor.formatter.apply('format'); 
    12911267    equal(editor.getContent(), '<p><b>abc</b></p>'); 
     1268}); 
     1269 
     1270test('Caret format inside non-ascii single block word', function() { 
     1271    editor.setContent('<p>noël</p>'); 
     1272    editor.formatter.register('format', { 
     1273        inline: 'b' 
     1274    }); 
     1275    Utils.setSelection('p', 2, 'p', 2); 
     1276    editor.formatter.apply('format'); 
     1277    equal(editor.getContent(), '<p><b>noël</b></p>'); 
    12921278}); 
    12931279 
     
    16801666}); 
    16811667 
    1682 test('Bug #6518 - Apply div blocks to inline editor paragraph', function() { 
    1683     inlineEditor.setContent('<p>a</p><p>b</p>'); 
    1684     inlineEditor.selection.select(inlineEditor.getBody().firstChild, true); 
    1685     inlineEditor.selection.collapse(true); 
    1686     inlineEditor.formatter.register('format', { 
    1687         block: 'div' 
    1688     }); 
    1689     inlineEditor.formatter.apply('format'); 
    1690     equal(inlineEditor.getContent(), '<div>a</div><p>b</p>'); 
     1668asyncTest('Bug #6518 - Apply div blocks to inline editor paragraph', function() { 
     1669    tinymce.init({ 
     1670        selector: "#elm2", 
     1671        inline: true, 
     1672        add_unload_trigger: false, 
     1673        skin: false, 
     1674        indent: false, 
     1675        convert_fonts_to_spans: false, 
     1676        disable_nodechange: true, 
     1677        entities: 'raw', 
     1678        valid_styles: { 
     1679            '*': 'color,font-size,font-family,background-color,font-weight,font-style,text-decoration,float,margin,margin-top,margin-right,margin-bottom,margin-left,display,text-align' 
     1680        }, 
     1681        init_instance_callback: function(ed) { 
     1682            QUnit.start(); 
     1683 
     1684            ed.setContent('<p>a</p><p>b</p>'); 
     1685            ed.selection.select(ed.getBody().firstChild, true); 
     1686            ed.selection.collapse(true); 
     1687            ed.formatter.register('format', { 
     1688                block: 'div' 
     1689            }); 
     1690            ed.formatter.apply('format'); 
     1691            equal(ed.getContent(), '<div>a</div><p>b</p>'); 
     1692        } 
     1693    }); 
    16911694}); 
    16921695 
    16931696asyncTest('Bug #7412 - valid_styles affects the Bold and Italic buttons, although it shouldn\'t', function() { 
    1694     tinymce.remove(); 
    1695  
    1696     document.getElementById('view').innerHTML = '<textarea id="elm1"></textarea>'; 
    1697  
    16981697    tinymce.init({ 
    1699         selector: "#elm1", 
     1698        selector: "#elm3", 
    17001699        add_unload_trigger: false, 
    17011700        valid_styles: { 
     
    17031702        }, 
    17041703        init_instance_callback: function(ed) { 
    1705             window.editor = ed; 
    17061704            QUnit.start(); 
    17071705 
    1708             editor.getBody().innerHTML = '<p>1 <span style="text-decoration: underline;">1234</span> 1</p>'; 
    1709             var rng = editor.dom.createRng(); 
    1710             rng.setStart(editor.dom.select('span')[0], 0); 
    1711             rng.setEnd(editor.dom.select('span')[0], 1); 
    1712             editor.selection.setRng(rng); 
    1713             editor.formatter.toggle('bold'); 
    1714             equal(getContent(), '<p>1 <strong><span style="text-decoration: underline;">1234</span></strong> 1</p>'); 
     1706            ed.getBody().innerHTML = '<p>1 <span style="text-decoration: underline;">1234</span> 1</p>'; 
     1707            var rng = ed.dom.createRng(); 
     1708            rng.setStart(ed.dom.select('span')[0], 0); 
     1709            rng.setEnd(ed.dom.select('span')[0], 1); 
     1710            ed.selection.setRng(rng); 
     1711            ed.formatter.toggle('bold'); 
     1712            equal(ed.getContent(), '<p>1 <strong><span style="text-decoration: underline;">1234</span></strong> 1</p>'); 
    17151713        } 
    17161714    }); 
     
    17221720    Utils.setSelection('#a', 0, '#b', 0); 
    17231721    editor.execCommand('formatBlock', false, 'h1'); 
    1724     equal(getContent(), '<h1 id="a">one</h1>\n<div id="b">two</div>'); 
     1722    equal(getContent(), '<h1 id="a">one</h1><div id="b">two</div>'); 
    17251723}); 
    17261724 
    17271725test('Format selection over fragments', function(){ 
    1728     editor.setContent("<strong>a</strong>bc<em>d</em>"); 
     1726    editor.setContent("<p><strong>a</strong>bc<em>d</em></p>"); 
    17291727    Utils.setSelection('strong', 1, 'em', 0); 
    17301728    editor.formatter.apply('underline'); 
    17311729    equal(getContent(), '<p><strong>a</strong><span style="text-decoration: underline;">bc</span><em>d</em></p>'); 
    17321730}); 
     1731 
     1732test("Wrapper with fontSize should retain priority within a branch of nested inline format wrappers", function() { 
     1733    editor.setContent("<p>abc</p>"); 
     1734    Utils.setSelection('p', 0, 'p', 3); 
     1735 
     1736    editor.formatter.apply('fontsize', {value: '18px'}); 
     1737    editor.formatter.apply('bold'); 
     1738    editor.formatter.apply('underline'); 
     1739    editor.formatter.apply('forecolor', {value: '#ff0000'}); 
     1740 
     1741    equal(getContent(), '<p><span style="color: #ff0000; font-size: 18px; text-decoration: underline;"><strong>abc</strong></span></p>'); 
     1742}); 
     1743 
     1744test("Child wrapper having the same format as the immediate parent, shouldn't be removed if it also has other formats merged", function() { 
     1745    editor.getBody().innerHTML = '<p><span style="font-family: verdana;">a <span style="color: #ff0000;">b</span>c</span></p>'; 
     1746    Utils.setSelection('span span', 0, 'span span', 1); 
     1747    editor.formatter.apply('fontname', {value: "verdana"}); 
     1748    equal(getContent(), '<p><span style="font-family: verdana;">a <span style="color: #ff0000;">b</span>c</span></p>'); 
     1749}); 
     1750 
     1751test("When format with backgroundColor is applied, all the nested childNodes having fontSize should receive backgroundColor as well", function() { 
     1752    editor.getBody().innerHTML = '<p>a <span style="font-size: 36pt;">b</span> c</p>'; 
     1753    editor.selection.select(editor.dom.select('p')[0]); 
     1754 
     1755    editor.formatter.apply('hilitecolor', {value: "#ff0000"}); 
     1756    equal(getContent(), '<p><span style="background-color: #ff0000;">a <span style="font-size: 36pt; background-color: #ff0000;">b</span> c</span></p>'); 
     1757 
     1758    editor.formatter.remove('hilitecolor', {value: "#ff0000"}); 
     1759    equal(getContent(), '<p>a <span style="font-size: 36pt;">b</span> c</p>'); 
     1760}); 
     1761 
     1762test("TINY-782: Can't apply sub/sup to word on own line with large font", function() { 
     1763    editor.getBody().innerHTML = '<p><span style="font-size: 18px;">abc</p>'; 
     1764    Utils.setSelection('span', 0, 'span', 3); 
     1765    editor.formatter.apply('superscript'); 
     1766    equal(getContent(), '<p><span style="font-size: 18px;"><sup>abc</sup></span></p>'); 
     1767}); 
     1768 
     1769test("TINY-671: Background color on nested font size bug", function() { 
     1770    editor.getBody().innerHTML = '<p><strong><span style="font-size: 18px;">abc</span></strong></p>'; 
     1771    Utils.setSelection('span', 0, 'span', 3); 
     1772    editor.formatter.apply('hilitecolor', {value: '#ff0000'}); 
     1773    equal(getContent(), '<p><span style="font-size: 18px; background-color: #ff0000;"><strong>abc</strong></span></p>'); 
     1774}); 
     1775 
     1776test("TINY-865: Font size removed when changing background color", function() { 
     1777    editor.getBody().innerHTML = '<p><span style="background-color: #ffff00;"><span style="font-size: 8pt;">a</span> <span style="font-size: 36pt;">b</span> <span style="font-size: 8pt;">c</span></span></p>'; 
     1778    Utils.setSelection('span span:nth-child(2)', 0, 'span span:nth-child(2)', 1); 
     1779    editor.formatter.apply('hilitecolor', {value: '#ff0000'}); 
     1780    equal(getContent(), '<p><span style="background-color: #ffff00;"><span style="font-size: 8pt;">a</span> <span style="font-size: 36pt; background-color: #ff0000;">b</span> <span style="font-size: 8pt;">c</span></span></p>'); 
     1781}); 
     1782 
     1783test("TINY-935: Text color, then size, then change color wraps span doesn't change color", function() { 
     1784    editor.getBody().innerHTML = '<p><span style="color: #00ff00; font-size: 14pt;">text</span></p>'; 
     1785    Utils.setSelection('span', 0, 'span', 4); 
     1786    editor.formatter.apply('forecolor', {value: '#ff0000'}); 
     1787    equal(getContent(), '<p><span style="color: #ff0000; font-size: 14pt;">text</span></p>'); 
     1788}); 
     1789 
     1790test("GH-3519: Font family selection does not work after changing font size", function() { 
     1791    editor.getBody().innerHTML = '<p><span style="font-size: 14pt; font-family: \'comic sans ms\', sans-serif;">text</span></p>'; 
     1792    Utils.setSelection('span', 0, 'span', 4); 
     1793    editor.formatter.apply('fontname', {value: "verdana"}); 
     1794    equal(getContent(), '<p><span style="font-size: 14pt; font-family: verdana;">text</span></p>'); 
     1795}); 
  • trunk/tests/qunit/editor/tinymce/Formatter_check.js

    r36352 r40399  
    229229    ok(!inlineEditor.formatter.match('div'), 'Formatter.match on div says true'); 
    230230}); 
    231  
    232 test('Get preview css text for formats', function() { 
    233     ok(/font-weight\:(bold|700)/.test(editor.formatter.getCssText('bold')), 'Bold not found in preview style'); 
    234     ok(/font-weight\:(bold|700)/.test(editor.formatter.getCssText({inline: 'b'})), 'Bold not found in preview style'); 
    235 }); 
  • trunk/tests/qunit/editor/tinymce/SelectionOverrides.js

    r38773 r40399  
    4848    function assertCaretInCaretBlockContainer() { 
    4949        var beforeRng = editor.selection.getRng(); 
    50         equal(CaretContainer.isCaretContainerBlock(beforeRng.startContainer.parentNode), true, 'Not in caret block container.'); 
     50        equal(CaretContainer.isCaretContainerBlock(beforeRng.startContainer), true, 'Not in caret block container.'); 
    5151    } 
    5252 
     
    225225        equal(editor.getContent(), '<p contenteditable="false">1</p><p contenteditable="false">2</p>'); 
    226226        assertCaretInCaretBlockContainer(); 
    227         equal(rng.startContainer.parentNode.previousSibling, editor.dom.select('p')[0]); 
     227        equal(rng.startContainer.previousSibling, editor.dom.select('p')[0]); 
    228228    }); 
    229229 
     
    264264        equal(editor.getContent(), '<p contenteditable="false">1</p><p contenteditable="false">2</p>'); 
    265265        assertCaretInCaretBlockContainer(); 
    266         equal(rng.startContainer.parentNode.nextSibling, editor.dom.select('p')[2]); 
     266        equal(rng.startContainer.nextSibling, editor.dom.select('p')[2]); 
    267267    }); 
    268268 
     
    329329        equal(editor.selection.getNode().nodeName !== 'P', true); 
    330330    }); 
     331 
     332    test('offscreen copy of cE=false block remains offscreen', function() { 
     333        if (tinymce.isIE || tinymce.isGecko || tinymce.isOpera) { 
     334            editor.setContent( 
     335                '<table contenteditable="false" style="width: 100%; table-layout: fixed">' + 
     336                '<tbody><tr><td>1</td><td>2</td></tr></tbody>' + 
     337                '</table>' 
     338            ); 
     339 
     340            editor.selection.select(editor.dom.select('table')[0]); 
     341            var offscreenSelection = editor.dom.select('.mce-offscreen-selection')[0]; 
     342 
     343            ok(offscreenSelection.offsetLeft !== undefined, 'The offscreen selection\'s left border is undefined'); 
     344            ok(offscreenSelection.offsetLeft < 0, 'The offscreen selection\'s left border is onscreen'); 
     345            ok(offscreenSelection.offsetWidth + offscreenSelection.offsetLeft < 0, 
     346                'The cE=false offscreen selection is visible on-screen. Right edge: ' + 
     347                offscreenSelection.offsetLeft + '+' + offscreenSelection.offsetWidth + '=' + 
     348                (offscreenSelection.offsetLeft + offscreenSelection.offsetWidth) + 'px' 
     349            ); 
     350        } else { 
     351            // Chrome and Safari behave correctly, and PhantomJS also declares itself as WebKit but does not 
     352            // put the off-screen selection off-screen, so fails the above tests. However, it has no visible UI, 
     353            // so everything is off-screen anyway :-) 
     354            ok(true, 'Not a tested browser - Chrome & Safari work, PhantomJS does not put the selection off screen'); 
     355        } 
     356    }); 
    331357}); 
  • trunk/tests/qunit/editor/tinymce/UndoManager.js

    r38773 r40399  
    9797    ok(editor.undoManager.typing); 
    9898 
    99     editor.dom.fire(editor.getBody(), 'keyup', {keyCode: 13}); 
     99    editor.dom.fire(editor.getBody(), 'keydown', {keyCode: 13}); 
    100100    ok(!editor.undoManager.typing); 
    101101 
     
    452452    ok(editor.isDirty(), "Dirty state should be true"); 
    453453}); 
     454 
     455test('ExecCommand while typing should produce undo level', function() { 
     456    editor.undoManager.clear(); 
     457    editor.setDirty(false); 
     458    editor.setContent('<p>a</p>'); 
     459    Utils.setSelection('p', 1); 
     460 
     461    equal(editor.undoManager.typing, false); 
     462    Utils.type({keyCode: 66, charCode: 66}); 
     463    equal(editor.undoManager.typing, true); 
     464    equal(editor.getContent(), '<p>aB</p>'); 
     465    editor.execCommand('mceInsertContent', false, 'C'); 
     466    equal(editor.undoManager.typing, false); 
     467    equal(editor.undoManager.data.length, 3); 
     468    equal(editor.undoManager.data[0].content, '<p>a</p>'); 
     469    equal(editor.undoManager.data[1].content, '<p>aB</p>'); 
     470    equal(editor.undoManager.data[2].content, '<p>aBC</p>'); 
     471}); 
     472 
     473test('transact while typing should produce undo level', function() { 
     474    editor.undoManager.clear(); 
     475    editor.setDirty(false); 
     476    editor.setContent('<p>a</p>'); 
     477    Utils.setSelection('p', 1); 
     478 
     479    equal(editor.undoManager.typing, false); 
     480    Utils.type({keyCode: 66, charCode: 66}); 
     481    equal(editor.undoManager.typing, true); 
     482    equal(editor.getContent(), '<p>aB</p>'); 
     483    editor.undoManager.transact(function () { 
     484        editor.getBody().firstChild.firstChild.data = 'aBC'; 
     485    }); 
     486    equal(editor.undoManager.typing, false); 
     487    equal(editor.undoManager.data.length, 3); 
     488    equal(editor.undoManager.data[0].content, '<p>a</p>'); 
     489    equal(editor.undoManager.data[1].content, '<p>aB</p>'); 
     490    equal(editor.undoManager.data[2].content, '<p>aBC</p>'); 
     491}); 
  • trunk/tests/qunit/editor/tinymce/caret/CaretContainer.js

    r38773 r40399  
    119119        equal(CaretContainer.endsWithCaretContainer(getRoot().firstChild), true); 
    120120    }); 
     121 
     122    test('hasContent', function() { 
     123        setViewHtml('<span contentEditable="false">1</span>'); 
     124        var caretContainerBlock = CaretContainer.insertBlock('p', getRoot().firstChild, true); 
     125        equal(CaretContainer.hasContent(caretContainerBlock), false); 
     126        caretContainerBlock.insertBefore(document.createTextNode('a'), caretContainerBlock.firstChild); 
     127        equal(CaretContainer.hasContent(caretContainerBlock), true); 
     128    }); 
     129 
     130    test('showCaretContainerBlock', function() { 
     131        setViewHtml('<span contentEditable="false">1</span>'); 
     132        var caretContainerBlock = CaretContainer.insertBlock('p', getRoot().firstChild, true); 
     133        caretContainerBlock.insertBefore(document.createTextNode('a'), caretContainerBlock.firstChild); 
     134        CaretContainer.showCaretContainerBlock(caretContainerBlock); 
     135        equal(caretContainerBlock.outerHTML, '<p>a</p>'); 
     136    }); 
    121137}); 
  • trunk/tests/qunit/editor/tinymce/caret/FakeCaret.js

    r36352 r40399  
    3535        equal($fakeCaretElm[0].nodeName, 'P'); 
    3636        equal($fakeCaretElm.attr('data-mce-caret'), 'before'); 
    37         Utils.assertRange(rng, Utils.createRange($fakeCaretElm[0].firstChild, 0, $fakeCaretElm[0].firstChild, 1)); 
     37        Utils.assertRange(rng, Utils.createRange($fakeCaretElm[0], 0, $fakeCaretElm[0], 0)); 
    3838 
    3939        fakeCaret.hide(); 
     
    5151        equal($fakeCaretElm[1].nodeName, 'P'); 
    5252        equal($fakeCaretElm.eq(1).attr('data-mce-caret'), 'after'); 
    53         Utils.assertRange(rng, Utils.createRange($fakeCaretElm[1].firstChild, 0, $fakeCaretElm[1].firstChild, 1)); 
     53        Utils.assertRange(rng, Utils.createRange($fakeCaretElm[1], 0, $fakeCaretElm[1], 0)); 
    5454 
    5555        fakeCaret.hide(); 
  • trunk/tests/qunit/editor/tinymce/dom/DOMUtils.js

    r29994 r40399  
    3636            'border: 1pt none black;' 
    3737        ); 
    38          
     38 
    3939        equal( 
    4040            dom.serializeStyle(dom.parseStyle('border-width: 1pt 4pt 2pt 3pt; border-style: solid dashed dotted none; border-color: black red green blue;')), 
     
    340340    }); 
    341341 
     342    var eqNodeName = function(name) { 
     343        return function (n) { 
     344            return n.nodeName === name; 
     345        }; 
     346    }; 
     347 
    342348    test('getParent', 6, function() { 
    343349        DOM.add(document.body, 'div', {id : 'test'}); 
     
    345351        DOM.get('test').innerHTML = '<div><span>ab<a id="test2" href="">abc</a>c</span></div>'; 
    346352 
    347         equal(DOM.getParent('test2', function(n) {return n.nodeName == 'SPAN';}).nodeName, 'SPAN'); 
    348         equal(DOM.getParent('test2', function(n) {return n.nodeName == 'BODY';}).nodeName, 'BODY'); 
    349         equal(DOM.getParent('test2', function(n) {return n.nodeName == 'BODY';}, document.body), null); 
    350         equal(DOM.getParent('test2', function() {return false;}), null); 
     353        equal(DOM.getParent('test2', eqNodeName('SPAN')).nodeName, 'SPAN'); 
     354        equal(DOM.getParent('test2', eqNodeName('BODY')).nodeName, 'BODY'); 
     355        equal(DOM.getParent('test2', eqNodeName('BODY'), document.body), null); 
     356        equal(DOM.getParent('test2', eqNodeName('X')), null); 
    351357        equal(DOM.getParent('test2', 'SPAN').nodeName, 'SPAN'); 
    352358        equal(DOM.getParent('test2', 'body', DOM.get('test')), null); 
     
    361367        DOM.get('test').innerHTML = '<div><span class="test">ab<span><a id="test2" href="">abc</a>c</span></span></div>'; 
    362368 
    363         equal(DOM.getParents('test2', function(n) {return n.nodeName == 'SPAN';}).length, 2); 
     369        equal(DOM.getParents('test2', eqNodeName('SPAN')).length, 2); 
    364370        equal(DOM.getParents('test2', 'span').length, 2); 
    365371        equal(DOM.getParents('test2', 'span.test').length, 1); 
     
    434440        equal(DOM.getNext(DOM.get('test').firstChild, 'div'), null); 
    435441        equal(DOM.getNext(null, 'div'), null); 
    436         equal(DOM.getNext(DOM.get('test').firstChild, function(n) {return n.nodeName == 'EM';}).nodeName, 'EM'); 
     442        equal(DOM.getNext(DOM.get('test').firstChild, eqNodeName('EM')).nodeName, 'EM'); 
    437443 
    438444        DOM.remove('test'); 
     
    447453        equal(DOM.getPrev(DOM.get('test').lastChild, 'div'), null); 
    448454        equal(DOM.getPrev(null, 'div'), null); 
    449         equal(DOM.getPrev(DOM.get('test').lastChild, function(n) {return n.nodeName == 'STRONG';}).nodeName, 'STRONG'); 
     455        equal(DOM.getPrev(DOM.get('test').lastChild, eqNodeName('STRONG')).nodeName, 'STRONG'); 
    450456 
    451457        DOM.remove('test'); 
     
    582588    }); 
    583589 
    584     test('isEmpty', 14, function() { 
     590    test('isEmpty', function() { 
    585591        DOM.schema = new tinymce.html.Schema(); // A schema will be added when used within a editor instance 
    586592        DOM.add(document.body, 'div', {id : 'test'}, ''); 
     
    626632        DOM.setHTML('test', '<div><!-- comment --></div>'); 
    627633        ok(!DOM.isEmpty(DOM.get('test')), 'Element with comment.'); 
     634 
     635        DOM.setHTML('test', '<span data-mce-bogus="1"></span>'); 
     636        ok(DOM.isEmpty(DOM.get('test')), 'Contains just a bogus element.'); 
     637 
     638        DOM.setHTML('test', '<span data-mce-bogus="1">a</span>'); 
     639        ok(!DOM.isEmpty(DOM.get('test')), 'Contains a text node in a bogus element.'); 
     640 
     641        DOM.setHTML('test', '<span data-mce-bogus="all">a</span>'); 
     642        ok(DOM.isEmpty(DOM.get('test')), 'Contains just a bogus all element.'); 
     643 
     644        DOM.setHTML('test', '<span data-mce-bogus="all">a</span>b'); 
     645        ok(!DOM.isEmpty(DOM.get('test')), 'Contains a bogus all element but some text as well.'); 
     646 
     647        DOM.setHTML('test', '<code> </code>'); 
     648        ok(!DOM.isEmpty(DOM.get('test')), 'Contains a code element should be treated as content.'); 
     649 
     650        DOM.setHTML('test', '<pre> </pre>'); 
     651        ok(!DOM.isEmpty(DOM.get('test')), 'Contains a pre element should be treated as content.'); 
     652 
     653        DOM.setHTML('test', '<code></code>'); 
     654        ok(!DOM.isEmpty(DOM.get('test')), 'Contains a code element should be treated as content.'); 
     655 
     656        DOM.setHTML('test', '<pre></pre>'); 
     657        ok(!DOM.isEmpty(DOM.get('test')), 'Contains a pre element should be treated as content.'); 
    628658 
    629659        DOM.remove('test'); 
     
    635665    }); 
    636666 
     667    test('isEmpty on pre', function() { 
     668        var elm = DOM.create('pre', null, '  '); 
     669        equal(false, DOM.isEmpty(elm)); 
     670    }); 
     671 
    637672    test('isEmpty with list of elements considered non-empty without schema', function() { 
    638673        var domWithoutSchema = new tinymce.dom.DOMUtils(document, {keep_values: true}); 
     
    646681        ok(DOM.isEmpty(elm, 'No children')); 
    647682    }); 
    648      
     683 
    649684    test('isEmpty on P with two BR in EM', function() { 
    650685        var elm = DOM.create('p', null, '<em><br><br></em>'); 
     
    655690        var count = 0; 
    656691 
    657         DOM.bind(document, 'click', function() {count++;}); 
     692        DOM.bind(document, 'click', function() { 
     693            count++; 
     694        }); 
    658695        DOM.fire(document, 'click'); 
    659696        DOM.unbind(document, 'click'); 
     
    661698 
    662699        count = 0; 
    663         DOM.bind([document, window], 'click', function(e) {e.stopPropagation(); count++;}); 
     700        DOM.bind([document, window], 'click', function(e) { 
     701            e.stopPropagation(); 
     702            count++; 
     703        }); 
    664704        DOM.fire(document, 'click'); 
    665705        DOM.fire(window, 'click'); 
  • trunk/tests/qunit/editor/tinymce/dom/Selection.js

    r38034 r40399  
    11ModuleLoader.require([ 
    22    "tinymce/caret/CaretContainer", 
     3    "tinymce/text/Zwsp", 
    34    "tinymce/Env" 
    4 ], function(CaretContainer, Env) { 
     5], function(CaretContainer, Zwsp, Env) { 
    56    module("tinymce.dom.Selection", { 
    67        setupModule: function() { 
     
    504505        CaretContainer.insertBlock('p', editor.$('p')[0], true); 
    505506        rng = editor.dom.createRng(); 
    506         rng.setStart(editor.$('p')[0].firstChild, 0); 
    507         rng.setEnd(editor.$('p')[0].firstChild, 1); 
     507        rng.setStart(editor.$('p')[0], 0); 
     508        rng.setEnd(editor.$('p')[0], 0); 
    508509        editor.selection.setRng(rng); 
    509510        bookmark = editor.selection.getBookmark(2); 
     
    847848        }); 
    848849 
     850        test('normalize lean left from br into formatter caret container', function() { 
     851            var rng; 
     852 
     853            editor.getBody().innerHTML = '<p><span id="_mce_caret">' + Zwsp.ZWSP + '</span><br /></p>'; 
     854            rng = editor.dom.createRng(); 
     855            rng.setStartBefore(editor.getBody().firstChild.lastChild); 
     856            rng.setEndBefore(editor.getBody().firstChild.lastChild); 
     857            editor.selection.setRng(rng); 
     858            editor.selection.normalize(); 
     859 
     860            rng = editor.selection.getRng(true); 
     861            equal(rng.startContainer.nodeType, 3); 
     862            equal(rng.startOffset, 1); 
     863        }); 
     864 
    849865        test('normalize don\'t lean left into empty inline elements if there is a br element after caret', function() { 
    850866            var rng; 
     
    10561072        equal(rng.endOffset, 1); 
    10571073    }); 
     1074 
     1075    test('getRng should return null if win.document is not defined or null', function() { 
     1076        var win = editor.selection.win, 
     1077            rng = editor.dom.createRng(); 
     1078 
     1079        editor.setContent('<p>x</p>'); 
     1080 
     1081        rng.setStart(editor.$('p')[0].firstChild, 0); 
     1082        rng.setEnd(editor.$('p')[0].firstChild, 1); 
     1083 
     1084        editor.selection.setRng(rng); 
     1085        editor.selection.setRng(null); 
     1086 
     1087        editor.selection.win = {}; 
     1088        rng = editor.selection.getRng(true); 
     1089        equal(rng, null); 
     1090 
     1091        editor.selection.win = {document:null}; 
     1092        rng = editor.selection.getRng(true); 
     1093        equal(rng, null); 
     1094 
     1095        editor.selection.win = win; 
     1096    }); 
     1097 
     1098    test('image selection webkit bug', function() { 
     1099        var testImageSelection = function (inputHtml, expectedContainerName, expectedOffset) { 
     1100            editor.setContent(inputHtml); 
     1101            editor.selection.select(editor.dom.select('img')[0]); 
     1102 
     1103            var rng = editor.selection.getRng(true); 
     1104            equal(rng.startContainer.nodeName, 'P'); 
     1105            equal(rng.startOffset, expectedOffset); 
     1106            equal(rng.startContainer.nodeName, 'P'); 
     1107            equal(rng.endOffset, expectedOffset + 1); 
     1108            equal(editor.selection.getNode().nodeName, 'IMG'); 
     1109            equal(editor.selection.getStart().nodeName, 'IMG'); 
     1110            equal(editor.selection.getEnd().nodeName, 'IMG'); 
     1111 
     1112            var nativeRng = editor.selection.getSel().getRangeAt(0); 
     1113            equal(nativeRng.startContainer.nodeName, 'P'); 
     1114            equal(nativeRng.startOffset, expectedOffset); 
     1115            equal(nativeRng.startContainer.nodeName, 'P'); 
     1116            equal(nativeRng.endOffset, expectedOffset + 1); 
     1117        }; 
     1118 
     1119        testImageSelection('<p><img src="#"></p>', 'P', 0); 
     1120        testImageSelection('<p><img src="#">abc</p>', 'P', 0); 
     1121        testImageSelection('<p>abc<img src="#"></p>', 'P', 1); 
     1122        testImageSelection('<p>abc<img src="#">def</p>', 'P', 1); 
     1123        testImageSelection('<p><img style="float: right;" src="#"></p>', 'P', 0); 
     1124        testImageSelection('<p><img style="float: right;" src="#">abc</p>', 'P', 0); 
     1125        testImageSelection('<p>abc<img style="float: right;" src="#"></p>', 'P', 1); 
     1126        testImageSelection('<p>abc<img style="float: right;" src="#">def</p>', 'P', 1); 
     1127        testImageSelection('<p><img style="float: left;" src="#"></p>', 'P', 0); 
     1128        testImageSelection('<p><img style="float: left;" src="#">abc</p>', 'P', 0); 
     1129        testImageSelection('<p>abc<img style="float: left;" src="#"></p>', 'P', 1); 
     1130        testImageSelection('<p>abc<img style="float: left;" src="#">def</p>', 'P', 1); 
     1131        testImageSelection('<p dir="rtl"><img style="float: right;" src="#"></p>', 'P', 0); 
     1132        testImageSelection('<p dir="rtl"><img style="float: right;" src="#">abc</p>', 'P', 0); 
     1133        testImageSelection('<p dir="rtl">abc<img style="float: right;" src="#"></p>', 'P', 1); 
     1134        testImageSelection('<p dir="rtl">abc<img style="float: right;" src="#">def</p>', 'P', 1); 
     1135        testImageSelection('<p dir="rtl"><img style="float: left;" src="#"></p>', 'P', 0); 
     1136        testImageSelection('<p dir="rtl"><img style="float: left;" src="#">abc</p>', 'P', 0); 
     1137        testImageSelection('<p dir="rtl">abc<img style="float: left;" src="#"></p>', 'P', 1); 
     1138        testImageSelection('<p dir="rtl">abc<img style="float: left;" src="#">def</p>', 'P', 1); 
     1139    }); 
    10581140}); 
    10591141 
  • trunk/tests/qunit/editor/tinymce/dom/Serializer.js

    r37000 r40399  
    2626    ser.setRules('a[href|target<_blank?_top|title:forced value]'); 
    2727    DOM.setHTML('test', '<a href="file.htm" data-mce-href="file.htm" target="_blank" title="title">link</a><a href="#" data-mce-href="#" target="test">test2</a>'); 
    28     equal(ser.serialize(DOM.get('test')), '<a href="file.htm" target="_blank" title="forced value">link</a><a href="#" title="forced value">test2</a>'); 
     28    equal(ser.serialize(DOM.get('test')), '<a href="file.htm" target="_blank" title="forced value" rel="noopener noreferrer">link</a><a href="#" title="forced value">test2</a>'); 
    2929 
    3030    ser.setRules('img[src|border=0|alt=]'); 
     
    235235}); 
    236236 
     237test('Padd empty elements with BR', function() { 
     238    var ser = new tinymce.dom.Serializer({padd_empty_with_br: true}); 
     239 
     240    ser.setRules('#p,table,tr,#td,br'); 
     241 
     242    DOM.setHTML('test', '<p>a</p><p></p>'); 
     243    equal(ser.serialize(DOM.get('test')), '<p>a</p><p><br /></p>'); 
     244    DOM.setHTML('test', '<p>a</p><table><tr><td><br></td></tr></table>'); 
     245    equal(ser.serialize(DOM.get('test')), '<p>a</p><table><tr><td><br /></td></tr></table>'); 
     246}); 
     247 
    237248test('Remove empty elements', function() { 
    238249    var ser = new tinymce.dom.Serializer({fix_list_elements : true}); 
     
    345356    DOM.setHTML('test', '<script>\n\n<![CDATA[\n\n1 < 2;\n\n]]>\n\n</s' + 'cript>'); 
    346357    equal(ser.serialize(DOM.get('test')).replace(/\r/g, ''), '<s' + 'cript>// <![CDATA[\n1 < 2;\n// ]]></s' + 'cript>'); 
     358}); 
     359 
     360test('Whitespace preserve in pre', function() { 
     361    var ser = new tinymce.dom.Serializer({fix_list_elements : true}); 
     362    ser.setRules('pre'); 
     363 
     364    DOM.setHTML('test', '<pre>  </pre>'); 
     365    equal(ser.serialize(DOM.get('test')), '<pre>  </pre>'); 
    347366}); 
    348367 
     
    525544    equal(ser.trimHtml('<p data-x="1" data-y="2" data-z="3">a</p>'), '<p data-z="3">a</p>'); 
    526545}); 
     546 
     547test('addTempAttr same attr twice', function() { 
     548    var ser1 = new tinymce.dom.Serializer({}); 
     549    var ser2 = new tinymce.dom.Serializer({}); 
     550 
     551    ser1.addTempAttr('data-x'); 
     552    ser2.addTempAttr('data-x'); 
     553 
     554    DOM.setHTML('test', '<p data-x="1" data-z="3">a</p>'); 
     555    equal(ser1.serialize(DOM.get('test'), {getInner: 1}), '<p data-z="3">a</p>'); 
     556    equal(ser1.trimHtml('<p data-x="1" data-z="3">a</p>'), '<p data-z="3">a</p>'); 
     557    equal(ser2.serialize(DOM.get('test'), {getInner: 1}), '<p data-z="3">a</p>'); 
     558    equal(ser2.trimHtml('<p data-x="1" data-z="3">a</p>'), '<p data-z="3">a</p>'); 
     559}); 
  • trunk/tests/qunit/editor/tinymce/file/ImageScanner.js

    r38034 r40399  
    33    "tinymce/file/UploadStatus", 
    44    "tinymce/file/BlobCache", 
     5    "tinymce/file/Conversions", 
    56    "tinymce/Env" 
    6 ], function(ImageScanner, UploadStatus, BlobCache, Env) { 
     7], function(ImageScanner, UploadStatus, BlobCache, Conversions, Env) { 
    78    if (!tinymce.Env.fileApi) { 
    89        return; 
    910    } 
    1011 
     12    QUnit.config.autostart = false; 
     13 
    1114    module("tinymce.file.ImageScanner"); 
    1215 
    1316    var base64Src = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAAAAACH5BAAAAAAALAAAAAABAAEAAAICTAEAOw=='; 
     17    var blobUriSrc; 
     18 
     19    Conversions.uriToBlob(base64Src).then(function(blob) { 
     20        blobUriSrc = URL.createObjectURL(blob); 
     21        QUnit.start(); 
     22    }); 
    1423 
    1524    QUnit.asyncTest("findAll", function() { 
     
    1827        document.getElementById('view').innerHTML = ( 
    1928            '<img src="' + base64Src + '">' + 
     29            '<img src="' + blobUriSrc + '">' + 
    2030            '<img src="' + Env.transparentSrc + '">' + 
    2131            '<img src="' + base64Src + '" data-mce-bogus="1">' + 
     
    2535        imageScanner.findAll(document.getElementById('view')).then(function(result) { 
    2636            QUnit.start(); 
    27             equal(result.length, 1); 
    28             equal('data:image/gif;base64,' + result[0].blobInfo.base64(), base64Src); 
     37            var blobInfo = result[0].blobInfo; 
     38            equal(result.length, 2); 
     39            equal('data:image/gif;base64,' + blobInfo.base64(), base64Src); 
    2940            strictEqual(result[0].image, document.getElementById('view').firstChild); 
    3041        }); 
  • trunk/tests/qunit/editor/tinymce/html/DomParser.js

    r37000 r40399  
    100100    }); 
    101101 
     102    test('Whitespace preserved in PRE', function() { 
     103        parser = new tinymce.html.DomParser({}, schema); 
     104        root = parser.parse('<PRE>  </PRE>'); 
     105        equal(serializer.serialize(root), '<pre>  </pre>', 'Whitespace around and inside PRE'); 
     106        deepEqual(countNodes(root), {body:1, pre:1, '#text':1}, 'Whitespace around and inside PRE (count)'); 
     107    }); 
     108 
    102109    test('Whitespace preserved in SPAN inside PRE', function() { 
    103110        parser = new tinymce.html.DomParser({}, schema); 
     
    105112        equal(serializer.serialize(root), '<pre>  \t\r\n  <span>    test    </span> \t\r\n   </pre>', 'Whitespace around and inside PRE'); 
    106113        deepEqual(countNodes(root), {body:1, pre:1, span:1, '#text':3}, 'Whitespace around and inside PRE (count)'); 
     114    }); 
     115 
     116    test('Whitespace preserved in code', function() { 
     117        parser = new tinymce.html.DomParser({}, schema); 
     118        root = parser.parse('<code>  a  </code>'); 
     119        equal(serializer.serialize(root), '<code>  a  </code>', 'Whitespace inside code'); 
     120        deepEqual(countNodes(root), {body:1, code:1, '#text':1}, 'Whitespace inside code (count)'); 
     121    }); 
     122 
     123    test('Whitespace preserved in code', function() { 
     124        parser = new tinymce.html.DomParser({}, schema); 
     125        root = parser.parse('<code>  </code>'); 
     126        equal(serializer.serialize(root), '<code>  </code>', 'Whitespace inside code'); 
     127        deepEqual(countNodes(root), {body:1, code:1, '#text':1}, 'Whitespace inside code (count)'); 
    107128    }); 
    108129 
     
    423444    }); 
    424445 
     446    test('Parse html4 lists into html5 lists', function() { 
     447        var parser, root, schema = new tinymce.html.Schema(); 
     448 
     449        parser = new tinymce.html.DomParser({fix_list_elements: true}, schema); 
     450        root = parser.parse('<ul><ul><li>a</li></ul></ul><ul><li>a</li><ul><li>b</li></ul></ul>'); 
     451        equal(serializer.serialize(root), '<ul><li style="list-style-type: none"><ul><li>a</li></ul></li></ul><ul><li>a<ul><li>b</li></ul></li></ul>'); 
     452    }); 
     453 
    425454    test('Parse contents with html4 anchors and allow_html_in_named_anchor: false', function() { 
    426455        var parser, root, schema = new tinymce.html.Schema(); 
     
    509538        root = parser.parse('<ul><li></li></ul><ul><li> </li></ul>'); 
    510539        equal(serializer.serialize(root), ''); 
     540    }); 
     541 
     542    test('Padd empty with br', function() { 
     543        var schema = new tinymce.html.Schema(); 
     544        var parser = new tinymce.html.DomParser({padd_empty_with_br: true}, schema); 
     545        var serializer = new tinymce.html.Serializer({padd_empty_with_br: true}, schema); 
     546        var root = parser.parse('<p>a</p><p></p>'); 
     547        equal(serializer.serialize(root), '<p>a</p><p><br /></p>'); 
    511548    }); 
    512549 
  • trunk/tests/qunit/editor/tinymce/html/Node.js

    r27679 r40399  
    140140    ok(node.next === node3, 'node.next'); 
    141141    equal(node.prev, undefined, 'node.prev'); 
    142     ok(node3.prev, node, 'node3.prev'); 
     142    equal(node3.prev, node, 'node3.prev'); 
    143143    equal(node3.next, undefined, 'node3.next'); 
    144144}); 
  • trunk/tests/qunit/editor/tinymce/html/SaxParser.js

    r33013 r40399  
    605605        parser.parse('<!--[if !IE]>alert(1)<![endif]-->'); 
    606606        equal(writer.getContent(), '<!-- [if !IE]>alert(1)<![endif]-->'); 
     607 
     608        writer.reset(); 
     609        parser.parse('<!--[iF !IE]>alert(1)<![endif]-->'); 
     610        equal(writer.getContent(), '<!-- [iF !IE]>alert(1)<![endif]-->'); 
    607611    }); 
    608612 
  • trunk/tests/qunit/editor/tinymce/html/Schema.js

    r36352 r40399  
    1414 
    1515    schema = new tinymce.html.Schema({valid_elements: '*[id|class]'}); 
    16     deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {} }); 
     16    deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {}}); 
    1717    deepEqual(schema.getElementRule('b').attributesOrder, ["id", "class"]); 
    1818 
    1919    schema = new tinymce.html.Schema({valid_elements: 'b*[id|class]'}); 
    20     deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {} }); 
     20    deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {}}); 
    2121    deepEqual(schema.getElementRule('b').attributesOrder, ["id", "class"]); 
    22     deepEqual(schema.getElementRule('body').attributes, {"id": {}, "class": {} }); 
     22    deepEqual(schema.getElementRule('body').attributes, {"id": {}, "class": {}}); 
    2323    deepEqual(schema.getElementRule('body').attributesOrder, ["id", "class"]); 
    2424    equal(schema.getElementRule('img'), undefined); 
    2525 
    2626    schema = new tinymce.html.Schema({valid_elements: 'b?[id|class]'}); 
    27     deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {} }); 
     27    deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {}}); 
    2828    deepEqual(schema.getElementRule('b').attributesOrder, ["id", "class"]); 
    29     deepEqual(schema.getElementRule('bx').attributes, {"id": {}, "class": {} }); 
     29    deepEqual(schema.getElementRule('bx').attributes, {"id": {}, "class": {}}); 
    3030    deepEqual(schema.getElementRule('bx').attributesOrder, ["id", "class"]); 
    3131    equal(schema.getElementRule('body'), undefined); 
    3232 
    3333    schema = new tinymce.html.Schema({valid_elements: 'b+[id|class]'}); 
    34     deepEqual(schema.getElementRule('body').attributes, {"id": {}, "class": {} }); 
     34    deepEqual(schema.getElementRule('body').attributes, {"id": {}, "class": {}}); 
    3535    deepEqual(schema.getElementRule('body').attributesOrder, ["id", "class"]); 
    36     deepEqual(schema.getElementRule('bx').attributes, {"id": {}, "class": {} }); 
     36    deepEqual(schema.getElementRule('bx').attributes, {"id": {}, "class": {}}); 
    3737    deepEqual(schema.getElementRule('bx').attributesOrder, ["id", "class"]); 
    3838    equal(schema.getElementRule('b'), undefined); 
     
    4545 
    4646    schema = new tinymce.html.Schema({valid_elements: 'b[id|class|*]'}); 
    47     deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {} }); 
     47    deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {}}); 
    4848    deepEqual(schema.getElementRule('b').attributesOrder, ["id", "class"]); 
    4949    ok(schema.getElementRule('b').attributePatterns[0].pattern.test('x')); 
    5050 
    5151    schema = new tinymce.html.Schema({valid_elements: 'b[id|class|x?]'}); 
    52     deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {} }); 
     52    deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {}}); 
    5353    deepEqual(schema.getElementRule('b').attributesOrder, ["id", "class"]); 
    5454    ok(schema.getElementRule('b').attributePatterns[0].pattern.test('xy')); 
     
    5757 
    5858    schema = new tinymce.html.Schema({valid_elements: 'b[id|class|x+]'}); 
    59     deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {} }); 
     59    deepEqual(schema.getElementRule('b').attributes, {"id": {}, "class": {}}); 
    6060    deepEqual(schema.getElementRule('b').attributesOrder, ["id", "class"]); 
    6161    ok(!schema.getElementRule('b').attributePatterns[0].pattern.test('x')); 
     
    118118    schema = new tinymce.html.Schema({valid_elements: 'span[dir<ltr?rtl]'}); 
    119119    deepEqual(schema.getElementRule('span'), {"attributes": {"dir": {"validValues": {"rtl": {}, "ltr": {}}}}, "attributesOrder": ["dir"]}); 
     120}); 
     121 
     122test('Required parents', function() { 
     123    var schema; 
     124 
     125    schema = new tinymce.html.Schema(); 
     126    deepEqual(schema.getElementRule('tr').parentsRequired, ['tbody', 'thead', 'tfoot']); 
     127    deepEqual(schema.getElementRule('li').parentsRequired, ['ul', 'ol']); 
     128    deepEqual(schema.getElementRule('div').parentsRequired, undefined); 
    120129}); 
    121130 
     
    221230        "INPUT": {}, "IMG": {}, "HR": {}, "FRAME": {}, "COL": {}, "BR": {}, 
    222231        "BASEFONT": {}, "BASE": {}, "AREA": {}, "SOURCE" : {}, 
    223         "TD": {}, "TH": {}, "IFRAME": {}, "VIDEO": {}, "AUDIO": {}, "OBJECT": {}, "WBR": {}, "TRACK" : {}, "SCRIPT" : {}, 
     232        "TD": {}, "TH": {}, "IFRAME": {}, "VIDEO": {}, "AUDIO": {}, "OBJECT": {}, "WBR": {}, "TRACK" : {}, "SCRIPT" : {}, "PRE": {}, "CODE": {}, 
    224233        "embed": {}, "param": {}, "meta": {}, "link": {}, "isindex": {}, 
    225234        "input": {}, "img": {}, "hr": {}, "frame": {}, "col": {}, "br": {}, 
    226235        "basefont": {}, "base": {}, "area": {}, "source" : {}, 
    227         "td": {}, "th": {}, "iframe": {}, "video": {}, "audio": {}, "object": {}, "wbr" : {}, "track" : {},  "script" : {} 
     236        "td": {}, "th": {}, "iframe": {}, "video": {}, "audio": {}, "object": {}, "wbr" : {}, "track" : {}, "script" : {}, "pre": {}, "code": {} 
    228237    }); 
    229238}); 
     
    236245    schema = new tinymce.html.Schema(); 
    237246    deepEqual(schema.getWhiteSpaceElements(), { 
    238         "IFRAME": {}, "NOSCRIPT": {}, "OBJECT": {}, "PRE": {}, 
     247        "IFRAME": {}, "NOSCRIPT": {}, "OBJECT": {}, "PRE": {}, "CODE": {}, 
    239248        "SCRIPT": {}, "STYLE": {}, "TEXTAREA": {}, "VIDEO": {}, "AUDIO": {}, 
    240         "iframe": {}, "noscript": {}, "object": {}, "pre": {}, 
     249        "iframe": {}, "noscript": {}, "object": {}, "pre": {}, "code": {}, 
    241250        "script": {}, "style": {}, "textarea": {}, "video": {}, "audio": {} 
    242251    }); 
  • trunk/tests/qunit/editor/tinymce/html/Styles.js

    r28768 r40399  
    44    var styles = new tinymce.html.Styles(); 
    55 
    6     expect(11); 
     6    expect(12); 
    77 
    88    equal(styles.serialize(styles.parse('FONT-SIZE:10px')), "font-size: 10px;"); 
     
    1717    equal(styles.serialize(styles.parse('value: "&"')), "value: '&';"); 
    1818    equal(styles.serialize(styles.parse('value: ')), ""); 
     19    equal(styles.serialize(styles.parse("background: url('http://www.site.com/(foo)');")), "background: url('http://www.site.com/(foo)');"); 
    1920}); 
    2021 
     
    6263        'border: 1pt none black;' 
    6364    ); 
    64      
     65 
    6566    equal( 
    6667        styles.serialize(styles.parse('border-width: 1pt 4pt 2pt 3pt; border-style: solid dashed dotted none; border-color: black red green blue;')), 
     
    138139}); 
    139140 
     141test('Suspicious (XSS) property names', function() { 
     142    var styles = new tinymce.html.Styles(); 
     143 
     144    equal(styles.serialize(styles.parse('font-fa"on-load\\3dxss\\28\\29\\20mily:\'arial\'')), ""); 
     145    equal(styles.serialize(styles.parse('font-fa\\"on-load\\3dxss\\28\\29\\20mily:\'arial\'')), ""); 
     146    equal(styles.serialize(styles.parse('font-fa\\22on-load\\3dxss\\28\\29\\20mily:\'arial\'')), ""); 
     147}); 
     148 
    140149test('Script urls denied', function() { 
    141150    var styles = new tinymce.html.Styles(); 
    142151 
    143152    equal(styles.serialize(styles.parse('behavior:url(test.htc)')), ""); 
     153    equal(styles.serialize(styles.parse('b\\65havior:url(test.htc)')), ""); 
    144154    equal(styles.serialize(styles.parse('color:expression(alert(1))')), ""); 
    145155    equal(styles.serialize(styles.parse('color:\\65xpression(alert(1))')), ""); 
     
    149159    equal(styles.serialize(styles.parse('background:url(jAvaScript:alert(1)')), ""); 
    150160    equal(styles.serialize(styles.parse('background:url(javascript:alert(1)')), ""); 
     161    equal(styles.serialize(styles.parse('background:url(j\\61vascript:alert(1)')), ""); 
     162    equal(styles.serialize(styles.parse('background:url(\\6a\\61vascript:alert(1)')), ""); 
     163    equal(styles.serialize(styles.parse('background:url(\\6A\\61vascript:alert(1)')), ""); 
     164    equal(styles.serialize(styles.parse('background:url\\28\\6A\\61vascript:alert(1)')), ""); 
     165    equal(styles.serialize(styles.parse('background:\\75rl(j\\61vascript:alert(1)')), ""); 
     166    equal(styles.serialize(styles.parse('b\\61ckground:\\75rl(j\\61vascript:alert(1)')), ""); 
    151167    equal(styles.serialize(styles.parse('background:url(vbscript:alert(1)')), ""); 
    152168    equal(styles.serialize(styles.parse('background:url(j\navas\u0000cr\tipt:alert(1)')), ""); 
    153169    equal(styles.serialize(styles.parse('background:url(data:image/svg+xml,%3Csvg/%3E)')), ""); 
     170    equal(styles.serialize(styles.parse('background:url( data:image/svg+xml,%3Csvg/%3E)')), ""); 
     171    equal(styles.serialize(styles.parse('background:url\\28 data:image/svg+xml,%3Csvg/%3E)')), ""); 
     172    equal(styles.serialize(styles.parse('background:url("data: image/svg+xml,%3Csvg/%3E")')), ""); 
     173    equal(styles.serialize(styles.parse('background:url("data: ima ge/svg+xml,%3Csvg/%3E")')), ""); 
     174    equal(styles.serialize(styles.parse('background:url("data: image /svg+xml,%3Csvg/%3E")')), ""); 
    154175}); 
    155176 
  • trunk/tests/qunit/editor/tinymce/ui/Window.js

    r27679 r40399  
    3737 
    3838    test("title, no buttonbar, autoResize, title is widest", function() { 
    39         var win = createWindow({ 
     39        var win1 = createWindow({ 
     40            x: 100, 
     41            y: 120, 
     42            title: "XXXXXXXXXXXXXXXXXXX", 
     43            items: [ 
     44                {type: 'spacer', classes: 'red', flex: 1} 
     45            ] 
     46        }); 
     47 
     48        var win2 = createWindow({ 
    4049            x: 100, 
    4150            y: 120, 
     
    4655        }); 
    4756 
    48         Utils.nearlyEqualRects(Utils.size(win), [326, 61], 60); 
    49         Utils.nearlyEqualRects(Utils.size(win.find("spacer")[0]), [324, 20], 60); 
     57        equal(Utils.size(win2)[0] > Utils.size(win1)[0], true, 'Window 2 should be wider since the title spaces out the window'); 
     58        equal(Utils.size(win2.find("spacer")[0]) > Utils.size(win1.find("spacer")[0]), true, 'Window 2 spacer should be widger than window 1'); 
    5059    }); 
    5160 
  • trunk/tests/qunit/editor/tinymce/util/I18n.js

    r31700 r40399  
    66 
    77test("Translate strings", function() { 
     8    var undef; 
     9    var translate = tinymce.util.I18n.translate; 
     10 
    811    tinymce.util.I18n.add("code", { 
    912        "text": "text translation", 
    1013        "value:{0}{1}": "value translation:{0}{1}", 
    1114        "text{context:something}": "text translation with context", 
    12         "value:{0}{1}{context:something}": "value translation:{0}{1} with context" 
     15        "value:{0}{1}{context:something}": "value translation:{0}{1} with context", 
     16        "empty string": "" 
    1317    }); 
    1418 
    15     equal(tinymce.util.I18n.translate("text"), "text translation"); 
    16     equal(tinymce.util.I18n.translate("untranslated text"), "untranslated text"); 
    17     equal(tinymce.util.I18n.translate(["untranslated value:{0}{1}", "a", "b"]), "untranslated value:ab"); 
    18     equal(tinymce.util.I18n.translate(["value:{0}{1}", "a", "b"]), "value translation:ab"); 
    19     equal(tinymce.util.I18n.translate("untranslated text{context:context}"), "untranslated text"); 
    20     equal(tinymce.util.I18n.translate(["untranslated value:{0}{1}{context:something}", "a", "b"]), "untranslated value:ab"); 
    21     equal(tinymce.util.I18n.translate(["value:{0}{1}{context:something}", "a", "b"]), "value translation:ab with context"); 
     19    equal(translate("text"), "text translation"); 
     20    equal(translate("untranslated text"), "untranslated text"); 
     21    equal(translate(["untranslated value:{0}{1}", "a", "b"]), "untranslated value:ab"); 
     22    equal(translate(["value:{0}{1}", "a", "b"]), "value translation:ab"); 
     23    equal(translate("untranslated text{context:context}"), "untranslated text"); 
     24    equal(translate(["untranslated value:{0}{1}{context:something}", "a", "b"]), "untranslated value:ab"); 
     25    equal(translate(["value:{0}{1}{context:something}", "a", "b"]), "value translation:ab with context"); 
     26 
     27    // check if translate survives some awkward cases 
     28    deepEqual(translate("empty string"), ""); 
     29    equal(translate(["untranslated value:{0}{1}", "a"]), "untranslated value:a{1}", 
     30        "Do not strip tokens that weren't replaced."); 
     31 
     32    equal(translate([{}]), "[object Object]"); 
     33    equal(translate(function(){}), "[object Function]"); 
     34 
     35    equal(translate(null), ""); 
     36    equal(translate(0), 0, "0"); 
     37    equal(translate(true), "true", "true"); 
     38    equal(translate(false), "false", "false"); 
     39 
     40    equal(translate({}), "[object Object]", "[object Object]"); 
     41    equal(translate({raw:""}), "", "empty string"); 
     42    equal(translate({raw:false}), "false", "false"); 
     43    equal(translate({raw:undef}), ""); 
     44    equal(translate({raw:null}), ""); 
     45 
     46    // https://github.com/tinymce/tinymce/issues/3029 
     47    equal(translate("hasOwnProperty"), "hasOwnProperty"); 
     48    tinymce.util.I18n.add("code", { 
     49        "hasOwnProperty": "good" 
     50    }); 
     51    equal(translate("hasOwnProperty"), "good"); 
     52 
    2253}); 
    2354 
  • trunk/tests/qunit/editor/tinymce/util/Quirks_webkit.js

    r38034 r40399  
    126126    }); 
    127127 
     128    test('Delete from after image to paragraph', function() { 
     129        editor.getBody().innerHTML = '<p>a</p><p><img src="about:blank"></p>'; 
     130        var rng = editor.dom.createRng(); 
     131        rng.setStartAfter(editor.dom.select('img')[0]); 
     132        rng.setEndAfter(editor.dom.select('img')[0]); 
     133        editor.selection.setRng(rng); 
     134        editor.execCommand('Delete'); 
     135        equal(Utils.normalizeHtml(Utils.cleanHtml(editor.getBody().innerHTML)), '<p>a</p>'); 
     136        equal(editor.selection.getStart().nodeName, 'P'); 
     137    }); 
     138 
    128139    test('ForwardDelete from end of H1 to P with style span', function() { 
    129140        editor.getBody().innerHTML = '<h1>a</h1><p><span style="color:red">b</span></p>'; 
     
    335346        equal(editor.selection.getStart(true).nodeName, 'P'); 
    336347    }); 
     348 
     349    test('Delete with similar sibling nodes', function() { 
     350        editor.getBody().innerHTML = '<p>Test test</p><p>a</p><p>a</p><p id="t1">a</p><p>test1</p><p id="t2">test2</p>'; 
     351        Utils.setSelection('p#t1', 1, 'p#t2', 5); 
     352        editor.fire('keydown', {keyCode: 8}); 
     353        equal(Utils.cleanHtml(editor.getBody().innerHTML), '<p>test test</p><p>a</p><p>a</p><p id="t1">a</p>'); 
     354        equal(editor.selection.getStart(true).nodeName, 'P'); 
     355    }); 
    337356} else { 
    338357    test("Skipped since the browser isn't WebKit", function() { 
Note: See TracChangeset for help on using the changeset viewer.