From 1286fa454972a39811a85378cd1017d53c98e4eb Mon Sep 17 00:00:00 2001
From: Aiosa <469130@mail.muni.cz>
Date: Fri, 10 Jan 2025 22:13:16 +0100
Subject: [PATCH] Test drawers collide with drawer render testing - remove
 after cache tests.

---
 test/modules/tilecache.js | 276 +++++++++++++++++++-------------------
 1 file changed, 141 insertions(+), 135 deletions(-)

diff --git a/test/modules/tilecache.js b/test/modules/tilecache.js
index 73b06aa0..6bb481cd 100644
--- a/test/modules/tilecache.js
+++ b/test/modules/tilecache.js
@@ -86,141 +86,6 @@
         destroyE++;
     });
 
-    OpenSeadragon.TestCacheDrawer = class extends OpenSeadragon.DrawerBase {
-        constructor(opts) {
-            super(opts);
-            this.testEvents = new OpenSeadragon.EventSource();
-        }
-
-        static isSupported() {
-            return true;
-        }
-
-        _createDrawingElement() {
-            return document.createElement("div");
-        }
-
-        draw(tiledImages) {
-            for (let image of tiledImages) {
-                const tilesDoDraw = image.getTilesToDraw().map(info => info.tile);
-                for (let tile of tilesDoDraw) {
-                    const data = this.getDataToDraw(tile);
-                    this.testEvents.raiseEvent('test-tile', {
-                       tile: tile,
-                       dataToDraw: data,
-                    });
-                }
-            }
-        }
-
-        dataFree(data) {
-            this.testEvents.raiseEvent('free-data');
-        }
-
-        canRotate() {
-            return true;
-        }
-
-        destroy() {
-            this.destroyInternalCache();
-        }
-
-        setImageSmoothingEnabled(imageSmoothingEnabled){
-            //noop
-        }
-
-        drawDebuggingRect(rect) {
-            //noop
-        }
-
-        clear(){
-            //noop
-        }
-    }
-
-    OpenSeadragon.SyncInternalCacheDrawer = class extends OpenSeadragon.TestCacheDrawer {
-
-        getType() {
-            return "test-cache-drawer-sync";
-        }
-
-        getSupportedDataFormats() {
-            return [T_C, T_E];
-        }
-
-        // Make test use private cache
-        get defaultOptions() {
-            return {
-                usePrivateCache: true,
-                preloadCache: false,
-            };
-        }
-
-        dataCreate(cache, tile) {
-            this.testEvents.raiseEvent('create-data');
-            return cache.data;
-        }
-    }
-
-    OpenSeadragon.AsnycInternalCacheDrawer = class extends OpenSeadragon.TestCacheDrawer {
-
-        getType() {
-            return "test-cache-drawer-async";
-        }
-
-        getSupportedDataFormats() {
-            return [T_A];
-        }
-
-        // Make test use private cache
-        get defaultOptions() {
-            return {
-                usePrivateCache: true,
-                preloadCache: true,
-            };
-        }
-
-        dataCreate(cache, tile) {
-            this.testEvents.raiseEvent('create-data');
-            return cache.getDataAs(T_C, true);
-        }
-
-        dataFree(data) {
-            super.dataFree(data);
-            // Be nice and truly destroy the data copy
-            OpenSeadragon.convertor.destroy(data, T_C);
-        }
-    }
-
-    OpenSeadragon.EmptyTestT_ATileSource = class extends OpenSeadragon.TileSource {
-
-        supports( data, url ){
-            return data && data.isTestSource;
-        }
-
-        configure( data, url, postData ){
-            return {
-                width: 512, /* width *required */
-                height: 512, /* height *required */
-                tileSize: 128, /* tileSize *required */
-                tileOverlap: 0, /* tileOverlap *required */
-                minLevel: 0, /* minLevel */
-                maxLevel: 3, /* maxLevel */
-                tilesUrl: "", /* tilesUrl */
-                fileFormat: "", /* fileFormat */
-                displayRects: null /* displayRects */
-            }
-        }
-
-        getTileUrl(level, x, y) {
-            return String(level); //treat each tile on level same to introduce cache overlaps
-        }
-
-        downloadTileStart(context) {
-            context.finish(0, null, T_A);
-        }
-    }
-
     // ----------
     QUnit.module('TileCache', {
         beforeEach: function () {
@@ -233,12 +98,153 @@
             typeAtoB = 0, typeBtoC = 0, typeCtoA = 0, typeDtoA = 0, typeCtoE = 0;
             copyA = 0, copyB = 0, copyC = 0, copyD = 0, copyE = 0;
             destroyA = 0, destroyB = 0, destroyC = 0, destroyD = 0, destroyE = 0;
+
+            OpenSeadragon.TestCacheDrawer = class extends OpenSeadragon.DrawerBase {
+                constructor(opts) {
+                    super(opts);
+                    this.testEvents = new OpenSeadragon.EventSource();
+                }
+
+                static isSupported() {
+                    return true;
+                }
+
+                _createDrawingElement() {
+                    return document.createElement("div");
+                }
+
+                draw(tiledImages) {
+                    for (let image of tiledImages) {
+                        const tilesDoDraw = image.getTilesToDraw().map(info => info.tile);
+                        for (let tile of tilesDoDraw) {
+                            const data = this.getDataToDraw(tile);
+                            this.testEvents.raiseEvent('test-tile', {
+                                tile: tile,
+                                dataToDraw: data,
+                            });
+                        }
+                    }
+                }
+
+                dataFree(data) {
+                    this.testEvents.raiseEvent('free-data');
+                }
+
+                canRotate() {
+                    return true;
+                }
+
+                destroy() {
+                    this.destroyInternalCache();
+                }
+
+                setImageSmoothingEnabled(imageSmoothingEnabled){
+                    //noop
+                }
+
+                drawDebuggingRect(rect) {
+                    //noop
+                }
+
+                clear(){
+                    //noop
+                }
+            }
+
+            OpenSeadragon.SyncInternalCacheDrawer = class extends OpenSeadragon.TestCacheDrawer {
+
+                getType() {
+                    return "test-cache-drawer-sync";
+                }
+
+                getSupportedDataFormats() {
+                    return [T_C, T_E];
+                }
+
+                // Make test use private cache
+                get defaultOptions() {
+                    return {
+                        usePrivateCache: true,
+                        preloadCache: false,
+                    };
+                }
+
+                dataCreate(cache, tile) {
+                    this.testEvents.raiseEvent('create-data');
+                    return cache.data;
+                }
+            }
+
+            OpenSeadragon.AsnycInternalCacheDrawer = class extends OpenSeadragon.TestCacheDrawer {
+
+                getType() {
+                    return "test-cache-drawer-async";
+                }
+
+                getSupportedDataFormats() {
+                    return [T_A];
+                }
+
+                // Make test use private cache
+                get defaultOptions() {
+                    return {
+                        usePrivateCache: true,
+                        preloadCache: true,
+                    };
+                }
+
+                dataCreate(cache, tile) {
+                    this.testEvents.raiseEvent('create-data');
+                    return cache.getDataAs(T_C, true);
+                }
+
+                dataFree(data) {
+                    super.dataFree(data);
+                    // Be nice and truly destroy the data copy
+                    OpenSeadragon.convertor.destroy(data, T_C);
+                }
+            }
+
+            OpenSeadragon.EmptyTestT_ATileSource = class extends OpenSeadragon.TileSource {
+
+                supports( data, url ){
+                    return data && data.isTestSource;
+                }
+
+                configure( data, url, postData ){
+                    return {
+                        width: 512, /* width *required */
+                        height: 512, /* height *required */
+                        tileSize: 128, /* tileSize *required */
+                        tileOverlap: 0, /* tileOverlap *required */
+                        minLevel: 0, /* minLevel */
+                        maxLevel: 3, /* maxLevel */
+                        tilesUrl: "", /* tilesUrl */
+                        fileFormat: "", /* fileFormat */
+                        displayRects: null /* displayRects */
+                    }
+                }
+
+                getTileUrl(level, x, y) {
+                    return String(level); //treat each tile on level same to introduce cache overlaps
+                }
+
+                downloadTileStart(context) {
+                    context.finish(0, null, T_A);
+                }
+            }
         },
         afterEach: function () {
             if (viewer && viewer.close) {
                 viewer.close();
             }
 
+            // Some tests test all drawers - remove test drawers to avoid collision with other tests
+            OpenSeadragon.EmptyTestT_ATileSource = null;
+            OpenSeadragon.AsnycInternalCacheDrawer = null;
+            OpenSeadragon.SyncInternalCacheDrawer = null;
+            OpenSeadragon.TestCacheDrawer = null;
+
             viewer = null;
         }
     });