wbase 0.0.14 → 0.0.15

data/app/assets/javascripts/wbase/admin/tinymce/themes/inlite/src/test/js/browser/alien/BookmarkTest.js

@@ -0,0 +1,65 @@
+asynctest('browser/alien/BookmarkTest', [
+	'ephox/tinymce',
+	'ephox.agar.api.Pipeline',
+	'ephox.agar.api.Chain',
+	'ephox.agar.api.Cursors',
+	'ephox.agar.api.Assertions',
+	'ephox.mcagar.api.TinyDom',
+	'tinymce/inlite/alien/Bookmark'
+], function (tinymce, Pipeline, Chain, Cursors, Assertions, TinyDom, Bookmark) {
+	var success = arguments[arguments.length - 2];
+	var failure = arguments[arguments.length - 1];
+
+	var toNativeRange = function (range) {
+		var domRange = document.createRange();
+		domRange.setStart(range.start().dom(), range.soffset());
+		domRange.setEnd(range.finish().dom(), range.foffset());
+		return domRange;
+	};
+
+	var rangeToBookmark = function (dom) {
+		return function (range) {
+			return Bookmark.create(dom, range);
+		};
+	};
+
+	var bookmarkToRange = function (dom) {
+		return function (bookmark) {
+			return Bookmark.resolve(dom, bookmark);
+		};
+	};
+
+	var cAssertRangeEq = function (expected) {
+		return Chain.op(function (actual) {
+			Assertions.assertEq('Not equal startContainer', expected.start().dom(), actual.startContainer);
+			Assertions.assertEq('Not equal startOffset', expected.soffset(), actual.startOffset);
+			Assertions.assertEq('Not equal endContainer', expected.finish().dom(), actual.endContainer);
+			Assertions.assertEq('Not equal endOffset', expected.foffset(), actual.endOffset);
+		});
+	};
+
+	var sTestBookmark = function (html, path) {
+		var dom = tinymce.DOM;
+		var elm = TinyDom.fromDom(dom.create('div', {}, html));
+
+		return Chain.asStep(elm, [
+			Cursors.cFollowPath(Cursors.pathFrom(path)),
+			Chain.mapper(toNativeRange),
+			Chain.mapper(rangeToBookmark(dom)),
+			Chain.mapper(bookmarkToRange(dom)),
+			cAssertRangeEq(Cursors.calculate(elm, Cursors.pathFrom(path)))
+		]);
+	};
+
+	Pipeline.async({}, [
+		sTestBookmark('abc', {element: [0], offset: 0}),
+		sTestBookmark('abc', {element: [0], offset: 1}),
+		sTestBookmark('abc', {start: {element: [0], offset: 0}, finish: {element: [0], offset: 1}}),
+		sTestBookmark('<b>a</b>', {element: [0, 0], offset: 0}),
+		sTestBookmark('<b>a</b>', {element: [0, 0], offset: 0}),
+		sTestBookmark('<b>a</b>', {start: {element: [0, 0], offset: 0}, finish: {element: [0, 0], offset: 1}}),
+		sTestBookmark('<b>a</b><b>b</b>', {start: {element: [0, 0], offset: 0}, finish: {element: [1, 0], offset: 1}})
+	], function () {
+		success();
+	}, failure);
+});

data/app/assets/javascripts/wbase/admin/tinymce/themes/inlite/src/test/js/browser/alien/UnlinkTest.js

