mirror/openseadragon
1
0
Fork 0
mirror of https://github.com/openseadragon/openseadragon.git synced 2025-02-16 23:03:13 +03:00
Code Issues Projects Releases Wiki Activity

Everything but the navigator tests

Browse Source
This commit is contained in:
nein09 2017-12-06 17:20:39 -08:00
parent b096e369d0
commit 6f789e7e88
14 changed files with 454 additions and 424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
test/helpers/test.js
View File

@ -119,13 +119,12 @@
if (result === undefined) { if (result === undefined) {
result = original.apply(this, arguments); result = original.apply(this, arguments);
} }
return result; return result;
}; };
}, },
// ---------- // ----------
testDeprecation: function(obj0, member0, obj1, member1, assert) { testDeprecation: function(assert, obj0, member0, obj1, member1) {
var called = false; var called = false;
var errored = false; var errored = false;

72
test/modules/drawer.js
View File

@ -1,15 +1,15 @@
/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog */ /* global QUnit, $, Util, testLog */
(function() { (function() {
var viewer; var viewer;
module('Drawer', { QUnit.module('Drawer', {
setup: function () { beforeEach: function () {
var example = $('<div id="example"></div>').appendTo("#qunit-fixture"); $('<div id="example"></div>').appendTo("#qunit-fixture");
testLog.reset(); testLog.reset();
}, },
teardown: function () { afterEach: function () {
if (viewer && viewer.close) { if (viewer && viewer.close) {
viewer.close(); viewer.close();
} }
@ -29,15 +29,17 @@
}; };
// ---------- // ----------
asyncTest('basics', function() { QUnit.test('basics', function(assert) {
var done = assert.async();
createViewer(); createViewer();
ok(viewer.drawer, 'Drawer exists'); assert.ok(viewer.drawer, 'Drawer exists');
equal(viewer.drawer.canRotate(), OpenSeadragon.supportsCanvas, 'we can rotate if we have canvas'); assert.equal(viewer.drawer.canRotate(), OpenSeadragon.supportsCanvas, 'we can rotate if we have canvas');
start(); done();
}); });
// ---------- // ----------
asyncTest('rotation', function() { QUnit.test('rotation', function(assert) {
var done = assert.async();
createViewer({ createViewer({
tileSources: '/test/data/testpattern.dzi' tileSources: '/test/data/testpattern.dzi'
}); });
@ -45,27 +47,29 @@
viewer.addHandler('open', function handler(event) { viewer.addHandler('open', function handler(event) {
viewer.viewport.setRotation(30); viewer.viewport.setRotation(30);
Util.spyOnce(viewer.drawer.context, 'rotate', function() { Util.spyOnce(viewer.drawer.context, 'rotate', function() {
ok(true, 'drawing with new rotation'); assert.ok(true, 'drawing with new rotation');
start(); done();
}); });
}); });
}); });
// ---------- // ----------
asyncTest('debug', function() { QUnit.test('debug', function(assert) {
var done = assert.async();
createViewer({ createViewer({
tileSources: '/test/data/testpattern.dzi', tileSources: '/test/data/testpattern.dzi',
debugMode: true debugMode: true
}); });
Util.spyOnce(viewer.drawer, 'drawDebugInfo', function() { Util.spyOnce(viewer.drawer, 'drawDebugInfo', function() {
ok(true, 'drawDebugInfo is called'); assert.ok(true, 'drawDebugInfo is called');
start(); done();
}); });
}); });
// ---------- // ----------
asyncTest('sketchCanvas', function() { QUnit.test('sketchCanvas', function(assert) {
var done = assert.async();
createViewer({ createViewer({
tileSources: '/test/data/testpattern.dzi' tileSources: '/test/data/testpattern.dzi'
}); });
@ -73,9 +77,9 @@
viewer.addHandler('tile-drawn', function noOpacityHandler() { viewer.addHandler('tile-drawn', function noOpacityHandler() {
viewer.removeHandler('tile-drawn', noOpacityHandler); viewer.removeHandler('tile-drawn', noOpacityHandler);
equal(drawer.sketchCanvas, null, assert.equal(drawer.sketchCanvas, null,
'The sketch canvas should be null if no decimal opacity is used.'); 'The sketch canvas should be null if no decimal opacity is used.');
equal(drawer.sketchContext, null, assert.equal(drawer.sketchContext, null,
'The sketch context should be null if no decimal opacity is used.'); 'The sketch context should be null if no decimal opacity is used.');
testOpacityDecimal(); testOpacityDecimal();
}); });
@ -95,32 +99,34 @@
return; return;
} }
viewer.removeHandler('tile-drawn', opacityDecimalHandler); viewer.removeHandler('tile-drawn', opacityDecimalHandler);
notEqual(drawer.sketchCanvas, null, assert.notEqual(drawer.sketchCanvas, null,
'The sketch canvas should not be null once a decimal opacity has been used.'); 'The sketch canvas should not be null once a decimal opacity has been used.');
notEqual(drawer.sketchContext, null, assert.notEqual(drawer.sketchContext, null,
'The sketch context should not be null once a decimal opacity has been used.'); 'The sketch context should not be null once a decimal opacity has been used.');
start(); done();
}); });
} }
}); });
// ---------- // ----------
asyncTest('deprecations', function() { QUnit.test('deprecations', function(assert) {
var done = assert.async();
createViewer({ createViewer({
tileSources: '/test/data/testpattern.dzi' tileSources: '/test/data/testpattern.dzi'
}); });
viewer.world.addHandler('add-item', function() { viewer.world.addHandler('add-item', function() {
Util.testDeprecation(viewer.drawer, 'addOverlay', viewer, 'addOverlay'); Util.testDeprecation(assert, viewer.drawer, 'addOverlay', viewer, 'addOverlay');
Util.testDeprecation(viewer.drawer, 'updateOverlay', viewer, 'updateOverlay'); Util.testDeprecation(assert, viewer.drawer, 'updateOverlay', viewer, 'updateOverlay');
Util.testDeprecation(viewer.drawer, 'removeOverlay', viewer, 'removeOverlay'); Util.testDeprecation(assert, viewer.drawer, 'removeOverlay', viewer, 'removeOverlay');
Util.testDeprecation(viewer.drawer, 'clearOverlays', viewer, 'clearOverlays'); Util.testDeprecation(assert, viewer.drawer, 'clearOverlays', viewer, 'clearOverlays');
Util.testDeprecation(viewer.drawer, 'needsUpdate', viewer.world, 'needsDraw'); Util.testDeprecation(assert, viewer.drawer, 'needsUpdate', viewer.world, 'needsDraw');
Util.testDeprecation(viewer.drawer, 'numTilesLoaded', viewer.tileCache, 'numTilesLoaded'); Util.testDeprecation(assert, viewer.drawer, 'numTilesLoaded', viewer.tileCache, 'numTilesLoaded');
Util.testDeprecation(viewer.drawer, 'reset', viewer.world, 'resetItems'); Util.testDeprecation(assert, viewer.drawer, 'reset', viewer.world, 'resetItems');
Util.testDeprecation(viewer.drawer, 'update', viewer.world, 'draw'); Util.testDeprecation(assert, viewer.drawer, 'update', viewer.world, 'draw');
Util.testDeprecation(viewer.drawer, 'setOpacity', viewer.world.getItemAt(0), 'setOpacity'); Util.testDeprecation(assert, viewer.drawer, 'setOpacity', viewer.world.getItemAt(0), 'setOpacity');
Util.testDeprecation(viewer.drawer, 'getOpacity', viewer.world.getItemAt(0), 'getOpacity'); Util.testDeprecation(assert, viewer.drawer, 'getOpacity', viewer.world.getItemAt(0), 'getOpacity');
start(); done();
}); });
}); });

20
test/modules/dzitilesource.js
View File

@ -1,42 +1,48 @@
/* global QUnit, testLog */
/*global module:true, test:true, equal:true, OpenSeadragon:true*/
(function() { (function() {
module('DziTileSource', { QUnit.module('DziTileSource', {
setup: function() { beforeEach: function() {
testLog.reset(); testLog.reset();
} }
}); });
function testImplicitTilesUrl(dziUrl, expected, msg) { function testImplicitTilesUrl(assert, dziUrl, expected, msg) {
var source = new OpenSeadragon.DziTileSource(); var source = new OpenSeadragon.DziTileSource();
var options = source.configure({ var options = source.configure({
Image: {Size: {Width:0, Height: 0}} Image: {Size: {Width:0, Height: 0}}
}, dziUrl); }, dziUrl);
equal(options.tilesUrl, expected, msg); assert.equal(options.tilesUrl, expected, msg);
} }
test('test implicit tilesUrl guessed from dzi url', function() { QUnit.test('test implicit tilesUrl guessed from dzi url', function(assert) {
testImplicitTilesUrl( testImplicitTilesUrl(
assert,
'/path/my.dzi', '/path/my_files/', '/path/my.dzi', '/path/my_files/',
'dzi extension should be stripped'); 'dzi extension should be stripped');
testImplicitTilesUrl( testImplicitTilesUrl(
assert,
'/path/my', '/path/my_files/', '/path/my', '/path/my_files/',
'no extension should still produce _files path'); 'no extension should still produce _files path');
testImplicitTilesUrl( testImplicitTilesUrl(
assert,
'/my/', '/my_files/', '/my/', '/my_files/',
'no extension with trailing slash should preserve slash'); 'no extension with trailing slash should preserve slash');
testImplicitTilesUrl( testImplicitTilesUrl(
assert,
'my.xml', 'my_files/', 'my.xml', 'my_files/',
'relative link should stay the same'); 'relative link should stay the same');
testImplicitTilesUrl( testImplicitTilesUrl(
assert,
'/p/foo.dzi?a=1&b=2', '/p/foo_files/', '/p/foo.dzi?a=1&b=2', '/p/foo_files/',
'querystring in dzi url should be ignored after slashes'); 'querystring in dzi url should be ignored after slashes');
testImplicitTilesUrl( testImplicitTilesUrl(
assert,
'/iiipsrv?DeepZoom=/path/my.dzi', '/iiipsrv?DeepZoom=/path/my_files/', '/iiipsrv?DeepZoom=/path/my.dzi', '/iiipsrv?DeepZoom=/path/my_files/',
'querystring in dzi url should not be ignored before slashes'); 'querystring in dzi url should not be ignored before slashes');
testImplicitTilesUrl( testImplicitTilesUrl(
assert,
'/fcg-bin/iipsrv.fcgi?Deepzoom=123test.tif.dzi', '/fcg-bin/iipsrv.fcgi?Deepzoom=123test.tif_files/', '/fcg-bin/iipsrv.fcgi?Deepzoom=123test.tif.dzi', '/fcg-bin/iipsrv.fcgi?Deepzoom=123test.tif_files/',
'filename in querystring does not have to contain slash'); 'filename in querystring does not have to contain slash');
}); });

2
test/modules/formats.js
View File

@ -21,7 +21,7 @@
}; };
var testOpen = function(tileSource, assert) { var testOpen = function(tileSource, assert) {
var timeWatcher = Util.timeWatcher(7000, assert); var timeWatcher = Util.timeWatcher(assert, 7000);
viewer = OpenSeadragon({ viewer = OpenSeadragon({
id: 'example', id: 'example',

22
test/modules/imageloader.js
View File

@ -1,4 +1,4 @@
/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog */ /* global QUnit, $, testLog */
(function() { (function() {
var viewer, var viewer,
@ -8,13 +8,13 @@
springStiffness: 100 // Faster animation = faster tests springStiffness: 100 // Faster animation = faster tests
}; };
module('ImageLoader', { QUnit.module('ImageLoader', {
setup: function () { beforeEach: function () {
var example = $('<div id="example"></div>').appendTo("#qunit-fixture"); $('<div id="example"></div>').appendTo("#qunit-fixture");
testLog.reset(); testLog.reset();
}, },
teardown: function () { afterEach: function () {
if (viewer && viewer.close) { if (viewer && viewer.close) {
viewer.close(); viewer.close();
} }
@ -25,7 +25,7 @@
// ---------- // ----------
test('Default timeout', function() { QUnit.test('Default timeout', function(assert) {
var actual, var actual,
expected = OpenSeadragon.DEFAULT_SETTINGS.timeout, expected = OpenSeadragon.DEFAULT_SETTINGS.timeout,
message, message,
@ -37,7 +37,7 @@
message = 'ImageLoader timeout should be set to the default value of ' + expected + ' when none is specified'; message = 'ImageLoader timeout should be set to the default value of ' + expected + ' when none is specified';
actual = imageLoader.timeout; actual = imageLoader.timeout;
equal(actual, expected, message); assert.equal(actual, expected, message);
// Manually seize the ImageLoader // Manually seize the ImageLoader
imageLoader.jobsInProgress = imageLoader.jobLimit; imageLoader.jobsInProgress = imageLoader.jobLimit;
@ -51,12 +51,12 @@
message = 'ImageJob should inherit the ImageLoader timeout value'; message = 'ImageJob should inherit the ImageLoader timeout value';
actual = imageLoader.jobQueue.shift().timeout; actual = imageLoader.jobQueue.shift().timeout;
equal(actual, expected, message); assert.equal(actual, expected, message);
}); });
// ---------- // ----------
test('Configure timeout', function() { QUnit.test('Configure timeout', function(assert) {
var actual, var actual,
expected = 123456, expected = 123456,
message, message,
@ -69,7 +69,7 @@
message = 'ImageLoader timeout should be configurable'; message = 'ImageLoader timeout should be configurable';
actual = imageLoader.timeout; actual = imageLoader.timeout;
equal(actual, expected, message); assert.equal(actual, expected, message);
imageLoader.jobsInProgress = imageLoader.jobLimit; imageLoader.jobsInProgress = imageLoader.jobLimit;
imageLoader.addJob({ imageLoader.addJob({
@ -82,7 +82,7 @@
message = 'ImageJob should inherit the ImageLoader timeout value'; message = 'ImageJob should inherit the ImageLoader timeout value';
actual = imageLoader.jobQueue.shift().timeout; actual = imageLoader.jobQueue.shift().timeout;
equal(actual, expected, message); assert.equal(actual, expected, message);
}); });
})(); })();

174
test/modules/rectangle.js
View File

@ -1,152 +1,152 @@
/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog */ /* global QUnit, Util */
(function() { (function() {
module('Rectangle', {}); QUnit.module('Rectangle', {});
var precision = 0.000000001; var precision = 0.000000001;
test('Constructor', function() { QUnit.test('Constructor', function(assert) {
var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 5); var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 5);
strictEqual(rect.x, 1, 'rect.x should be 1'); assert.strictEqual(rect.x, 1, 'rect.x should be 1');
strictEqual(rect.y, 2, 'rect.y should be 2'); assert.strictEqual(rect.y, 2, 'rect.y should be 2');
strictEqual(rect.width, 3, 'rect.width should be 3'); assert.strictEqual(rect.width, 3, 'rect.width should be 3');
strictEqual(rect.height, 4, 'rect.height should be 4'); assert.strictEqual(rect.height, 4, 'rect.height should be 4');
strictEqual(rect.degrees, 5, 'rect.degrees should be 5'); assert.strictEqual(rect.degrees, 5, 'rect.degrees should be 5');
rect = new OpenSeadragon.Rect(); rect = new OpenSeadragon.Rect();
strictEqual(rect.x, 0, 'rect.x should be 0'); assert.strictEqual(rect.x, 0, 'rect.x should be 0');
strictEqual(rect.y, 0, 'rect.y should be 0'); assert.strictEqual(rect.y, 0, 'rect.y should be 0');
strictEqual(rect.width, 0, 'rect.width should be 0'); assert.strictEqual(rect.width, 0, 'rect.width should be 0');
strictEqual(rect.height, 0, 'rect.height should be 0'); assert.strictEqual(rect.height, 0, 'rect.height should be 0');
strictEqual(rect.degrees, 0, 'rect.degrees should be 0'); assert.strictEqual(rect.degrees, 0, 'rect.degrees should be 0');
rect = new OpenSeadragon.Rect(0, 0, 1, 2, -405); rect = new OpenSeadragon.Rect(0, 0, 1, 2, -405);
Util.assessNumericValue(Math.sqrt(2) / 2, rect.x, precision, Util.assessNumericValue(assert, Math.sqrt(2) / 2, rect.x, precision,
'rect.x should be sqrt(2)/2'); 'rect.x should be sqrt(2)/2');
Util.assessNumericValue(-Math.sqrt(2) / 2, rect.y, precision, Util.assessNumericValue(assert, -Math.sqrt(2) / 2, rect.y, precision,
'rect.y should be -sqrt(2)/2'); 'rect.y should be -sqrt(2)/2');
Util.assessNumericValue(2, rect.width, precision, Util.assessNumericValue(assert, 2, rect.width, precision,
'rect.width should be 2'); 'rect.width should be 2');
Util.assessNumericValue(1, rect.height, precision, Util.assessNumericValue(assert, 1, rect.height, precision,
'rect.height should be 1'); 'rect.height should be 1');
strictEqual(45, rect.degrees, 'rect.degrees should be 45'); assert.strictEqual(45, rect.degrees, 'rect.degrees should be 45');
rect = new OpenSeadragon.Rect(0, 0, 1, 2, 135); rect = new OpenSeadragon.Rect(0, 0, 1, 2, 135);
Util.assessNumericValue(-Math.sqrt(2), rect.x, precision, Util.assessNumericValue(assert, -Math.sqrt(2), rect.x, precision,
'rect.x should be -sqrt(2)'); 'rect.x should be -sqrt(2)');
Util.assessNumericValue(-Math.sqrt(2), rect.y, precision, Util.assessNumericValue(assert, -Math.sqrt(2), rect.y, precision,
'rect.y should be -sqrt(2)'); 'rect.y should be -sqrt(2)');
Util.assessNumericValue(2, rect.width, precision, Util.assessNumericValue(assert, 2, rect.width, precision,
'rect.width should be 2'); 'rect.width should be 2');
Util.assessNumericValue(1, rect.height, precision, Util.assessNumericValue(assert, 1, rect.height, precision,
'rect.height should be 1'); 'rect.height should be 1');
strictEqual(45, rect.degrees, 'rect.degrees should be 45'); assert.strictEqual(45, rect.degrees, 'rect.degrees should be 45');
rect = new OpenSeadragon.Rect(0, 0, 1, 1, 585); rect = new OpenSeadragon.Rect(0, 0, 1, 1, 585);
Util.assessNumericValue(0, rect.x, precision, Util.assessNumericValue(assert, 0, rect.x, precision,
'rect.x should be 0'); 'rect.x should be 0');
Util.assessNumericValue(-Math.sqrt(2), rect.y, precision, Util.assessNumericValue(assert, -Math.sqrt(2), rect.y, precision,
'rect.y should be -sqrt(2)'); 'rect.y should be -sqrt(2)');
Util.assessNumericValue(1, rect.width, precision, Util.assessNumericValue(assert, 1, rect.width, precision,
'rect.width should be 1'); 'rect.width should be 1');
Util.assessNumericValue(1, rect.height, precision, Util.assessNumericValue(assert, 1, rect.height, precision,
'rect.height should be 1'); 'rect.height should be 1');
strictEqual(45, rect.degrees, 'rect.degrees should be 45'); assert.strictEqual(45, rect.degrees, 'rect.degrees should be 45');
}); });
test('getTopLeft', function() { QUnit.test('getTopLeft', function(assert) {
var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 5); var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 5);
var expected = new OpenSeadragon.Point(1, 2); var expected = new OpenSeadragon.Point(1, 2);
ok(expected.equals(rect.getTopLeft()), "Incorrect top left point."); assert.ok(expected.equals(rect.getTopLeft()), "Incorrect top left point.");
}); });
test('getTopRight', function() { QUnit.test('getTopRight', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 1, 3); var rect = new OpenSeadragon.Rect(0, 0, 1, 3);
var expected = new OpenSeadragon.Point(1, 0); var expected = new OpenSeadragon.Point(1, 0);
ok(expected.equals(rect.getTopRight()), "Incorrect top right point."); assert.ok(expected.equals(rect.getTopRight()), "Incorrect top right point.");
rect.degrees = 45; rect.degrees = 45;
expected = new OpenSeadragon.Point(1 / Math.sqrt(2), 1 / Math.sqrt(2)); expected = new OpenSeadragon.Point(1 / Math.sqrt(2), 1 / Math.sqrt(2));
Util.assertPointsEquals(expected, rect.getTopRight(), precision, Util.assertPointsEquals(assert, expected, rect.getTopRight(), precision,
"Incorrect top right point with rotation."); "Incorrect top right point with rotation.");
}); });
test('getBottomLeft', function() { QUnit.test('getBottomLeft', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 3, 1); var rect = new OpenSeadragon.Rect(0, 0, 3, 1);
var expected = new OpenSeadragon.Point(0, 1); var expected = new OpenSeadragon.Point(0, 1);
ok(expected.equals(rect.getBottomLeft()), "Incorrect bottom left point."); assert.ok(expected.equals(rect.getBottomLeft()), "Incorrect bottom left point.");
rect.degrees = 45; rect.degrees = 45;
expected = new OpenSeadragon.Point(-1 / Math.sqrt(2), 1 / Math.sqrt(2)); expected = new OpenSeadragon.Point(-1 / Math.sqrt(2), 1 / Math.sqrt(2));
Util.assertPointsEquals(expected, rect.getBottomLeft(), precision, Util.assertPointsEquals(assert, expected, rect.getBottomLeft(), precision,
"Incorrect bottom left point with rotation."); "Incorrect bottom left point with rotation.");
}); });
test('getBottomRight', function() { QUnit.test('getBottomRight', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 1, 1); var rect = new OpenSeadragon.Rect(0, 0, 1, 1);
var expected = new OpenSeadragon.Point(1, 1); var expected = new OpenSeadragon.Point(1, 1);
ok(expected.equals(rect.getBottomRight()), "Incorrect bottom right point."); assert.ok(expected.equals(rect.getBottomRight()), "Incorrect bottom right point.");
rect.degrees = 45; rect.degrees = 45;
expected = new OpenSeadragon.Point(0, Math.sqrt(2)); expected = new OpenSeadragon.Point(0, Math.sqrt(2));
Util.assertPointsEquals(expected, rect.getBottomRight(), precision, Util.assertPointsEquals(assert, expected, rect.getBottomRight(), precision,
"Incorrect bottom right point with 45 rotation."); "Incorrect bottom right point with 45 rotation.");
rect.degrees = 90; rect.degrees = 90;
expected = new OpenSeadragon.Point(-1, 1); expected = new OpenSeadragon.Point(-1, 1);
Util.assertPointsEquals(expected, rect.getBottomRight(), precision, Util.assertPointsEquals(assert, expected, rect.getBottomRight(), precision,
"Incorrect bottom right point with 90 rotation."); "Incorrect bottom right point with 90 rotation.");
rect.degrees = 135; rect.degrees = 135;
expected = new OpenSeadragon.Point(-Math.sqrt(2), 0); expected = new OpenSeadragon.Point(-Math.sqrt(2), 0);
Util.assertPointsEquals(expected, rect.getBottomRight(), precision, Util.assertPointsEquals(assert, expected, rect.getBottomRight(), precision,
"Incorrect bottom right point with 135 rotation."); "Incorrect bottom right point with 135 rotation.");
}); });
test('getCenter', function() { QUnit.test('getCenter', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 1, 1); var rect = new OpenSeadragon.Rect(0, 0, 1, 1);
var expected = new OpenSeadragon.Point(0.5, 0.5); var expected = new OpenSeadragon.Point(0.5, 0.5);
ok(expected.equals(rect.getCenter()), "Incorrect center point."); assert.ok(expected.equals(rect.getCenter()), "Incorrect center point.");
rect.degrees = 45; rect.degrees = 45;
expected = new OpenSeadragon.Point(0, 0.5 * Math.sqrt(2)); expected = new OpenSeadragon.Point(0, 0.5 * Math.sqrt(2));
Util.assertPointsEquals(expected, rect.getCenter(), precision, Util.assertPointsEquals(assert, expected, rect.getCenter(), precision,
"Incorrect bottom right point with 45 rotation."); "Incorrect bottom right point with 45 rotation.");
rect.degrees = 90; rect.degrees = 90;
expected = new OpenSeadragon.Point(-0.5, 0.5); expected = new OpenSeadragon.Point(-0.5, 0.5);
Util.assertPointsEquals(expected, rect.getCenter(), precision, Util.assertPointsEquals(assert, expected, rect.getCenter(), precision,
"Incorrect bottom right point with 90 rotation."); "Incorrect bottom right point with 90 rotation.");
rect.degrees = 135; rect.degrees = 135;
expected = new OpenSeadragon.Point(-0.5 * Math.sqrt(2), 0); expected = new OpenSeadragon.Point(-0.5 * Math.sqrt(2), 0);
Util.assertPointsEquals(expected, rect.getCenter(), precision, Util.assertPointsEquals(assert, expected, rect.getCenter(), precision,
"Incorrect bottom right point with 135 rotation."); "Incorrect bottom right point with 135 rotation.");
}); });
test('times', function() { QUnit.test('times', function(assert) {
var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 45); var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 45);
var expected = new OpenSeadragon.Rect(2, 4, 6, 8, 45); var expected = new OpenSeadragon.Rect(2, 4, 6, 8, 45);
var actual = rect.times(2); var actual = rect.times(2);
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect x2 rectangles."); "Incorrect x2 rectangles.");
}); });
test('translate', function() { QUnit.test('translate', function(assert) {
var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 45); var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 45);
var expected = new OpenSeadragon.Rect(2, 4, 3, 4, 45); var expected = new OpenSeadragon.Rect(2, 4, 3, 4, 45);
var actual = rect.translate(new OpenSeadragon.Point(1, 2)); var actual = rect.translate(new OpenSeadragon.Point(1, 2));
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect translation."); "Incorrect translation.");
}); });
test('union', function() { QUnit.test('union', function(assert) {
var rect1 = new OpenSeadragon.Rect(2, 2, 2, 3); var rect1 = new OpenSeadragon.Rect(2, 2, 2, 3);
var rect2 = new OpenSeadragon.Rect(0, 1, 1, 1); var rect2 = new OpenSeadragon.Rect(0, 1, 1, 1);
var expected = new OpenSeadragon.Rect(0, 1, 4, 4); var expected = new OpenSeadragon.Rect(0, 1, 4, 4);
var actual = rect1.union(rect2); var actual = rect1.union(rect2);
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect union with horizontal rectangles."); "Incorrect union with horizontal rectangles.");
rect1 = new OpenSeadragon.Rect(0, -Math.sqrt(2), 2, 2, 45); rect1 = new OpenSeadragon.Rect(0, -Math.sqrt(2), 2, 2, 45);
@ -157,30 +157,30 @@
3 + Math.sqrt(2), 3 + Math.sqrt(2),
2 + Math.sqrt(2)); 2 + Math.sqrt(2));
actual = rect1.union(rect2); actual = rect1.union(rect2);
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect union with non horizontal rectangles."); "Incorrect union with non horizontal rectangles.");
}); });
test('intersection', function() { QUnit.test('intersection', function(assert) {
var rect1 = new OpenSeadragon.Rect(2, 2, 2, 3); var rect1 = new OpenSeadragon.Rect(2, 2, 2, 3);
var rect2 = new OpenSeadragon.Rect(0, 1, 1, 1); var rect2 = new OpenSeadragon.Rect(0, 1, 1, 1);
var expected = null; var expected = null;
var actual = rect1.intersection(rect2); var actual = rect1.intersection(rect2);
equal(expected, actual, assert.equal(expected, actual,
"Rectangle " + rect2 + " should not intersect " + rect1); "Rectangle " + rect2 + " should not intersect " + rect1);
actual = rect2.intersection(rect1); actual = rect2.intersection(rect1);
equal(expected, actual, assert.equal(expected, actual,
"Rectangle " + rect1 + " should not intersect " + rect2); "Rectangle " + rect1 + " should not intersect " + rect2);
rect1 = new OpenSeadragon.Rect(0, 0, 2, 1); rect1 = new OpenSeadragon.Rect(0, 0, 2, 1);
rect2 = new OpenSeadragon.Rect(1, 0, 2, 2); rect2 = new OpenSeadragon.Rect(1, 0, 2, 2);
expected = new OpenSeadragon.Rect(1, 0, 1, 1); expected = new OpenSeadragon.Rect(1, 0, 1, 1);
actual = rect1.intersection(rect2); actual = rect1.intersection(rect2);
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect2 + " with " + rect1 + " should be " + "Intersection of " + rect2 + " with " + rect1 + " should be " +
expected); expected);
actual = rect2.intersection(rect1); actual = rect2.intersection(rect1);
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect1 + " with " + rect2 + " should be " + "Intersection of " + rect1 + " with " + rect2 + " should be " +
expected); expected);
@ -188,11 +188,11 @@
rect2 = new OpenSeadragon.Rect(1, 1, 1, 1); rect2 = new OpenSeadragon.Rect(1, 1, 1, 1);
expected = new OpenSeadragon.Rect(1, 1, 1, 1); expected = new OpenSeadragon.Rect(1, 1, 1, 1);
actual = rect1.intersection(rect2); actual = rect1.intersection(rect2);
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect2 + " with " + rect1 + " should be " + "Intersection of " + rect2 + " with " + rect1 + " should be " +
expected); expected);
actual = rect2.intersection(rect1); actual = rect2.intersection(rect1);
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect1 + " with " + rect2 + " should be " + "Intersection of " + rect1 + " with " + rect2 + " should be " +
expected); expected);
@ -201,26 +201,26 @@
rect2 = new OpenSeadragon.Rect(0, 1, 1, 1); rect2 = new OpenSeadragon.Rect(0, 1, 1, 1);
expected = null; expected = null;
actual = rect1.intersection(rect2); actual = rect1.intersection(rect2);
equal(expected, actual, assert.equal(expected, actual,
"Rectangle " + rect2 + " should not intersect " + rect1); "Rectangle " + rect2 + " should not intersect " + rect1);
actual = rect2.intersection(rect1); actual = rect2.intersection(rect1);
equal(expected, actual, assert.equal(expected, actual,
"Rectangle " + rect1 + " should not intersect " + rect2); "Rectangle " + rect1 + " should not intersect " + rect2);
rect1 = new OpenSeadragon.Rect(2, 0, 2, 3, 45); rect1 = new OpenSeadragon.Rect(2, 0, 2, 3, 45);
rect2 = new OpenSeadragon.Rect(0, 1, 1, 1); rect2 = new OpenSeadragon.Rect(0, 1, 1, 1);
expected = new OpenSeadragon.Rect(0, 1, 1, 1); expected = new OpenSeadragon.Rect(0, 1, 1, 1);
actual = rect1.intersection(rect2); actual = rect1.intersection(rect2);
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect2 + " with " + rect1 + " should be " + "Intersection of " + rect2 + " with " + rect1 + " should be " +
expected); expected);
actual = rect2.intersection(rect1); actual = rect2.intersection(rect1);
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect1 + " with " + rect2 + " should be " + "Intersection of " + rect1 + " with " + rect2 + " should be " +
expected); expected);
}); });
test('rotate', function() { QUnit.test('rotate', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 2, 1); var rect = new OpenSeadragon.Rect(0, 0, 2, 1);
var expected = new OpenSeadragon.Rect( var expected = new OpenSeadragon.Rect(
@ -230,73 +230,73 @@
1, 1,
45); 45);
var actual = rect.rotate(-675); var actual = rect.rotate(-675);
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect rectangle after rotation of -675deg around center."); "Incorrect rectangle after rotation of -675deg around center.");
expected = new OpenSeadragon.Rect(0, 0, 2, 1, 33); expected = new OpenSeadragon.Rect(0, 0, 2, 1, 33);
actual = rect.rotate(33, rect.getTopLeft()); actual = rect.rotate(33, rect.getTopLeft());
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect rectangle after rotation of 33deg around topLeft."); "Incorrect rectangle after rotation of 33deg around topLeft.");
expected = new OpenSeadragon.Rect(0, 0, 2, 1, 101); expected = new OpenSeadragon.Rect(0, 0, 2, 1, 101);
actual = rect.rotate(101, rect.getTopLeft()); actual = rect.rotate(101, rect.getTopLeft());
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect rectangle after rotation of 187deg around topLeft."); "Incorrect rectangle after rotation of 187deg around topLeft.");
expected = new OpenSeadragon.Rect(0, 0, 2, 1, 187); expected = new OpenSeadragon.Rect(0, 0, 2, 1, 187);
actual = rect.rotate(187, rect.getTopLeft()); actual = rect.rotate(187, rect.getTopLeft());
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect rectangle after rotation of 187deg around topLeft."); "Incorrect rectangle after rotation of 187deg around topLeft.");
expected = new OpenSeadragon.Rect(0, 0, 2, 1, 300); expected = new OpenSeadragon.Rect(0, 0, 2, 1, 300);
actual = rect.rotate(300, rect.getTopLeft()); actual = rect.rotate(300, rect.getTopLeft());
Util.assertRectangleEquals(expected, actual, precision, Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect rectangle after rotation of 300deg around topLeft."); "Incorrect rectangle after rotation of 300deg around topLeft.");
}); });
test('getBoundingBox', function() { QUnit.test('getBoundingBox', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 2, 3); var rect = new OpenSeadragon.Rect(0, 0, 2, 3);
var bb = rect.getBoundingBox(); var bb = rect.getBoundingBox();
ok(rect.equals(bb), "Bounding box of horizontal rectangle should be " + assert.ok(rect.equals(bb), "Bounding box of horizontal rectangle should be " +
"identical to rectangle."); "identical to rectangle.");
rect.degrees = 90; rect.degrees = 90;
var expected = new OpenSeadragon.Rect(-3, 0, 3, 2); var expected = new OpenSeadragon.Rect(-3, 0, 3, 2);
Util.assertRectangleEquals(expected, rect.getBoundingBox(), precision, Util.assertRectangleEquals(assert, expected, rect.getBoundingBox(), precision,
"Bounding box of rect rotated 90deg."); "Bounding box of rect rotated 90deg.");
rect.degrees = 180; rect.degrees = 180;
var expected = new OpenSeadragon.Rect(-2, -3, 2, 3); expected = new OpenSeadragon.Rect(-2, -3, 2, 3);
Util.assertRectangleEquals(expected, rect.getBoundingBox(), precision, Util.assertRectangleEquals(assert, expected, rect.getBoundingBox(), precision,
"Bounding box of rect rotated 180deg."); "Bounding box of rect rotated 180deg.");
rect.degrees = 270; rect.degrees = 270;
var expected = new OpenSeadragon.Rect(0, -2, 3, 2); expected = new OpenSeadragon.Rect(0, -2, 3, 2);
Util.assertRectangleEquals(expected, rect.getBoundingBox(), precision, Util.assertRectangleEquals(assert, expected, rect.getBoundingBox(), precision,
"Bounding box of rect rotated 270deg."); "Bounding box of rect rotated 270deg.");
}); });
test('containsPoint', function() { QUnit.test('containsPoint', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 1, 1, 45); var rect = new OpenSeadragon.Rect(0, 0, 1, 1, 45);
ok(rect.containsPoint(new OpenSeadragon.Point(0, 0)), assert.ok(rect.containsPoint(new OpenSeadragon.Point(0, 0)),
'Point 0,0 should be inside ' + rect); 'Point 0,0 should be inside ' + rect);
ok(rect.containsPoint(rect.getTopRight()), assert.ok(rect.containsPoint(rect.getTopRight()),
'Top right vertex should be inside ' + rect); 'Top right vertex should be inside ' + rect);
ok(rect.containsPoint(rect.getBottomRight()), assert.ok(rect.containsPoint(rect.getBottomRight()),
'Bottom right vertex should be inside ' + rect); 'Bottom right vertex should be inside ' + rect);
ok(rect.containsPoint(rect.getBottomLeft()), assert.ok(rect.containsPoint(rect.getBottomLeft()),
'Bottom left vertex should be inside ' + rect); 'Bottom left vertex should be inside ' + rect);
ok(rect.containsPoint(rect.getCenter()), assert.ok(rect.containsPoint(rect.getCenter()),
'Center should be inside ' + rect); 'Center should be inside ' + rect);
notOk(rect.containsPoint(new OpenSeadragon.Point(1, 0)), assert.notOk(rect.containsPoint(new OpenSeadragon.Point(1, 0)),
'Point 1,0 should not be inside ' + rect); 'Point 1,0 should not be inside ' + rect);
ok(rect.containsPoint(new OpenSeadragon.Point(0.5, 0.5)), assert.ok(rect.containsPoint(new OpenSeadragon.Point(0.5, 0.5)),
'Point 0.5,0.5 should be inside ' + rect); 'Point 0.5,0.5 should be inside ' + rect);
ok(rect.containsPoint(new OpenSeadragon.Point(0.4, 0.5)), assert.ok(rect.containsPoint(new OpenSeadragon.Point(0.4, 0.5)),
'Point 0.4,0.5 should be inside ' + rect); 'Point 0.4,0.5 should be inside ' + rect);
notOk(rect.containsPoint(new OpenSeadragon.Point(0.6, 0.5)), assert.notOk(rect.containsPoint(new OpenSeadragon.Point(0.6, 0.5)),
'Point 0.6,0.5 should not be inside ' + rect); 'Point 0.6,0.5 should not be inside ' + rect);
}); });

