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

Temporarily disable tests - discussing design.

Browse Source
This commit is contained in:
Aiosa 2025-01-07 19:57:37 +01:00
parent 6315662078
commit 426700b1c6
1 changed files with 193 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

386
test/modules/tilecache.js
View File

@ -314,200 +314,200 @@
}); });
//Tile API and cache interaction //Tile API and cache interaction
QUnit.test('Tile: basic rendering & test setup', function(test) { // QUnit.test('Tile: basic rendering & test setup', function(test) {
const done = test.async(); // const done = test.async();
//
// const tileCache = viewer.tileCache;
// const drawer = viewer.drawer;
//
// let testTileCalled = false;
// drawer.testEvents.addHandler('test-tile', e => {
// testTileCalled = true;
// test.ok(e.dataToDraw, "Tile data is ready to be drawn");
// });
//
// viewer.addHandler('open', async () => {
// await viewer.waitForFinishedJobsForTest();
// await sleep(1); // necessary to make space for a draw call
//
// test.ok(viewer.world.getItemAt(0).source instanceof OpenSeadragon.EmptyTestT_ATileSource, "Tests are done with empty test source type T_A.");
// test.ok(viewer.world.getItemAt(1).source instanceof OpenSeadragon.EmptyTestT_ATileSource, "Tests are done with empty test source type T_A.");
// test.ok(testTileCalled, "Drawer tested at least one tile.");
//
// test.ok(typeAtoB > 1, "At least one conversion was triggered.");
// test.equal(typeAtoB, typeBtoC, "A->B = B->C, since we need to move all data to T_C for the drawer.");
//
// for (let tile of tileCache._tilesLoaded) {
// const cache = tile.getCache();
// test.equal(cache.type, T_A, "Cache data was not affected, the drawer uses internal cache.");
//
// const internalCache = cache.getCacheForRendering(drawer, tile);
// test.equal(internalCache.type, T_C, "Conversion A->C ready, since there is no way to get to T_E.");
// test.ok(internalCache.loaded, "Internal cache ready.");
// }
//
// done();
// });
// viewer.open([
// {isTestSource: true},
// {isTestSource: true},
// ]);
// });
const tileCache = viewer.tileCache; // QUnit.test('Tile & Invalidation API: basic conversion & preprocessing', function(test) {
const drawer = viewer.drawer; // const done = test.async();
//
let testTileCalled = false; // const tileCache = viewer.tileCache;
drawer.testEvents.addHandler('test-tile', e => { // const drawer = viewer.drawer;
testTileCalled = true; //
test.ok(e.dataToDraw, "Tile data is ready to be drawn"); // let testTileCalled = false;
}); //
// let _currentTestVal = undefined;
viewer.addHandler('open', async () => { // let previousTestValue = undefined;
await viewer.waitForFinishedJobsForTest(); // drawer.testEvents.addHandler('test-tile', e => {
await sleep(1); // necessary to make space for a draw call // test.ok(e.dataToDraw, "Tile data is ready to be drawn");
// if (_currentTestVal !== undefined) {
test.ok(viewer.world.getItemAt(0).source instanceof OpenSeadragon.EmptyTestT_ATileSource, "Tests are done with empty test source type T_A."); // testTileCalled = true;
test.ok(viewer.world.getItemAt(1).source instanceof OpenSeadragon.EmptyTestT_ATileSource, "Tests are done with empty test source type T_A."); // test.equal(e.dataToDraw, _currentTestVal, "Value is correct on the drawn data.");
test.ok(testTileCalled, "Drawer tested at least one tile."); // }
// });
test.ok(typeAtoB > 1, "At least one conversion was triggered."); //
test.equal(typeAtoB, typeBtoC, "A->B = B->C, since we need to move all data to T_C for the drawer."); // function testDrawingRoutine(value) {
// _currentTestVal = value;
for (let tile of tileCache._tilesLoaded) { // viewer.world.needsDraw();
const cache = tile.getCache(); // viewer.world.draw();
test.equal(cache.type, T_A, "Cache data was not affected, the drawer uses internal cache."); // previousTestValue = value;
// _currentTestVal = undefined;
const internalCache = cache.getCacheForRendering(drawer, tile); // }
test.equal(internalCache.type, T_C, "Conversion A->C ready, since there is no way to get to T_E."); //
test.ok(internalCache.loaded, "Internal cache ready."); // viewer.addHandler('open', async () => {
} // await viewer.waitForFinishedJobsForTest();
// await sleep(1); // necessary to make space for a draw call
done(); //
}); // // Test simple data set -> creates main cache
viewer.open([ //
{isTestSource: true}, // let testHandler = async e => {
{isTestSource: true}, // // data comes in as T_A
]); // test.equal(typeDtoA, 0, "No conversion needed to get type A.");
}); // test.equal(typeCtoA, 0, "No conversion needed to get type A.");
//
QUnit.test('Tile & Invalidation API: basic conversion & preprocessing', function(test) { // const data = await e.getData(T_A);
const done = test.async(); // test.equal(data, 1, "Copy: creation of a working cache.");
// e.tile.__TEST_PROCESSED = true;
const tileCache = viewer.tileCache; //
const drawer = viewer.drawer; // // Test value 2 since we set T_C no need to convert
// await e.setData(2, T_C);
let testTileCalled = false; // test.notOk(e.outdated(), "Event is still valid.");
// };
let _currentTestVal = undefined; //
let previousTestValue = undefined; // viewer.addHandler('tile-invalidated', testHandler);
drawer.testEvents.addHandler('test-tile', e => { // await viewer.world.requestInvalidate(true);
test.ok(e.dataToDraw, "Tile data is ready to be drawn"); // await sleep(1); // necessary to make space for internal updates
if (_currentTestVal !== undefined) { // testDrawingRoutine(2);
testTileCalled = true; //
test.equal(e.dataToDraw, _currentTestVal, "Value is correct on the drawn data."); // //test for each level only single cache was processed
} // const processedLevels = {};
}); // for (let tile of tileCache._tilesLoaded) {
// const level = tile.level;
function testDrawingRoutine(value) { //
_currentTestVal = value; // if (tile.__TEST_PROCESSED) {
viewer.world.needsDraw(); // test.ok(!processedLevels[level], "Only single tile processed per level.");
viewer.world.draw(); // processedLevels[level] = true;
previousTestValue = value; // delete tile.__TEST_PROCESSED;
_currentTestVal = undefined; // }
} //
// const origCache = tile.getCache(tile.originalCacheKey);
viewer.addHandler('open', async () => { // test.equal(origCache.type, T_A, "Original cache data was not affected, the drawer uses internal cache.");
await viewer.waitForFinishedJobsForTest(); // test.equal(origCache.data, 0, "Original cache data was not affected, the drawer uses internal cache.");
await sleep(1); // necessary to make space for a draw call //
// const cache = tile.getCache();
// Test simple data set -> creates main cache // test.equal(cache.type, T_C, "Main Cache Updated (suite 1)");
// test.equal(cache.data, previousTestValue, "Main Cache Updated (suite 1)");
let testHandler = async e => { //
// data comes in as T_A // const internalCache = cache.getCacheForRendering(drawer, tile);
test.equal(typeDtoA, 0, "No conversion needed to get type A."); // test.equal(T_C, internalCache.type, "Conversion A->C ready, since there is no way to get to T_E.");
test.equal(typeCtoA, 0, "No conversion needed to get type A."); // test.ok(internalCache.loaded, "Internal cache ready.");
// }
const data = await e.getData(T_A); //
test.equal(data, 1, "Copy: creation of a working cache."); // // Test that basic scenario with reset data false starts from the main cache data of previous round
e.tile.__TEST_PROCESSED = true; // const modificationConstant = 50;
// viewer.removeHandler('tile-invalidated', testHandler);
// Test value 2 since we set T_C no need to convert // testHandler = async e => {
await e.setData(2, T_C); // const data = await e.getData(T_B);
test.notOk(e.outdated(), "Event is still valid."); // test.equal(data, previousTestValue + 2, "C -> A -> B conversion happened.");
}; // await e.setData(data + modificationConstant, T_B);
// console.log(data + modificationConstant);
viewer.addHandler('tile-invalidated', testHandler); // test.notOk(e.outdated(), "Event is still valid.");
await viewer.world.requestInvalidate(true); // };
await sleep(1); // necessary to make space for internal updates // console.log(previousTestValue, modificationConstant)
testDrawingRoutine(2); //
// viewer.addHandler('tile-invalidated', testHandler);
//test for each level only single cache was processed // await viewer.world.requestInvalidate(false);
const processedLevels = {}; // await sleep(1); // necessary to make space for a draw call
for (let tile of tileCache._tilesLoaded) { // // We set data as TB - there is T_C -> T_A -> T_B -> T_C conversion round
const level = tile.level; // let newValue = previousTestValue + modificationConstant + 3;
// testDrawingRoutine(newValue);
if (tile.__TEST_PROCESSED) { //
test.ok(!processedLevels[level], "Only single tile processed per level."); // newValue--; // intenrla cache performed +1 conversion, but here we have main cache with one step less
processedLevels[level] = true; // for (let tile of tileCache._tilesLoaded) {
delete tile.__TEST_PROCESSED; // const cache = tile.getCache();
} // test.equal(cache.type, T_B, "Main Cache Updated (suite 2).");
// test.equal(cache.data, newValue, "Main Cache Updated (suite 2).");
const origCache = tile.getCache(tile.originalCacheKey); // }
test.equal(origCache.type, T_A, "Original cache data was not affected, the drawer uses internal cache."); //
test.equal(origCache.data, 0, "Original cache data was not affected, the drawer uses internal cache."); // // Now test whether data reset works, value 1 -> copy perfomed due to internal cache cration
// viewer.removeHandler('tile-invalidated', testHandler);
const cache = tile.getCache(); // testHandler = async e => {
test.equal(cache.type, T_C, "Main Cache Updated (suite 1)"); // const data = await e.getData(T_B);
test.equal(cache.data, previousTestValue, "Main Cache Updated (suite 1)"); // test.equal(data, 1, "Copy: creation of a working cache.");
// await e.setData(-8, T_E);
const internalCache = cache.getCacheForRendering(drawer, tile); // e.resetData();
test.equal(T_C, internalCache.type, "Conversion A->C ready, since there is no way to get to T_E."); // };
test.ok(internalCache.loaded, "Internal cache ready."); // viewer.addHandler('tile-invalidated', testHandler);
} // await viewer.world.requestInvalidate(true);
// await sleep(1); // necessary to make space for a draw call
// Test that basic scenario with reset data false starts from the main cache data of previous round // testDrawingRoutine(2); // Value +2 rendering from original data
const modificationConstant = 50; //
viewer.removeHandler('tile-invalidated', testHandler); // for (let tile of tileCache._tilesLoaded) {
testHandler = async e => { // const origCache = tile.getCache(tile.originalCacheKey);
const data = await e.getData(T_B); // test.ok(tile.getCache() === origCache, "Main cache is now original cache.");
test.equal(data, previousTestValue + 2, "C -> A -> B conversion happened."); // }
await e.setData(data + modificationConstant, T_B); //
console.log(data + modificationConstant); // // Now force main cache creation that differs
test.notOk(e.outdated(), "Event is still valid."); // viewer.removeHandler('tile-invalidated', testHandler);
}; // testHandler = async e => {
console.log(previousTestValue, modificationConstant) // await e.setData(41, T_B);
// };
viewer.addHandler('tile-invalidated', testHandler); // viewer.addHandler('tile-invalidated', testHandler);
await viewer.world.requestInvalidate(false); // await viewer.world.requestInvalidate(true);
await sleep(1); // necessary to make space for a draw call //
// We set data as TB - there is T_C -> T_A -> T_B -> T_C conversion round // // Now test whether data reset works, even with non-original data
let newValue = previousTestValue + modificationConstant + 3; // viewer.removeHandler('tile-invalidated', testHandler);
testDrawingRoutine(newValue); // testHandler = async e => {
// const data = await e.getData(T_B);
newValue--; // intenrla cache performed +1 conversion, but here we have main cache with one step less // test.equal(data, 42, "Copy: 41 + 1.");
for (let tile of tileCache._tilesLoaded) { // await e.setData(data, T_E);
const cache = tile.getCache(); // e.resetData();
test.equal(cache.type, T_B, "Main Cache Updated (suite 2)."); // };
test.equal(cache.data, newValue, "Main Cache Updated (suite 2)."); // viewer.addHandler('tile-invalidated', testHandler);
} // await viewer.world.requestInvalidate(false);
// await sleep(1); // necessary to make space for a draw call
// Now test whether data reset works, value 1 -> copy perfomed due to internal cache cration // testDrawingRoutine(42);
viewer.removeHandler('tile-invalidated', testHandler); //
testHandler = async e => { // for (let tile of tileCache._tilesLoaded) {
const data = await e.getData(T_B); // const origCache = tile.getCache(tile.originalCacheKey);
test.equal(data, 1, "Copy: creation of a working cache."); // test.equal(origCache.type, T_A, "Original cache data was not affected, the drawer uses main cache even after refresh.");
await e.setData(-8, T_E); // test.equal(origCache.data, 0, "Original cache data was not affected, the drawer uses main cache even after refresh.");
e.resetData(); // }
}; //
viewer.addHandler('tile-invalidated', testHandler); // test.ok(testTileCalled, "Drawer tested at least one tile.");
await viewer.world.requestInvalidate(true); // done();
await sleep(1); // necessary to make space for a draw call // });
testDrawingRoutine(2); // Value +2 rendering from original data // viewer.open([
// {isTestSource: true},
for (let tile of tileCache._tilesLoaded) { // {isTestSource: true},
const origCache = tile.getCache(tile.originalCacheKey); // ]);
test.ok(tile.getCache() === origCache, "Main cache is now original cache."); // });
}
// Now force main cache creation that differs
viewer.removeHandler('tile-invalidated', testHandler);
testHandler = async e => {
await e.setData(41, T_B);
};
viewer.addHandler('tile-invalidated', testHandler);
await viewer.world.requestInvalidate(true);
// Now test whether data reset works, even with non-original data
viewer.removeHandler('tile-invalidated', testHandler);
testHandler = async e => {
const data = await e.getData(T_B);
test.equal(data, 42, "Copy: 41 + 1.");
await e.setData(data, T_E);
e.resetData();
};
viewer.addHandler('tile-invalidated', testHandler);
await viewer.world.requestInvalidate(false);
await sleep(1); // necessary to make space for a draw call
testDrawingRoutine(42);
for (let tile of tileCache._tilesLoaded) {
const origCache = tile.getCache(tile.originalCacheKey);
test.equal(origCache.type, T_A, "Original cache data was not affected, the drawer uses main cache even after refresh.");
test.equal(origCache.data, 0, "Original cache data was not affected, the drawer uses main cache even after refresh.");
}
test.ok(testTileCalled, "Drawer tested at least one tile.");
done();
});
viewer.open([
{isTestSource: true},
{isTestSource: true},
]);
});
//Tile API and cache interaction //Tile API and cache interaction
QUnit.test('Tile API Cache Interaction', function(test) { QUnit.test('Tile API Cache Interaction', function(test) {