From 52a275808ff465b46f7e8a44d9dc84ec8dd4c343 Mon Sep 17 00:00:00 2001 From: nein09 Date: Mon, 4 Dec 2017 18:01:30 -0800 Subject: [PATCH] Multi-image and overlays tests --- test/modules/multi-image.js | 121 +++++++-------- test/modules/overlays.js | 290 +++++++++++++++++++----------------- test/test.html | 4 +- 3 files changed, 215 insertions(+), 200 deletions(-) diff --git a/test/modules/multi-image.js b/test/modules/multi-image.js index 1dc9cbca..8fab4eee 100644 --- a/test/modules/multi-image.js +++ b/test/modules/multi-image.js @@ -1,10 +1,10 @@ -/* global module, asyncTest, $, ok, equal, notEqual, start, test, Util, testLog, expect */ +/* global QUnit, $,testLog */ ( function() { var viewer; - module( 'Multi-Image', { - setup: function() { + QUnit.module( 'Multi-Image', { + beforeEach: function() { $( '
' ).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(); } @@ -26,10 +26,11 @@ } ); // ---------- - asyncTest( 'Multi-image operations', function() { - expect( 24 ); + QUnit.test( 'Multi-image operations', function(assert) { + var done = assert.async(); + assert.expect( 24 ); viewer.addHandler( "open", function( ) { - equal( 1, viewer.world.getItemCount( ), + assert.equal( 1, viewer.world.getItemCount( ), "One item should be present after opening." ); var options = { tileSource: { @@ -45,41 +46,41 @@ viewer.world.addHandler( "add-item", function addFirstItemHandler( event ) { viewer.world.removeHandler( "add-item", addFirstItemHandler ); var item1 = event.item; - equal( viewer.world.getItemCount( ), 2, + assert.equal( viewer.world.getItemCount( ), 2, "2 items should be present after adding a item." ); - equal( viewer.world.getIndexOfItem( item1 ), 1, + assert.equal( viewer.world.getIndexOfItem( item1 ), 1, "The first added item should have a index of 1" ); - equal( viewer.world.getItemAt( 1 ), item1, + assert.equal( viewer.world.getItemAt( 1 ), item1, "The item at index 1 should be the first added item." ); viewer.addTiledImage( options ); viewer.world.addHandler( "add-item", function addSecondItemHandler( event ) { viewer.world.removeHandler( "add-item", addSecondItemHandler ); var item2 = event.item; - equal( viewer.world.getItemCount( ), 3, + assert.equal( viewer.world.getItemCount( ), 3, "3 items should be present after adding a second item." ); - equal( viewer.world.getIndexOfItem( item2 ), 2, + assert.equal( viewer.world.getIndexOfItem( item2 ), 2, "If not specified, a item should be added with the highest index." ); - equal( viewer.world.getItemAt( 2 ), item2, + assert.equal( viewer.world.getItemAt( 2 ), item2, "The item at index 2 should be the second added item." ); viewer.world.addHandler( "item-index-change", function itemIndexChangedHandler( event ) { viewer.world.removeHandler( "item-index-change", itemIndexChangedHandler ); - equal( event.item, item2, + assert.equal( event.item, item2, "The item which changed index should be item2" ); - equal( event.previousIndex, 2, "Previous index should be 2." ); - equal( event.newIndex, 1, "New index should be 1." ); + assert.equal( event.previousIndex, 2, "Previous index should be 2." ); + assert.equal( event.newIndex, 1, "New index should be 1." ); }); viewer.world.setItemIndex( item2, 1 ); - equal( viewer.world.getIndexOfItem( item2 ), 1, + assert.equal( viewer.world.getIndexOfItem( item2 ), 1, "Item2 index should be 1 after setItemIndex." ); - equal( viewer.world.getIndexOfItem( item1 ), 2, + assert.equal( viewer.world.getIndexOfItem( item1 ), 2, "Item1 index should be 2 after setItemIndex." ); - equal( viewer.world.getItemAt( 1 ), item2, + assert.equal( viewer.world.getItemAt( 1 ), item2, "The item at index 1 should be item2." ); - equal( viewer.world.getItemAt( 2 ), item1, + assert.equal( viewer.world.getItemAt( 2 ), item1, "The item at index 2 should be item1." ); options.index = 2; @@ -88,11 +89,11 @@ viewer.world.addHandler( "add-item", function addThirdItemHandler( event ) { viewer.world.removeHandler( "add-item", addThirdItemHandler ); var item3 = event.item; - equal( viewer.world.getItemCount( ), 4, + assert.equal( viewer.world.getItemCount( ), 4, "4 items should be present after adding a third item." ); - equal( viewer.world.getIndexOfItem( item3 ), 2, + assert.equal( viewer.world.getIndexOfItem( item3 ), 2, "Item 3 should be added with index 2." ); - equal( viewer.world.getIndexOfItem( item2 ), 1, + assert.equal( viewer.world.getIndexOfItem( item2 ), 1, "Item 2 should stay at index 1." ); options.index = 2; @@ -101,26 +102,26 @@ viewer.world.addHandler( "add-item", function replaceAddItemHandler( event ) { viewer.world.removeHandler( "add-item", replaceAddItemHandler ); var item4 = event.item; - equal( viewer.world.getItemCount( ), 4, + assert.equal( viewer.world.getItemCount( ), 4, "4 items should still be present after replacing the second item." ); - equal( viewer.world.getIndexOfItem( item4 ), 2, + assert.equal( viewer.world.getIndexOfItem( item4 ), 2, "Item 4 should be added with index 2." ); - equal( viewer.world.getIndexOfItem( item3 ), -1, + assert.equal( viewer.world.getIndexOfItem( item3 ), -1, "Item 3 should be at index -1." ); viewer.world.addHandler( "remove-item", function removeItemHandler( event ) { viewer.world.removeHandler( "remove-item", removeItemHandler ); - equal( item2, event.item, "Removed item should be item2." ); + assert.equal( item2, event.item, "Removed item should be item2." ); - equal( viewer.world.getIndexOfItem( item1 ), 2, + assert.equal( viewer.world.getIndexOfItem( item1 ), 2, "Item 1 should be at index 2." ); - equal( viewer.world.getIndexOfItem( item2 ), -1, + assert.equal( viewer.world.getIndexOfItem( item2 ), -1, "Item 2 should be at index -1." ); - equal( viewer.world.getIndexOfItem( item4 ), 1, + assert.equal( viewer.world.getIndexOfItem( item4 ), 1, "Item 4 should be at index 1." ); - start(); + done(); }); viewer.world.removeItem( item2 ); @@ -133,7 +134,8 @@ }); // ---------- - asyncTest( 'Sequences as items', function() { + QUnit.test( 'Sequences as items', function(assert) { + var done = assert.async(); var options = { tileSource: [{ type: 'legacy-image-pyramid', @@ -158,9 +160,9 @@ viewer.addHandler( "add-item-failed", function addItemFailedHandler( event ) { viewer.removeHandler( "add-item-failed", addItemFailedHandler ); - equal( event.message, "[Viewer.addTiledImage] Sequences can not be added; add them one at a time instead." ); - equal( event.options, options, "Item failed event should give the options." ); - start(); + assert.equal( event.message, "[Viewer.addTiledImage] Sequences can not be added; add them one at a time instead." ); + assert.equal( event.options, options, "Item failed event should give the options." ); + done(); } ); viewer.addTiledImage( options ); @@ -169,13 +171,14 @@ }); // ---------- - asyncTest('items are added in order', function() { + QUnit.test('items are added in order', function(assert) { + var done = assert.async(); viewer.addHandler('open', function(event) { - equal(viewer.world.getItemAt(0).getContentSize().y, 2000, 'first image is tall'); - equal(viewer.world.getItemAt(0).getBounds().width, 4, 'first image has 4 width'); - equal(viewer.world.getItemAt(1).getContentSize().x, 2000, 'second image is wide'); - equal(viewer.world.getItemAt(1).getBounds().width, 2, 'second image has 2 width'); - start(); + assert.equal(viewer.world.getItemAt(0).getContentSize().y, 2000, 'first image is tall'); + assert.equal(viewer.world.getItemAt(0).getBounds().width, 4, 'first image has 4 width'); + assert.equal(viewer.world.getItemAt(1).getContentSize().x, 2000, 'second image is wide'); + assert.equal(viewer.world.getItemAt(1).getBounds().width, 2, 'second image has 2 width'); + done(); }); viewer.open([ @@ -189,15 +192,16 @@ ]); }); - asyncTest('Viewer.addSimpleImage', function() { + QUnit.test('Viewer.addSimpleImage', function(assert) { + var done = assert.async(); viewer.addHandler("open", function openHandler() { viewer.removeHandler("open", openHandler); viewer.world.addHandler('add-item', function itemAdded(event) { viewer.world.removeHandler('add-item', itemAdded); - equal(event.item.opacity, 0.5, + assert.equal(event.item.opacity, 0.5, 'Opacity option should be set when using addSimpleImage'); - start(); + done(); }); viewer.addSimpleImage({ @@ -208,7 +212,8 @@ viewer.open('/test/data/testpattern.dzi'); }); - asyncTest('Transparent image on top of others', function() { + QUnit.test('Transparent image on top of others', function(assert) { + var done = assert.async(); viewer.open('/test/data/testpattern.dzi'); var density = OpenSeadragon.pixelDensityRatio; @@ -222,10 +227,10 @@ // Pixel 250,250 will be in the hole of the A var expectedVal = getPixelValue(imageData, 250 * density, 250 * density); - notEqual(expectedVal.r, 0, 'Red channel should not be 0'); - notEqual(expectedVal.g, 0, 'Green channel should not be 0'); - notEqual(expectedVal.b, 0, 'Blue channel should not be 0'); - notEqual(expectedVal.a, 0, 'Alpha channel should not be 0'); + assert.notEqual(expectedVal.r, 0, 'Red channel should not be 0'); + assert.notEqual(expectedVal.g, 0, 'Green channel should not be 0'); + assert.notEqual(expectedVal.b, 0, 'Blue channel should not be 0'); + assert.notEqual(expectedVal.a, 0, 'Alpha channel should not be 0'); viewer.addSimpleImage({ url: '/test/data/A.png', @@ -235,22 +240,22 @@ var imageData = viewer.drawer.context.getImageData(0, 0, 500 * density, 500 * density); var actualVal = getPixelValue(imageData, 250 * density, 250 * density); - equal(actualVal.r, expectedVal.r, + assert.equal(actualVal.r, expectedVal.r, 'Red channel should not change in transparent part of the A'); - equal(actualVal.g, expectedVal.g, + assert.equal(actualVal.g, expectedVal.g, 'Green channel should not change in transparent part of the A'); - equal(actualVal.b, expectedVal.b, + assert.equal(actualVal.b, expectedVal.b, 'Blue channel should not change in transparent part of the A'); - equal(actualVal.a, expectedVal.a, + assert.equal(actualVal.a, expectedVal.a, 'Alpha channel should not change in transparent part of the A'); var onAVal = getPixelValue(imageData, 333 * density, 250 * density); - equal(onAVal.r, 0, 'Red channel should be null on the A'); - equal(onAVal.g, 0, 'Green channel should be null on the A'); - equal(onAVal.b, 0, 'Blue channel should be null on the A'); - equal(onAVal.a, 255, 'Alpha channel should be 255 on the A'); + assert.equal(onAVal.r, 0, 'Red channel should be null on the A'); + assert.equal(onAVal.g, 0, 'Green channel should be null on the A'); + assert.equal(onAVal.b, 0, 'Blue channel should be null on the A'); + assert.equal(onAVal.a, 255, 'Alpha channel should be 255 on the A'); - start(); + done(); }); } }); diff --git a/test/modules/overlays.js b/test/modules/overlays.js index 76e91272..3a7a8877 100644 --- a/test/modules/overlays.js +++ b/test/modules/overlays.js @@ -1,12 +1,12 @@ -/* global QUnit, module, Util, $, console, test, asyncTest, start, ok, equal, testLog */ +/* global QUnit, Util, $, console, testLog */ (function() { var viewer; // jQuery.position can give results quite different than what set in style.left var epsilon = 1; - module("Overlays", { - setup: function() { + QUnit.module("Overlays", { + beforeEach: function() { var example = $('
').appendTo("#qunit-fixture"); var fixedOverlay = $('
').appendTo(example); fixedOverlay.width(70); @@ -14,7 +14,7 @@ testLog.reset(); }, - teardown: function() { + afterEach: function() { resetTestVariables(); } }); @@ -53,8 +53,8 @@ } } - asyncTest('Overlays via viewer options', function() { - + QUnit.test('Overlays via viewer options', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -73,8 +73,8 @@ function openHandler() { viewer.removeHandler('open', openHandler); - equal(viewer.overlays.length, 1, "Global overlay should be added."); - equal(viewer.currentOverlays.length, 1, "Global overlay should be open."); + assert.equal(viewer.overlays.length, 1, "Global overlay should be added."); + assert.equal(viewer.currentOverlays.length, 1, "Global overlay should be open."); viewer.addHandler('open', openPageHandler); viewer.goToPage(1); @@ -83,8 +83,8 @@ function openPageHandler() { viewer.removeHandler('open', openPageHandler); - equal(viewer.overlays.length, 1, "Global overlay should stay after page switch."); - equal(viewer.currentOverlays.length, 1, "Global overlay should re-open after page switch."); + assert.equal(viewer.overlays.length, 1, "Global overlay should stay after page switch."); + assert.equal(viewer.currentOverlays.length, 1, "Global overlay should re-open after page switch."); viewer.addHandler('close', closeHandler); viewer.close(); @@ -93,15 +93,15 @@ function closeHandler() { viewer.removeHandler('close', closeHandler); - equal(viewer.overlays.length, 1, "Global overlay should not be removed on close."); - equal(viewer.currentOverlays.length, 0, "Global overlay should be closed on close."); + assert.equal(viewer.overlays.length, 1, "Global overlay should not be removed on close."); + assert.equal(viewer.currentOverlays.length, 0, "Global overlay should be closed on close."); - start(); + done(); } }); - asyncTest('Page Overlays via viewer options', function() { - + QUnit.test('Page Overlays via viewer options', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -144,8 +144,8 @@ function openHandler() { viewer.removeHandler('open', openHandler); - equal(viewer.overlays.length, 0, "No global overlay should be added."); - equal(viewer.currentOverlays.length, 1, "Page overlay should be open."); + assert.equal(viewer.overlays.length, 0, "No global overlay should be added."); + assert.equal(viewer.currentOverlays.length, 1, "Page overlay should be open."); viewer.addHandler('open', openPageHandler); viewer.goToPage(1); @@ -154,8 +154,8 @@ function openPageHandler() { viewer.removeHandler('open', openPageHandler); - equal(viewer.overlays.length, 0, "No global overlay should be added after page switch."); - equal(viewer.currentOverlays.length, 0, "No page overlay should be opened after page switch."); + assert.equal(viewer.overlays.length, 0, "No global overlay should be added after page switch."); + assert.equal(viewer.currentOverlays.length, 0, "No page overlay should be opened after page switch."); viewer.addHandler('close', closeHandler); viewer.close(); @@ -164,15 +164,15 @@ function closeHandler() { viewer.removeHandler('close', closeHandler); - equal(viewer.overlays.length, 0, "No global overlay should be added on close."); - equal(viewer.currentOverlays.length, 0, "Page overlay should be closed on close."); + assert.equal(viewer.overlays.length, 0, "No global overlay should be added on close."); + assert.equal(viewer.currentOverlays.length, 0, "Page overlay should be closed on close."); - start(); + done(); } }); - asyncTest('Overlays via addOverlay method', function() { - + QUnit.test('Overlays via addOverlay method', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -184,14 +184,14 @@ function openHandler() { viewer.removeHandler('open', openHandler); - equal(viewer.overlays.length, 0, "No global overlay should be added."); - equal(viewer.currentOverlays.length, 0, "No overlay should be open."); + assert.equal(viewer.overlays.length, 0, "No global overlay should be added."); + assert.equal(viewer.currentOverlays.length, 0, "No overlay should be open."); var rect = new OpenSeadragon.Rect(0.1, 0.1, 0.1, 0.1); var overlay = $("
").prop("id", "overlay").get(0); viewer.addOverlay(overlay, rect); - equal(viewer.overlays.length, 0, "No manual overlay should be added as global overlay."); - equal(viewer.currentOverlays.length, 1, "A manual overlay should be open."); + assert.equal(viewer.overlays.length, 0, "No manual overlay should be added as global overlay."); + assert.equal(viewer.currentOverlays.length, 1, "A manual overlay should be open."); viewer.addHandler('open', openPageHandler); viewer.goToPage(1); @@ -200,8 +200,8 @@ function openPageHandler() { viewer.removeHandler('open', openPageHandler); - equal(viewer.overlays.length, 0, "No global overlay should be added after page switch."); - equal(viewer.currentOverlays.length, 0, "Manual overlay should be removed after page switch."); + assert.equal(viewer.overlays.length, 0, "No global overlay should be added after page switch."); + assert.equal(viewer.currentOverlays.length, 0, "Manual overlay should be removed after page switch."); viewer.addHandler('close', closeHandler); viewer.close(); @@ -210,16 +210,16 @@ function closeHandler() { viewer.removeHandler('close', closeHandler); - equal(viewer.overlays.length, 0, "No global overlay should be added on close."); - equal(viewer.currentOverlays.length, 0, "Manual overlay should be removed on close."); + assert.equal(viewer.overlays.length, 0, "No global overlay should be added on close."); + assert.equal(viewer.currentOverlays.length, 0, "Manual overlay should be removed on close."); - start(); + done(); } }); - asyncTest('Overlays size in pixels', function() { - + QUnit.test('Overlays size in pixels', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -245,31 +245,31 @@ var expPosition = viewport.imageToViewerElementCoordinates( new OpenSeadragon.Point(13, 120)); var actPosition = $("#overlay").position(); - Util.assessNumericValue(actPosition.left, expPosition.x, epsilon, + Util.assessNumericValue(assert, actPosition.left, expPosition.x, epsilon, "X position mismatch " + contextMessage); - Util.assessNumericValue(actPosition.top, expPosition.y, epsilon, + Util.assessNumericValue(assert, actPosition.top, expPosition.y, epsilon, "Y position mismatch " + contextMessage); var zoom = viewport.viewportToImageZoom(viewport.getZoom(true)); var expectedWidth = 124 * zoom; var expectedHeight = 132 * zoom; - Util.assessNumericValue($("#overlay").width(), expectedWidth, epsilon, + Util.assessNumericValue(assert, $("#overlay").width(), expectedWidth, epsilon, "Width mismatch " + contextMessage); - Util.assessNumericValue($("#overlay").height(), expectedHeight, epsilon, + Util.assessNumericValue(assert, $("#overlay").height(), expectedHeight, epsilon, "Height mismatch " + contextMessage); expPosition = viewport.imageToViewerElementCoordinates( new OpenSeadragon.Point(400, 500)); actPosition = $("#fixed-overlay").position(); - Util.assessNumericValue(actPosition.left, expPosition.x, epsilon, + Util.assessNumericValue(assert, actPosition.left, expPosition.x, epsilon, "Fixed overlay X position mismatch " + contextMessage); - Util.assessNumericValue(actPosition.top, expPosition.y, epsilon, + Util.assessNumericValue(assert, actPosition.top, expPosition.y, epsilon, "Fixed overlay Y position mismatch " + contextMessage); - Util.assessNumericValue($("#fixed-overlay").width(), 70, epsilon, + Util.assessNumericValue(assert, $("#fixed-overlay").width(), 70, epsilon, "Fixed overlay width mismatch " + contextMessage); - Util.assessNumericValue($("#fixed-overlay").height(), 60, epsilon, + Util.assessNumericValue(assert, $("#fixed-overlay").height(), 60, epsilon, "Fixed overlay height mismatch " + contextMessage); } @@ -283,15 +283,15 @@ viewer.viewport.goHome(); waitForViewer(function() { checkOverlayPosition("after goHome using image coordinates"); - start(); + done(); }); }); }); }); - asyncTest('Overlays size in points', function() { - + QUnit.test('Overlays size in points', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -317,30 +317,30 @@ var expPosition = viewport.viewportToViewerElementCoordinates( new OpenSeadragon.Point(0.2, 0.1)); var actPosition = $("#overlay").position(); - Util.assessNumericValue(actPosition.left, expPosition.x, epsilon, + Util.assessNumericValue(assert, actPosition.left, expPosition.x, epsilon, "X position mismatch " + contextMessage); - Util.assessNumericValue(actPosition.top, expPosition.y, epsilon, + Util.assessNumericValue(assert, actPosition.top, expPosition.y, epsilon, "Y position mismatch " + contextMessage); var expectedSize = viewport.deltaPixelsFromPoints( new OpenSeadragon.Point(0.5, 0.1)); - Util.assessNumericValue($("#overlay").width(), expectedSize.x, epsilon, + Util.assessNumericValue(assert, $("#overlay").width(), expectedSize.x, epsilon, "Width mismatch " + contextMessage); - Util.assessNumericValue($("#overlay").height(), expectedSize.y, epsilon, + Util.assessNumericValue(assert, $("#overlay").height(), expectedSize.y, epsilon, "Height mismatch " + contextMessage); expPosition = viewport.viewportToViewerElementCoordinates( new OpenSeadragon.Point(0.5, 0.6)); actPosition = $("#fixed-overlay").position(); - Util.assessNumericValue(actPosition.left, expPosition.x, epsilon, + Util.assessNumericValue(assert, actPosition.left, expPosition.x, epsilon, "Fixed overlay X position mismatch " + contextMessage); - Util.assessNumericValue(actPosition.top, expPosition.y, epsilon, + Util.assessNumericValue(assert, actPosition.top, expPosition.y, epsilon, "Fixed overlay Y position mismatch " + contextMessage); - Util.assessNumericValue($("#fixed-overlay").width(), 70, epsilon, + Util.assessNumericValue(assert, $("#fixed-overlay").width(), 70, epsilon, "Fixed overlay width mismatch " + contextMessage); - Util.assessNumericValue($("#fixed-overlay").height(), 60, epsilon, + Util.assessNumericValue(assert, $("#fixed-overlay").height(), 60, epsilon, "Fixed overlay height mismatch " + contextMessage); } @@ -354,15 +354,15 @@ viewer.viewport.goHome(); waitForViewer(function() { checkOverlayPosition("after goHome using viewport coordinates"); - start(); + done(); }); }); }); }); - asyncTest('Overlays placement', function() { - + QUnit.test('Overlays placement', function(assert) { + var done = assert.async(); var scalableOverlayLocation = new OpenSeadragon.Rect(0.2, 0.1, 0.5, 0.1); var fixedOverlayLocation = new OpenSeadragon.Point(0.5, 0.6); @@ -393,9 +393,9 @@ var expPosition = viewport.viewportToViewerElementCoordinates( new OpenSeadragon.Point(0.2, 0.1)); var actPosition = $("#overlay").position(); - Util.assessNumericValue(actPosition.left, expPosition.x, epsilon, + Util.assessNumericValue(assert, actPosition.left, expPosition.x, epsilon, "X position mismatch " + contextMessage); - Util.assessNumericValue(actPosition.top, expPosition.y, epsilon, + Util.assessNumericValue(assert, actPosition.top, expPosition.y, epsilon, "Y position mismatch " + contextMessage); } @@ -406,9 +406,9 @@ new OpenSeadragon.Point(0.5, 0.6)) .plus(expectedOffset); var actPosition = $("#fixed-overlay").position(); - Util.assessNumericValue(actPosition.left, expPosition.x, epsilon, + Util.assessNumericValue(assert, actPosition.left, expPosition.x, epsilon, "Fixed overlay X position mismatch " + contextMessage); - Util.assessNumericValue(actPosition.top, expPosition.y, epsilon, + Util.assessNumericValue(assert, actPosition.top, expPosition.y, epsilon, "Fixed overlay Y position mismatch " + contextMessage); } @@ -439,7 +439,7 @@ checkFixedOverlayPosition(new OpenSeadragon.Point(-70, -60), "with BOTTOM_RIGHT placement."); - start(); + done(); }, 100); }, 100); @@ -447,8 +447,8 @@ }); }); - asyncTest('Overlays placement and resizing check', function() { - + QUnit.test('Overlays placement and resizing check', function(assert) { + var done = assert.async(); var fixedOverlayLocation = new OpenSeadragon.Point(0.5, 0.6); viewer = OpenSeadragon({ @@ -472,9 +472,9 @@ new OpenSeadragon.Point(0.5, 0.6)) .plus(expectedOffset); var actPosition = $("#fixed-overlay").position(); - Util.assessNumericValue(actPosition.left, expPosition.x, epsilon, + Util.assessNumericValue(assert, actPosition.left, expPosition.x, epsilon, "Fixed overlay X position mismatch " + contextMessage); - Util.assessNumericValue(actPosition.top, expPosition.y, epsilon, + Util.assessNumericValue(assert, actPosition.top, expPosition.y, epsilon, "Fixed overlay Y position mismatch " + contextMessage); } @@ -496,14 +496,14 @@ $("#fixed-overlay").width(70); $("#fixed-overlay").height(60); - start(); + done(); }, 100); }); }); - asyncTest('Overlays placement and no resizing check', function() { - + QUnit.test('Overlays placement and no resizing check', function(assert) { + var done = assert.async(); var fixedOverlayLocation = new OpenSeadragon.Point(0.5, 0.6); viewer = OpenSeadragon({ @@ -527,9 +527,9 @@ new OpenSeadragon.Point(0.5, 0.6)) .plus(expectedOffset); var actPosition = $("#fixed-overlay").position(); - Util.assessNumericValue(actPosition.left, expPosition.x, epsilon, + Util.assessNumericValue(assert, actPosition.left, expPosition.x, epsilon, "Fixed overlay X position mismatch " + contextMessage); - Util.assessNumericValue(actPosition.top, expPosition.y, epsilon, + Util.assessNumericValue(assert, actPosition.top, expPosition.y, epsilon, "Fixed overlay Y position mismatch " + contextMessage); } @@ -551,16 +551,17 @@ $("#fixed-overlay").width(70); $("#fixed-overlay").height(60); - start(); + done(); }, 100); }); }); // ---------- - asyncTest('overlays appear immediately', function() { - equal($('#immediate-overlay0').length, 0, 'overlay 0 does not exist'); - equal($('#immediate-overlay1').length, 0, 'overlay 1 does not exist'); + QUnit.test('overlays appear immediately', function(assert) { + var done = assert.async(); + assert.equal($('#immediate-overlay0').length, 0, 'overlay 0 does not exist'); + assert.equal($('#immediate-overlay1').length, 0, 'overlay 1 does not exist'); viewer = OpenSeadragon({ id: 'example-overlays', @@ -575,7 +576,7 @@ }); viewer.addHandler('open', function() { - equal($('#immediate-overlay0').length, 1, 'overlay 0 exists'); + assert.equal($('#immediate-overlay0').length, 1, 'overlay 0 exists'); viewer.addOverlay({ x: 0, @@ -583,13 +584,14 @@ id: "immediate-overlay1" }); - equal($('#immediate-overlay1').length, 1, 'overlay 1 exists'); - start(); + assert.equal($('#immediate-overlay1').length, 1, 'overlay 1 exists'); + done(); }); }); // ---------- - asyncTest('Overlay scaled horizontally only', function() { + QUnit.test('Overlay scaled horizontally only', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -615,16 +617,17 @@ waitForViewer(function() { var newWidth = $("#horizontally-scaled-overlay").width(); var newHeight = $("#horizontally-scaled-overlay").height(); - equal(newWidth, width * zoom, "Width should be scaled."); - equal(newHeight, height, "Height should not be scaled."); + assert.equal(newWidth, width * zoom, "Width should be scaled."); + assert.equal(newHeight, height, "Height should not be scaled."); - start(); + done(); }); }); }); // ---------- - asyncTest('Overlay scaled vertically only', function() { + QUnit.test('Overlay scaled vertically only', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -650,16 +653,17 @@ waitForViewer(function() { var newWidth = $("#vertically-scaled-overlay").width(); var newHeight = $("#vertically-scaled-overlay").height(); - equal(newWidth, width, "Width should not be scaled."); - equal(newHeight, height * zoom, "Height should be scaled."); + assert.equal(newWidth, width, "Width should not be scaled."); + assert.equal(newHeight, height * zoom, "Height should be scaled."); - start(); + done(); }); }); }); // ---------- - asyncTest('Overlay.getBounds', function() { + QUnit.test('Overlay.getBounds', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -713,7 +717,7 @@ var actualBounds = viewer.getOverlayById("fully-scaled-overlay") .getBounds(viewer.viewport); var expectedBounds = new OpenSeadragon.Rect(0, 0, 1, 1); - ok(expectedBounds.equals(actualBounds), + assert.ok(expectedBounds.equals(actualBounds), "The fully scaled overlay should have bounds " + expectedBounds + " but found " + actualBounds); @@ -722,7 +726,7 @@ .getBounds(viewer.viewport); expectedBounds = new OpenSeadragon.Rect( 0, 0.5 - notScaledSize.y / 2, 1, notScaledSize.y); - ok(expectedBounds.equals(actualBounds), + assert.ok(expectedBounds.equals(actualBounds), "The horizontally scaled overlay should have bounds " + expectedBounds + " but found " + actualBounds); @@ -730,7 +734,7 @@ .getBounds(viewer.viewport); expectedBounds = new OpenSeadragon.Rect( 0, 0, notScaledSize.x, 1); - ok(expectedBounds.equals(actualBounds), + assert.ok(expectedBounds.equals(actualBounds), "The vertically scaled overlay should have bounds " + expectedBounds + " but found " + actualBounds); @@ -738,16 +742,17 @@ .getBounds(viewer.viewport); expectedBounds = new OpenSeadragon.Rect( 1 - notScaledSize.x, 0, notScaledSize.x, notScaledSize.y); - ok(expectedBounds.equals(actualBounds), + assert.ok(expectedBounds.equals(actualBounds), "The not scaled overlay should have bounds " + expectedBounds + " but found " + actualBounds); - start(); + done(); }); }); // ---------- - asyncTest('Fully scaled overlay rotation mode NO_ROTATION', function() { + QUnit.test('Fully scaled overlay rotation mode NO_ROTATION', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -775,32 +780,33 @@ new OpenSeadragon.Point(1, 1)) .minus(expectedSize); var actualPosition = $overlay.position(); - Util.assessNumericValue(actualPosition.left, expectedPosition.x, epsilon, + Util.assessNumericValue(assert, actualPosition.left, expectedPosition.x, epsilon, "Scaled overlay position.x should adjust to rotation."); - Util.assessNumericValue(actualPosition.top, expectedPosition.y, epsilon, + Util.assessNumericValue(assert, actualPosition.top, expectedPosition.y, epsilon, "Scaled overlay position.y should adjust to rotation."); var actualWidth = $overlay.width(); var actualHeight = $overlay.height(); - Util.assessNumericValue(actualWidth, expectedSize.x, epsilon, + Util.assessNumericValue(assert, actualWidth, expectedSize.x, epsilon, "Scaled overlay width should not adjust to rotation."); - Util.assessNumericValue(actualHeight, expectedSize.y, epsilon, + Util.assessNumericValue(assert, actualHeight, expectedSize.y, epsilon, "Scaled overlay height should not adjust to rotation."); var actualBounds = viewer.getOverlayById("fully-scaled-overlay") .getBounds(viewport); var expectedBounds = new OpenSeadragon.Rect(0, 0, 1, 1) .rotate(-45, new OpenSeadragon.Point(1, 1)); - ok(expectedBounds.equals(actualBounds), + assert.ok(expectedBounds.equals(actualBounds), "The fully scaled overlay should have bounds " + expectedBounds + " but found " + actualBounds); - start(); + done(); }); }); // ---------- - asyncTest('Horizontally scaled overlay rotation mode NO_ROTATION', function() { + QUnit.test('Horizontally scaled overlay rotation mode NO_ROTATION', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -836,16 +842,16 @@ new OpenSeadragon.Point(0.5, 0.5)) .minus(new OpenSeadragon.Point(expectedWidth / 2, notScaledHeight / 2)); var actualPosition = $overlay.position(); - Util.assessNumericValue(actualPosition.left, expectedPosition.x, epsilon, + Util.assessNumericValue(assert, actualPosition.left, expectedPosition.x, epsilon, "Horizontally scaled overlay position.x should adjust to rotation."); - Util.assessNumericValue(actualPosition.top, expectedPosition.y, epsilon, + Util.assessNumericValue(assert, actualPosition.top, expectedPosition.y, epsilon, "Horizontally scaled overlay position.y should adjust to rotation."); var actualWidth = $overlay.width(); var actualHeight = $overlay.height(); - Util.assessNumericValue(actualWidth, expectedWidth, epsilon, + Util.assessNumericValue(assert, actualWidth, expectedWidth, epsilon, "Horizontally scaled overlay width should not adjust to rotation."); - Util.assessNumericValue(actualHeight, notScaledHeight, epsilon, + Util.assessNumericValue(assert, actualHeight, notScaledHeight, epsilon, "Horizontally scaled overlay height should not adjust to rotation."); var actualBounds = viewer.getOverlayById("horizontally-scaled-overlay") @@ -853,16 +859,17 @@ var expectedBounds = new OpenSeadragon.Rect( 0, 0.5 - notScaledSize.y / 2, 1, notScaledSize.y) .rotate(-45, new OpenSeadragon.Point(0.5, 0.5)); - ok(expectedBounds.equals(actualBounds), + assert.ok(expectedBounds.equals(actualBounds), "The horizontally scaled overlay should have bounds " + expectedBounds + " but found " + actualBounds); - start(); + done(); }); }); // ---------- - asyncTest('Vertically scaled overlay rotation mode NO_ROTATION', function() { + QUnit.test('Vertically scaled overlay rotation mode NO_ROTATION', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -898,16 +905,16 @@ new OpenSeadragon.Point(0, 0.5)) .minus(new OpenSeadragon.Point(0, expectedHeight / 2)); var actualPosition = $overlay.position(); - Util.assessNumericValue(actualPosition.left, expectedPosition.x, epsilon, + Util.assessNumericValue(assert, actualPosition.left, expectedPosition.x, epsilon, "Vertically scaled overlay position.x should adjust to rotation."); - Util.assessNumericValue(actualPosition.top, expectedPosition.y, epsilon, + Util.assessNumericValue(assert, actualPosition.top, expectedPosition.y, epsilon, "Vertically scaled overlay position.y should adjust to rotation."); var actualWidth = $overlay.width(); var actualHeight = $overlay.height(); - Util.assessNumericValue(actualWidth, notScaledWidth, epsilon, + Util.assessNumericValue(assert, actualWidth, notScaledWidth, epsilon, "Vertically scaled overlay width should not adjust to rotation."); - Util.assessNumericValue(actualHeight, expectedHeight, epsilon, + Util.assessNumericValue(assert, actualHeight, expectedHeight, epsilon, "Vertically scaled overlay height should not adjust to rotation."); var actualBounds = viewer.getOverlayById("vertically-scaled-overlay") @@ -915,16 +922,17 @@ var expectedBounds = new OpenSeadragon.Rect( 0, 0, notScaledSize.x, 1) .rotate(-45, new OpenSeadragon.Point(0, 0.5)); - ok(expectedBounds.equals(actualBounds), + assert.ok(expectedBounds.equals(actualBounds), "The vertically scaled overlay should have bounds " + expectedBounds + " but found " + actualBounds); - start(); + done(); }); }); // ---------- - asyncTest('Not scaled overlay rotation mode NO_ROTATION', function() { + QUnit.test('Not scaled overlay rotation mode NO_ROTATION', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -958,16 +966,16 @@ new OpenSeadragon.Point(1, 0)) .minus(new OpenSeadragon.Point(notScaledWidth, 0)); var actualPosition = $overlay.position(); - Util.assessNumericValue(actualPosition.left, expectedPosition.x, epsilon, + Util.assessNumericValue(assert, actualPosition.left, expectedPosition.x, epsilon, "Not scaled overlay position.x should adjust to rotation."); - Util.assessNumericValue(actualPosition.top, expectedPosition.y, epsilon, + Util.assessNumericValue(assert, actualPosition.top, expectedPosition.y, epsilon, "Not scaled overlay position.y should adjust to rotation."); var actualWidth = $overlay.width(); var actualHeight = $overlay.height(); - Util.assessNumericValue(actualWidth, notScaledWidth, epsilon, + Util.assessNumericValue(assert, actualWidth, notScaledWidth, epsilon, "Not scaled overlay width should not adjust to rotation."); - Util.assessNumericValue(actualHeight, notScaledHeight, epsilon, + Util.assessNumericValue(assert, actualHeight, notScaledHeight, epsilon, "Not scaled overlay height should not adjust to rotation."); var actualBounds = viewer.getOverlayById("not-scaled-overlay") @@ -975,16 +983,17 @@ var expectedBounds = new OpenSeadragon.Rect( 1 - notScaledSize.x, 0, notScaledSize.x, notScaledSize.y) .rotate(-45, new OpenSeadragon.Point(1, 0)); - ok(expectedBounds.equals(actualBounds), + assert.ok(expectedBounds.equals(actualBounds), "Not scaled overlay should have bounds " + expectedBounds + " but found " + actualBounds); - start(); + done(); }); }); // ---------- - asyncTest('Fully scaled overlay rotation mode BOUNDING_BOX', function() { + QUnit.test('Fully scaled overlay rotation mode BOUNDING_BOX', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -1009,16 +1018,16 @@ var expectedRect = viewport.viewportToViewerElementRectangle( new OpenSeadragon.Rect(0, 0, 1, 1)).getBoundingBox(); var actualPosition = $overlay.position(); - Util.assessNumericValue(actualPosition.left, expectedRect.x, epsilon, + Util.assessNumericValue(assert, actualPosition.left, expectedRect.x, epsilon, "Scaled overlay position.x should adjust to rotation."); - Util.assessNumericValue(actualPosition.top, expectedRect.y, epsilon, + Util.assessNumericValue(assert, actualPosition.top, expectedRect.y, epsilon, "Scaled overlay position.y should adjust to rotation."); var actualWidth = $overlay.width(); var actualHeight = $overlay.height(); - Util.assessNumericValue(actualWidth, expectedRect.width, epsilon, + Util.assessNumericValue(assert, actualWidth, expectedRect.width, epsilon, "Scaled overlay width should not adjust to rotation."); - Util.assessNumericValue(actualHeight, expectedRect.height, epsilon, + Util.assessNumericValue(assert, actualHeight, expectedRect.height, epsilon, "Scaled overlay height should not adjust to rotation."); var actualBounds = viewer.getOverlayById("fully-scaled-overlay") @@ -1026,23 +1035,24 @@ var expectedBounds = new OpenSeadragon.Rect( 0.5, -0.5, Math.sqrt(2), Math.sqrt(2), 45); var boundsEpsilon = 0.000001; - Util.assessNumericValue(actualBounds.x, expectedBounds.x, boundsEpsilon, + Util.assessNumericValue(assert, actualBounds.x, expectedBounds.x, boundsEpsilon, "The fully scaled overlay should have adjusted bounds.x"); - Util.assessNumericValue(actualBounds.y, expectedBounds.y, boundsEpsilon, + Util.assessNumericValue(assert, actualBounds.y, expectedBounds.y, boundsEpsilon, "The fully scaled overlay should have adjusted bounds.y"); - Util.assessNumericValue(actualBounds.width, expectedBounds.width, boundsEpsilon, + Util.assessNumericValue(assert, actualBounds.width, expectedBounds.width, boundsEpsilon, "The fully scaled overlay should have adjusted bounds.width"); - Util.assessNumericValue(actualBounds.height, expectedBounds.height, boundsEpsilon, + Util.assessNumericValue(assert, actualBounds.height, expectedBounds.height, boundsEpsilon, "The fully scaled overlay should have adjusted bounds.height"); - Util.assessNumericValue(actualBounds.degrees, expectedBounds.degrees, boundsEpsilon, + Util.assessNumericValue(assert, actualBounds.degrees, expectedBounds.degrees, boundsEpsilon, "The fully scaled overlay should have adjusted bounds.degrees"); - start(); + done(); }); }); // ---------- - asyncTest('Fully scaled overlay rotation mode EXACT', function() { + QUnit.test('Fully scaled overlay rotation mode EXACT', function(assert) { + var done = assert.async(); viewer = OpenSeadragon({ id: 'example-overlays', prefixUrl: '/build/openseadragon/images/', @@ -1073,16 +1083,16 @@ var actualStyle = $overlay.get(0).style; var left = Number(actualStyle.left.replace("px", "")); var top = Number(actualStyle.top.replace("px", "")); - Util.assessNumericValue(left, expectedPosition.x, epsilon, + Util.assessNumericValue(assert, left, expectedPosition.x, epsilon, "Scaled overlay position.x should adjust to rotation."); - Util.assessNumericValue(top, expectedPosition.y, epsilon, + Util.assessNumericValue(assert, top, expectedPosition.y, epsilon, "Scaled overlay position.y should adjust to rotation."); var actualWidth = $overlay.width(); var actualHeight = $overlay.height(); - Util.assessNumericValue(actualWidth, expectedSize.x, epsilon, + Util.assessNumericValue(assert, actualWidth, expectedSize.x, epsilon, "Scaled overlay width should not adjust to rotation."); - Util.assessNumericValue(actualHeight, expectedSize.y, epsilon, + Util.assessNumericValue(assert, actualHeight, expectedSize.y, epsilon, "Scaled overlay height should not adjust to rotation."); var transformOriginProp = OpenSeadragon.getCssPropertyWithVendorPrefix( @@ -1091,19 +1101,19 @@ 'transform'); var transformOrigin = actualStyle[transformOriginProp]; // Some browsers replace "right bottom" by "100% 100%" - ok(transformOrigin.match(/(100% 100%)|(right bottom)/), + assert.ok(transformOrigin.match(/(100% 100%)|(right bottom)/), "Transform origin should be right bottom. Got: " + transformOrigin); - equal(actualStyle[transformProp], "rotate(45deg)", + assert.equal(actualStyle[transformProp], "rotate(45deg)", "Transform should be rotate(45deg)."); var actualBounds = viewer.getOverlayById("fully-scaled-overlay") .getBounds(viewport); var expectedBounds = new OpenSeadragon.Rect(0, 0, 1, 1); - ok(expectedBounds.equals(actualBounds), + assert.ok(expectedBounds.equals(actualBounds), "The fully scaled overlay should have bounds " + expectedBounds + " but found " + actualBounds); - start(); + done(); }); }); })(); diff --git a/test/test.html b/test/test.html index 05cd4665..7de79323 100644 --- a/test/test.html +++ b/test/test.html @@ -28,9 +28,9 @@ -