17
test/modules/referencestrip.js
View File

@ -1,15 +1,15 @@
/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog */ /* global QUnit, $, testLog */
(function() { (function() {
var viewer; var viewer;
module('ReferenceStrip', { QUnit.module('ReferenceStrip', {
setup: function () { beforeEach: function () {
var example = $('<div id="example"></div>').appendTo("#qunit-fixture"); $('<div id="example"></div>').appendTo("#qunit-fixture");
testLog.reset(); testLog.reset();
}, },
teardown: function () { afterEach: function () {
if (viewer && viewer.close) { if (viewer && viewer.close) {
viewer.close(); viewer.close();
} }
@ -29,7 +29,8 @@
}; };
// ---------- // ----------
asyncTest('basics', function() { QUnit.test('basics', function(assert) {
var done = assert.async();
createViewer({ createViewer({
sequenceMode: true, sequenceMode: true,
showReferenceStrip: true, showReferenceStrip: true,
@ -39,8 +40,8 @@
] ]
}); });
ok(viewer.referenceStrip, 'referenceStrip exists'); assert.ok(viewer.referenceStrip, 'referenceStrip exists');
start(); done();
}); });
})(); })();

50
test/modules/spring.js
View File

@ -1,12 +1,12 @@
/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog, propEqual, console */ /* global QUnit, Util, console */
(function () { (function () {
var originalNow; var originalNow;
var now; var now;
module("spring", { QUnit.module("spring", {
setup: function () { beforeEach: function () {
now = 0; now = 0;
originalNow = OpenSeadragon.now; originalNow = OpenSeadragon.now;
@ -14,39 +14,41 @@
return now; return now;
}; };
}, },
teardown: function () { afterEach: function () {
OpenSeadragon.now = originalNow; OpenSeadragon.now = originalNow;
} }
}); });
asyncTest('regular spring', function() { QUnit.test('regular spring', function(assert) {
var done = assert.async();
var spring = new OpenSeadragon.Spring({ var spring = new OpenSeadragon.Spring({
initial: 5, initial: 5,
animationTime: 1, animationTime: 1,
springStiffness: 0.000001 springStiffness: 0.000001
}); });
equal(spring.current.value, 5, 'initial current value'); assert.equal(spring.current.value, 5, 'initial current value');
equal(spring.target.value, 5, 'initial target value'); assert.equal(spring.target.value, 5, 'initial target value');
spring.springTo(6); spring.springTo(6);
equal(spring.current.value, 5, 'current value after springTo'); assert.equal(spring.current.value, 5, 'current value after springTo');
equal(spring.target.value, 6, 'target value after springTo'); assert.equal(spring.target.value, 6, 'target value after springTo');
now = 500; now = 500;
spring.update(); spring.update();
Util.assessNumericValue(5.5, spring.current.value, 0.00001, 'current value after first update'); Util.assessNumericValue(assert, 5.5, spring.current.value, 0.00001, 'current value after first update');
equal(spring.target.value, 6, 'target value after first update'); assert.equal(spring.target.value, 6, 'target value after first update');
now = 1000; now = 1000;
spring.update(); spring.update();
equal(spring.current.value, 6, 'current value after second update'); assert.equal(spring.current.value, 6, 'current value after second update');
equal(spring.target.value, 6, 'target value after second update'); assert.equal(spring.target.value, 6, 'target value after second update');
start(); done();
}); });
asyncTest('exponential spring', function() { QUnit.test('exponential spring', function(assert) {
var done = assert.async();
var spring = new OpenSeadragon.Spring({ var spring = new OpenSeadragon.Spring({
exponential: true, exponential: true,
initial: 1, initial: 1,
@ -54,24 +56,24 @@
springStiffness: 0.000001 springStiffness: 0.000001
}); });
equal(spring.current.value, 1, 'initial current value'); assert.equal(spring.current.value, 1, 'initial current value');
equal(spring.target.value, 1, 'initial target value'); assert.equal(spring.target.value, 1, 'initial target value');
spring.springTo(2); spring.springTo(2);
equal(spring.current.value, 1, 'current value after springTo'); assert.equal(spring.current.value, 1, 'current value after springTo');
equal(spring.target.value, 2, 'target value after springTo'); assert.equal(spring.target.value, 2, 'target value after springTo');
now = 500; now = 500;
spring.update(); spring.update();
Util.assessNumericValue(1.41421, spring.current.value, 0.00001, 'current value after first update'); Util.assessNumericValue(assert, 1.41421, spring.current.value, 0.00001, 'current value after first update');
equal(spring.target.value, 2, 'target value after first update'); assert.equal(spring.target.value, 2, 'target value after first update');
now = 1000; now = 1000;
spring.update(); spring.update();
equal(spring.current.value, 2, 'current value after second update'); assert.equal(spring.current.value, 2, 'current value after second update');
equal(spring.target.value, 2, 'target value after second update'); assert.equal(spring.target.value, 2, 'target value after second update');
start(); done();
}); });
})(); })();

