'use strict';
class Node {
constructor(value) {
this.value = value;
this.left = null;
this.right = null;
}
}
class BinaryTree {
constructor() {
this.root = null;
}
preOrder() {
let resultArr = [];
let _preOrder = (root) => {
if (root !== null) {
resultArr.push(root.value);
if (root.left !== null) {
_preOrder(root.left);
}
if (root.right !== null) {
_preOrder(root.right);
}
}
};
_preOrder(this.root);
return resultArr;
}
inOrder() {
let resultArr = [];
let _inOrder = (root) => {
if (root !== null) {
if (root.left !== null) {
_inOrder(root.left);
}
resultArr.push(root.value);
if (root.right !== null) {
_inOrder(root.right);
}
}
};
_inOrder(this.root);
return resultArr;
}
postOrder() {
let resultArr = [];
let _postOrder = (root) => {
if (root !== null) {
if (root.left !== null) {
_postOrder(root.left);
}
if (root.right !== null) {
_postOrder(root.right);
}
resultArr.push(root.value);
}
};
_postOrder(this.root);
return resultArr;
}
addBinarySearch(value) {
let _add = (inputValue, root) => {
if (root === null) {
root = new Node(inputValue);
}
else if (root.value === inputValue) {
throw `Binary Search Tree already contains ${inputValue}. Nothing was added to the tree`;
}
else if (inputValue < root.value) {
root.left = _add(inputValue, root.left);
}
else if (inputValue > root.value) {
root.right = _add(inputValue, root.right);
}
return root;
};
try {
this.root = _add(value, this.root);
} catch (error) {
console.log(error);
}
}
findMax() {
if (this.root === null) {
throw 'Error: Binary Tree is empty';
}
else {
let max = null;
let _preOrderMax = (root, maxValue) => {
if (root !== null) {
if (root.value > maxValue) {
maxValue = root.value;
}
if (root.left !== null) {
maxValue = _preOrderMax(root.left, maxValue);
}
if (root.right !== null) {
maxValue = _preOrderMax(root.right, maxValue);
}
}
return maxValue;
};
max = this.root.value;
return _preOrderMax(this.root, max);
}
}
}
module.exports = BinaryTree;
/**
* @license Copyright (c) 2003-2020, CKSource - Frederico Knabben. All rights reserved.
* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
*/
import Model from '../../src/model/model';
import Element from '../../src/model/element';
import RootElement from '../../src/model/rootelement';
import count from '@ckeditor/ckeditor5-utils/src/count';
describe( 'RootElement', () => {
describe( 'constructor()', () => {
it( 'should create root element without attributes', () => {
const model = new Model();
const doc = model.document;
const root = new RootElement( doc );
expect( root ).to.be.an.instanceof( Element );
expect( root ).to.have.property( 'document' ).that.equals( doc );
expect( count( root.getAttributes() ) ).to.equal( 0 );
expect( root.childCount ).to.equal( 0 );
} );
} );
describe( 'is()', () => {
let root;
before( () => {
const model = new Model();
const doc = model.document;
root = new RootElement( doc, '$root' );
} );
it( 'should return true for rootElement, element, element with same name and element name', () => {
expect( root.is( 'element', '$root' ) ).to.be.true;
expect( root.is( 'model:element', '$root' ) ).to.be.true;
expect( root.is( 'element' ) ).to.be.true;
expect( root.is( 'model:element' ) ).to.be.true;
expect( root.is( 'rootElement', '$root' ) ).to.be.true;
expect( root.is( 'model:rootElement', '$root' ) ).to.be.true;
expect( root.is( 'rootElement' ) ).to.be.true;
expect( root.is( 'model:rootElement' ) ).to.be.true;
expect( root.is( 'node' ) ).to.be.true;
expect( root.is( 'model:node' ) ).to.be.true;
} );
it( 'should return false for other accept values', () => {
expect( root.is( 'element', '$graveyard' ) ).to.be.false;
expect( root.is( 'model:element', '$graveyard' ) ).to.be.false;
expect( root.is( 'rootElement', '$graveyard' ) ).to.be.false;
expect( root.is( 'model:rootElement', '$graveyard' ) ).to.be.false;
expect( root.is( '$graveyard' ) ).to.be.false;
expect( root.is( '$text' ) ).to.be.false;
expect( root.is( '$textProxy' ) ).to.be.false;
expect( root.is( 'documentFragment' ) ).to.be.false;
expect( root.is( 'view:element' ) ).to.be.false;
expect( root.is( '$root' ) ).to.be.false;
expect( root.is( 'model:$root' ) ).to.be.false;
expect( root.is( 'node', '$root' ) ).to.be.false;
expect( root.is( 'model:node', '$root' ) ).to.be.false;
} );
} );
} );
'use strict';
jest
.dontMock('../index')
.dontMock('q')
.dontMock('path')
.dontMock('absolute-path')
.dontMock('../docblock')
.setMock('../../../ModuleDescriptor', function(data) {return data;});
describe('DependencyGraph', function() {
var DependencyGraph;
var fileWatcher;
var fs;
beforeEach(function() {
fs = require('fs');
DependencyGraph = require('../index');
fileWatcher = {
on: function() {
return this;
}
};
});
describe('getOrderedDependencies', function() {
pit('should get dependencies', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("a")'
].join('\n'),
'a.js': [
'/**',
' * @providesModule a',
' */',
].join('\n'),
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{id: 'index', path: '/root/index.js', dependencies: ['a']},
{id: 'a', path: '/root/a.js', dependencies: []},
]);
});
});
pit('should get dependencies', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("image!a")'
].join('\n'),
'imgs': {
'a.png': ''
},
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher,
assetRoots: ['/root/imgs']
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{id: 'index', path: '/root/index.js', dependencies: ['image!a']},
{ id: 'image!a',
path: '/root/imgs/a.png',
dependencies: [],
isAsset: true
},
]);
});
});
pit('should get recursive dependencies', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("a")',
].join('\n'),
'a.js': [
'/**',
' * @providesModule a',
' */',
'require("index")',
].join('\n'),
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{id: 'index', path: '/root/index.js', dependencies: ['a']},
{id: 'a', path: '/root/a.js', dependencies: ['index']},
]);
});
});
pit('should work with packages', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage")',
].join('\n'),
'aPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'lol'
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{id: 'index', path: '/root/index.js', dependencies: ['aPackage']},
{ id: 'aPackage/main',
path: '/root/aPackage/main.js',
dependencies: []
},
]);
});
});
pit('should ignore malformed packages', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage")',
].join('\n'),
'aPackage': {
'package.json': 'lol',
'main.js': 'lol'
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{id: 'index', path: '/root/index.js', dependencies: ['aPackage']},
]);
});
});
pit('can have multiple modules with the same name', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("b")',
].join('\n'),
'b.js': [
'/**',
' * @providesModule b',
' */',
].join('\n'),
'c.js': [
'/**',
' * @providesModule c',
' */',
].join('\n'),
'somedir': {
'somefile.js': [
'/**',
' * @providesModule index',
' */',
'require("c")',
].join('\n')
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/somedir/somefile.js'))
.toEqual([
{ id: 'index',
path: '/root/somedir/somefile.js',
dependencies: ['c']
},
{ id: 'c',
path: '/root/c.js',
dependencies: []
},
]);
});
});
pit('providesModule wins when conflict with package', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage")',
].join('\n'),
'b.js': [
'/**',
' * @providesModule aPackage',
' */',
].join('\n'),
'aPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'lol'
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['aPackage']
},
{ id: 'aPackage',
path: '/root/b.js',
dependencies: []
},
]);
});
});
pit('should be forgiving with missing requires', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("lolomg")',
].join('\n')
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['lolomg']
}
]);
});
});
pit('should work with packages with subdirs', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage/subdir/lolynot")',
].join('\n'),
'aPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'lol',
'subdir': {
'lolynot.js': 'lolynot'
}
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['aPackage/subdir/lolynot']
},
{ id: 'aPackage/subdir/lolynot',
path: '/root/aPackage/subdir/lolynot.js',
dependencies: []
},
]);
});
});
pit('should work with packages with symlinked subdirs', function() {
var root = '/root';
fs.__setMockFilesystem({
'symlinkedPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'lol',
'subdir': {
'lolynot.js': 'lolynot'
}
},
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage/subdir/lolynot")',
].join('\n'),
'aPackage': { SYMLINK: '/symlinkedPackage' },
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['aPackage/subdir/lolynot']
},
{ id: 'aPackage/subdir/lolynot',
path: '/symlinkedPackage/subdir/lolynot.js',
dependencies: []
},
]);
});
});
pit('should work with relative modules in packages', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage")',
].join('\n'),
'aPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'require("./subdir/lolynot")',
'subdir': {
'lolynot.js': 'require("../other")'
},
'other.js': 'some code'
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['aPackage']
},
{ id: 'aPackage/main',
path: '/root/aPackage/main.js',
dependencies: ['./subdir/lolynot']
},
{ id: 'aPackage/subdir/lolynot',
path: '/root/aPackage/subdir/lolynot.js',
dependencies: ['../other']
},
{ id: 'aPackage/other',
path: '/root/aPackage/other.js',
dependencies: []
},
]);
});
});
});
describe('file watch updating', function() {
var triggerFileChange;
beforeEach(function() {
fileWatcher = {
on: function(eventType, callback) {
if (eventType !== 'all') {
throw new Error('Can only handle "all" event in watcher.');
}
triggerFileChange = callback;
return this;
}
};
});
pit('updates module dependencies', function() {
var root = '/root';
var filesystem = fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage")',
'require("foo")'
].join('\n'),
'foo': [
'/**',
' * @providesModule foo',
' */',
'require("aPackage")'
].join('\n'),
'aPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'main',
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
filesystem.root['index.js'] =
filesystem.root['index.js'].replace('require("foo")', '');
triggerFileChange('change', 'index.js', root);
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['aPackage']
},
{ id: 'aPackage/main',
path: '/root/aPackage/main.js',
dependencies: []
},
]);
});
});
});
pit('updates module dependencies on file change', function() {
var root = '/root';
var filesystem = fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage")',
'require("foo")'
].join('\n'),
'foo.js': [
'/**',
' * @providesModule foo',
' */',
'require("aPackage")'
].join('\n'),
'aPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'main',
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
filesystem.root['index.js'] =
filesystem.root['index.js'].replace('require("foo")', '');
triggerFileChange('change', 'index.js', root);
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['aPackage']
},
{ id: 'aPackage/main',
path: '/root/aPackage/main.js',
dependencies: []
},
]);
});
});
});
pit('updates module dependencies on file delete', function() {
var root = '/root';
var filesystem = fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage")',
'require("foo")'
].join('\n'),
'foo.js': [
'/**',
' * @providesModule foo',
' */',
'require("aPackage")'
].join('\n'),
'aPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'main',
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
delete filesystem.root.foo;
triggerFileChange('delete', 'foo.js', root);
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['aPackage', 'foo']
},
{ id: 'aPackage/main',
path: '/root/aPackage/main.js',
dependencies: []
},
]);
});
});
});
pit('updates module dependencies on file add', function() {
var root = '/root';
var filesystem = fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage")',
'require("foo")'
].join('\n'),
'foo.js': [
'/**',
' * @providesModule foo',
' */',
'require("aPackage")'
].join('\n'),
'aPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'main',
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
filesystem.root['bar.js'] = [
'/**',
' * @providesModule bar',
' */',
'require("foo")'
].join('\n');
triggerFileChange('add', 'bar.js', root);
filesystem.root.aPackage['main.js'] = 'require("bar")';
triggerFileChange('change', 'aPackage/main.js', root);
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['aPackage', 'foo']
},
{ id: 'aPackage/main',
path: '/root/aPackage/main.js',
dependencies: ['bar']
},
{ id: 'bar',
path: '/root/bar.js',
dependencies: ['foo']
},
{ id: 'foo',
path: '/root/foo.js',
dependencies: ['aPackage']
},
]);
});
});
});
pit('runs changes through ignore filter', function() {
var root = '/root';
var filesystem = fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage")',
'require("foo")'
].join('\n'),
'foo.js': [
'/**',
' * @providesModule foo',
' */',
'require("aPackage")'
].join('\n'),
'aPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'main',
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher,
ignoreFilePath: function(filePath) {
if (filePath === '/root/bar.js') {
return true;
}
return false;
}
});
return dgraph.load().then(function() {
filesystem.root['bar.js'] = [
'/**',
' * @providesModule bar',
' */',
'require("foo")'
].join('\n');
triggerFileChange('add', 'bar.js', root);
filesystem.root.aPackage['main.js'] = 'require("bar")';
triggerFileChange('change', 'aPackage/main.js', root);
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['aPackage', 'foo']
},
{ id: 'aPackage/main',
path: '/root/aPackage/main.js',
dependencies: ['bar']
},
{ id: 'foo',
path: '/root/foo.js',
dependencies: ['aPackage']
},
]);
});
});
});
pit('should ignore directory updates', function() {
var root = '/root';
fs.__setMockFilesystem({
'root': {
'index.js': [
'/**',
' * @providesModule index',
' */',
'require("aPackage")',
'require("foo")'
].join('\n'),
'foo.js': [
'/**',
' * @providesModule foo',
' */',
'require("aPackage")'
].join('\n'),
'aPackage': {
'package.json': JSON.stringify({
name: 'aPackage',
main: 'main.js'
}),
'main.js': 'main',
}
}
});
var dgraph = new DependencyGraph({
roots: [root],
fileWatcher: fileWatcher
});
return dgraph.load().then(function() {
triggerFileChange('change', 'aPackage', '/root', {
isDirectory: function(){ return true; }
});
return dgraph.load().then(function() {
expect(dgraph.getOrderedDependencies('/root/index.js'))
.toEqual([
{ id: 'index',
path: '/root/index.js',
dependencies: ['aPackage', 'foo']
},
{ id: 'aPackage/main',
path: '/root/aPackage/main.js',
dependencies: []
},
{ id: 'foo',
path: '/root/foo.js',
dependencies: ['aPackage']
},
]);
});
});
});
});
});
module("tinymce.html.Node");
test('construction', function() {
var node;
expect(15);
node = new tinymce.html.Node('#text', 3);
equal(node.name, '#text');
equal(node.type, 3);
node = new tinymce.html.Node('#comment', 8);
equal(node.name, '#comment');
equal(node.type, 8);
node = new tinymce.html.Node('b', 1);
equal(node.name, 'b');
equal(node.type, 1);
deepEqual(node.attributes, []);
node = new tinymce.html.Node('#pi', 7);
equal(node.name, '#pi');
equal(node.type, 7);
node = new tinymce.html.Node('#doctype', 10);
equal(node.name, '#doctype');
equal(node.type, 10);
node = new tinymce.html.Node('#cdata', 4);
equal(node.name, '#cdata');
equal(node.type, 4);
node = new tinymce.html.Node('#frag', 11);
equal(node.name, '#frag');
equal(node.type, 11);
});
test('append inside empty node', function() {
var root, node;
expect(10);
root = new tinymce.html.Node('#frag', 11);
node = root.append(new tinymce.html.Node('b', 1));
ok(root.firstChild.parent === root);
equal(root.firstChild.next, undefined);
equal(root.firstChild.prev, undefined);
equal(root.firstChild.firstChild, undefined);
equal(root.firstChild.lastChild, undefined);
ok(node.parent === root);
equal(node.next, undefined);
equal(node.prev, undefined);
equal(node.firstChild, undefined);
equal(node.lastChild, undefined);
});
test('append node after node', function() {
var root, node, node2;
expect(17);
root = new tinymce.html.Node('#frag', 11);
node2 = root.append(new tinymce.html.Node('a', 1));
node = root.append(new tinymce.html.Node('b', 1));
ok(root.firstChild.parent === root, 'root.firstChild.parent === root');
ok(root.firstChild === node2, 'root.firstChild');
ok(root.lastChild === node, 'root.firstChild');
ok(root.firstChild.next === node, 'root.firstChild.next');
equal(root.firstChild.prev, undefined, 'root.firstChild.prev');
equal(root.firstChild.firstChild, undefined, 'root.firstChild.firstChild');
equal(root.firstChild.lastChild, undefined, 'root.firstChild.lastChild');
ok(node2.parent === root, 'node2.parent === root');
ok(node2.next === node, 'node2.next');
equal(node2.prev, undefined, 'node2.prev');
equal(node2.firstChild, undefined, 'node2.firstChild');
equal(node2.lastChild, undefined, 'node2.lastChild');
ok(node.parent === root, 'node.parent === root');
equal(node.next, undefined, 'node.next');
ok(node.prev === node2, 'node.prev');
equal(node.firstChild, undefined, 'node.firstChild');
equal(node.lastChild, undefined, 'node.lastChild');
});
test('append existing node before other existing node', function() {
var root, node, node2;
expect(8);
root = new tinymce.html.Node('#frag', 11);
node = root.append(new tinymce.html.Node('a', 1));
node2 = root.append(new tinymce.html.Node('b', 1));
root.append(node);
ok(root.firstChild === node2, 'root.firstChild');
ok(root.lastChild === node, 'root.lastChild');
equal(node.next, undefined, 'node.next');
ok(node.prev === node2, 'node.prev');
ok(node.parent === root, 'node.parent');
ok(node2.parent === root, 'node2.parent');
equal(node2.prev, undefined, 'node2.prev');
ok(node2.next === node, 'node2.next');
});
test('remove unattached node', function() {
expect(1);
ok(!new tinymce.html.Node('#text', 3).remove().parent);
});
test('remove single child', function() {
var root, node;
expect(6);
root = new tinymce.html.Node('#frag', 11);
node = root.append(new tinymce.html.Node('p', 1));
node = root.firstChild.remove();
equal(root.firstChild, undefined);
equal(root.lastChild, undefined);
equal(node.parent, undefined);
equal(node.next, undefined);
equal(node.prev, undefined);
equal(node.name, 'p');
});
test('remove middle node', function() {
var root, node, node2, node3;
expect(9);
root = new tinymce.html.Node('#frag', 11);
node = root.append(new tinymce.html.Node('a', 1));
node2 = root.append(new tinymce.html.Node('b', 1));
node3 = root.append(new tinymce.html.Node('c', 1));
node2.remove();
equal(node2.parent, undefined);
equal(node2.next, undefined);
equal(node2.prev, undefined);
ok(root.firstChild === node, 'root.firstChild');
ok(root.lastChild === node3, 'root.lastChild');
ok(node.next === node3, 'node.next');
equal(node.prev, undefined, 'node.prev');
ok(node3.prev, node, 'node3.prev');
equal(node3.next, undefined, 'node3.next');
});
test('insert after last', function() {
var fragment, root, node, node2;
expect(5);
fragment = new tinymce.html.Node('#frag', 11);
root = fragment.append(new tinymce.html.Node('body', 1));
node = root.append(new tinymce.html.Node('a', 1));
node2 = root.insert(new tinymce.html.Node('x', 1), node);
ok(root.firstChild === node, 'root.firstChild');
ok(root.lastChild === node2, 'root.lastChild');
ok(node.next === node2, 'node.next');
ok(node2.prev === node, 'node2.prev');
ok(node2.parent === root, 'node3.next');
});
test('insert before first', function() {
var fragment, root, node, node2;
expect(8);
fragment = new tinymce.html.Node('#frag', 11);
root = fragment.append(new tinymce.html.Node('body', 1));
node = root.append(new tinymce.html.Node('a', 1));
node2 = root.insert(new tinymce.html.Node('x', 1), node, true);
ok(root.firstChild === node2, 'root.firstChild');
ok(root.lastChild === node, 'root.lastChild');
ok(node2.parent === root, 'node2.lastChild');
ok(node2.next === node, 'node2.next');
ok(node2.prev === undefined, 'node2.prev');
ok(node.parent === root, 'node.lastChild');
ok(node.next === undefined, 'node.next');
ok(node.prev === node2, 'node.prev');
});
test('insert before second', function() {
var fragment, root, node, node2, node3;
expect(5);
fragment = new tinymce.html.Node('#frag', 11);
root = fragment.append(new tinymce.html.Node('body', 1));
node = root.append(new tinymce.html.Node('a', 1));
node2 = root.append(new tinymce.html.Node('b', 1));
node3 = root.insert(new tinymce.html.Node('x', 1), node2, true);
ok(root.firstChild === node, 'root.firstChild');
ok(root.lastChild === node2, 'root.lastChild');
ok(node3.parent === root, 'node3.parent');
ok(node3.next === node2, 'node3.next');
ok(node3.prev === node, 'node3.prev');
});
test('insert after and between two nodes', function() {
var root, node, node2, node3, fragment;
expect(7);
fragment = new tinymce.html.Node('#frag', 11);
root = fragment.append(new tinymce.html.Node('body', 1));
node = root.append(new tinymce.html.Node('a', 1));
node2 = root.append(new tinymce.html.Node('b', 1));
node3 = root.insert(new tinymce.html.Node('x', 1), node);
ok(root.firstChild === node, 'root.firstChild');
ok(root.lastChild === node2, 'root.lastChild');
ok(node.next === node3, 'node.next');
ok(node2.prev === node3, 'node2.prev');
ok(node3.parent === root, 'node3.next');
ok(node3.next === node2, 'node3.next');
ok(node3.prev === node, 'node3.prev');
});
test('replace single child', function() {
var root, node1, node2;
expect(5);
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('b', 1));
node2 = root.append(new tinymce.html.Node('em', 1));
node1.replace(node2);
ok(root.firstChild === node2, 'root.firstChild');
ok(root.lastChild === node2, 'root.lastChild');
ok(node2.parent === root, 'node2.parent');
ok(!node2.next, 'node2.next');
ok(!node2.prev, 'node2.prev');
});
test('replace first child', function() {
var root, node1, node2, node3;
expect(5);
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('b', 1));
node2 = root.append(new tinymce.html.Node('em', 1));
node3 = root.append(new tinymce.html.Node('b', 1));
node1.replace(node2);
ok(root.firstChild === node2, 'root.firstChild');
ok(root.lastChild === node3, 'root.lastChild');
ok(node2.parent === root, 'node2.parent');
ok(node2.next === node3, 'node2.next');
ok(!node2.prev, 'node2.prev');
});
test('replace last child', function() {
var root, node1, node2, node3;
expect(5);
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('b', 1));
node3 = root.append(new tinymce.html.Node('b', 1));
node2 = root.append(new tinymce.html.Node('em', 1));
node3.replace(node2);
ok(root.firstChild === node1, 'root.firstChild');
ok(root.lastChild === node2, 'root.lastChild');
ok(node2.parent === root, 'node2.parent');
ok(!node2.next, 'node2.next');
ok(node2.prev === node1, 'node2.prev');
});
test('replace middle child', function() {
var root, node1, node2, node3, node4;
expect(5);
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('b', 1));
node2 = root.append(new tinymce.html.Node('b', 1));
node3 = root.append(new tinymce.html.Node('b', 1));
node4 = root.append(new tinymce.html.Node('em', 1));
node2.replace(node4);
ok(root.firstChild === node1, 'root.firstChild');
ok(root.lastChild === node3, 'root.lastChild');
ok(node4.parent === root, 'node4.parent');
ok(node4.next === node3, 'node4.next');
ok(node4.prev === node1, 'node4.prev');
});
test('attr', 22, function() {
var node;
node = new tinymce.html.Node('b', 1);
deepEqual(node.attributes, []);
node.attr('attr1', 'value1');
equal(node.attr('attr1'), 'value1');
equal(node.attr('attr2'), undefined);
deepEqual(node.attributes, [{name: 'attr1', value: 'value1'}]);
deepEqual(node.attributes.map, {'attr1': 'value1'});
node = new tinymce.html.Node('b', 1);
deepEqual(node.attributes, []);
node.attr('attr1', 'value1');
node.attr('attr1', 'valueX');
equal(node.attr('attr1'), 'valueX');
deepEqual(node.attributes, [{name: 'attr1', value: 'valueX'}]);
deepEqual(node.attributes.map, {'attr1': 'valueX'});
node = new tinymce.html.Node('b', 1);
deepEqual(node.attributes, []);
node.attr('attr1', 'value1');
node.attr('attr2', 'value2');
equal(node.attr('attr1'), 'value1');
equal(node.attr('attr2'), 'value2');
deepEqual(node.attributes, [{name: 'attr1', value: 'value1'}, {name: 'attr2', value: 'value2'}]);
deepEqual(node.attributes.map, {'attr1': 'value1', 'attr2': 'value2'});
node = new tinymce.html.Node('b', 1);
deepEqual(node.attributes, []);
node.attr('attr1', 'value1');
node.attr('attr1', null);
equal(node.attr('attr1'), undefined);
deepEqual(node.attributes, []);
deepEqual(node.attributes.map, {});
node = new tinymce.html.Node('b', 1);
node.attr({a:'1', b:'2'});
deepEqual(node.attributes, [{name: 'a', value: '1'}, {name: 'b', value: '2'}]);
deepEqual(node.attributes.map, {a:'1', b:'2'});
node = new tinymce.html.Node('b', 1);
node.attr(null);
deepEqual(node.attributes, []);
deepEqual(node.attributes.map, {});
});
test('clone', function() {
var root, node, clone;
expect(16);
node = new tinymce.html.Node('#text', 3);
node.value = 'value';
clone = node.clone();
equal(clone.name, '#text');
equal(clone.type, 3);
equal(clone.value, 'value');
equal(clone.parent, undefined);
equal(clone.next, undefined);
equal(clone.prev, undefined);
root = new tinymce.html.Node('#frag', 11);
node = new tinymce.html.Node('#text', 3);
node.value = 'value';
root.append(node);
equal(clone.name, '#text');
equal(clone.type, 3);
equal(clone.value, 'value');
equal(clone.parent, undefined);
equal(clone.next, undefined);
equal(clone.prev, undefined);
node = new tinymce.html.Node('b', 1);
node.attr('id', 'id');
node.attr('class', 'class');
node.attr('title', 'title');
clone = node.clone();
equal(clone.name, 'b');
equal(clone.type, 1);
deepEqual(clone.attributes, [{name: 'class', value: 'class'}, {name: 'title', value: 'title'}]);
deepEqual(clone.attributes.map, {'class': 'class', 'title': 'title'});
});
test('unwrap', function() {
var root, node1, node2, node3;
expect(7);
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('b', 1));
node2 = node1.append(new tinymce.html.Node('em', 1));
node1.unwrap();
ok(root.firstChild === node2, 'root.firstChild');
ok(root.lastChild === node2, 'root.lastChild');
ok(node2.parent === root, 'node2.parent');
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('b', 1));
node2 = node1.append(new tinymce.html.Node('em', 1));
node3 = node1.append(new tinymce.html.Node('span', 1));
node1.unwrap();
ok(root.firstChild === node2, 'root.firstChild');
ok(root.lastChild === node3, 'root.lastChild');
ok(node2.parent === root, 'node2.parent');
ok(node3.parent === root, 'node3.parent');
});
test('empty', function() {
var root, node1, node2;
expect(4);
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('b', 1));
node2 = node1.append(new tinymce.html.Node('em', 1));
node1.empty();
ok(root.firstChild === node1, 'root.firstChild');
ok(root.lastChild === node1, 'root.firstChild');
ok(!node1.firstChild, 'node1.firstChild');
ok(!node1.lastChild, 'node1.firstChild');
});
test('isEmpty', function() {
var root, node1, node2;
expect(9);
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('p', 1));
node2 = node1.append(new tinymce.html.Node('b', 1));
ok(root.isEmpty({img: 1}), 'Is empty 1');
ok(node1.isEmpty({img: 1}), 'Is empty 2');
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('p', 1));
node2 = node1.append(new tinymce.html.Node('img', 1));
ok(!root.isEmpty({img: 1}), 'Is not empty 1');
ok(!node1.isEmpty({img: 1}), 'Is not empty 2');
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('p', 1));
node2 = node1.append(new tinymce.html.Node('#text', 3));
node2.value = 'X';
ok(!root.isEmpty({img: 1}), 'Is not empty 3');
ok(!node1.isEmpty({img: 1}), 'Is not empty 4');
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('p', 1));
node2 = node1.append(new tinymce.html.Node('#text', 3));
node2.value = '';
ok(root.isEmpty({img: 1}), 'Is empty 4');
ok(node1.isEmpty({img: 1}), 'Is empty 5');
root = new tinymce.html.Node('#frag', 11);
node1 = root.append(new tinymce.html.Node('a', 1)).attr('name', 'x');
ok(!root.isEmpty({img: 1}), 'Contains anchor with name attribute.');
});
ModuleLoader.require([
'tinymce/caret/CaretBookmark',
'tinymce/caret/CaretPosition'
], function(CaretBookmark, CaretPosition) {
var assertCaretPosition = Utils.assertCaretPosition;
module('tinymce.caret.CaretBookmark');
function getRoot() {
return document.getElementById('view');
}
function setupHtml(html) {
getRoot().innerHTML = html;
}
function createTextPos(textNode, offset) {
return new CaretPosition(textNode, offset);
}
test('create element index', function() {
setupHtml('<b></b><i></i><b></b>');
equal(CaretBookmark.create(getRoot(), CaretPosition.before(getRoot().childNodes[0])), 'b[0],before');
equal(CaretBookmark.create(getRoot(), CaretPosition.before(getRoot().childNodes[1])), 'i[0],before');
equal(CaretBookmark.create(getRoot(), CaretPosition.before(getRoot().childNodes[2])), 'b[1],before');
equal(CaretBookmark.create(getRoot(), CaretPosition.after(getRoot().childNodes[2])), 'b[1],after');
});
test('create text index', function() {
setupHtml('a<b></b>b<b></b>ccc');
equal(CaretBookmark.create(getRoot(), createTextPos(getRoot().childNodes[0], 0)), 'text()[0],0');
equal(CaretBookmark.create(getRoot(), createTextPos(getRoot().childNodes[2], 1)), 'text()[1],1');
equal(CaretBookmark.create(getRoot(), createTextPos(getRoot().childNodes[4], 3)), 'text()[2],3');
});
test('create text index on fragmented text nodes', function() {
setupHtml('a');
getRoot().appendChild(document.createTextNode('b'));
getRoot().appendChild(document.createTextNode('c'));
getRoot().appendChild(document.createElement('b'));
getRoot().appendChild(document.createTextNode('d'));
getRoot().appendChild(document.createTextNode('e'));
equal(getRoot().childNodes.length, 6);
equal(CaretBookmark.create(getRoot(), createTextPos(getRoot().childNodes[0], 0)), 'text()[0],0');
equal(CaretBookmark.create(getRoot(), createTextPos(getRoot().childNodes[1], 0)), 'text()[0],1');
equal(CaretBookmark.create(getRoot(), createTextPos(getRoot().childNodes[2], 0)), 'text()[0],2');
equal(CaretBookmark.create(getRoot(), createTextPos(getRoot().childNodes[4], 0)), 'text()[1],0');
equal(CaretBookmark.create(getRoot(), createTextPos(getRoot().childNodes[5], 0)), 'text()[1],1');
});
test('create br element index', function() {
setupHtml('<p><br data-mce-bogus="1"></p><p><br></p>');
equal(CaretBookmark.create(getRoot(), CaretPosition.before(getRoot().firstChild.firstChild)), 'p[0]/br[0],before');
equal(CaretBookmark.create(getRoot(), CaretPosition.before(getRoot().lastChild.firstChild)), 'p[1]/br[0],before');
});
test('create deep element index', function() {
setupHtml('<p><span>a</span><span><b id="a"></b><b id="b"></b><b id="c"></b></span></p>');
equal(CaretBookmark.create(getRoot(), CaretPosition.before(document.getElementById('a'))), 'p[0]/span[1]/b[0],before');
equal(CaretBookmark.create(getRoot(), CaretPosition.before(document.getElementById('b'))), 'p[0]/span[1]/b[1],before');
equal(CaretBookmark.create(getRoot(), CaretPosition.before(document.getElementById('c'))), 'p[0]/span[1]/b[2],before');
equal(CaretBookmark.create(getRoot(), CaretPosition.after(document.getElementById('c'))), 'p[0]/span[1]/b[2],after');
});
test('create deep text index', function() {
setupHtml('<p><span>a</span><span id="x">a<b></b>b<b></b>ccc</span></p>');
equal(CaretBookmark.create(getRoot(), createTextPos(document.getElementById('x').childNodes[0], 0)), 'p[0]/span[1]/text()[0],0');
equal(CaretBookmark.create(getRoot(), createTextPos(document.getElementById('x').childNodes[2], 1)), 'p[0]/span[1]/text()[1],1');
equal(CaretBookmark.create(getRoot(), createTextPos(document.getElementById('x').childNodes[4], 3)), 'p[0]/span[1]/text()[2],3');
});
test('create element index from bogus', function() {
setupHtml('<b></b><span data-mce-bogus="1"><b></b><span data-mce-bogus="1"><b></b><b></b></span></span>');
equal(CaretBookmark.create(getRoot(), CaretPosition.before(getRoot().lastChild.lastChild.childNodes[1])), 'b[3],before');
});
test('resolve element index', function() {
setupHtml('<b></b><i></i><b></b>');
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'b[0],before'), CaretPosition.before(getRoot().childNodes[0]));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'b[1],before'), CaretPosition.before(getRoot().childNodes[2]));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'b[1],after'), CaretPosition.after(getRoot().childNodes[2]));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'i[0],before'), CaretPosition.before(getRoot().childNodes[1]));
});
test('resolve odd element names', function() {
setupHtml('<h-2X>abc</h-2X>');
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'h-2X[0]/text()[0],2'), createTextPos(getRoot().childNodes[0].firstChild, 2));
});
test('resolve deep element index', function() {
setupHtml('<p><span>a</span><span><b id="a"></b><b id="b"></b><b id="c"></b></span></p>');
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'p[0]/span[1]/b[0],before'), CaretPosition.before(document.getElementById('a')));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'p[0]/span[1]/b[1],before'), CaretPosition.before(document.getElementById('b')));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'p[0]/span[1]/b[2],before'), CaretPosition.before(document.getElementById('c')));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'p[0]/span[1]/b[2],after'), CaretPosition.after(document.getElementById('c')));
});
test('resolve text index', function() {
setupHtml('a<b></b>b<b></b>ccc');
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[0],0'), createTextPos(getRoot().childNodes[0], 0));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[1],1'), createTextPos(getRoot().childNodes[2], 1));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[2],3'), createTextPos(getRoot().childNodes[4], 3));
});
test('resolve text index on fragmented text nodes', function() {
setupHtml('a');
getRoot().appendChild(document.createTextNode('b'));
getRoot().appendChild(document.createTextNode('c'));
getRoot().appendChild(document.createElement('b'));
getRoot().appendChild(document.createTextNode('d'));
getRoot().appendChild(document.createTextNode('e'));
equal(getRoot().childNodes.length, 6);
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[0],0'), createTextPos(getRoot().childNodes[0], 0));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[0],1'), createTextPos(getRoot().childNodes[0], 1));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[0],2'), createTextPos(getRoot().childNodes[1], 1));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[0],3'), createTextPos(getRoot().childNodes[2], 1));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[0],4'), createTextPos(getRoot().childNodes[2], 1));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[1],0'), createTextPos(getRoot().childNodes[4], 0));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[1],1'), createTextPos(getRoot().childNodes[4], 1));
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[1],2'), createTextPos(getRoot().childNodes[5], 1));
});
test('resolve text index with to high offset', function() {
setupHtml('abc');
assertCaretPosition(CaretBookmark.resolve(getRoot(), 'text()[0],10'), createTextPos(getRoot().childNodes[0], 3));
});
test('resolve invalid paths', function() {
setupHtml('<b><i></i></b>');
equal(CaretBookmark.resolve(getRoot(), 'x[0]/y[1]/z[2]'), null);
equal(CaretBookmark.resolve(getRoot(), 'b[0]/i[2]'), null);
equal(CaretBookmark.resolve(getRoot(), 'x'), null);
equal(CaretBookmark.resolve(getRoot(), null), null);
});
});
ModuleLoader.require([
"tinymce/Env",
"tinymce/caret/CaretPosition"
], function(Env, CaretPosition) {
module("tinymce.caret.CaretPosition");
if (!Env.ceFalse) {
return;
}
var createRange = Utils.createRange,
assertCaretPosition = Utils.assertCaretPosition,
assertRange = Utils.assertRange;
function getRoot() {
return document.getElementById('view');
}
function setupHtml(html) {
tinymce.$(getRoot()).empty();
getRoot().innerHTML = html;
}
test('Constructor', function() {
setupHtml('abc');
strictEqual(new CaretPosition(getRoot(), 0).container(), getRoot());
strictEqual(new CaretPosition(getRoot(), 1).offset(), 1);
strictEqual(new CaretPosition(getRoot().firstChild, 0).container(), getRoot().firstChild);
strictEqual(new CaretPosition(getRoot().firstChild, 1).offset(), 1);
});
test('fromRangeStart', function() {
setupHtml('abc');
assertCaretPosition(CaretPosition.fromRangeStart(createRange(getRoot(), 0)), new CaretPosition(getRoot(), 0));
assertCaretPosition(CaretPosition.fromRangeStart(createRange(getRoot(), 1)), new CaretPosition(getRoot(), 1));
assertCaretPosition(CaretPosition.fromRangeStart(createRange(getRoot().firstChild, 1)), new CaretPosition(getRoot().firstChild, 1));
});
test('fromRangeEnd', function() {
setupHtml('abc');
assertCaretPosition(CaretPosition.fromRangeEnd(createRange(getRoot(), 0, getRoot(), 1)), new CaretPosition(getRoot(), 1));
assertCaretPosition(CaretPosition.fromRangeEnd(createRange(getRoot().firstChild, 0, getRoot().firstChild, 1)), new CaretPosition(getRoot().firstChild, 1));
});
test('after', function() {
setupHtml('abc<b>123</b>');
assertCaretPosition(CaretPosition.after(getRoot().firstChild), new CaretPosition(getRoot(), 1));
assertCaretPosition(CaretPosition.after(getRoot().lastChild), new CaretPosition(getRoot(), 2));
});
test('before', function() {
setupHtml('abc<b>123</b>');
assertCaretPosition(CaretPosition.before(getRoot().firstChild), new CaretPosition(getRoot(), 0));
assertCaretPosition(CaretPosition.before(getRoot().lastChild), new CaretPosition(getRoot(), 1));
});
test('isAtStart', function() {
setupHtml('abc<b>123</b>123');
ok(new CaretPosition(getRoot(), 0).isAtStart());
ok(!new CaretPosition(getRoot(), 1).isAtStart());
ok(!new CaretPosition(getRoot(), 3).isAtStart());
ok(new CaretPosition(getRoot().firstChild, 0).isAtStart());
ok(!new CaretPosition(getRoot().firstChild, 1).isAtStart());
ok(!new CaretPosition(getRoot().firstChild, 3).isAtStart());
});
test('isAtEnd', function() {
setupHtml('abc<b>123</b>123');
ok(new CaretPosition(getRoot(), 3).isAtEnd());
ok(!new CaretPosition(getRoot(), 2).isAtEnd());
ok(!new CaretPosition(getRoot(), 0).isAtEnd());
ok(new CaretPosition(getRoot().firstChild, 3).isAtEnd());
ok(!new CaretPosition(getRoot().firstChild, 0).isAtEnd());
ok(!new CaretPosition(getRoot().firstChild, 1).isAtEnd());
});
test('toRange', function() {
setupHtml('abc');
assertRange(new CaretPosition(getRoot(), 0).toRange(), createRange(getRoot(), 0));
assertRange(new CaretPosition(getRoot(), 1).toRange(), createRange(getRoot(), 1));
assertRange(new CaretPosition(getRoot().firstChild, 1).toRange(), createRange(getRoot().firstChild, 1));
});
test('isEqual', function() {
setupHtml('abc');
equal(new CaretPosition(getRoot(), 0).isEqual(new CaretPosition(getRoot(), 0)), true);
equal(new CaretPosition(getRoot(), 1).isEqual(new CaretPosition(getRoot(), 0)), false);
equal(new CaretPosition(getRoot(), 0).isEqual(new CaretPosition(getRoot().firstChild, 0)), false);
});
test('isVisible', function() {
setupHtml('<b> abc</b>');
equal(new CaretPosition(getRoot().firstChild.firstChild, 0).isVisible(), false);
equal(new CaretPosition(getRoot().firstChild.firstChild, 3).isVisible(), true);
});
test('getClientRects', function() {
setupHtml(
'<b>abc</b>' +
'<div contentEditable="false">1</div>' +
'<div contentEditable="false">2</div>' +
'<div contentEditable="false">2</div>' +
'<input style="margin: 10px">' +
'<input style="margin: 10px">' +
'<input style="margin: 10px">' +
'<p>123</p>' +
'<br>'
);
equal(new CaretPosition(getRoot().firstChild.firstChild, 0).getClientRects().length, 1);
equal(new CaretPosition(getRoot(), 1).getClientRects().length, 1);
equal(new CaretPosition(getRoot(), 2).getClientRects().length, 2);
equal(new CaretPosition(getRoot(), 3).getClientRects().length, 2);
equal(new CaretPosition(getRoot(), 4).getClientRects().length, 2);
equal(new CaretPosition(getRoot(), 5).getClientRects().length, 1);
equal(new CaretPosition(getRoot(), 6).getClientRects().length, 1);
equal(new CaretPosition(getRoot(), 7).getClientRects().length, 1);
equal(new CaretPosition(getRoot(), 8).getClientRects().length, 1);
equal(new CaretPosition(getRoot(), 9).getClientRects().length, 0);
});
test('getClientRects between inline node and cE=false', function() {
setupHtml(
'<span contentEditable="false">def</span>' +
'<b>ghi</b>'
);
equal(new CaretPosition(getRoot(), 1).getClientRects().length, 1);
});
test('getClientRects at last visible character', function() {
setupHtml('<b>a </b>');
equal(new CaretPosition(getRoot().firstChild.firstChild, 1).getClientRects().length, 1);
});
test('getClientRects at extending character', function() {
setupHtml('a\u0301b');
equal(new CaretPosition(getRoot().firstChild, 0).getClientRects().length, 1);
equal(new CaretPosition(getRoot().firstChild, 1).getClientRects().length, 0);
equal(new CaretPosition(getRoot().firstChild, 2).getClientRects().length, 1);
});
test('getClientRects at whitespace character', function() {
setupHtml(' a ');
equal(new CaretPosition(getRoot().firstChild, 0).getClientRects().length, 0);
equal(new CaretPosition(getRoot().firstChild, 1).getClientRects().length, 0);
equal(new CaretPosition(getRoot().firstChild, 2).getClientRects().length, 1);
equal(new CaretPosition(getRoot().firstChild, 3).getClientRects().length, 1);
equal(new CaretPosition(getRoot().firstChild, 4).getClientRects().length, 0);
equal(new CaretPosition(getRoot().firstChild, 5).getClientRects().length, 0);
});
test('getNode', function() {
setupHtml('<b>abc</b><input><input>');
equal(new CaretPosition(getRoot().firstChild.firstChild, 0).getNode(), getRoot().firstChild.firstChild);
equal(new CaretPosition(getRoot(), 1).getNode(), getRoot().childNodes[1]);
equal(new CaretPosition(getRoot(), 2).getNode(), getRoot().childNodes[2]);
equal(new CaretPosition(getRoot(), 3).getNode(), getRoot().childNodes[2]);
});
test('getNode (before)', function() {
setupHtml('<b>abc</b><input><input>');
equal(new CaretPosition(getRoot().firstChild.firstChild, 0).getNode(true), getRoot().firstChild.firstChild);
equal(new CaretPosition(getRoot(), 1).getNode(true), getRoot().childNodes[0]);
equal(new CaretPosition(getRoot(), 2).getNode(true), getRoot().childNodes[1]);
equal(new CaretPosition(getRoot(), 3).getNode(true), getRoot().childNodes[2]);
});
});
Accelerate Your Automation Test Cycles With LambdaTest
Leverage LambdaTest’s cloud-based platform to execute your automation tests in parallel and trim down your test execution time significantly. Your first 100 automation testing minutes are on us.
