task-signal-any-priority.tentative.any.js (7230B)
1 // META: global=window,worker 2 3 test((t) => { 4 const signal = TaskSignal.any([]); 5 assert_true(signal instanceof TaskSignal); 6 assert_equals(signal.priority, 'user-visible'); 7 }, "TaskSignal.any() returns a user-visible TaskSignal when no priority is specified"); 8 9 test((t) => { 10 let signal = TaskSignal.any([], {priority: 'user-blocking'}); 11 assert_equals(signal.priority, 'user-blocking'); 12 13 signal = TaskSignal.any([], {priority: 'user-visible'}); 14 assert_equals(signal.priority, 'user-visible'); 15 16 signal = TaskSignal.any([], {priority: 'background'}); 17 assert_equals(signal.priority, 'background'); 18 }, "TaskSignal.any() returns a signal with the correct priority when intialized with a string"); 19 20 test((t) => { 21 let controller = new TaskController({priority: 'user-blocking'}); 22 let signal = TaskSignal.any([], {priority: controller.signal}); 23 assert_equals(signal.priority, 'user-blocking'); 24 25 controller = new TaskController({priority: 'user-visible'}); 26 signal = TaskSignal.any([], {priority: controller.signal}); 27 assert_equals(signal.priority, 'user-visible'); 28 29 controller = new TaskController({priority: 'background'}); 30 signal = TaskSignal.any([], {priority: controller.signal}); 31 assert_equals(signal.priority, 'background'); 32 }, "TaskSignal.any() returns a signal with the correct priority when intialized with a TaskSignal"); 33 34 test((t) => { 35 let controller = new TaskController({priority: 'user-blocking'}); 36 let signal = TaskSignal.any([], {priority: controller.signal}); 37 assert_equals(signal.priority, 'user-blocking'); 38 39 controller.setPriority('user-visible'); 40 assert_equals(signal.priority, 'user-visible'); 41 42 controller.setPriority('background'); 43 assert_equals(signal.priority, 'background'); 44 45 controller.setPriority('user-blocking'); 46 assert_equals(signal.priority, 'user-blocking'); 47 }, "TaskSignal.any() returns a signal with dynamic priority"); 48 49 test((t) => { 50 const controller = new TaskController(); 51 const signal = TaskSignal.any([], {priority: controller.signal}); 52 53 let eventFiredCount = 0; 54 signal.onprioritychange = t.step_func((e) => { 55 assert_equals(e.target, signal, 56 `The event target is the signal returned by TaskSignal.any()`); 57 ++eventFiredCount; 58 }); 59 60 controller.setPriority('background'); 61 assert_equals(eventFiredCount, 1); 62 63 controller.setPriority('user-visible'); 64 assert_equals(eventFiredCount, 2); 65 66 controller.setPriority('user-blocking'); 67 assert_equals(eventFiredCount, 3); 68 }, "Priority change events fire for composite signals"); 69 70 71 test((t) => { 72 const controller = new TaskController(); 73 let signal = TaskSignal.any([], {priority: controller.signal}); 74 signal = TaskSignal.any([], {priority: signal}); 75 signal = TaskSignal.any([], {priority: signal}); 76 signal = TaskSignal.any([], {priority: signal}); 77 signal = TaskSignal.any([], {priority: signal}); 78 79 assert_equals(signal.priority, 'user-visible'); 80 81 let eventFiredCount = 0; 82 signal.onprioritychange = t.step_func((e) => { 83 assert_equals(e.target, signal, 84 "The event target is the signal returned by TaskSignal.any()"); 85 ++eventFiredCount; 86 }); 87 88 controller.setPriority('background'); 89 assert_equals(eventFiredCount, 1); 90 assert_equals(signal.priority, 'background'); 91 92 controller.setPriority('user-visible'); 93 assert_equals(eventFiredCount, 2); 94 assert_equals(signal.priority, 'user-visible'); 95 96 controller.setPriority('user-blocking'); 97 assert_equals(eventFiredCount, 3); 98 assert_equals(signal.priority, 'user-blocking'); 99 }, "Priority change events fire for composite signals with intermediate sources"); 100 101 test((t) => { 102 const controller = new TaskController(); 103 const signals = []; 104 const results = []; 105 106 let id = 0; 107 for (let i = 0; i < 3; i++) { 108 const signal = TaskSignal.any([], {priority: controller.signal}); 109 const eventId = id++; 110 signal.addEventListener('prioritychange', () => { 111 results.push(eventId); 112 }); 113 signals.push(signal); 114 } 115 for (let i = 0; i < 3; i++) { 116 const signal = TaskSignal.any([], {priority: signals[i]}); 117 const eventId = id++; 118 signal.addEventListener('prioritychange', () => { 119 results.push(eventId); 120 }); 121 } 122 123 controller.setPriority('background'); 124 assert_equals(results.toString(), '0,1,2,3,4,5') 125 126 controller.setPriority('user-blocking'); 127 assert_equals(results.toString(), '0,1,2,3,4,5,0,1,2,3,4,5') 128 }, "Priority change propagates to multiple dependent signals in the right order"); 129 130 test((t) => { 131 const controller = new TaskController(); 132 const signal = TaskSignal.any([], {priority: controller.signal}); 133 134 let fired = false; 135 signal.onabort = t.step_func(() => { 136 assert_unreached("The signal should not abort"); 137 fired = true; 138 }); 139 140 controller.abort(); 141 assert_false(fired); 142 }, "TaskSignal.any() does not propagate abort when not given dependent abort signals"); 143 144 test((t) => { 145 const taskController = new TaskController(); 146 const abortController = new AbortController(); 147 const signal = TaskSignal.any([abortController.signal], {priority: taskController.signal}); 148 149 let priorityFireCount = 0; 150 signal.onprioritychange = t.step_func(() => { 151 ++priorityFireCount; 152 }); 153 154 let abortFired = false; 155 signal.onabort = t.step_func(() => { 156 abortFired = true; 157 }); 158 159 taskController.setPriority('background'); 160 assert_equals(signal.priority, 'background'); 161 assert_equals(priorityFireCount, 1); 162 163 taskController.abort(); 164 assert_false(abortFired, "The signal should use abortController for abort"); 165 166 abortController.abort(); 167 assert_true(abortFired); 168 169 taskController.setPriority('user-visible'); 170 assert_equals(signal.priority, 'user-visible'); 171 assert_equals(priorityFireCount, 2); 172 }, "TaskSignal.any() propagates abort and priority"); 173 174 175 test((t) => { 176 const controller = new TaskController(); 177 const signal = TaskSignal.any([AbortSignal.abort()], {priority: controller.signal}); 178 179 let fired = false; 180 signal.onprioritychange = t.step_func(() => { 181 fired = true; 182 }); 183 184 controller.setPriority('background'); 185 assert_true(fired); 186 }, "TaskSignal.any() propagates priority after returning an aborted signal"); 187 188 test((t) => { 189 // Add a dependent in the initial event dispatch stage. 190 let controller = new TaskController(); 191 let fired = false; 192 controller.signal.onprioritychange = t.step_func(() => { 193 fired = true; 194 const newSignal = TaskSignal.any([], {priority: controller.signal}); 195 assert_equals(newSignal.priority, 'background'); 196 newSignal.onprioritychange = t.unreached_func('onprioritychange called'); 197 }); 198 controller.setPriority('background'); 199 assert_true(fired); 200 201 // Add a dependent while signaling prioritychange on dependents. 202 fired = false; 203 controller = new TaskController(); 204 const signal = TaskSignal.any([], {priority: controller.signal}); 205 signal.onprioritychange = t.step_func(() => { 206 fired = true; 207 const newSignal = TaskSignal.any([], {priority: signal}); 208 assert_equals(newSignal.priority, 'background'); 209 newSignal.onprioritychange = t.unreached_func('onprioritychange called'); 210 }); 211 controller.setPriority('background'); 212 assert_true(fired); 213 }, "TaskSignal.any() does not fire prioritychange for dependents added during prioritychange");