37
test/modules/tilecache.js
View File

@ -1,18 +1,20 @@
/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog */ /* global QUnit, testLog */
(function() { (function() {
// ---------- // ----------
module('TileCache', { QUnit.module('TileCache', {
setup: function () { beforeEach: function () {
testLog.reset(); testLog.reset();
}, },
teardown: function () { afterEach: function () {
} }
}); });
// ---------- // ----------
asyncTest('basics', function() { // TODO: this used to be async
QUnit.test('basics', function(assert) {
var done = assert.async();
var fakeViewer = { var fakeViewer = {
raiseEvent: function() {} raiseEvent: function() {}
}; };
@ -38,35 +40,36 @@
}; };
var cache = new OpenSeadragon.TileCache(); var cache = new OpenSeadragon.TileCache();
equal(cache.numTilesLoaded(), 0, 'no tiles to begin with'); assert.equal(cache.numTilesLoaded(), 0, 'no tiles to begin with');
cache.cacheTile({ cache.cacheTile({
tile: fakeTile0, tile: fakeTile0,
tiledImage: fakeTiledImage0 tiledImage: fakeTiledImage0
}); });
equal(cache.numTilesLoaded(), 1, 'tile count after cache'); assert.equal(cache.numTilesLoaded(), 1, 'tile count after cache');
cache.cacheTile({ cache.cacheTile({
tile: fakeTile1, tile: fakeTile1,
tiledImage: fakeTiledImage1 tiledImage: fakeTiledImage1
}); });
equal(cache.numTilesLoaded(), 2, 'tile count after second cache'); assert.equal(cache.numTilesLoaded(), 2, 'tile count after second cache');
cache.clearTilesFor(fakeTiledImage0); cache.clearTilesFor(fakeTiledImage0);
equal(cache.numTilesLoaded(), 1, 'tile count after first clear'); assert.equal(cache.numTilesLoaded(), 1, 'tile count after first clear');
cache.clearTilesFor(fakeTiledImage1); cache.clearTilesFor(fakeTiledImage1);
equal(cache.numTilesLoaded(), 0, 'tile count after second clear'); assert.equal(cache.numTilesLoaded(), 0, 'tile count after second clear');
start(); done();
}); });
// ---------- // ----------
asyncTest('maxImageCacheCount', function() { QUnit.test('maxImageCacheCount', function(assert) {
var done = assert.async();
var fakeViewer = { var fakeViewer = {
raiseEvent: function() {} raiseEvent: function() {}
}; };
@ -99,30 +102,30 @@
maxImageCacheCount: 1 maxImageCacheCount: 1
}); });
equal(cache.numTilesLoaded(), 0, 'no tiles to begin with'); assert.equal(cache.numTilesLoaded(), 0, 'no tiles to begin with');
cache.cacheTile({ cache.cacheTile({
tile: fakeTile0, tile: fakeTile0,
tiledImage: fakeTiledImage0 tiledImage: fakeTiledImage0
}); });
equal(cache.numTilesLoaded(), 1, 'tile count after add'); assert.equal(cache.numTilesLoaded(), 1, 'tile count after add');
cache.cacheTile({ cache.cacheTile({
tile: fakeTile1, tile: fakeTile1,
tiledImage: fakeTiledImage0 tiledImage: fakeTiledImage0
}); });
equal(cache.numTilesLoaded(), 1, 'tile count after add of second image'); assert.equal(cache.numTilesLoaded(), 1, 'tile count after add of second image');
cache.cacheTile({ cache.cacheTile({
tile: fakeTile2, tile: fakeTile2,
tiledImage: fakeTiledImage0 tiledImage: fakeTiledImage0
}); });
equal(cache.numTilesLoaded(), 2, 'tile count after additional same image'); assert.equal(cache.numTilesLoaded(), 2, 'tile count after additional same image');
start(); done();
}); });
})(); })();

