mirror/openseadragon
1
0
Fork 0
mirror of https://github.com/openseadragon/openseadragon.git synced 2024-11-21 20:56:09 +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) {
result = original.apply(this, arguments);
}
return result;
};
},
// ----------
testDeprecation: function(obj0, member0, obj1, member1, assert) {
testDeprecation: function(assert, obj0, member0, obj1, member1) {
var called = 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() {
var viewer;
module('Drawer', {
setup: function () {
var example = $('<div id="example"></div>').appendTo("#qunit-fixture");
QUnit.module('Drawer', {
beforeEach: function () {
$('<div id="example"></div>').appendTo("#qunit-fixture");
testLog.reset();
},
teardown: function () {
afterEach: function () {
if (viewer && viewer.close) {
viewer.close();
}
@ -29,15 +29,17 @@
};
// ----------
asyncTest('basics', function() {
QUnit.test('basics', function(assert) {
var done = assert.async();
createViewer();
ok(viewer.drawer, 'Drawer exists');
equal(viewer.drawer.canRotate(), OpenSeadragon.supportsCanvas, 'we can rotate if we have canvas');
start();
assert.ok(viewer.drawer, 'Drawer exists');
assert.equal(viewer.drawer.canRotate(), OpenSeadragon.supportsCanvas, 'we can rotate if we have canvas');
done();
});
// ----------
asyncTest('rotation', function() {
QUnit.test('rotation', function(assert) {
var done = assert.async();
createViewer({
tileSources: '/test/data/testpattern.dzi'
});
@ -45,27 +47,29 @@
viewer.addHandler('open', function handler(event) {
viewer.viewport.setRotation(30);
Util.spyOnce(viewer.drawer.context, 'rotate', function() {
ok(true, 'drawing with new rotation');
start();
assert.ok(true, 'drawing with new rotation');
done();
});
});
});
// ----------
asyncTest('debug', function() {
QUnit.test('debug', function(assert) {
var done = assert.async();
createViewer({
tileSources: '/test/data/testpattern.dzi',
debugMode: true
});
Util.spyOnce(viewer.drawer, 'drawDebugInfo', function() {
ok(true, 'drawDebugInfo is called');
start();
assert.ok(true, 'drawDebugInfo is called');
done();
});
});
// ----------
asyncTest('sketchCanvas', function() {
QUnit.test('sketchCanvas', function(assert) {
var done = assert.async();
createViewer({
tileSources: '/test/data/testpattern.dzi'
});
@ -73,9 +77,9 @@
viewer.addHandler('tile-drawn', function 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.');
equal(drawer.sketchContext, null,
assert.equal(drawer.sketchContext, null,
'The sketch context should be null if no decimal opacity is used.');
testOpacityDecimal();
});
@ -95,32 +99,34 @@
return;
}
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.');
notEqual(drawer.sketchContext, null,
assert.notEqual(drawer.sketchContext, null,
'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({
tileSources: '/test/data/testpattern.dzi'
});
viewer.world.addHandler('add-item', function() {
Util.testDeprecation(viewer.drawer, 'addOverlay', viewer, 'addOverlay');
Util.testDeprecation(viewer.drawer, 'updateOverlay', viewer, 'updateOverlay');
Util.testDeprecation(viewer.drawer, 'removeOverlay', viewer, 'removeOverlay');
Util.testDeprecation(viewer.drawer, 'clearOverlays', viewer, 'clearOverlays');
Util.testDeprecation(viewer.drawer, 'needsUpdate', viewer.world, 'needsDraw');
Util.testDeprecation(viewer.drawer, 'numTilesLoaded', viewer.tileCache, 'numTilesLoaded');
Util.testDeprecation(viewer.drawer, 'reset', viewer.world, 'resetItems');
Util.testDeprecation(viewer.drawer, 'update', viewer.world, 'draw');
Util.testDeprecation(viewer.drawer, 'setOpacity', viewer.world.getItemAt(0), 'setOpacity');
Util.testDeprecation(viewer.drawer, 'getOpacity', viewer.world.getItemAt(0), 'getOpacity');
start();
Util.testDeprecation(assert, viewer.drawer, 'addOverlay', viewer, 'addOverlay');
Util.testDeprecation(assert, viewer.drawer, 'updateOverlay', viewer, 'updateOverlay');
Util.testDeprecation(assert, viewer.drawer, 'removeOverlay', viewer, 'removeOverlay');
Util.testDeprecation(assert, viewer.drawer, 'clearOverlays', viewer, 'clearOverlays');
Util.testDeprecation(assert, viewer.drawer, 'needsUpdate', viewer.world, 'needsDraw');
Util.testDeprecation(assert, viewer.drawer, 'numTilesLoaded', viewer.tileCache, 'numTilesLoaded');
Util.testDeprecation(assert, viewer.drawer, 'reset', viewer.world, 'resetItems');
Util.testDeprecation(assert, viewer.drawer, 'update', viewer.world, 'draw');
Util.testDeprecation(assert, viewer.drawer, 'setOpacity', viewer.world.getItemAt(0), 'setOpacity');
Util.testDeprecation(assert, viewer.drawer, 'getOpacity', viewer.world.getItemAt(0), 'getOpacity');
done();
});
});

20
test/modules/dzitilesource.js
View File

@ -1,42 +1,48 @@
/*global module:true, test:true, equal:true, OpenSeadragon:true*/
/* global QUnit, testLog */
(function() {
module('DziTileSource', {
setup: function() {
QUnit.module('DziTileSource', {
beforeEach: function() {
testLog.reset();
}
});
function testImplicitTilesUrl(dziUrl, expected, msg) {
function testImplicitTilesUrl(assert, dziUrl, expected, msg) {
var source = new OpenSeadragon.DziTileSource();
var options = source.configure({
Image: {Size: {Width:0, Height: 0}}
}, 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(
assert,
'/path/my.dzi', '/path/my_files/',
'dzi extension should be stripped');
testImplicitTilesUrl(
assert,
'/path/my', '/path/my_files/',
'no extension should still produce _files path');
testImplicitTilesUrl(
assert,
'/my/', '/my_files/',
'no extension with trailing slash should preserve slash');
testImplicitTilesUrl(
assert,
'my.xml', 'my_files/',
'relative link should stay the same');
testImplicitTilesUrl(
assert,
'/p/foo.dzi?a=1&b=2', '/p/foo_files/',
'querystring in dzi url should be ignored after slashes');
testImplicitTilesUrl(
assert,
'/iiipsrv?DeepZoom=/path/my.dzi', '/iiipsrv?DeepZoom=/path/my_files/',
'querystring in dzi url should not be ignored before slashes');
testImplicitTilesUrl(
assert,
'/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');
});

2
test/modules/formats.js
View File

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

26
test/modules/imageloader.js
View File

@ -1,4 +1,4 @@
/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog */
/* global QUnit, $, testLog */
(function() {
var viewer,
@ -8,13 +8,13 @@
springStiffness: 100 // Faster animation = faster tests
};
module('ImageLoader', {
setup: function () {
var example = $('<div id="example"></div>').appendTo("#qunit-fixture");
QUnit.module('ImageLoader', {
beforeEach: function () {
$('<div id="example"></div>').appendTo("#qunit-fixture");
testLog.reset();
},
teardown: function () {
afterEach: function () {
if (viewer && viewer.close) {
viewer.close();
}
@ -25,19 +25,19 @@
// ----------
test('Default timeout', function() {
QUnit.test('Default timeout', function(assert) {
var actual,
expected = OpenSeadragon.DEFAULT_SETTINGS.timeout,
message,
options = OpenSeadragon.extend(true, baseOptions, {
imageLoaderLimit: 1
}),
}),
viewer = OpenSeadragon(options),
imageLoader = viewer.imageLoader;
message = 'ImageLoader timeout should be set to the default value of ' + expected + ' when none is specified';
actual = imageLoader.timeout;
equal(actual, expected, message);
assert.equal(actual, expected, message);
// Manually seize the ImageLoader
imageLoader.jobsInProgress = imageLoader.jobLimit;
@ -51,12 +51,12 @@
message = 'ImageJob should inherit the ImageLoader timeout value';
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,
expected = 123456,
message,
@ -69,7 +69,7 @@
message = 'ImageLoader timeout should be configurable';
actual = imageLoader.timeout;
equal(actual, expected, message);
assert.equal(actual, expected, message);
imageLoader.jobsInProgress = imageLoader.jobLimit;
imageLoader.addJob({
@ -82,7 +82,7 @@
message = 'ImageJob should inherit the ImageLoader timeout value';
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() {
module('Rectangle', {});
QUnit.module('Rectangle', {});
var precision = 0.000000001;
test('Constructor', function() {
QUnit.test('Constructor', function(assert) {
var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 5);
strictEqual(rect.x, 1, 'rect.x should be 1');
strictEqual(rect.y, 2, 'rect.y should be 2');
strictEqual(rect.width, 3, 'rect.width should be 3');
strictEqual(rect.height, 4, 'rect.height should be 4');
strictEqual(rect.degrees, 5, 'rect.degrees should be 5');
assert.strictEqual(rect.x, 1, 'rect.x should be 1');
assert.strictEqual(rect.y, 2, 'rect.y should be 2');
assert.strictEqual(rect.width, 3, 'rect.width should be 3');
assert.strictEqual(rect.height, 4, 'rect.height should be 4');
assert.strictEqual(rect.degrees, 5, 'rect.degrees should be 5');
rect = new OpenSeadragon.Rect();
strictEqual(rect.x, 0, 'rect.x should be 0');
strictEqual(rect.y, 0, 'rect.y should be 0');
strictEqual(rect.width, 0, 'rect.width should be 0');
strictEqual(rect.height, 0, 'rect.height should be 0');
strictEqual(rect.degrees, 0, 'rect.degrees should be 0');
assert.strictEqual(rect.x, 0, 'rect.x should be 0');
assert.strictEqual(rect.y, 0, 'rect.y should be 0');
assert.strictEqual(rect.width, 0, 'rect.width should be 0');
assert.strictEqual(rect.height, 0, 'rect.height should be 0');
assert.strictEqual(rect.degrees, 0, 'rect.degrees should be 0');
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');
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');
Util.assessNumericValue(2, rect.width, precision,
Util.assessNumericValue(assert, 2, rect.width, precision,
'rect.width should be 2');
Util.assessNumericValue(1, rect.height, precision,
Util.assessNumericValue(assert, 1, rect.height, precision,
'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);
Util.assessNumericValue(-Math.sqrt(2), rect.x, precision,
Util.assessNumericValue(assert, -Math.sqrt(2), rect.x, precision,
'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)');
Util.assessNumericValue(2, rect.width, precision,
Util.assessNumericValue(assert, 2, rect.width, precision,
'rect.width should be 2');
Util.assessNumericValue(1, rect.height, precision,
Util.assessNumericValue(assert, 1, rect.height, precision,
'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);
Util.assessNumericValue(0, rect.x, precision,
Util.assessNumericValue(assert, 0, rect.x, precision,
'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)');
Util.assessNumericValue(1, rect.width, precision,
Util.assessNumericValue(assert, 1, rect.width, precision,
'rect.width should be 1');
Util.assessNumericValue(1, rect.height, precision,
Util.assessNumericValue(assert, 1, rect.height, precision,
'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 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 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;
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.");
});
test('getBottomLeft', function() {
QUnit.test('getBottomLeft', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 3, 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;
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.");
});
test('getBottomRight', function() {
QUnit.test('getBottomRight', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 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;
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.");
rect.degrees = 90;
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.");
rect.degrees = 135;
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.");
});
test('getCenter', function() {
QUnit.test('getCenter', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 1, 1);
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;
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.");
rect.degrees = 90;
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.");
rect.degrees = 135;
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.");
});
test('times', function() {
QUnit.test('times', function(assert) {
var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 45);
var expected = new OpenSeadragon.Rect(2, 4, 6, 8, 45);
var actual = rect.times(2);
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect x2 rectangles.");
});
test('translate', function() {
QUnit.test('translate', function(assert) {
var rect = new OpenSeadragon.Rect(1, 2, 3, 4, 45);
var expected = new OpenSeadragon.Rect(2, 4, 3, 4, 45);
var actual = rect.translate(new OpenSeadragon.Point(1, 2));
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect translation.");
});
test('union', function() {
QUnit.test('union', function(assert) {
var rect1 = new OpenSeadragon.Rect(2, 2, 2, 3);
var rect2 = new OpenSeadragon.Rect(0, 1, 1, 1);
var expected = new OpenSeadragon.Rect(0, 1, 4, 4);
var actual = rect1.union(rect2);
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect union with horizontal rectangles.");
rect1 = new OpenSeadragon.Rect(0, -Math.sqrt(2), 2, 2, 45);
@ -157,30 +157,30 @@
3 + Math.sqrt(2),
2 + Math.sqrt(2));
actual = rect1.union(rect2);
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect union with non horizontal rectangles.");
});
test('intersection', function() {
QUnit.test('intersection', function(assert) {
var rect1 = new OpenSeadragon.Rect(2, 2, 2, 3);
var rect2 = new OpenSeadragon.Rect(0, 1, 1, 1);
var expected = null;
var actual = rect1.intersection(rect2);
equal(expected, actual,
assert.equal(expected, actual,
"Rectangle " + rect2 + " should not intersect " + rect1);
actual = rect2.intersection(rect1);
equal(expected, actual,
assert.equal(expected, actual,
"Rectangle " + rect1 + " should not intersect " + rect2);
rect1 = new OpenSeadragon.Rect(0, 0, 2, 1);
rect2 = new OpenSeadragon.Rect(1, 0, 2, 2);
expected = new OpenSeadragon.Rect(1, 0, 1, 1);
actual = rect1.intersection(rect2);
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect2 + " with " + rect1 + " should be " +
expected);
actual = rect2.intersection(rect1);
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect1 + " with " + rect2 + " should be " +
expected);
@ -188,11 +188,11 @@
rect2 = new OpenSeadragon.Rect(1, 1, 1, 1);
expected = new OpenSeadragon.Rect(1, 1, 1, 1);
actual = rect1.intersection(rect2);
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect2 + " with " + rect1 + " should be " +
expected);
actual = rect2.intersection(rect1);
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect1 + " with " + rect2 + " should be " +
expected);
@ -201,26 +201,26 @@
rect2 = new OpenSeadragon.Rect(0, 1, 1, 1);
expected = null;
actual = rect1.intersection(rect2);
equal(expected, actual,
assert.equal(expected, actual,
"Rectangle " + rect2 + " should not intersect " + rect1);
actual = rect2.intersection(rect1);
equal(expected, actual,
assert.equal(expected, actual,
"Rectangle " + rect1 + " should not intersect " + rect2);
rect1 = new OpenSeadragon.Rect(2, 0, 2, 3, 45);
rect2 = new OpenSeadragon.Rect(0, 1, 1, 1);
expected = new OpenSeadragon.Rect(0, 1, 1, 1);
actual = rect1.intersection(rect2);
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect2 + " with " + rect1 + " should be " +
expected);
actual = rect2.intersection(rect1);
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Intersection of " + rect1 + " with " + rect2 + " should be " +
expected);
});
test('rotate', function() {
QUnit.test('rotate', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 2, 1);
var expected = new OpenSeadragon.Rect(
@ -230,73 +230,73 @@
1,
45);
var actual = rect.rotate(-675);
Util.assertRectangleEquals(expected, actual, precision,
Util.assertRectangleEquals(assert, expected, actual, precision,
"Incorrect rectangle after rotation of -675deg around center.");
expected = new OpenSeadragon.Rect(0, 0, 2, 1, 33);
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.");
expected = new OpenSeadragon.Rect(0, 0, 2, 1, 101);
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.");
expected = new OpenSeadragon.Rect(0, 0, 2, 1, 187);
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.");
expected = new OpenSeadragon.Rect(0, 0, 2, 1, 300);
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.");
});
test('getBoundingBox', function() {
QUnit.test('getBoundingBox', function(assert) {
var rect = new OpenSeadragon.Rect(0, 0, 2, 3);
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.");
rect.degrees = 90;
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.");
rect.degrees = 180;
var expected = new OpenSeadragon.Rect(-2, -3, 2, 3);
Util.assertRectangleEquals(expected, rect.getBoundingBox(), precision,
expected = new OpenSeadragon.Rect(-2, -3, 2, 3);
Util.assertRectangleEquals(assert, expected, rect.getBoundingBox(), precision,
"Bounding box of rect rotated 180deg.");
rect.degrees = 270;
var expected = new OpenSeadragon.Rect(0, -2, 3, 2);
Util.assertRectangleEquals(expected, rect.getBoundingBox(), precision,
expected = new OpenSeadragon.Rect(0, -2, 3, 2);
Util.assertRectangleEquals(assert, expected, rect.getBoundingBox(), precision,
"Bounding box of rect rotated 270deg.");
});
test('containsPoint', function() {
QUnit.test('containsPoint', function(assert) {
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);
ok(rect.containsPoint(rect.getTopRight()),
assert.ok(rect.containsPoint(rect.getTopRight()),
'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);
ok(rect.containsPoint(rect.getBottomLeft()),
assert.ok(rect.containsPoint(rect.getBottomLeft()),
'Bottom left vertex should be inside ' + rect);
ok(rect.containsPoint(rect.getCenter()),
assert.ok(rect.containsPoint(rect.getCenter()),
'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);
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);
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);
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);
});

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() {
var viewer;
module('ReferenceStrip', {
setup: function () {
var example = $('<div id="example"></div>').appendTo("#qunit-fixture");
QUnit.module('ReferenceStrip', {
beforeEach: function () {
$('<div id="example"></div>').appendTo("#qunit-fixture");
testLog.reset();
},
teardown: function () {
afterEach: function () {
if (viewer && viewer.close) {
viewer.close();
}
@ -29,7 +29,8 @@
};
// ----------
asyncTest('basics', function() {
QUnit.test('basics', function(assert) {
var done = assert.async();
createViewer({
sequenceMode: true,
showReferenceStrip: true,
@ -39,8 +40,8 @@
]
});
ok(viewer.referenceStrip, 'referenceStrip exists');
start();
assert.ok(viewer.referenceStrip, 'referenceStrip exists');
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 () {
var originalNow;
var now;
module("spring", {
setup: function () {
QUnit.module("spring", {
beforeEach: function () {
now = 0;
originalNow = OpenSeadragon.now;
@ -14,39 +14,41 @@
return now;
};
},
teardown: function () {
afterEach: function () {
OpenSeadragon.now = originalNow;
}
});
asyncTest('regular spring', function() {
QUnit.test('regular spring', function(assert) {
var done = assert.async();
var spring = new OpenSeadragon.Spring({
initial: 5,
animationTime: 1,
springStiffness: 0.000001
});
equal(spring.current.value, 5, 'initial current value');
equal(spring.target.value, 5, 'initial target value');
assert.equal(spring.current.value, 5, 'initial current value');
assert.equal(spring.target.value, 5, 'initial target value');
spring.springTo(6);
equal(spring.current.value, 5, 'current value after springTo');
equal(spring.target.value, 6, 'target value after springTo');
assert.equal(spring.current.value, 5, 'current value after springTo');
assert.equal(spring.target.value, 6, 'target value after springTo');
now = 500;
spring.update();
Util.assessNumericValue(5.5, spring.current.value, 0.00001, 'current value after first update');
equal(spring.target.value, 6, 'target value after first update');
Util.assessNumericValue(assert, 5.5, spring.current.value, 0.00001, 'current value after first update');
assert.equal(spring.target.value, 6, 'target value after first update');
now = 1000;
spring.update();
equal(spring.current.value, 6, 'current value after second update');
equal(spring.target.value, 6, 'target value after second update');
assert.equal(spring.current.value, 6, 'current 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({
exponential: true,
initial: 1,
@ -54,24 +56,24 @@
springStiffness: 0.000001
});
equal(spring.current.value, 1, 'initial current value');
equal(spring.target.value, 1, 'initial target value');
assert.equal(spring.current.value, 1, 'initial current value');
assert.equal(spring.target.value, 1, 'initial target value');
spring.springTo(2);
equal(spring.current.value, 1, 'current value after springTo');
equal(spring.target.value, 2, 'target value after springTo');
assert.equal(spring.current.value, 1, 'current value after springTo');
assert.equal(spring.target.value, 2, 'target value after springTo');
now = 500;
spring.update();
Util.assessNumericValue(1.41421, spring.current.value, 0.00001, 'current value after first update');
equal(spring.target.value, 2, 'target value after first update');
Util.assessNumericValue(assert, 1.41421, spring.current.value, 0.00001, 'current value after first update');
assert.equal(spring.target.value, 2, 'target value after first update');
now = 1000;
spring.update();
equal(spring.current.value, 2, 'current value after second update');
equal(spring.target.value, 2, 'target value after second update');
assert.equal(spring.current.value, 2, 'current 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() {
// ----------
module('TileCache', {
setup: function () {
QUnit.module('TileCache', {
beforeEach: function () {
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 = {
raiseEvent: function() {}
};
@ -38,35 +40,36 @@
};
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({
tile: fakeTile0,
tiledImage: fakeTiledImage0
});
equal(cache.numTilesLoaded(), 1, 'tile count after cache');
assert.equal(cache.numTilesLoaded(), 1, 'tile count after cache');
cache.cacheTile({
tile: fakeTile1,
tiledImage: fakeTiledImage1
});
equal(cache.numTilesLoaded(), 2, 'tile count after second cache');
assert.equal(cache.numTilesLoaded(), 2, 'tile count after second cache');
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);
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 = {
raiseEvent: function() {}
};
@ -99,30 +102,30 @@
maxImageCacheCount: 1
});
equal(cache.numTilesLoaded(), 0, 'no tiles to begin with');
assert.equal(cache.numTilesLoaded(), 0, 'no tiles to begin with');
cache.cacheTile({
tile: fakeTile0,
tiledImage: fakeTiledImage0
});
equal(cache.numTilesLoaded(), 1, 'tile count after add');
assert.equal(cache.numTilesLoaded(), 1, 'tile count after add');
cache.cacheTile({
tile: fakeTile1,
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({
tile: fakeTile2,
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() {
var viewer;
module('TiledImage', {
setup: function() {
var example = $('<div id="example"></div>').appendTo("#qunit-fixture");
QUnit.module('TiledImage', {
beforeEach: function() {
$('<div id="example"></div>').appendTo("#qunit-fixture");
testLog.reset();
@ -15,7 +15,7 @@
springStiffness: 100 // Faster animation = faster tests
});
},
teardown: function() {
afterEach: function() {
if (viewer && 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();
equal(bounds.x, expected.x, message + ' x');
equal(bounds.y, expected.y, message + ' y');
equal(bounds.width, expected.width, message + ' width');
equal(bounds.height, expected.height, message + ' height');
assert.equal(bounds.x, expected.x, message + ' x');
assert.equal(bounds.y, expected.y, message + ' y');
assert.equal(bounds.width, expected.width, message + ' width');
assert.equal(bounds.height, expected.height, message + ' height');
};
// ----------
asyncTest('metrics', function() {
QUnit.test('metrics', function(assert) {
var done = assert.async();
var handlerCount = 0;
viewer.addHandler('open', function(event) {
var image = viewer.world.getItemAt(0);
var contentSize = image.getContentSize();
equal(contentSize.x, 500, 'contentSize.x');
equal(contentSize.y, 2000, 'contentSize.y');
assert.equal(contentSize.x, 500, 'contentSize.x');
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 viewportPoint = new OpenSeadragon.Point(10, 11);
var imagePoint = viewportPoint.minus(image.getBounds().getTopLeft()).times(scale);
propEqual(image.viewportToImageCoordinates(viewportPoint), imagePoint, 'viewportToImageCoordinates');
propEqual(image.imageToViewportCoordinates(imagePoint), viewportPoint, 'imageToViewportCoordinates');
assert.propEqual(image.viewportToImageCoordinates(viewportPoint), imagePoint, 'viewportToImageCoordinates');
assert.propEqual(image.imageToViewportCoordinates(imagePoint), viewportPoint, 'imageToViewportCoordinates');
var viewportRect = new OpenSeadragon.Rect(viewportPoint.x, viewportPoint.y, 6, 7);
var imageRect = new OpenSeadragon.Rect(imagePoint.x, imagePoint.y,
viewportRect.width * scale, viewportRect.height * scale);
propEqual(image.viewportToImageRectangle(viewportRect), imageRect, 'viewportToImageRectangle');
propEqual(image.imageToViewportRectangle(imageRect), viewportRect, 'imageToViewportRectangle');
assert.propEqual(image.viewportToImageRectangle(viewportRect), imageRect, 'viewportToImageRectangle');
assert.propEqual(image.imageToViewportRectangle(imageRect), viewportRect, 'imageToViewportRectangle');
image.addHandler('bounds-change', function boundsChangeHandler(event) {
image.removeHandler('bounds-change', boundsChangeHandler);
@ -65,16 +66,16 @@
});
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);
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);
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');
start();
assert.equal(handlerCount, 1, 'correct number of handlers called');
done();
});
viewer.open({
@ -86,25 +87,26 @@
});
// ----------
asyncTest('animation', function() {
QUnit.test('animation', function(assert) {
var done = assert.async();
viewer.addHandler("open", function() {
var image = viewer.world.getItemAt(0);
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(), new OpenSeadragon.Rect(0, 0, 1, 1), 'target 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));
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(), new OpenSeadragon.Rect(1, 2, 1, 1), 'target bounds after position');
assert.propEqual(image.getBounds(true), new OpenSeadragon.Rect(0, 0, 1, 1), 'current bounds after position');
image.setWidth(3);
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(), new OpenSeadragon.Rect(1, 2, 3, 3), 'target 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.removeHandler('animation-finish', animationHandler);
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');
start();
assert.propEqual(image.getBounds(), new OpenSeadragon.Rect(1, 2, 3, 3), 'target bounds after animation');
assert.propEqual(image.getBounds(true), new OpenSeadragon.Rect(1, 2, 3, 3), 'current bounds after animation');
done();
});
});
@ -112,55 +114,56 @@
});
// ----------
asyncTest('update', function() {
QUnit.test('update', function(assert) {
var done = assert.async();
var handlerCount = 0;
viewer.addHandler('open', function(event) {
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.removeHandler('update-level', updateLevelHandler);
handlerCount++;
equal(event.eventSource, viewer, 'sender of update-level event was viewer');
equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
ok('havedrawn' in event, 'update-level event includes havedrawn');
ok('level' in event, 'update-level event includes level');
ok('opacity' in event, 'update-level event includes opacity');
ok('visibility' in event, 'update-level event includes visibility');
ok('topleft' in event, 'update-level event includes topleft');
ok('bottomright' in event, 'update-level event includes bottomright');
ok('currenttime' in event, 'update-level event includes currenttime');
ok('best' in event, 'update-level event includes best');
assert.equal(event.eventSource, viewer, 'sender of update-level event was viewer');
assert.equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
assert.ok('havedrawn' in event, 'update-level event includes havedrawn');
assert.ok('level' in event, 'update-level event includes level');
assert.ok('opacity' in event, 'update-level event includes opacity');
assert.ok('visibility' in event, 'update-level event includes visibility');
assert.ok('topleft' in event, 'update-level event includes topleft');
assert.ok('bottomright' in event, 'update-level event includes bottomright');
assert.ok('currenttime' in event, 'update-level event includes currenttime');
assert.ok('best' in event, 'update-level event includes best');
});
viewer.addHandler('update-tile', function updateTileHandler(event) {
viewer.removeHandler('update-tile', updateTileHandler);
handlerCount++;
equal(event.eventSource, viewer, 'sender of update-tile event was viewer');
equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
ok(event.tile, 'update-tile event includes tile');
assert.equal(event.eventSource, viewer, 'sender of update-tile event was viewer');
assert.equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
assert.ok(event.tile, 'update-tile event includes tile');
});
viewer.addHandler('tile-drawing', function tileDrawingHandler(event) {
viewer.removeHandler('tile-drawing', tileDrawingHandler);
handlerCount++;
equal(event.eventSource, viewer, 'sender of tile-drawing event was viewer');
equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
ok(event.tile, 'tile-drawing event includes a tile');
ok(event.context, 'tile-drawing event includes a context');
ok(event.rendered, 'tile-drawing event includes a rendered');
assert.equal(event.eventSource, viewer, 'sender of tile-drawing event was viewer');
assert.equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
assert.ok(event.tile, 'tile-drawing event includes a tile');
assert.ok(event.context, 'tile-drawing event includes a context');
assert.ok(event.rendered, 'tile-drawing event includes a rendered');
});
viewer.addHandler('tile-drawn', function tileDrawnHandler(event) {
viewer.removeHandler('tile-drawn', tileDrawnHandler);
handlerCount++;
equal(event.eventSource, viewer, 'sender of tile-drawn event was viewer');
equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
ok(event.tile, 'tile-drawn event includes tile');
assert.equal(event.eventSource, viewer, 'sender of tile-drawn event was viewer');
assert.equal(event.tiledImage, image, 'tiledImage of update-level event is correct');
assert.ok(event.tile, 'tile-drawn event includes tile');
equal(handlerCount, 4, 'correct number of handlers called');
start();
assert.equal(handlerCount, 4, 'correct number of handlers called');
done();
});
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.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();
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.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();
equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles after destroy');
start();
assert.equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles after destroy');
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');
});
// ----------
asyncTest('clip', function() {
QUnit.test('clip', function(assert) {
var done = assert.async();
var clip = new OpenSeadragon.Rect(100, 100, 800, 800);
viewer.addHandler('open', function() {
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);
equal(image.getClip(), null, 'clip is cleared');
assert.equal(image.getClip(), null, 'clip is cleared');
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) {
var homeBounds = viewer.viewport.getHomeBounds();
var canvasClip = viewer.drawer
.viewportToDrawerRectangle(homeBounds);
var precision = 0.00000001;
Util.assertRectangleEquals(rect, canvasClip, precision,
Util.assertRectangleEquals(assert, rect, canvasClip, precision,
'clipping should be ' + canvasClip);
start();
done();
});
});
@ -223,15 +228,16 @@
});
// ----------
asyncTest('clip-change event', function() {
expect(0);
QUnit.test('clip-change event', function(assert) {
var done = assert.async();
assert.expect(0);
var clip = new OpenSeadragon.Rect(100, 100, 800, 800);
viewer.addHandler('open', function() {
var image = viewer.world.getItemAt(0);
image.addOnceHandler('clip-change', function() {
image.addOnceHandler('clip-change', function() {
start();
done();
});
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);
viewer.addHandler('open', function() {
var image = viewer.world.getItemAt(0);
var bounds = image.getClippedBounds();
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.');
image = viewer.world.getItemAt(1);
bounds = image.getClippedBounds();
expectedBounds = new OpenSeadragon.Rect(1, 2, 2, 2);
propEqual(bounds, expectedBounds,
assert.propEqual(bounds, expectedBounds,
'getClipBounds should work when no clipping set.');
start();
done();
});
viewer.open([{
@ -278,15 +285,15 @@
});
// ----------
asyncTest('opacity', function() {
QUnit.test('opacity', function(assert) {
var done = assert.async();
function testDefaultOpacity() {
viewer.removeHandler('open', testDefaultOpacity);
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);
strictEqual(image.getOpacity(), 1, 'opacity is set correctly');
assert.strictEqual(image.getOpacity(), 1, 'opacity is set correctly');
viewer.addHandler('open', testTileSourceOpacity);
viewer.open({
@ -298,12 +305,12 @@
function testTileSourceOpacity() {
viewer.removeHandler('open', testTileSourceOpacity);
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);
strictEqual(image.getOpacity(), 0, 'opacity is set correctly');
assert.strictEqual(image.getOpacity(), 0, 'opacity is set correctly');
start();
done();
}
viewer.addHandler('open', testDefaultOpacity);
@ -315,20 +322,20 @@
});
// ----------
asyncTest('rotation', function() {
QUnit.test('rotation', function(assert) {
var done = assert.async();
function testDefaultRotation() {
var image = viewer.world.getItemAt(0);
strictEqual(image.getRotation(true), 0, 'image has default current rotation');
strictEqual(image.getRotation(false), 0, 'image has default target rotation');
assert.strictEqual(image.getRotation(true), 0, 'image has default current rotation');
assert.strictEqual(image.getRotation(false), 0, 'image has default target rotation');
image.setRotation(400);
strictEqual(image.getRotation(true), 0, 'current rotation is not changed');
strictEqual(image.getRotation(false), 400, 'target rotation is set correctly');
assert.strictEqual(image.getRotation(true), 0, 'current rotation is not changed');
assert.strictEqual(image.getRotation(false), 400, 'target rotation is set correctly');
image.setRotation(200, true);
strictEqual(image.getRotation(true), 200, 'current rotation is set correctly');
strictEqual(image.getRotation(false), 200, 'target rotation is set correctly');
assert.strictEqual(image.getRotation(true), 200, 'current rotation is set correctly');
assert.strictEqual(image.getRotation(false), 200, 'target rotation is set correctly');
viewer.addOnceHandler('open', testTileSourceRotation);
viewer.open({
@ -339,9 +346,9 @@
function testTileSourceRotation() {
var image = viewer.world.getItemAt(0);
strictEqual(image.getRotation(true), -60, 'image has correct current rotation');
strictEqual(image.getRotation(false), -60, 'image has correct target rotation');
start();
assert.strictEqual(image.getRotation(true), -60, 'image has correct current rotation');
assert.strictEqual(image.getRotation(false), -60, 'image has correct target rotation');
done();
}
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) {
ok(actual.equals(expected), message + ' should be ' +
assert.ok(actual.equals(expected), message + ' should be ' +
expected.toString() + ', found ' + actual.toString());
}
@ -386,7 +393,7 @@
actualBounds = wideImage.getBounds(true);
expectedBounds = new OpenSeadragon.Rect(0, 1.75, 1, 0.25);
assertRectEquals(actualBounds, expectedBounds, 'Wide image bounds');
start();
done();
});
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) {
ok(actual.equals(expected), message + ' should be ' +
assert.ok(actual.equals(expected), message + ' should be ' +
expected.toString() + ', found ' + actual.toString());
}
@ -421,7 +428,7 @@
actualBounds = wideImage.getBounds(true);
expectedBounds = new OpenSeadragon.Rect(0, 1.75, 1, 0.25);
assertRectEquals(actualBounds, expectedBounds, 'Wide image bounds');
start();
done();
});
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) {
ok(actual.equals(expected), message + ' should be ' +
assert.ok(actual.equals(expected), message + ' should be ' +
expected.toString() + ', found ' + actual.toString());
}
@ -467,7 +474,7 @@
actualBounds = wideImage.getBounds(true);
expectedBounds = new OpenSeadragon.Rect(1, 1, 16, 4);
assertRectEquals(actualBounds, expectedBounds, 'Wide image bounds');
start();
done();
});
viewer.open([{
@ -488,27 +495,28 @@
});
// ----------
asyncTest('fullyLoaded', function() {
QUnit.test('fullyLoaded', function(assert) {
var done = assert.async();
viewer.addHandler('open', function openHandler() {
viewer.removeHandler('open', openHandler);
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 fullyLoadedChangeHandler = function(event) {
if (count === 0) {
equal(event.fullyLoaded, true, 'event includes true fullyLoaded property');
equal(image.getFullyLoaded(), true, 'image is fully loaded after event');
assert.equal(event.fullyLoaded, true, 'event includes true fullyLoaded property');
assert.equal(image.getFullyLoaded(), true, 'image is fully loaded after event');
viewer.viewport.zoomBy(5, null, true);
} else if (count === 1) {
equal(event.fullyLoaded, false, 'event includes false fullyLoaded property');
equal(image.getFullyLoaded(), false, 'image is not fully loaded after zoom');
assert.equal(event.fullyLoaded, false, 'event includes false fullyLoaded property');
assert.equal(image.getFullyLoaded(), false, 'image is not fully loaded after zoom');
} else {
image.removeHandler('fully-loaded-change', fullyLoadedChangeHandler);
equal(image.getFullyLoaded(), true, 'image is once again fully loaded');
start();
assert.equal(image.getFullyLoaded(), true, 'image is once again fully loaded');
done();
}
count++;
@ -529,7 +537,7 @@
};
}
test('_getCornerTiles without wrapping', function() {
QUnit.test('_getCornerTiles without wrapping', function(assert) {
var tiledImageMock = {
wrapHorizontal: false,
wrapVertical: false,
@ -548,10 +556,10 @@
function assertCornerTiles(topLeftBound, bottomRightBound,
expectedTopLeft, expectedBottomRight) {
var cornerTiles = _getCornerTiles(11, topLeftBound, bottomRightBound);
ok(cornerTiles.topLeft.equals(expectedTopLeft),
assert.ok(cornerTiles.topLeft.equals(expectedTopLeft),
'Top left tile should be ' + expectedTopLeft.toString() +
' found ' + cornerTiles.topLeft.toString());
ok(cornerTiles.bottomRight.equals(expectedBottomRight),
assert.ok(cornerTiles.bottomRight.equals(expectedBottomRight),
'Bottom right tile should be ' + expectedBottomRight.toString() +
' found ' + cornerTiles.bottomRight.toString());
}
@ -561,7 +569,7 @@
new OpenSeadragon.Point(1, 10 / 15),
new OpenSeadragon.Point(0, 0),
new OpenSeadragon.Point(7, 6)
)
);
// Floating point errors should be handled
assertCornerTiles(
@ -569,17 +577,17 @@
new OpenSeadragon.Point(1 + 1e-14, 10 / 15 + 1e-14),
new OpenSeadragon.Point(0, 0),
new OpenSeadragon.Point(7, 6)
)
);
assertCornerTiles(
new OpenSeadragon.Point(0.3, 0.5),
new OpenSeadragon.Point(0.5, 0.6),
new OpenSeadragon.Point(2, 5),
new OpenSeadragon.Point(3, 6)
)
);
});
test('_getCornerTiles with horizontal wrapping', function() {
QUnit.test('_getCornerTiles with horizontal wrapping', function(assert) {
var tiledImageMock = {
wrapHorizontal: true,
wrapVertical: false,
@ -598,10 +606,10 @@
function assertCornerTiles(topLeftBound, bottomRightBound,
expectedTopLeft, expectedBottomRight) {
var cornerTiles = _getCornerTiles(11, topLeftBound, bottomRightBound);
ok(cornerTiles.topLeft.equals(expectedTopLeft),
assert.ok(cornerTiles.topLeft.equals(expectedTopLeft),
'Top left tile should be ' + expectedTopLeft.toString() +
' found ' + cornerTiles.topLeft.toString());
ok(cornerTiles.bottomRight.equals(expectedBottomRight),
assert.ok(cornerTiles.bottomRight.equals(expectedBottomRight),
'Bottom right tile should be ' + expectedBottomRight.toString() +
' found ' + cornerTiles.bottomRight.toString());
}
@ -611,24 +619,24 @@
new OpenSeadragon.Point(1, 10 / 15),
new OpenSeadragon.Point(0, 0),
new OpenSeadragon.Point(8, 6)
)
);
assertCornerTiles(
new OpenSeadragon.Point(-1, 0),
new OpenSeadragon.Point(0.5, 10 / 15 + 1e-14),
new OpenSeadragon.Point(-8, 0),
new OpenSeadragon.Point(3, 6)
)
);
assertCornerTiles(
new OpenSeadragon.Point(1.3, 0.5),
new OpenSeadragon.Point(1.5, 0.6),
new OpenSeadragon.Point(10, 5),
new OpenSeadragon.Point(11, 6)
)
);
});
test('_getCornerTiles with vertical wrapping', function() {
QUnit.test('_getCornerTiles with vertical wrapping', function(assert) {
var tiledImageMock = {
wrapHorizontal: false,
wrapVertical: true,
@ -647,10 +655,10 @@
function assertCornerTiles(topLeftBound, bottomRightBound,
expectedTopLeft, expectedBottomRight) {
var cornerTiles = _getCornerTiles(11, topLeftBound, bottomRightBound);
ok(cornerTiles.topLeft.equals(expectedTopLeft),
assert.ok(cornerTiles.topLeft.equals(expectedTopLeft),
'Top left tile should be ' + expectedTopLeft.toString() +
' found ' + cornerTiles.topLeft.toString());
ok(cornerTiles.bottomRight.equals(expectedBottomRight),
assert.ok(cornerTiles.bottomRight.equals(expectedBottomRight),
'Bottom right tile should be ' + expectedBottomRight.toString() +
' found ' + cornerTiles.bottomRight.toString());
}
@ -660,21 +668,21 @@
new OpenSeadragon.Point(1, 10 / 15),
new OpenSeadragon.Point(0, 0),
new OpenSeadragon.Point(7, 7)
)
);
assertCornerTiles(
new OpenSeadragon.Point(0, -10 / 15 / 2),
new OpenSeadragon.Point(0.5, 0.5),
new OpenSeadragon.Point(0, -4),
new OpenSeadragon.Point(3, 5)
)
);
assertCornerTiles(
new OpenSeadragon.Point(0, 10 / 15 + 0.1),
new OpenSeadragon.Point(0.3, 10 / 15 + 0.3),
new OpenSeadragon.Point(0, 7),
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() {
module('TileSource', {
setup: function() {
QUnit.module('TileSource', {
beforeEach: function() {
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();
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.getTileWidth(), 0, "getTileWidth() 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,
source = new OpenSeadragon.TileSource({
tileSize: tileSize
});
equal(source.tileSize, undefined, "tileSize should not be set on the tileSource");
equal(source.getTileWidth(), tileSize, "getTileWidth() should equal tileSize");
equal(source.getTileHeight(), tileSize, "getTileHeight() should equal tileSize");
assert.equal(source.tileSize, undefined, "tileSize should not be set on the tileSource");
assert.equal(source.getTileWidth(), tileSize, "getTileWidth() 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,
tileHeight = 512,
source = new OpenSeadragon.TileSource({
@ -35,20 +35,20 @@
tileHeight: tileHeight
});
equal(source._tileWidth, tileWidth, "tileWidth option should set _tileWidth");
equal(source._tileHeight, tileHeight, "tileHeight option should set _tileHeight");
equal(source.tileWidth, undefined, "tileWidth should be renamed _tileWidth");
equal(source.tileHeight, undefined, "tileHeight should be renamed _tileHeight");
equal(source.getTileWidth(), tileWidth, "getTileWidth() should equal tileWidth");
equal(source.getTileHeight(), tileHeight, "getTileHeight() should equal tileHeight");
assert.equal(source._tileWidth, tileWidth, "tileWidth option should set _tileWidth");
assert.equal(source._tileHeight, tileHeight, "tileHeight option should set _tileHeight");
assert.equal(source.tileWidth, undefined, "tileWidth should be renamed _tileWidth");
assert.equal(source.tileHeight, undefined, "tileHeight should be renamed _tileHeight");
assert.equal(source.getTileWidth(), tileWidth, "getTileWidth() should equal tileWidth");
assert.equal(source.getTileHeight(), tileHeight, "getTileHeight() should equal tileHeight");
});
test('getTileSize() deprecation', function() {
QUnit.test('getTileSize() deprecation', function(assert) {
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({
width: 1500,
height: 1000,
@ -57,11 +57,11 @@
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) {
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() +
" should be tile " + expected.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() {
var viewer;
module('TileSourceCollection', {
setup: function () {
QUnit.module('TileSourceCollection', {
beforeEach: function () {
testLog.reset();
},
teardown: function () {
afterEach: function () {
}
});
// ----------
asyncTest('deprecation', function() {
Util.testDeprecation(OpenSeadragon, 'TileSourceCollection');
start();
QUnit.test('deprecation', function(assert) {
var done = assert.async();
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() {
var viewer;
module('World', {
setup: function () {
var example = $('<div id="example"></div>').appendTo("#qunit-fixture");
QUnit.module('World', {
beforeEach: function () {
$('<div id="example"></div>').appendTo("#qunit-fixture");
testLog.reset();
@ -15,7 +15,7 @@
springStiffness: 100 // Faster animation = faster tests
});
},
teardown: function () {
afterEach: function () {
if (viewer && viewer.close) {
viewer.close();
}
@ -25,54 +25,56 @@
});
// ----------
var checkBounds = function(expected, message) {
var checkBounds = function(assert, expected, message) {
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() {
ok(viewer.world, 'World exists');
QUnit.test('adding a tiled image', function(assert) {
var done = assert.async();
assert.ok(viewer.world, 'World exists');
viewer.world.addHandler('add-item', function(event) {
ok(event, 'add-item handler received event data');
equal(event.eventSource, viewer.world, 'sender of add-item event was world');
ok(event.item, 'add-item event includes item');
equal(viewer.world.getItemCount(), 1, 'there is now 1 item');
equal(event.item, viewer.world.getItemAt(0), 'item is accessible via getItemAt');
equal(viewer.world.getIndexOfItem(event.item), 0, 'item index is 0');
start();
assert.ok(event, 'add-item handler received event data');
assert.equal(event.eventSource, viewer.world, 'sender of add-item event was world');
assert.ok(event.item, 'add-item event includes item');
assert.equal(viewer.world.getItemCount(), 1, 'there is now 1 item');
assert.equal(event.item, viewer.world.getItemAt(0), 'item is accessible via getItemAt');
assert.equal(viewer.world.getIndexOfItem(event.item), 0, 'item index is 0');
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');
});
// ----------
asyncTest('metrics', function() {
QUnit.test('metrics', function(assert) {
var done = assert.async();
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;
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.removeHandler('metrics-change', metricsChangeHandler);
ok(event, 'metrics-change handler received event data');
equal(event.eventSource, viewer.world, 'sender of metrics-change event was world');
checkBounds(new OpenSeadragon.Rect(0, 0, 7, 12), 'bounds after position');
assert.ok(event, 'metrics-change handler received event data');
assert.equal(event.eventSource, viewer.world, 'sender of metrics-change event was world');
checkBounds(assert, new OpenSeadragon.Rect(0, 0, 7, 12), 'bounds after position');
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));
});
checkBounds(new OpenSeadragon.Rect(0, 0, 1, 1), 'default bounds');
equal(viewer.world.getContentFactor(), 1, 'default content factor');
checkBounds(assert, new OpenSeadragon.Rect(0, 0, 1, 1), 'default bounds');
assert.equal(viewer.world.getContentFactor(), 1, 'default content factor');
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;
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 item1 = viewer.world.getItemAt(1);
viewer.world.addHandler('item-index-change', function(event) {
handlerCount++;
ok(event, 'item-index-change handler received event data');
equal(event.eventSource, viewer.world, 'sender of item-index-change event was world');
equal(event.item, item0, 'item-index-change event includes correct item');
equal(event.newIndex, 1, 'item-index-change event includes correct newIndex');
equal(event.previousIndex, 0, 'item-index-change event includes correct previousIndex');
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.ok(event, 'item-index-change handler received event data');
assert.equal(event.eventSource, viewer.world, 'sender of item-index-change event was world');
assert.equal(event.item, item0, 'item-index-change event includes correct item');
assert.equal(event.newIndex, 1, 'item-index-change event includes correct newIndex');
assert.equal(event.previousIndex, 0, 'item-index-change event includes correct previousIndex');
assert.equal(viewer.world.getItemAt(0), item1, 'item1 is now at index 0');
assert.equal(viewer.world.getItemAt(1), item0, 'item0 is now at index 1');
});
viewer.world.setItemIndex(item0, 1);
@ -110,11 +113,11 @@
viewer.world.addHandler('remove-item', function removeHandler(event) {
viewer.world.removeHandler('remove-item', removeHandler);
handlerCount++;
ok(event, 'remove-item handler received event data');
equal(event.eventSource, viewer.world, 'sender of remove-item event was world');
equal(event.item, item1, 'remove-item event includes correct item');
equal(viewer.world.getItemCount(), 2, 'after removal, only two items remain');
equal(viewer.world.getItemAt(0), item0, 'item0 is now at index 0');
assert.ok(event, 'remove-item handler received event data');
assert.equal(event.eventSource, viewer.world, 'sender of remove-item event was world');
assert.equal(event.item, item1, 'remove-item event includes correct item');
assert.equal(viewer.world.getItemCount(), 2, 'after removal, only two items remain');
assert.equal(viewer.world.getItemAt(0), item0, 'item0 is now at index 0');
});
viewer.world.removeItem(item1);
@ -124,17 +127,17 @@
removeCount++;
if (removeCount === 2) {
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();
equal(handlerCount, 3, 'correct number of handlers called');
start();
assert.equal(handlerCount, 3, 'correct number of handlers called');
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',
@ -144,11 +147,12 @@
});
// ----------
asyncTest('draw', function() {
QUnit.test('draw', function(assert) {
var done = assert.async();
var handlerCount = 0;
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.removeHandler('update-level', updateHandler);
@ -157,34 +161,36 @@
viewer.world.draw();
equal(handlerCount, 1, 'correct number of handlers called');
start();
assert.equal(handlerCount, 1, 'correct number of handlers called');
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');
});
// ----------
asyncTest('resetItems', function() {
QUnit.test('resetItems', function(assert) {
var done = assert.async();
viewer.addHandler('tile-drawn', function 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();
equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles after reset');
start();
assert.equal(viewer.tileCache.numTilesLoaded(), 0, 'no tiles after reset');
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');
});
// ----------
asyncTest('arrange', function() {
QUnit.test('arrange', function(assert) {
var done = assert.async();
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({
layout: 'horizontal',
@ -193,7 +199,7 @@
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({
layout: 'horizontal',
@ -202,7 +208,7 @@
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({
layout: 'vertical',
@ -211,7 +217,7 @@
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({
layout: 'horizontal',
@ -221,7 +227,7 @@
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({
layout: 'vertical',
@ -231,9 +237,9 @@
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([

8
test/test.html
View File

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