@@ -0,0 +1,38 @@
+asynctest('browser/alien/UnlinkTest', [
+	'ephox.mcagar.api.TinyLoader',
+	'ephox.mcagar.api.TinyApis',
+	'tinymce/inlite/alien/Unlink',
+	'ephox.agar.api.Pipeline',
+	'ephox.agar.api.Step',
+	'ephox.agar.api.GeneralSteps'
+], function (TinyLoader, TinyApis, Unlink, Pipeline, Step, GeneralSteps) {
+	var success = arguments[arguments.length - 2];
+	var failure = arguments[arguments.length - 1];
+
+	var sUnlinkSelection = function (editor) {
+		return Step.sync(function () {
+			Unlink.unlinkSelection(editor);
+		});
+	};
+
+	TinyLoader.setup(function (editor, onSuccess, onFailure) {
+		var tinyApis = TinyApis(editor);
+
+		var sAssertUnlink = function (inputHtml, startPath, startOffset, finishPath, finishOffset, expectedHtml) {
+			return GeneralSteps.sequence([
+				tinyApis.sSetContent(inputHtml),
+				tinyApis.sSetSelection(startPath, startOffset, finishPath, finishOffset),
+				sUnlinkSelection(editor),
+				tinyApis.sAssertContent(expectedHtml, 'Should match expected anchor less html')
+			]);
+		};
+
+		Pipeline.async({}, [
+			sAssertUnlink('<p><a href="#">a</a></p>', [0, 0, 0], 0, [0, 0, 0], 1, '<p>a</p>'),
+			sAssertUnlink('<p><a href="#">a</a>b</p>', [0, 0, 0], 0, [0, 1], 1, '<p>ab</p>'),
+			sAssertUnlink('<p><a href="#">a</a><p><a href="#">b</a>', [0, 0, 0], 0, [0, 0, 0], 1, '<p>a</p>\n<p><a href="#">b</a></p>'),
+			sAssertUnlink('<p><a href="#">a</a><p><a href="#">b</a>', [0, 0, 0], 0, [1, 0, 0], 1, '<p>a</p>\n<p>b</p>')
+		], onSuccess, onFailure);
+	}, {
+	}, success, failure);
+});

data/app/assets/javascripts/wbase/admin/tinymce/themes/inlite/src/test/js/browser/core/ActionsTest.js