276
test/modules/tiledimage.js
View File

@ -1,11 +1,11 @@
/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog, propEqual */ /* global QUnit, $, Util, testLog */
(function() { (function() {
var viewer; var viewer;
module('TiledImage', { QUnit.module('TiledImage', {
setup: function() { beforeEach: function() {
var example = $('<div id="example"></div>').appendTo("#qunit-fixture"); $('<div id="example"></div>').appendTo("#qunit-fixture");
testLog.reset(); testLog.reset();
@ -15,7 +15,7 @@
springStiffness: 100 // Faster animation = faster tests springStiffness: 100 // Faster animation = faster tests
}); });
}, },
teardown: function() { afterEach: function() {
if (viewer && viewer.close) { if (viewer && viewer.close) {
viewer.close(); viewer.close();
} }
@ -25,39 +25,40 @@
}); });
// ---------- // ----------
var checkBounds = function(image, expected, message) { var checkBounds = function(assert, image, expected, message) {
var bounds = image.getBounds(); var bounds = image.getBounds();
equal(bounds.x, expected.x, message + ' x'); assert.equal(bounds.x, expected.x, message + ' x');
equal(bounds.y, expected.y, message + ' y'); assert.equal(bounds.y, expected.y, message + ' y');
equal(bounds.width, expected.width, message + ' width'); assert.equal(bounds.width, expected.width, message + ' width');
equal(bounds.height, expected.height, message + ' height'); assert.equal(bounds.height, expected.height, message + ' height');
}; };
// ---------- // ----------
asyncTest('metrics', function() { QUnit.test('metrics', function(assert) {
var done = assert.async();
var handlerCount = 0; var handlerCount = 0;
viewer.addHandler('open', function(event) { viewer.addHandler('open', function(event) {
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
var contentSize = image.getContentSize(); var contentSize = image.getContentSize();
equal(contentSize.x, 500, 'contentSize.x'); assert.equal(contentSize.x, 500, 'contentSize.x');
equal(contentSize.y, 2000, 'contentSize.y'); assert.equal(contentSize.y, 2000, 'contentSize.y');
checkBounds(image, new OpenSeadragon.Rect(5, 6, 10, 40), 'initial bounds'); checkBounds(assert, image, new OpenSeadragon.Rect(5, 6, 10, 40), 'initial bounds');
var scale = image.getContentSize().x / image.getBounds().width; var scale = image.getContentSize().x / image.getBounds().width;
var viewportPoint = new OpenSeadragon.Point(10, 11); var viewportPoint = new OpenSeadragon.Point(10, 11);
var imagePoint = viewportPoint.minus(image.getBounds().getTopLeft()).times(scale); var imagePoint = viewportPoint.minus(image.getBounds().getTopLeft()).times(scale);
propEqual(image.viewportToImageCoordinates(viewportPoint), imagePoint, 'viewportToImageCoordinates'); assert.propEqual(image.viewportToImageCoordinates(viewportPoint), imagePoint, 'viewportToImageCoordinates');
propEqual(image.imageToViewportCoordinates(imagePoint), viewportPoint, 'imageToViewportCoordinates'); assert.propEqual(image.imageToViewportCoordinates(imagePoint), viewportPoint, 'imageToViewportCoordinates');
var viewportRect = new OpenSeadragon.Rect(viewportPoint.x, viewportPoint.y, 6, 7); var viewportRect = new OpenSeadragon.Rect(viewportPoint.x, viewportPoint.y, 6, 7);
var imageRect = new OpenSeadragon.Rect(imagePoint.x, imagePoint.y, var imageRect = new OpenSeadragon.Rect(imagePoint.x, imagePoint.y,
viewportRect.width * scale, viewportRect.height * scale); viewportRect.width * scale, viewportRect.height * scale);
propEqual(image.viewportToImageRectangle(viewportRect), imageRect, 'viewportToImageRectangle'); assert.propEqual(image.viewportToImageRectangle(viewportRect), imageRect, 'viewportToImageRectangle');
propEqual(image.imageToViewportRectangle(imageRect), viewportRect, 'imageToViewportRectangle'); assert.propEqual(image.imageToViewportRectangle(imageRect), viewportRect, 'imageToViewportRectangle');
image.addHandler('bounds-change', function boundsChangeHandler(event) { image.addHandler('bounds-change', function boundsChangeHandler(event) {
image.removeHandler('bounds-change', boundsChangeHandler); image.removeHandler('bounds-change', boundsChangeHandler);
@ -65,16 +66,16 @@
}); });
image.setPosition(new OpenSeadragon.Point(7, 8)); image.setPosition(new OpenSeadragon.Point(7, 8));
checkBounds(image, new OpenSeadragon.Rect(7, 8, 10, 40), 'bounds after position'); checkBounds(assert, image, new OpenSeadragon.Rect(7, 8, 10, 40), 'bounds after position');
image.setWidth(5); image.setWidth(5);
checkBounds(image, new OpenSeadragon.Rect(7, 8, 5, 20), 'bounds after width'); checkBounds(assert, image, new OpenSeadragon.Rect(7, 8, 5, 20), 'bounds after width');
image.setHeight(4); image.setHeight(4);
checkBounds(image, new OpenSeadragon.Rect(7, 8, 1, 4), 'bounds after width'); checkBounds(assert, image, new OpenSeadragon.Rect(7, 8, 1, 4), 'bounds after width');
equal(handlerCount, 1, 'correct number of handlers called'); assert.equal(handlerCount, 1, 'correct number of handlers called');
start(); done();
}); });
viewer.open({ viewer.open({
@ -86,25 +87,26 @@
}); });
// ---------- // ----------
asyncTest('animation', function() { QUnit.test('animation', function(assert) {
var done = assert.async();
viewer.addHandler("open", function() { viewer.addHandler("open", function() {
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
propEqual(image.getBounds(), new OpenSeadragon.Rect(0, 0, 1, 1), 'target bounds on open'); assert.propEqual(image.getBounds(), new OpenSeadragon.Rect(0, 0, 1, 1), 'target bounds on open');
propEqual(image.getBounds(true), new OpenSeadragon.Rect(0, 0, 1, 1), 'current bounds on open'); assert.propEqual(image.getBounds(true), new OpenSeadragon.Rect(0, 0, 1, 1), 'current bounds on open');
image.setPosition(new OpenSeadragon.Point(1, 2)); image.setPosition(new OpenSeadragon.Point(1, 2));
propEqual(image.getBounds(), new OpenSeadragon.Rect(1, 2, 1, 1), 'target bounds after position'); assert.propEqual(image.getBounds(), new OpenSeadragon.Rect(1, 2, 1, 1), 'target bounds after position');
propEqual(image.getBounds(true), new OpenSeadragon.Rect(0, 0, 1, 1), 'current bounds after position'); assert.propEqual(image.getBounds(true), new OpenSeadragon.Rect(0, 0, 1, 1), 'current bounds after position');
image.setWidth(3); image.setWidth(3);
propEqual(image.getBounds(), new OpenSeadragon.Rect(1, 2, 3, 3), 'target bounds after width'); assert.propEqual(image.getBounds(), new OpenSeadragon.Rect(1, 2, 3, 3), 'target bounds after width');
propEqual(image.getBounds(true), new OpenSeadragon.Rect(0, 0, 1, 1), 'current bounds after width'); assert.propEqual(image.getBounds(true), new OpenSeadragon.Rect(0, 0, 1, 1), 'current bounds after width');
viewer.addHandler('animation-finish', function animationHandler() { viewer.addHandler('animation-finish', function animationHandler() {
viewer.removeHandler('animation-finish', animationHandler); viewer.removeHandler('animation-finish', animationHandler);
propEqual(image.getBounds(), new OpenSeadragon.Rect(1, 2, 3, 3), 'target bounds after animation'); assert.propEqual(image.getBounds(), new OpenSeadragon.Rect(1, 2, 3, 3), 'target bounds after animation');
propEqual(image.getBounds(true), new OpenSeadragon.Rect(1, 2, 3, 3), 'current bounds after animation'); assert.propEqual(image.getBounds(true), new OpenSeadragon.Rect(1, 2, 3, 3), 'current bounds after animation');
start(); done();
}); });
}); });
@ -112,55 +114,56 @@
}); });
// ---------- // ----------
asyncTest('update', function() { QUnit.test('update', function(assert) {
var done = assert.async();
var handlerCount = 0; var handlerCount = 0;
viewer.addHandler('open', function(event) { viewer.addHandler('open', function(event) {
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
equal(image.needsDraw(), true, 'needs draw after open'); assert.equal(image.needsDraw(), true, 'needs draw after open');
viewer.addHandler('update-level', function updateLevelHandler(event) { viewer.addHandler('update-level', function updateLevelHandler(event) {
viewer.removeHandler('update-level', updateLevelHandler); viewer.removeHandler('update-level', updateLevelHandler);
handlerCount++; handlerCount++;
equal(event.eventSource, viewer, 'sender of update-level event was viewer'); assert.equal(event.eventSource, viewer, 'sender of update-level event was viewer');
equal(event.tiledImage, image, 'tiledImage of update-level event is correct'); assert.equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
ok('havedrawn' in event, 'update-level event includes havedrawn'); assert.ok('havedrawn' in event, 'update-level event includes havedrawn');
ok('level' in event, 'update-level event includes level'); assert.ok('level' in event, 'update-level event includes level');
ok('opacity' in event, 'update-level event includes opacity'); assert.ok('opacity' in event, 'update-level event includes opacity');
ok('visibility' in event, 'update-level event includes visibility'); assert.ok('visibility' in event, 'update-level event includes visibility');
ok('topleft' in event, 'update-level event includes topleft'); assert.ok('topleft' in event, 'update-level event includes topleft');
ok('bottomright' in event, 'update-level event includes bottomright'); assert.ok('bottomright' in event, 'update-level event includes bottomright');
ok('currenttime' in event, 'update-level event includes currenttime'); assert.ok('currenttime' in event, 'update-level event includes currenttime');
ok('best' in event, 'update-level event includes best'); assert.ok('best' in event, 'update-level event includes best');
}); });
viewer.addHandler('update-tile', function updateTileHandler(event) { viewer.addHandler('update-tile', function updateTileHandler(event) {
viewer.removeHandler('update-tile', updateTileHandler); viewer.removeHandler('update-tile', updateTileHandler);
handlerCount++; handlerCount++;
equal(event.eventSource, viewer, 'sender of update-tile event was viewer'); assert.equal(event.eventSource, viewer, 'sender of update-tile event was viewer');
equal(event.tiledImage, image, 'tiledImage of update-level event is correct'); assert.equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
ok(event.tile, 'update-tile event includes tile'); assert.ok(event.tile, 'update-tile event includes tile');
}); });
viewer.addHandler('tile-drawing', function tileDrawingHandler(event) { viewer.addHandler('tile-drawing', function tileDrawingHandler(event) {
viewer.removeHandler('tile-drawing', tileDrawingHandler); viewer.removeHandler('tile-drawing', tileDrawingHandler);
handlerCount++; handlerCount++;
equal(event.eventSource, viewer, 'sender of tile-drawing event was viewer'); assert.equal(event.eventSource, viewer, 'sender of tile-drawing event was viewer');
equal(event.tiledImage, image, 'tiledImage of update-level event is correct'); assert.equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
ok(event.tile, 'tile-drawing event includes a tile'); assert.ok(event.tile, 'tile-drawing event includes a tile');
ok(event.context, 'tile-drawing event includes a context'); assert.ok(event.context, 'tile-drawing event includes a context');
ok(event.rendered, 'tile-drawing event includes a rendered'); assert.ok(event.rendered, 'tile-drawing event includes a rendered');
}); });
viewer.addHandler('tile-drawn', function tileDrawnHandler(event) { viewer.addHandler('tile-drawn', function tileDrawnHandler(event) {
viewer.removeHandler('tile-drawn', tileDrawnHandler); viewer.removeHandler('tile-drawn', tileDrawnHandler);
handlerCount++; handlerCount++;
equal(event.eventSource, viewer, 'sender of tile-drawn event was viewer'); assert.equal(event.eventSource, viewer, 'sender of tile-drawn event was viewer');
equal(event.tiledImage, image, 'tiledImage of update-level event is correct'); assert.equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
ok(event.tile, 'tile-drawn event includes tile'); assert.ok(event.tile, 'tile-drawn event includes tile');
equal(handlerCount, 4, 'correct number of handlers called'); assert.equal(handlerCount, 4, 'correct number of handlers called');
start(); done();
}); });
image.draw(); image.draw();
@ -170,49 +173,51 @@
}); });
// ---------- // ----------
asyncTest('reset', function() { QUnit.test('reset', function(assert) {
var done = assert.async();
viewer.addHandler('tile-drawn', function updateHandler() { viewer.addHandler('tile-drawn', function updateHandler() {
viewer.removeHandler('tile-drawn', updateHandler); viewer.removeHandler('tile-drawn', updateHandler);
ok(viewer.tileCache.numTilesLoaded() > 0, 'we have tiles after tile-drawn'); assert.ok(viewer.tileCache.numTilesLoaded() > 0, 'we have tiles after tile-drawn');
viewer.world.getItemAt(0).reset(); viewer.world.getItemAt(0).reset();
equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles after reset'); assert.equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles after reset');
viewer.addHandler('tile-drawn', function updateHandler2() { viewer.addHandler('tile-drawn', function updateHandler2() {
viewer.removeHandler('tile-drawn', updateHandler2); viewer.removeHandler('tile-drawn', updateHandler2);
ok(viewer.tileCache.numTilesLoaded() > 0, 'more tiles load'); assert.ok(viewer.tileCache.numTilesLoaded() > 0, 'more tiles load');
viewer.world.getItemAt(0).destroy(); viewer.world.getItemAt(0).destroy();
equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles after destroy'); assert.equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles after destroy');
start(); done();
}); });
}); });
equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles at start'); assert.equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles at start');
viewer.open('/test/data/testpattern.dzi'); viewer.open('/test/data/testpattern.dzi');
}); });
// ---------- // ----------
asyncTest('clip', function() { QUnit.test('clip', function(assert) {
var done = assert.async();
var clip = new OpenSeadragon.Rect(100, 100, 800, 800); var clip = new OpenSeadragon.Rect(100, 100, 800, 800);
viewer.addHandler('open', function() { viewer.addHandler('open', function() {
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
propEqual(image.getClip(), clip, 'image has correct clip'); assert.propEqual(image.getClip(), clip, 'image has correct clip');
image.setClip(null); image.setClip(null);
equal(image.getClip(), null, 'clip is cleared'); assert.equal(image.getClip(), null, 'clip is cleared');
image.setClip(clip); image.setClip(clip);
propEqual(image.getClip(), clip, 'clip is set correctly'); assert.propEqual(image.getClip(), clip, 'clip is set correctly');
Util.spyOnce(viewer.drawer, 'setClip', function(rect) { Util.spyOnce(viewer.drawer, 'setClip', function(rect) {
var homeBounds = viewer.viewport.getHomeBounds(); var homeBounds = viewer.viewport.getHomeBounds();
var canvasClip = viewer.drawer var canvasClip = viewer.drawer
.viewportToDrawerRectangle(homeBounds); .viewportToDrawerRectangle(homeBounds);
var precision = 0.00000001; var precision = 0.00000001;
Util.assertRectangleEquals(rect, canvasClip, precision, Util.assertRectangleEquals(assert, rect, canvasClip, precision,
'clipping should be ' + canvasClip); 'clipping should be ' + canvasClip);
start(); done();
}); });
}); });
@ -223,15 +228,16 @@
}); });
// ---------- // ----------
asyncTest('clip-change event', function() { QUnit.test('clip-change event', function(assert) {
expect(0); var done = assert.async();
assert.expect(0);
var clip = new OpenSeadragon.Rect(100, 100, 800, 800); var clip = new OpenSeadragon.Rect(100, 100, 800, 800);
viewer.addHandler('open', function() { viewer.addHandler('open', function() {
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
image.addOnceHandler('clip-change', function() { image.addOnceHandler('clip-change', function() {
image.addOnceHandler('clip-change', function() { image.addOnceHandler('clip-change', function() {
start(); done();
}); });
image.setClip(clip); image.setClip(clip);
}); });
@ -244,23 +250,24 @@
}); });
// ---------- // ----------
asyncTest('getClipBounds', function() { QUnit.test('getClipBounds', function(assert) {
var done = assert.async();
var clip = new OpenSeadragon.Rect(100, 200, 800, 500); var clip = new OpenSeadragon.Rect(100, 200, 800, 500);
viewer.addHandler('open', function() { viewer.addHandler('open', function() {
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
var bounds = image.getClippedBounds(); var bounds = image.getClippedBounds();
var expectedBounds = new OpenSeadragon.Rect(1.2, 1.4, 1.6, 1); var expectedBounds = new OpenSeadragon.Rect(1.2, 1.4, 1.6, 1);
propEqual(bounds, expectedBounds, assert.propEqual(bounds, expectedBounds,
'getClipBounds should take clipping into account.'); 'getClipBounds should take clipping into account.');
image = viewer.world.getItemAt(1); image = viewer.world.getItemAt(1);
bounds = image.getClippedBounds(); bounds = image.getClippedBounds();
expectedBounds = new OpenSeadragon.Rect(1, 2, 2, 2); expectedBounds = new OpenSeadragon.Rect(1, 2, 2, 2);
propEqual(bounds, expectedBounds, assert.propEqual(bounds, expectedBounds,
'getClipBounds should work when no clipping set.'); 'getClipBounds should work when no clipping set.');
start(); done();
}); });
viewer.open([{ viewer.open([{
@ -278,15 +285,15 @@
}); });
// ---------- // ----------
asyncTest('opacity', function() { QUnit.test('opacity', function(assert) {
var done = assert.async();
function testDefaultOpacity() { function testDefaultOpacity() {
viewer.removeHandler('open', testDefaultOpacity); viewer.removeHandler('open', testDefaultOpacity);
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
strictEqual(image.getOpacity(), 0.5, 'image has default opacity'); assert.strictEqual(image.getOpacity(), 0.5, 'image has default opacity');
image.setOpacity(1); image.setOpacity(1);
strictEqual(image.getOpacity(), 1, 'opacity is set correctly'); assert.strictEqual(image.getOpacity(), 1, 'opacity is set correctly');
viewer.addHandler('open', testTileSourceOpacity); viewer.addHandler('open', testTileSourceOpacity);
viewer.open({ viewer.open({
@ -298,12 +305,12 @@
function testTileSourceOpacity() { function testTileSourceOpacity() {
viewer.removeHandler('open', testTileSourceOpacity); viewer.removeHandler('open', testTileSourceOpacity);
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
strictEqual(image.getOpacity(), 0.25, 'image has correct opacity'); assert.strictEqual(image.getOpacity(), 0.25, 'image has correct opacity');
image.setOpacity(0); image.setOpacity(0);
strictEqual(image.getOpacity(), 0, 'opacity is set correctly'); assert.strictEqual(image.getOpacity(), 0, 'opacity is set correctly');
start(); done();
} }
viewer.addHandler('open', testDefaultOpacity); viewer.addHandler('open', testDefaultOpacity);
@ -315,20 +322,20 @@
}); });
// ---------- // ----------
asyncTest('rotation', function() { QUnit.test('rotation', function(assert) {
var done = assert.async();
function testDefaultRotation() { function testDefaultRotation() {
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
strictEqual(image.getRotation(true), 0, 'image has default current rotation'); assert.strictEqual(image.getRotation(true), 0, 'image has default current rotation');
strictEqual(image.getRotation(false), 0, 'image has default target rotation'); assert.strictEqual(image.getRotation(false), 0, 'image has default target rotation');
image.setRotation(400); image.setRotation(400);
strictEqual(image.getRotation(true), 0, 'current rotation is not changed'); assert.strictEqual(image.getRotation(true), 0, 'current rotation is not changed');
strictEqual(image.getRotation(false), 400, 'target rotation is set correctly'); assert.strictEqual(image.getRotation(false), 400, 'target rotation is set correctly');
image.setRotation(200, true); image.setRotation(200, true);
strictEqual(image.getRotation(true), 200, 'current rotation is set correctly'); assert.strictEqual(image.getRotation(true), 200, 'current rotation is set correctly');
strictEqual(image.getRotation(false), 200, 'target rotation is set correctly'); assert.strictEqual(image.getRotation(false), 200, 'target rotation is set correctly');
viewer.addOnceHandler('open', testTileSourceRotation); viewer.addOnceHandler('open', testTileSourceRotation);
viewer.open({ viewer.open({
@ -339,9 +346,9 @@
function testTileSourceRotation() { function testTileSourceRotation() {
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
strictEqual(image.getRotation(true), -60, 'image has correct current rotation'); assert.strictEqual(image.getRotation(true), -60, 'image has correct current rotation');
strictEqual(image.getRotation(false), -60, 'image has correct target rotation'); assert.strictEqual(image.getRotation(false), -60, 'image has correct target rotation');
start(); done();
} }
viewer.addOnceHandler('open', testDefaultRotation); viewer.addOnceHandler('open', testDefaultRotation);
@ -350,10 +357,10 @@
}); });
}); });
asyncTest('fitBounds', function() { QUnit.test('fitBounds', function(assert) {
var done = assert.async();
function assertRectEquals(actual, expected, message) { function assertRectEquals(actual, expected, message) {
ok(actual.equals(expected), message + ' should be ' + assert.ok(actual.equals(expected), message + ' should be ' +
expected.toString() + ', found ' + actual.toString()); expected.toString() + ', found ' + actual.toString());
} }
@ -386,7 +393,7 @@
actualBounds = wideImage.getBounds(true); actualBounds = wideImage.getBounds(true);
expectedBounds = new OpenSeadragon.Rect(0, 1.75, 1, 0.25); expectedBounds = new OpenSeadragon.Rect(0, 1.75, 1, 0.25);
assertRectEquals(actualBounds, expectedBounds, 'Wide image bounds'); assertRectEquals(actualBounds, expectedBounds, 'Wide image bounds');
start(); done();
}); });
viewer.open([ viewer.open([
@ -397,10 +404,10 @@
}); });
// ---------- // ----------
asyncTest('fitBounds in constructor', function() { QUnit.test('fitBounds in constructor', function(assert) {
var done = assert.async();
function assertRectEquals(actual, expected, message) { function assertRectEquals(actual, expected, message) {
ok(actual.equals(expected), message + ' should be ' + assert.ok(actual.equals(expected), message + ' should be ' +
expected.toString() + ', found ' + actual.toString()); expected.toString() + ', found ' + actual.toString());
} }
@ -421,7 +428,7 @@
actualBounds = wideImage.getBounds(true); actualBounds = wideImage.getBounds(true);
expectedBounds = new OpenSeadragon.Rect(0, 1.75, 1, 0.25); expectedBounds = new OpenSeadragon.Rect(0, 1.75, 1, 0.25);
assertRectEquals(actualBounds, expectedBounds, 'Wide image bounds'); assertRectEquals(actualBounds, expectedBounds, 'Wide image bounds');
start(); done();
}); });
viewer.open([{ viewer.open([{
@ -443,10 +450,10 @@
}); });
// ---------- // ----------
asyncTest('fitBounds with clipping', function() { QUnit.test('fitBounds with clipping', function(assert) {
var done = assert.async();
function assertRectEquals(actual, expected, message) { function assertRectEquals(actual, expected, message) {
ok(actual.equals(expected), message + ' should be ' + assert.ok(actual.equals(expected), message + ' should be ' +
expected.toString() + ', found ' + actual.toString()); expected.toString() + ', found ' + actual.toString());
} }
@ -467,7 +474,7 @@
actualBounds = wideImage.getBounds(true); actualBounds = wideImage.getBounds(true);
expectedBounds = new OpenSeadragon.Rect(1, 1, 16, 4); expectedBounds = new OpenSeadragon.Rect(1, 1, 16, 4);
assertRectEquals(actualBounds, expectedBounds, 'Wide image bounds'); assertRectEquals(actualBounds, expectedBounds, 'Wide image bounds');
start(); done();
}); });
viewer.open([{ viewer.open([{
@ -488,27 +495,28 @@
}); });
// ---------- // ----------
asyncTest('fullyLoaded', function() { QUnit.test('fullyLoaded', function(assert) {
var done = assert.async();
viewer.addHandler('open', function openHandler() { viewer.addHandler('open', function openHandler() {
viewer.removeHandler('open', openHandler); viewer.removeHandler('open', openHandler);
var image = viewer.world.getItemAt(0); var image = viewer.world.getItemAt(0);
equal(image.getFullyLoaded(), false, 'not fully loaded at first'); assert.equal(image.getFullyLoaded(), false, 'not fully loaded at first');
var count = 0; var count = 0;
var fullyLoadedChangeHandler = function(event) { var fullyLoadedChangeHandler = function(event) {
if (count === 0) { if (count === 0) {
equal(event.fullyLoaded, true, 'event includes true fullyLoaded property'); assert.equal(event.fullyLoaded, true, 'event includes true fullyLoaded property');
equal(image.getFullyLoaded(), true, 'image is fully loaded after event'); assert.equal(image.getFullyLoaded(), true, 'image is fully loaded after event');
viewer.viewport.zoomBy(5, null, true); viewer.viewport.zoomBy(5, null, true);
} else if (count === 1) { } else if (count === 1) {
equal(event.fullyLoaded, false, 'event includes false fullyLoaded property'); assert.equal(event.fullyLoaded, false, 'event includes false fullyLoaded property');
equal(image.getFullyLoaded(), false, 'image is not fully loaded after zoom'); assert.equal(image.getFullyLoaded(), false, 'image is not fully loaded after zoom');
} else { } else {
image.removeHandler('fully-loaded-change', fullyLoadedChangeHandler); image.removeHandler('fully-loaded-change', fullyLoadedChangeHandler);
equal(image.getFullyLoaded(), true, 'image is once again fully loaded'); assert.equal(image.getFullyLoaded(), true, 'image is once again fully loaded');
start(); done();
} }
count++; count++;
@ -529,7 +537,7 @@
}; };
} }
test('_getCornerTiles without wrapping', function() { QUnit.test('_getCornerTiles without wrapping', function(assert) {
var tiledImageMock = { var tiledImageMock = {
wrapHorizontal: false, wrapHorizontal: false,
wrapVertical: false, wrapVertical: false,
@ -548,10 +556,10 @@
function assertCornerTiles(topLeftBound, bottomRightBound, function assertCornerTiles(topLeftBound, bottomRightBound,
expectedTopLeft, expectedBottomRight) { expectedTopLeft, expectedBottomRight) {
var cornerTiles = _getCornerTiles(11, topLeftBound, bottomRightBound); var cornerTiles = _getCornerTiles(11, topLeftBound, bottomRightBound);
ok(cornerTiles.topLeft.equals(expectedTopLeft), assert.ok(cornerTiles.topLeft.equals(expectedTopLeft),
'Top left tile should be ' + expectedTopLeft.toString() + 'Top left tile should be ' + expectedTopLeft.toString() +
' found ' + cornerTiles.topLeft.toString()); ' found ' + cornerTiles.topLeft.toString());
ok(cornerTiles.bottomRight.equals(expectedBottomRight), assert.ok(cornerTiles.bottomRight.equals(expectedBottomRight),
'Bottom right tile should be ' + expectedBottomRight.toString() + 'Bottom right tile should be ' + expectedBottomRight.toString() +
' found ' + cornerTiles.bottomRight.toString()); ' found ' + cornerTiles.bottomRight.toString());
} }
@ -561,7 +569,7 @@
new OpenSeadragon.Point(1, 10 / 15), new OpenSeadragon.Point(1, 10 / 15),
new OpenSeadragon.Point(0, 0), new OpenSeadragon.Point(0, 0),
new OpenSeadragon.Point(7, 6) new OpenSeadragon.Point(7, 6)
) );
// Floating point errors should be handled // Floating point errors should be handled
assertCornerTiles( assertCornerTiles(
@ -569,17 +577,17 @@
new OpenSeadragon.Point(1 + 1e-14, 10 / 15 + 1e-14), new OpenSeadragon.Point(1 + 1e-14, 10 / 15 + 1e-14),
new OpenSeadragon.Point(0, 0), new OpenSeadragon.Point(0, 0),
new OpenSeadragon.Point(7, 6) new OpenSeadragon.Point(7, 6)
) );
assertCornerTiles( assertCornerTiles(
new OpenSeadragon.Point(0.3, 0.5), new OpenSeadragon.Point(0.3, 0.5),
new OpenSeadragon.Point(0.5, 0.6), new OpenSeadragon.Point(0.5, 0.6),
new OpenSeadragon.Point(2, 5), new OpenSeadragon.Point(2, 5),
new OpenSeadragon.Point(3, 6) new OpenSeadragon.Point(3, 6)
) );
}); });
test('_getCornerTiles with horizontal wrapping', function() { QUnit.test('_getCornerTiles with horizontal wrapping', function(assert) {
var tiledImageMock = { var tiledImageMock = {
wrapHorizontal: true, wrapHorizontal: true,
wrapVertical: false, wrapVertical: false,
@ -598,10 +606,10 @@
function assertCornerTiles(topLeftBound, bottomRightBound, function assertCornerTiles(topLeftBound, bottomRightBound,
expectedTopLeft, expectedBottomRight) { expectedTopLeft, expectedBottomRight) {
var cornerTiles = _getCornerTiles(11, topLeftBound, bottomRightBound); var cornerTiles = _getCornerTiles(11, topLeftBound, bottomRightBound);
ok(cornerTiles.topLeft.equals(expectedTopLeft), assert.ok(cornerTiles.topLeft.equals(expectedTopLeft),
'Top left tile should be ' + expectedTopLeft.toString() + 'Top left tile should be ' + expectedTopLeft.toString() +
' found ' + cornerTiles.topLeft.toString()); ' found ' + cornerTiles.topLeft.toString());
ok(cornerTiles.bottomRight.equals(expectedBottomRight), assert.ok(cornerTiles.bottomRight.equals(expectedBottomRight),
'Bottom right tile should be ' + expectedBottomRight.toString() + 'Bottom right tile should be ' + expectedBottomRight.toString() +
' found ' + cornerTiles.bottomRight.toString()); ' found ' + cornerTiles.bottomRight.toString());
} }
@ -611,24 +619,24 @@
new OpenSeadragon.Point(1, 10 / 15), new OpenSeadragon.Point(1, 10 / 15),
new OpenSeadragon.Point(0, 0), new OpenSeadragon.Point(0, 0),
new OpenSeadragon.Point(8, 6) new OpenSeadragon.Point(8, 6)
) );
assertCornerTiles( assertCornerTiles(
new OpenSeadragon.Point(-1, 0), new OpenSeadragon.Point(-1, 0),
new OpenSeadragon.Point(0.5, 10 / 15 + 1e-14), new OpenSeadragon.Point(0.5, 10 / 15 + 1e-14),
new OpenSeadragon.Point(-8, 0), new OpenSeadragon.Point(-8, 0),
new OpenSeadragon.Point(3, 6) new OpenSeadragon.Point(3, 6)
) );
assertCornerTiles( assertCornerTiles(
new OpenSeadragon.Point(1.3, 0.5), new OpenSeadragon.Point(1.3, 0.5),
new OpenSeadragon.Point(1.5, 0.6), new OpenSeadragon.Point(1.5, 0.6),
new OpenSeadragon.Point(10, 5), new OpenSeadragon.Point(10, 5),
new OpenSeadragon.Point(11, 6) new OpenSeadragon.Point(11, 6)
) );
}); });
test('_getCornerTiles with vertical wrapping', function() { QUnit.test('_getCornerTiles with vertical wrapping', function(assert) {
var tiledImageMock = { var tiledImageMock = {
wrapHorizontal: false, wrapHorizontal: false,
wrapVertical: true, wrapVertical: true,
@ -647,10 +655,10 @@
function assertCornerTiles(topLeftBound, bottomRightBound, function assertCornerTiles(topLeftBound, bottomRightBound,
expectedTopLeft, expectedBottomRight) { expectedTopLeft, expectedBottomRight) {
var cornerTiles = _getCornerTiles(11, topLeftBound, bottomRightBound); var cornerTiles = _getCornerTiles(11, topLeftBound, bottomRightBound);
ok(cornerTiles.topLeft.equals(expectedTopLeft), assert.ok(cornerTiles.topLeft.equals(expectedTopLeft),
'Top left tile should be ' + expectedTopLeft.toString() + 'Top left tile should be ' + expectedTopLeft.toString() +
' found ' + cornerTiles.topLeft.toString()); ' found ' + cornerTiles.topLeft.toString());
ok(cornerTiles.bottomRight.equals(expectedBottomRight), assert.ok(cornerTiles.bottomRight.equals(expectedBottomRight),
'Bottom right tile should be ' + expectedBottomRight.toString() + 'Bottom right tile should be ' + expectedBottomRight.toString() +
' found ' + cornerTiles.bottomRight.toString()); ' found ' + cornerTiles.bottomRight.toString());
} }
@ -660,21 +668,21 @@
new OpenSeadragon.Point(1, 10 / 15), new OpenSeadragon.Point(1, 10 / 15),
new OpenSeadragon.Point(0, 0), new OpenSeadragon.Point(0, 0),
new OpenSeadragon.Point(7, 7) new OpenSeadragon.Point(7, 7)
) );
assertCornerTiles( assertCornerTiles(
new OpenSeadragon.Point(0, -10 / 15 / 2), new OpenSeadragon.Point(0, -10 / 15 / 2),
new OpenSeadragon.Point(0.5, 0.5), new OpenSeadragon.Point(0.5, 0.5),
new OpenSeadragon.Point(0, -4), new OpenSeadragon.Point(0, -4),
new OpenSeadragon.Point(3, 5) new OpenSeadragon.Point(3, 5)
) );
assertCornerTiles( assertCornerTiles(
new OpenSeadragon.Point(0, 10 / 15 + 0.1), new OpenSeadragon.Point(0, 10 / 15 + 0.1),
new OpenSeadragon.Point(0.3, 10 / 15 + 0.3), new OpenSeadragon.Point(0.3, 10 / 15 + 0.3),
new OpenSeadragon.Point(0, 7), new OpenSeadragon.Point(0, 7),
new OpenSeadragon.Point(2, 9) new OpenSeadragon.Point(2, 9)
) );
}); });
})(); })();

44
test/modules/tilesource.js
View File

@ -1,33 +1,33 @@
/* global module, ok, equal, start, test, testLog, Util */ /* global QUnit, testLog, Util */
(function() { (function() {
module('TileSource', { QUnit.module('TileSource', {
setup: function() { beforeEach: function() {
testLog.reset(); testLog.reset();
} }
}); });
test("should set sane tile size defaults", function() { QUnit.test("should set sane tile size defaults", function(assert) {
var source = new OpenSeadragon.TileSource(); var source = new OpenSeadragon.TileSource();
equal(source.getTileWidth(), 0, "getTileWidth() should return 0 if not provided a size"); assert.equal(source.getTileWidth(), 0, "getTileWidth() should return 0 if not provided a size");
equal(source.getTileHeight(), 0, "getTileHeight() should return 0 if not provided a size"); assert.equal(source.getTileHeight(), 0, "getTileHeight() should return 0 if not provided a size");
}); });
test("providing tileSize", function(){ QUnit.test("providing tileSize", function(assert){
var tileSize = 256, var tileSize = 256,
source = new OpenSeadragon.TileSource({ source = new OpenSeadragon.TileSource({
tileSize: tileSize tileSize: tileSize
}); });
equal(source.tileSize, undefined, "tileSize should not be set on the tileSource"); assert.equal(source.tileSize, undefined, "tileSize should not be set on the tileSource");
equal(source.getTileWidth(), tileSize, "getTileWidth() should equal tileSize"); assert.equal(source.getTileWidth(), tileSize, "getTileWidth() should equal tileSize");
equal(source.getTileHeight(), tileSize, "getTileHeight() should equal tileSize"); assert.equal(source.getTileHeight(), tileSize, "getTileHeight() should equal tileSize");
}); });
test("providing tileWidth and tileHeight", function(){ QUnit.test("providing tileWidth and tileHeight", function(assert){
var tileWidth = 256, var tileWidth = 256,
tileHeight = 512, tileHeight = 512,
source = new OpenSeadragon.TileSource({ source = new OpenSeadragon.TileSource({
@ -35,20 +35,20 @@
tileHeight: tileHeight tileHeight: tileHeight
}); });
equal(source._tileWidth, tileWidth, "tileWidth option should set _tileWidth"); assert.equal(source._tileWidth, tileWidth, "tileWidth option should set _tileWidth");
equal(source._tileHeight, tileHeight, "tileHeight option should set _tileHeight"); assert.equal(source._tileHeight, tileHeight, "tileHeight option should set _tileHeight");
equal(source.tileWidth, undefined, "tileWidth should be renamed _tileWidth"); assert.equal(source.tileWidth, undefined, "tileWidth should be renamed _tileWidth");
equal(source.tileHeight, undefined, "tileHeight should be renamed _tileHeight"); assert.equal(source.tileHeight, undefined, "tileHeight should be renamed _tileHeight");
equal(source.getTileWidth(), tileWidth, "getTileWidth() should equal tileWidth"); assert.equal(source.getTileWidth(), tileWidth, "getTileWidth() should equal tileWidth");
equal(source.getTileHeight(), tileHeight, "getTileHeight() should equal tileHeight"); assert.equal(source.getTileHeight(), tileHeight, "getTileHeight() should equal tileHeight");
}); });
test('getTileSize() deprecation', function() { QUnit.test('getTileSize() deprecation', function(assert) {
var source = new OpenSeadragon.TileSource(); var source = new OpenSeadragon.TileSource();
Util.testDeprecation(source, 'getTileSize'); Util.testDeprecation(assert, source, 'getTileSize');
}); });
test('getTileAtPoint', function() { QUnit.test('getTileAtPoint', function(assert) {
var tileSource = new OpenSeadragon.TileSource({ var tileSource = new OpenSeadragon.TileSource({
width: 1500, width: 1500,
height: 1000, height: 1000,
@ -57,11 +57,11 @@
tileOverlap: 1, tileOverlap: 1,
}); });
equal(tileSource.maxLevel, 11, "The max level should be 11."); assert.equal(tileSource.maxLevel, 11, "The max level should be 11.");
function assertTileAtPoint(level, position, expected) { function assertTileAtPoint(level, position, expected) {
var actual = tileSource.getTileAtPoint(level, position); var actual = tileSource.getTileAtPoint(level, position);
ok(actual.equals(expected), "The tile at level " + level + assert.ok(actual.equals(expected), "The tile at level " + level +
", position " + position.toString() + ", position " + position.toString() +
" should be tile " + expected.toString() + " should be tile " + expected.toString() +
" got " + actual.toString()); " got " + actual.toString());

17
test/modules/tilesourcecollection.js
View File

@ -1,20 +1,19 @@
/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog */ /* global QUnit, Util, testLog */
(function() { (function() {
var viewer; QUnit.module('TileSourceCollection', {
beforeEach: function () {
module('TileSourceCollection', {
setup: function () {
testLog.reset(); testLog.reset();
}, },
teardown: function () { afterEach: function () {
} }
}); });
// ---------- // ----------
asyncTest('deprecation', function() { QUnit.test('deprecation', function(assert) {
Util.testDeprecation(OpenSeadragon, 'TileSourceCollection'); var done = assert.async();
start(); Util.testDeprecation(assert, OpenSeadragon, 'TileSourceCollection');
done();
}); });
})(); })();

132
test/modules/world.js
View File

@ -1,11 +1,11 @@
/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog */ /* global QUnit, $, testLog */
(function() { (function() {
var viewer; var viewer;
module('World', { QUnit.module('World', {
setup: function () { beforeEach: function () {
var example = $('<div id="example"></div>').appendTo("#qunit-fixture"); $('<div id="example"></div>').appendTo("#qunit-fixture");
testLog.reset(); testLog.reset();
@ -15,7 +15,7 @@
springStiffness: 100 // Faster animation = faster tests springStiffness: 100 // Faster animation = faster tests
}); });
}, },
teardown: function () { afterEach: function () {
if (viewer && viewer.close) { if (viewer && viewer.close) {
viewer.close(); viewer.close();
} }
@ -25,54 +25,56 @@
}); });
// ---------- // ----------
var checkBounds = function(expected, message) { var checkBounds = function(assert, expected, message) {
var bounds = viewer.world.getHomeBounds(); var bounds = viewer.world.getHomeBounds();
ok(bounds.equals(expected), message + ' ' + bounds.toString()); assert.ok(bounds.equals(expected), message + ' ' + bounds.toString());
}; };
// ---------- // ----------
asyncTest('adding a tiled image', function() { QUnit.test('adding a tiled image', function(assert) {
ok(viewer.world, 'World exists'); var done = assert.async();
assert.ok(viewer.world, 'World exists');
viewer.world.addHandler('add-item', function(event) { viewer.world.addHandler('add-item', function(event) {
ok(event, 'add-item handler received event data'); assert.ok(event, 'add-item handler received event data');
equal(event.eventSource, viewer.world, 'sender of add-item event was world'); assert.equal(event.eventSource, viewer.world, 'sender of add-item event was world');
ok(event.item, 'add-item event includes item'); assert.ok(event.item, 'add-item event includes item');
equal(viewer.world.getItemCount(), 1, 'there is now 1 item'); assert.equal(viewer.world.getItemCount(), 1, 'there is now 1 item');
equal(event.item, viewer.world.getItemAt(0), 'item is accessible via getItemAt'); assert.equal(event.item, viewer.world.getItemAt(0), 'item is accessible via getItemAt');
equal(viewer.world.getIndexOfItem(event.item), 0, 'item index is 0'); assert.equal(viewer.world.getIndexOfItem(event.item), 0, 'item index is 0');
start(); done();
}); });
equal(viewer.world.getItemCount(), 0, 'no items to start with'); assert.equal(viewer.world.getItemCount(), 0, 'no items to start with');
viewer.open('/test/data/testpattern.dzi'); viewer.open('/test/data/testpattern.dzi');
}); });
// ---------- // ----------
asyncTest('metrics', function() { QUnit.test('metrics', function(assert) {
var done = assert.async();
viewer.addHandler('open', function(event) { viewer.addHandler('open', function(event) {
checkBounds(new OpenSeadragon.Rect(0, 0, 4, 4), 'bounds after open'); checkBounds(assert, new OpenSeadragon.Rect(0, 0, 4, 4), 'bounds after open');
var expectedContentFactor = viewer.world.getItemAt(1).getContentSize().x / 2; var expectedContentFactor = viewer.world.getItemAt(1).getContentSize().x / 2;
equal(viewer.world.getContentFactor(), expectedContentFactor, 'content factor has changed'); assert.equal(viewer.world.getContentFactor(), expectedContentFactor, 'content factor has changed');
viewer.world.addHandler('metrics-change', function metricsChangeHandler(event) { viewer.world.addHandler('metrics-change', function metricsChangeHandler(event) {
viewer.world.removeHandler('metrics-change', metricsChangeHandler); viewer.world.removeHandler('metrics-change', metricsChangeHandler);
ok(event, 'metrics-change handler received event data'); assert.ok(event, 'metrics-change handler received event data');
equal(event.eventSource, viewer.world, 'sender of metrics-change event was world'); assert.equal(event.eventSource, viewer.world, 'sender of metrics-change event was world');
checkBounds(new OpenSeadragon.Rect(0, 0, 7, 12), 'bounds after position'); checkBounds(assert, new OpenSeadragon.Rect(0, 0, 7, 12), 'bounds after position');
viewer.world.getItemAt(0).setWidth(20); viewer.world.getItemAt(0).setWidth(20);
checkBounds(new OpenSeadragon.Rect(0, 0, 20, 20), 'bounds after size'); checkBounds(assert, new OpenSeadragon.Rect(0, 0, 20, 20), 'bounds after size');
start(); done();
}); });
viewer.world.getItemAt(1).setPosition(new OpenSeadragon.Point(5, 10)); viewer.world.getItemAt(1).setPosition(new OpenSeadragon.Point(5, 10));
}); });
checkBounds(new OpenSeadragon.Rect(0, 0, 1, 1), 'default bounds'); checkBounds(assert, new OpenSeadragon.Rect(0, 0, 1, 1), 'default bounds');
equal(viewer.world.getContentFactor(), 1, 'default content factor'); assert.equal(viewer.world.getContentFactor(), 1, 'default content factor');
viewer.open([ viewer.open([
{ {
@ -86,23 +88,24 @@
}); });
// ---------- // ----------
asyncTest('remove/reorder tiled images', function() { QUnit.test('remove/reorder tiled images', function(assert) {
var done = assert.async();
var handlerCount = 0; var handlerCount = 0;
viewer.addHandler('open', function(event) { viewer.addHandler('open', function(event) {
equal(viewer.world.getItemCount(), 3, 'there are now 3 items'); assert.equal(viewer.world.getItemCount(), 3, 'there are now 3 items');
var item0 = viewer.world.getItemAt(0); var item0 = viewer.world.getItemAt(0);
var item1 = viewer.world.getItemAt(1); var item1 = viewer.world.getItemAt(1);
viewer.world.addHandler('item-index-change', function(event) { viewer.world.addHandler('item-index-change', function(event) {
handlerCount++; handlerCount++;
ok(event, 'item-index-change handler received event data'); assert.ok(event, 'item-index-change handler received event data');
equal(event.eventSource, viewer.world, 'sender of item-index-change event was world'); assert.equal(event.eventSource, viewer.world, 'sender of item-index-change event was world');
equal(event.item, item0, 'item-index-change event includes correct item'); assert.equal(event.item, item0, 'item-index-change event includes correct item');
equal(event.newIndex, 1, 'item-index-change event includes correct newIndex'); assert.equal(event.newIndex, 1, 'item-index-change event includes correct newIndex');
equal(event.previousIndex, 0, 'item-index-change event includes correct previousIndex'); assert.equal(event.previousIndex, 0, 'item-index-change event includes correct previousIndex');
equal(viewer.world.getItemAt(0), item1, 'item1 is now at index 0'); assert.equal(viewer.world.getItemAt(0), item1, 'item1 is now at index 0');
equal(viewer.world.getItemAt(1), item0, 'item0 is now at index 1'); assert.equal(viewer.world.getItemAt(1), item0, 'item0 is now at index 1');
}); });
viewer.world.setItemIndex(item0, 1); viewer.world.setItemIndex(item0, 1);
@ -110,11 +113,11 @@
viewer.world.addHandler('remove-item', function removeHandler(event) { viewer.world.addHandler('remove-item', function removeHandler(event) {
viewer.world.removeHandler('remove-item', removeHandler); viewer.world.removeHandler('remove-item', removeHandler);
handlerCount++; handlerCount++;
ok(event, 'remove-item handler received event data'); assert.ok(event, 'remove-item handler received event data');
equal(event.eventSource, viewer.world, 'sender of remove-item event was world'); assert.equal(event.eventSource, viewer.world, 'sender of remove-item event was world');
equal(event.item, item1, 'remove-item event includes correct item'); assert.equal(event.item, item1, 'remove-item event includes correct item');
equal(viewer.world.getItemCount(), 2, 'after removal, only two items remain'); assert.equal(viewer.world.getItemCount(), 2, 'after removal, only two items remain');
equal(viewer.world.getItemAt(0), item0, 'item0 is now at index 0'); assert.equal(viewer.world.getItemAt(0), item0, 'item0 is now at index 0');
}); });
viewer.world.removeItem(item1); viewer.world.removeItem(item1);
@ -124,17 +127,17 @@
removeCount++; removeCount++;
if (removeCount === 2) { if (removeCount === 2) {
handlerCount++; handlerCount++;
equal(viewer.world.getItemCount(), 0, 'after removeAll, no items remain'); assert.equal(viewer.world.getItemCount(), 0, 'after removeAll, no items remain');
} }
}); });
viewer.world.removeAll(); viewer.world.removeAll();
equal(handlerCount, 3, 'correct number of handlers called'); assert.equal(handlerCount, 3, 'correct number of handlers called');
start(); done();
}); });
equal(viewer.world.getItemCount(), 0, 'no items to start with'); assert.equal(viewer.world.getItemCount(), 0, 'no items to start with');
viewer.open([ viewer.open([
'/test/data/testpattern.dzi', '/test/data/testpattern.dzi',
@ -144,11 +147,12 @@
}); });
// ---------- // ----------
asyncTest('draw', function() { QUnit.test('draw', function(assert) {
var done = assert.async();
var handlerCount = 0; var handlerCount = 0;
viewer.addHandler('open', function(event) { viewer.addHandler('open', function(event) {
equal(viewer.world.needsDraw(), true, 'needs draw after open'); assert.equal(viewer.world.needsDraw(), true, 'needs draw after open');
viewer.addHandler('update-level', function updateHandler() { viewer.addHandler('update-level', function updateHandler() {
viewer.removeHandler('update-level', updateHandler); viewer.removeHandler('update-level', updateHandler);
@ -157,34 +161,36 @@
viewer.world.draw(); viewer.world.draw();
equal(handlerCount, 1, 'correct number of handlers called'); assert.equal(handlerCount, 1, 'correct number of handlers called');
start(); done();
}); });
equal(viewer.world.needsDraw(), false, 'needs no draw at first'); assert.equal(viewer.world.needsDraw(), false, 'needs no draw at first');
viewer.open('/test/data/testpattern.dzi'); viewer.open('/test/data/testpattern.dzi');
}); });
// ---------- // ----------
asyncTest('resetItems', function() { QUnit.test('resetItems', function(assert) {
var done = assert.async();
viewer.addHandler('tile-drawn', function updateHandler() { viewer.addHandler('tile-drawn', function updateHandler() {
viewer.removeHandler('tile-drawn', updateHandler); viewer.removeHandler('tile-drawn', updateHandler);
ok(viewer.tileCache.numTilesLoaded() > 0, 'we have tiles after tile-drawn'); assert.ok(viewer.tileCache.numTilesLoaded() > 0, 'we have tiles after tile-drawn');
viewer.world.resetItems(); viewer.world.resetItems();
equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles after reset'); assert.equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles after reset');
start(); done();
}); });
equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles at start'); assert.equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles at start');
viewer.open('/test/data/testpattern.dzi'); viewer.open('/test/data/testpattern.dzi');
}); });
// ---------- // ----------
asyncTest('arrange', function() { QUnit.test('arrange', function(assert) {
var done = assert.async();
viewer.addHandler('open', function(event) { viewer.addHandler('open', function(event) {
checkBounds(new OpenSeadragon.Rect(0, 0, 1, 1), 'all stacked'); checkBounds(assert, new OpenSeadragon.Rect(0, 0, 1, 1), 'all stacked');
viewer.world.arrange({ viewer.world.arrange({
layout: 'horizontal', layout: 'horizontal',
@ -193,7 +199,7 @@
tileMargin: 0.5 tileMargin: 0.5
}); });
checkBounds(new OpenSeadragon.Rect(0, 0, 4, 1), 'one horizontal row'); checkBounds(assert, new OpenSeadragon.Rect(0, 0, 4, 1), 'one horizontal row');
viewer.world.arrange({ viewer.world.arrange({
layout: 'horizontal', layout: 'horizontal',
@ -202,7 +208,7 @@
tileMargin: 0.5 tileMargin: 0.5
}); });
checkBounds(new OpenSeadragon.Rect(0, 0, 2.5, 2.5), 'grid'); checkBounds(assert, new OpenSeadragon.Rect(0, 0, 2.5, 2.5), 'grid');
viewer.world.arrange({ viewer.world.arrange({
layout: 'vertical', layout: 'vertical',
@ -211,7 +217,7 @@
tileMargin: 0.5 tileMargin: 0.5
}); });
checkBounds(new OpenSeadragon.Rect(0, 0, 1, 4), 'one vertical column'); checkBounds(assert, new OpenSeadragon.Rect(0, 0, 1, 4), 'one vertical column');
viewer.world.arrange({ viewer.world.arrange({
layout: 'horizontal', layout: 'horizontal',
@ -221,7 +227,7 @@
tileMargin: 0.5 tileMargin: 0.5
}); });
checkBounds(new OpenSeadragon.Rect(0, 0, 4, 1), 'three horizontal columns (one horizontal row)'); checkBounds(assert, new OpenSeadragon.Rect(0, 0, 4, 1), 'three horizontal columns (one horizontal row)');
viewer.world.arrange({ viewer.world.arrange({
layout: 'vertical', layout: 'vertical',
@ -231,9 +237,9 @@
tileMargin: 0.5 tileMargin: 0.5
}); });
checkBounds(new OpenSeadragon.Rect(0, 0, 1, 4), 'three vertical rows (one vertical column)'); checkBounds(assert, new OpenSeadragon.Rect(0, 0, 1, 4), 'three vertical rows (one vertical column)');
start(); done();
}); });
viewer.open([ viewer.open([

8
test/test.html
View File

@ -32,7 +32,7 @@
<script src="/test/modules/overlays.js"></script> <script src="/test/modules/overlays.js"></script>
<script src="/test/modules/controls.js"></script> <script src="/test/modules/controls.js"></script>
<script src="/test/modules/viewport.js"></script> <script src="/test/modules/viewport.js"></script>
<!--<script src="/test/modules/world.js"></script> <script src="/test/modules/world.js"></script>
<script src="/test/modules/drawer.js"></script> <script src="/test/modules/drawer.js"></script>
<script src="/test/modules/tiledimage.js"></script> <script src="/test/modules/tiledimage.js"></script>
<script src="/test/modules/tilecache.js"></script> <script src="/test/modules/tilecache.js"></script>
@ -41,10 +41,10 @@
<script src="/test/modules/dzitilesource.js"></script> <script src="/test/modules/dzitilesource.js"></script>
<script src="/test/modules/tilesourcecollection.js"></script> <script src="/test/modules/tilesourcecollection.js"></script>
<script src="/test/modules/spring.js"></script> <script src="/test/modules/spring.js"></script>
<script src="/test/modules/rectangle.js"></script> --> <script src="/test/modules/rectangle.js"></script>
<script src="/test/modules/ajax-tiles.js"></script> <script src="/test/modules/ajax-tiles.js"></script>
<!-- <script src="/test/modules/imageloader.js"></script> <script src="/test/modules/imageloader.js"></script>
The navigator tests are the slowest (for now; hopefully they can be sped up) <!--The navigator tests are the slowest (for now; hopefully they can be sped up)
so we put them last. so we put them last.
<script src="/test/modules/navigator.js"></script> --> <script src="/test/modules/navigator.js"></script> -->
</body> </body>