@@ -0,0 +1,177 @@
+asynctest('browser/core/ActionsTest', [
+	'ephox.mcagar.api.TinyLoader',
+	'ephox.mcagar.api.TinyApis',
+	'tinymce/inlite/core/Actions',
+	'ephox.agar.api.Pipeline',
+	'ephox.agar.api.Step',
+	'ephox.agar.api.GeneralSteps'
+], function (TinyLoader, TinyApis, Actions, Pipeline, Step, GeneralSteps) {
+	var success = arguments[arguments.length - 2];
+	var failure = arguments[arguments.length - 1];
+
+	var wrap = function (f, args) {
+		return function () {
+			var currentArgs = Array.prototype.slice.call(arguments);
+			return Step.sync(function () {
+				f.apply(null, [].concat(args).concat(currentArgs));
+			});
+		};
+	};
+
+	var sInsertTableTests = function (editor, tinyApis) {
+		var sInsertTableTest = function (cols, rows, expectedHtml, message) {
+			var sInsertTable = wrap(Actions.insertTable, editor);
+
+			return GeneralSteps.sequence([
+				tinyApis.sSetContent(''),
+				sInsertTable(cols, rows),
+				tinyApis.sAssertContent(expectedHtml, message)
+			]);
+		};
+
+		return GeneralSteps.sequence([
+			sInsertTableTest(2, 3, [
+					'<table style="width: 100%;">',
+						'<tbody>',
+							'<tr>',
+								'<td>&nbsp;</td>',
+								'<td>&nbsp;</td>',
+							'</tr>',
+						'<tr>',
+							'<td>&nbsp;</td>',
+							'<td>&nbsp;</td>',
+						'</tr>',
+							'<tr>',
+								'<td>&nbsp;</td>',
+								'<td>&nbsp;</td>',
+							'</tr>',
+						'</tbody>',
+					'</table>'
+				].join('\n'),
+				'Should be a 2x3 table'
+			),
+
+			sInsertTableTest(3, 2, [
+					'<table style="width: 100%;">',
+						'<tbody>',
+							'<tr>',
+								'<td>&nbsp;</td>',
+								'<td>&nbsp;</td>',
+								'<td>&nbsp;</td>',
+							'</tr>',
+							'<tr>',
+								'<td>&nbsp;</td>',
+								'<td>&nbsp;</td>',
+								'<td>&nbsp;</td>',
+							'</tr>',
+						'</tbody>',
+					'</table>'
+				].join('\n'),
+				'Should be a 3x2 table'
+			)
+		]);
+	};
+
+	var sFormatBlockTests = function (editor, tinyApis) {
+		var sFormatBlockTest = function (name) {
+			var sFormatBlock = wrap(Actions.formatBlock, editor);
+
+			return GeneralSteps.sequence([
+				tinyApis.sSetContent('<p>a</p>'),
+				tinyApis.sSetCursor([0], 0),
+				sFormatBlock(name),
+				tinyApis.sAssertContent('<' + name + '>a</' + name + '>', 'Should be a ' + name + ' block')
+			]);
+		};
+
+		return GeneralSteps.sequence([
+			sFormatBlockTest('h1'),
+			sFormatBlockTest('h2'),
+			sFormatBlockTest('pre')
+		]);
+	};
+
+	var sCreateLinkTests = function (editor, tinyApis) {
+		var sCreateLinkTest = function (inputHtml, url, sPath, sOffset, fPath, fOffset, expectedHtml) {
+			var sCreateLink = wrap(Actions.createLink, editor);
+
+			return GeneralSteps.sequence([
+				tinyApis.sSetContent(inputHtml),
+				tinyApis.sSetSelection(sPath, sOffset, fPath, fOffset),
+				sCreateLink(url),
+				tinyApis.sAssertContent(expectedHtml, 'Should have a link')
+			]);
+		};
+
+		return GeneralSteps.sequence([
+			sCreateLinkTest('<p>a</p>', '#1', [0, 0], 0, [0, 0], 1, '<p><a href="#1">a</a></p>'),
+			sCreateLinkTest('<p><a href="#1">a</a></p>', '#2', [0, 0], 0, [0, 0], 1, '<p><a href="#2">a</a></p>'),
+			sCreateLinkTest('<p><a href="#1"><em>a</em></a></p>', '#2',	[0, 0, 0], 0, [0, 0, 0], 1,	'<p><a href="#2"><em>a</em></a></p>')
+		]);
+	};
+
+	var sUnlinkTests = function (editor, tinyApis) {
+		var sUnlinkTest = function (inputHtml, sPath, sOffset, fPath, fOffset, expectedHtml) {
+			var sUnlink = wrap(Actions.unlink, editor);
+
+			return GeneralSteps.sequence([
+				tinyApis.sSetContent(inputHtml),
+				tinyApis.sSetSelection(sPath, sOffset, fPath, fOffset),
+				sUnlink(),
+				tinyApis.sAssertContent(expectedHtml, 'Should not have a link')
+			]);
+		};
+
+		return GeneralSteps.sequence([
+			sUnlinkTest('<p>a</p>', [0, 0], 0, [0, 0], 1, '<p>a</p>'),
+			sUnlinkTest('<p><a href="#">a</a></p>', [0, 0, 0], 0, [0, 0, 0], 1, '<p>a</p>'),
+			sUnlinkTest('<p><a href="#"><em>a</em></a></p>', [0, 0, 0], 0, [0, 0, 0], 1, '<p><em>a</em></p>'),
+			sUnlinkTest('<p><a href="#">a</a>b</p>', [0, 0, 0], 0, [0, 1], 1, '<p>ab</p>')
+		]);
+	};
+
+	var base64ToBlob = function (base64, type) {
+		var buff = atob(base64);
+		var bytes = new Uint8Array(buff.length);
+
+		for (var i = 0; i < bytes.length; i++) {
+			bytes[i] = buff.charCodeAt(i);
+		}
+
+		return new Blob([bytes], {type: type});
+	};
+
+	var sInsertBlobTests = function (editor, tinyApis) {
+		var sInsertBlobTest = function (inputHtml, path, offset, blob, base64, expectedHtml) {
+			var sInsertBlob = wrap(Actions.insertBlob, editor);
+
+			return GeneralSteps.sequence([
+				tinyApis.sSetContent(inputHtml),
+				tinyApis.sSetCursor(path, offset),
+				sInsertBlob(blob, base64),
+				tinyApis.sAssertContent(expectedHtml, 'Should have a image')
+			]);
+		};
+
+		var base64 = 'R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
+		var blob = base64ToBlob(base64, 'image/gif');
+
+		return GeneralSteps.sequence([
+			sInsertBlobTest('<p>a</p>', [0, 0], 0, base64, blob, '<p><img src="data:image/gif;base64,' + base64 + '" />a</p>')
+		]);
+	};
+
+	TinyLoader.setup(function (editor, onSuccess, onFailure) {
+		var tinyApis = TinyApis(editor);
+
+		Pipeline.async({}, [
+			sInsertTableTests(editor, tinyApis),
+			sFormatBlockTests(editor, tinyApis),
+			sInsertBlobTests(editor, tinyApis),
+			sCreateLinkTests(editor, tinyApis),
+			sUnlinkTests(editor, tinyApis)
+		], onSuccess, onFailure);
+	}, {
+		inline: true
+	}, success, failure);
+});

data/app/assets/javascripts/wbase/admin/tinymce/themes/inlite/src/test/js/browser/core/ElementMatcher.js

@@ -0,0 +1,69 @@
+asynctest('browser/core/ElementMatcherTest', [
+	'ephox.mcagar.api.TinyLoader',
+	'ephox.mcagar.api.TinyApis',
+	'ephox.agar.api.Step',
+	'ephox.agar.api.Assertions',
+	'tinymce/inlite/core/ElementMatcher',
+	'tinymce/inlite/core/PredicateId',
+	'ephox.agar.api.Pipeline'
+], function (TinyLoader, TinyApis, Step, Assertions, ElementMatcher, PredicateId, Pipeline) {
+	var success = arguments[arguments.length - 2];
+	var failure = arguments[arguments.length - 1];
+
+	var eq = function (target) {
+		return function (elm) {
+			return elm === target;
+		};
+	};
+
+	var constantFalse = function (/*elm*/) {
+		return false;
+	};
+
+	var sElementTest = function (tinyApis, editor, inputHtml, selector) {
+		return Step.sync(function () {
+			var target, result;
+
+			editor.setContent(inputHtml);
+			target = editor.dom.select(selector)[0];
+
+			result = ElementMatcher.element(target, [
+				PredicateId.create('a', constantFalse),
+				PredicateId.create('b', eq(target))
+			])(editor);
+
+			Assertions.assertEq(result.id, 'b', 'Should be matching B');
+			Assertions.assertEq(result.rect.w > 0, true, 'Should be have width');
+		});
+	};
+
+	var sParentTest = function (tinyApis, editor, inputHtml, selector) {
+		return Step.sync(function () {
+			var target, parents, result;
+
+			editor.setContent(inputHtml);
+			target = editor.dom.select(selector)[0];
+			parents = editor.dom.getParents(target);
+
+			result = ElementMatcher.parent(parents, [
+				PredicateId.create('a', constantFalse),
+				PredicateId.create('b', eq(parents[1])),
+				PredicateId.create('c', eq(parents[0]))
+			])(editor);
+
+			Assertions.assertEq(result.id, 'c', 'Should be matching C the closest one');
+			Assertions.assertEq(result.rect.w > 0, true, 'Should be have width');
+		});
+	};
+
+	TinyLoader.setup(function (editor, onSuccess, onFailure) {
+		var tinyApis = TinyApis(editor);
+
+		Pipeline.async({}, [
+			sElementTest(tinyApis, editor, '<p>a</p>', 'p'),
+			sParentTest(tinyApis, editor, '<div><p><em>a</em></p></div>', 'em')
+		], onSuccess, onFailure);
+	}, {
+		inline: true
+	}, success, failure);
+});

data/app/assets/javascripts/wbase/admin/tinymce/themes/inlite/src/test/js/browser/core/LayoutTest.js

@@ -0,0 +1,118 @@
+test('browser/core/LayoutTest', [
+	'ephox/tinymce',
+	'tinymce/inlite/core/Layout'
+], function (tinymce, Layout) {
+	// TODO: Move this to atomic test when we can require parts of tinymce core using bolt
+
+	var rect = function (x, y, w, h) {
+		return {x: x, y: y, w: w, h: h};
+	};
+
+	var clientRect = function (x, y, w, h) {
+		return {left: x, top: y, width: w, height: h, bottom: y + h, right: x + w};
+	};
+
+	var assertLayout = function (expected, rects) {
+		var result;
+
+		result = Layout.calc(
+			rects.targetRect,
+			rects.contentAreaRect,
+			rects.panelRect
+		);
+
+		assert.eq(expected, result);
+	};
+
+	var testCalcPanelAtBottomLeft = function () {
+		assertLayout({
+			rect: rect(0, 10, 20, 10),
+			position: 'bl-tl'
+		}, {
+			contentAreaRect: rect(0, 0, 100, 100),
+			targetRect: rect(0, 0, 10, 10),
+			panelRect: rect(0, 0, 20, 10)
+		});
+	};
+
+	var testCalcPanelAtBottomRight = function () {
+		assertLayout({
+			rect: rect(80, 10, 20, 10),
+			position: 'br-tr'
+		}, {
+			contentAreaRect: rect(0, 0, 100, 100),
+			targetRect: rect(90, 0, 10, 10),
+			panelRect: rect(0, 0, 20, 10)
+		});
+	};
+
+	var testCalcPanelAtTopLeft = function () {
+		assertLayout({
+			rect: rect(0, 10, 20, 10),
+			position: 'tl-bl'
+		}, {
+			contentAreaRect: rect(0, 0, 100, 100),
+			targetRect: rect(0, 20, 10, 10),
+			panelRect: rect(0, 0, 20, 10)
+		});
+	};
+
+	var testCalcPanelAtTopRight = function () {
+		assertLayout({
+			rect: rect(80, 10, 20, 10),
+			position: 'tr-br'
+		}, {
+			contentAreaRect: rect(0, 0, 100, 100),
+			targetRect: rect(90, 20, 10, 10),
+			panelRect: rect(0, 0, 20, 10)
+		});
+	};
+
+	var testCalcPanelAtTopCenter = function () {
+		assertLayout({
+			rect: rect(35, 10, 20, 10),
+			position: 'tc-bc'
+		}, {
+			contentAreaRect: rect(0, 0, 100, 100),
+			targetRect: rect(40, 20, 10, 10),
+			panelRect: rect(0, 0, 20, 10)
+		});
+	};
+
+	var testCalcPanelAtBottomCenter = function () {
+		assertLayout({
+			rect: rect(35, 10, 20, 10),
+			position: 'bc-tc'
+		}, {
+			contentAreaRect: rect(0, 0, 100, 100),
+			targetRect: rect(40, 0, 10, 10),
+			panelRect: rect(0, 0, 20, 10)
+		});
+	};
+
+	var testUserConstrain = function () {
+		var targetRect, contentAreaRect, panelRect, userConstrainedPanelRect, handler;
+
+		contentAreaRect = rect(0, 0, 100, 100);
+		targetRect = rect(40, 0, 10, 10);
+		panelRect = rect(0, 0, 20, 10);
+
+		handler = function (rects) {
+			assert.eq(rects.elementRect, clientRect(40, 0, 10, 10));
+			assert.eq(rects.contentAreaRect, clientRect(0, 0, 100, 100));
+			assert.eq(rects.panelRect, clientRect(0, 0, 20, 10));
+			return clientRect(1, 2, 3, 4);
+		};
+
+		userConstrainedPanelRect = Layout.userConstrain(handler, targetRect, contentAreaRect, panelRect);
+		assert.eq(userConstrainedPanelRect, rect(1, 2, 3, 4));
+	};
+
+	testCalcPanelAtBottomLeft();
+	testCalcPanelAtBottomRight();
+	testCalcPanelAtTopLeft();
+	testCalcPanelAtTopRight();
+	testCalcPanelAtTopCenter();
+	testCalcPanelAtBottomCenter();
+	testUserConstrain();
+});

data/app/assets/javascripts/wbase/admin/tinymce/themes/inlite/src/test/js/browser/core/MeasureTest.js

@@ -0,0 +1,62 @@
+asynctest('browser/core/MeasureTest', [
+	'ephox.mcagar.api.TinyLoader',
+	'tinymce/inlite/core/Measure',
+	'ephox.agar.api.Pipeline',
+	'ephox.mcagar.api.TinyApis',
+	'ephox.agar.api.Step',
+	'ephox.agar.api.Chain',
+	'ephox.agar.api.UiFinder',
+	'ephox.agar.api.Assertions'
+], function (TinyLoader, Measure, Pipeline, TinyApis, Step, Chain, UiFinder, Assertions) {
+	var success = arguments[arguments.length - 2];
+	var failure = arguments[arguments.length - 1];
+
+	var containsXY = function (r, x, y) {
+		return x >= r.x && x <= r.x + r.w && y >= r.y && y <= r.y + r.h;
+	};
+
+	var contains = function (a, b) {
+		return containsXY(a, b.x, b.y) && containsXY(a, b.x + b.w, b.y + b.h);
+	};
+
+	var sAssertRect = function (editor, measure) {
+		return Step.sync(function () {
+			var elementRect = measure();
+			var pageAreaRect = Measure.getPageAreaRect(editor);
+			var contentAreaRect = Measure.getContentAreaRect(editor);
+
+			Assertions.assertEq('Rect is not in page area rect', contains(pageAreaRect, elementRect), true);
+			Assertions.assertEq('Rect is not in content area rect', contains(contentAreaRect, elementRect), true);
+			Assertions.assertEq('Rect should have width', elementRect.w > 0, true);
+			Assertions.assertEq('Rect should have height', elementRect.h > 0, true);
+		});
+	};
+
+	var getElementRectFromSelector = function (editor, selector) {
+		return function () {
+			var elm = editor.dom.select(selector)[0];
+			var rect = Measure.getElementRect(editor, elm);
+			return rect;
+		};
+	};
+
+	var getSelectionRectFromSelector = function (editor) {
+		return function () {
+			var rect = Measure.getSelectionRect(editor);
+			return rect;
+		};
+	};
+
+	TinyLoader.setup(function (editor, onSuccess, onFailure) {
+		var tinyApis = TinyApis(editor);
+
+		Pipeline.async({}, [
+			tinyApis.sSetContent('<p>a</p><div style="width: 50px; height: 300px">b</div><p>c</p>'),
+			sAssertRect(editor, getElementRectFromSelector(editor, 'p:nth-child(1)')),
+			tinyApis.sSetCursor([0, 0], 0),
+			sAssertRect(editor, getSelectionRectFromSelector(editor))
+		], onSuccess, onFailure);
+	}, {
+		inline: true
+	}, success, failure);
+});

data/app/assets/javascripts/wbase/admin/tinymce/themes/inlite/src/test/js/browser/core/PredicateIdTest.js

@@ -0,0 +1,26 @@
+test('browser/core/PredicateIdTest', [
+	'ephox/tinymce',
+	'tinymce/inlite/core/PredicateId'
+], function (tinymce, PredicateId) {
+	var testFromContextToolbars = function () {
+		var isTrue = function () {
+			return true;
+		};
+
+		var isFalse = function () {
+			return false;
+		};
+
+		var predIds = PredicateId.fromContextToolbars([
+			{toolbar: 'a b c', predicate: isTrue, id: 'a'},
+			{toolbar: 'd e', predicate: isFalse, id: 'b'}
+		]);
+
+		assert.eq([
+			PredicateId.create('a', isTrue),
+			PredicateId.create('b', isFalse)
+		], predIds);
+	};
+
+	testFromContextToolbars();
+});

data/app/assets/javascripts/wbase/admin/tinymce/themes/inlite/src/test/js/browser/core/SelectionMatcherTest.js

@@ -0,0 +1,76 @@
+asynctest('browser/core/SelectionMatcherTest', [
+	'ephox.mcagar.api.TinyLoader',
+	'ephox.mcagar.api.TinyApis',
+	'ephox.agar.api.Step',
+	'ephox.agar.api.Assertions',
+	'tinymce/inlite/core/SelectionMatcher',
+	'tinymce/inlite/core/PredicateId',
+	'ephox.agar.api.GeneralSteps',
+	'ephox.agar.api.Pipeline'
+], function (TinyLoader, TinyApis, Step, Assertions, SelectionMatcher, PredicateId, GeneralSteps, Pipeline) {
+	var success = arguments[arguments.length - 2];
+	var failure = arguments[arguments.length - 1];
+
+	var assertResult = function (expectedResultState, result) {
+		Assertions.assertEq('Should not be null', result !== null, expectedResultState);
+
+		if (expectedResultState === true) {
+			Assertions.assertEq('Should be matching a', result.id, 'a');
+			Assertions.assertEq('Should be have width', result.rect.w > 0, true);
+		}
+	};
+
+	var sTextSelectionTest = function (tinyApis, editor, inputHtml, spath, soffset, fpath, foffset, expectedResultState) {
+		var sAssertTextSelectionResult = Step.sync(function () {
+			var result = SelectionMatcher.textSelection('a')(editor);
+			assertResult(expectedResultState, result);
+		});
+
+		return GeneralSteps.sequence([
+			tinyApis.sSetContent(inputHtml),
+			tinyApis.sSetSelection(spath, soffset, fpath, foffset),
+			sAssertTextSelectionResult
+		]);
+	};
+
+	var sTextSelectionTests = function (tinyApis, editor) {
+		return GeneralSteps.sequence([
+			sTextSelectionTest(tinyApis, editor, '<p>a</p>', [0], 0, [0], 1, true),
+			sTextSelectionTest(tinyApis, editor, '<p>a</p>', [0], 0, [0], 0, false)
+		]);
+	};
+
+	var sEmptyTextBlockTest = function (tinyApis, editor, inputHtml, spath, soffset, fpath, foffset, expectedResultState) {
+		var sAssertTextSelectionResult = Step.sync(function () {
+			var elements = editor.dom.getParents(editor.selection.getStart());
+			var result = SelectionMatcher.emptyTextBlock(elements, 'a')(editor);
+			assertResult(expectedResultState, result);
+		});
+
+		return GeneralSteps.sequence([
+			tinyApis.sSetContent(inputHtml),
+			tinyApis.sSetSelection(spath, soffset, fpath, foffset),
+			sAssertTextSelectionResult
+		]);
+	};
+
+	var sEmptyTextBlockTests = function (tinyApis, editor) {
+		return GeneralSteps.sequence([
+			sEmptyTextBlockTest(tinyApis, editor, '<p>a</p>', [0], 0, [0], 0, false),
+			sEmptyTextBlockTest(tinyApis, editor, '<p>a</p>', [0], 0, [0], 1, false),
+			sEmptyTextBlockTest(tinyApis, editor, '<p><br></p>', [0], 0, [0], 0, true),
+			sEmptyTextBlockTest(tinyApis, editor, '<p><em><br></em></p>', [0, 0], 0, [0, 0], 0, true)
+		]);
+	};
+
+	TinyLoader.setup(function (editor, onSuccess, onFailure) {
+		var tinyApis = TinyApis(editor);
+
+		Pipeline.async({}, [
+			sTextSelectionTests(tinyApis, editor),
+			sEmptyTextBlockTests(tinyApis, editor)
+		], onSuccess, onFailure);
+	}, {
+		inline: true
+	}, success, failure);
+});

data/app/assets/javascripts/wbase/admin/tinymce/themes/inlite/src/test/js/browser/file/ConversionsTest.js

@@ -0,0 +1,41 @@
+asynctest('atomic/core/ConvertTest', [
+	'ephox/tinymce',
+	'tinymce/inlite/file/Conversions',
+	'ephox.agar.api.Step',
+	'ephox.agar.api.Pipeline',
+	'ephox.agar.api.Assertions'
+], function (tinymce, Conversions, Step, Pipeline, Assertions) {
+	var success = arguments[arguments.length - 2];
+	var failure = arguments[arguments.length - 1];
+
+	var base64ToBlob = function (base64, type) {
+		var buff = atob(base64);
+		var bytes = new Uint8Array(buff.length);
+
+		for (var i = 0; i < bytes.length; i++) {
+			bytes[i] = buff.charCodeAt(i);
+		}
+
+		return new Blob([bytes], {type: type});
+	};
+
+	var sBlobToBase64 = function () {
+		return Step.async(function (next) {
+			var base64 = 'R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
+			var blob = base64ToBlob(base64, 'image/gif');
+
+			Conversions.blobToBase64(blob).then(function (convertedBase64) {
+				Assertions.assertEq('Not the correct base64', base64, convertedBase64);
+				next();
+			});
+		});
+	};
+
+	Pipeline.async({}, [
+		sBlobToBase64()
+	], function () {
+		success();
+	}, function () {
+		failure();
+	});
+});