third_party/WebKit/LayoutTests/inspector/throttler.html

   1 <html>
   2 <head>
   3 <script src="../http/tests/inspector/inspector-test.js"></script>
   4 <script>
   5
   6 function test()
   7 {
   8     var ProcessMock = function(name, runnable)
   9     {
  10         this._runnable = runnable;
  11         this.processName = name;
  12         this.run = this.run.bind(this);
  13         this.run.processName = name;
  14
  15         this.startPromise = new Promise(onStart.bind(this));
  16         this.finishPromise = new Promise(onFinish.bind(this));
  17
  18         function onStart(startCallback)
  19         {
  20             this._startCallback = startCallback;
  21         }
  22
  23         function onFinish(finishCallback)
  24         {
  25             this._finishCallback = finishCallback;
  26         }
  27     }
  28
  29     ProcessMock.create = function(name, runnable)
  30     {
  31         return new ProcessMock(name, runnable);
  32     }
  33
  34     ProcessMock.prototype = {
  35         run: function()
  36         {
  37             InspectorTest.addResult("Process '" + this.processName + "' STARTED.");
  38             this._startCallback();
  39             if (this._runnable)
  40                 this._runnable.call(null);
  41             return this.finishPromise;
  42         },
  43
  44         finish: function()
  45         {
  46             this.startPromise.then(onFinish.bind(this));
  47
  48             function onFinish()
  49             {
  50                 InspectorTest.addResult("Process '" + this.processName + "' FINISHED.");
  51                 this._finishCallback();
  52             }
  53         },
  54     }
  55
  56     var throttler = new WebInspector.Throttler(1989);
  57     var timeoutMock = new InspectorTest.TimeoutMock();
  58     throttler._setTimeout = timeoutMock.setTimeout;
  59     throttler._clearTimeout = timeoutMock.clearTimeout;
  60     InspectorTest.addSniffer(throttler, "schedule", logSchedule, true);
  61
  62     function testSimpleSchedule(next, runningProcess)
  63     {
  64         assertThrottlerIdle();
  65         throttler.schedule(ProcessMock.create("operation #1").run, false);
  66         var process = ProcessMock.create("operation #2");
  67         throttler.schedule(process.run);
  68
  69         var promise = Promise.resolve();
  70         if (runningProcess) {
  71             runningProcess.finish();
  72             promise = waitForProcessFinish();
  73         }
  74
  75         promise.then(function() {
  76             assertThrottlerTimeout();
  77             timeoutMock.fireAllTimers();
  78             process.finish();
  79             return waitForProcessFinish();
  80         }).then(next);
  81     }
  82
  83     function testAsSoonAsPossibleOverrideTimeout(next, runningProcess)
  84     {
  85         assertThrottlerIdle();
  86         throttler.schedule(ProcessMock.create("operation #1").run);
  87         var process = ProcessMock.create("operation #2");
  88         throttler.schedule(process.run, true);
  89
  90         var promise = Promise.resolve();
  91         if (runningProcess) {
  92             runningProcess.finish();
  93             promise = waitForProcessFinish();
  94         }
  95
  96         promise.then(function() {
  97             assertThrottlerTimeout();
  98             timeoutMock.fireAllTimers();
  99             process.finish();
 100             return waitForProcessFinish();
 101         }).then(next);
 102     }
 103
 104     function testAlwaysExecuteLastScheduled(next, runningProcess)
 105     {
 106         assertThrottlerIdle();
 107         var process = null;
 108         for (var i = 0; i < 4; ++i) {
 109             process = ProcessMock.create("operation #" + i);
 110             throttler.schedule(process.run, i % 2 === 0);
 111         }
 112         var promise = Promise.resolve();
 113         if (runningProcess) {
 114             runningProcess.finish();
 115             promise = waitForProcessFinish();
 116         }
 117         promise.then(function() {
 118             assertThrottlerTimeout();
 119             timeoutMock.fireAllTimers();
 120             process.finish();
 121             return waitForProcessFinish();
 122         }).then(next);
 123     }
 124
 125     InspectorTest.runTestSuite([
 126         testSimpleSchedule,
 127
 128         testAsSoonAsPossibleOverrideTimeout,
 129
 130         testAlwaysExecuteLastScheduled,
 131
 132         function testSimpleScheduleDuringProcess(next)
 133         {
 134             var runningProcess = throttlerToRunningState();
 135             runningProcess.startPromise.then(function() {
 136                 testSimpleSchedule(next, runningProcess);
 137             });
 138         },
 139
 140         function testAsSoonAsPossibleOverrideDuringProcess(next)
 141         {
 142             var runningProcess = throttlerToRunningState();
 143             runningProcess.startPromise.then(function() {
 144                 testAsSoonAsPossibleOverrideTimeout(next, runningProcess);
 145             });
 146         },
 147
 148         function testAlwaysExecuteLastScheduledDuringProcess(next)
 149         {
 150             var runningProcess = throttlerToRunningState();
 151             runningProcess.startPromise.then(function() {
 152                 testAlwaysExecuteLastScheduled(next, runningProcess);
 153             });
 154         },
 155
 156         function testScheduleFromProcess(next)
 157         {
 158             var nextProcess;
 159             assertThrottlerIdle();
 160             var process = ProcessMock.create("operation #1", processBody);
 161             throttler.schedule(process.run);
 162             assertThrottlerTimeout();
 163             timeoutMock.fireAllTimers();
 164             process.finish();
 165             waitForProcessFinish().then(function() {
 166                 assertThrottlerTimeout();
 167                 timeoutMock.fireAllTimers();
 168                 nextProcess.finish();
 169                 return waitForProcessFinish();
 170             }).then(next);
 171
 172             function processBody()
 173             {
 174                 nextProcess = ProcessMock.create("operation #2");
 175                 throttler.schedule(nextProcess.run, false);
 176             }
 177         },
 178
 179         function testExceptionFromProcess(next)
 180         {
 181             var process = ProcessMock.create("operation #1", processBody);
 182             throttler.schedule(process.run);
 183             timeoutMock.fireAllTimers();
 184             waitForProcessFinish().then(function() {
 185                 assertThrottlerIdle();
 186                 next();
 187             });
 188
 189             function processBody()
 190             {
 191                 throw new Error("Exception during process execution.");
 192             }
 193         }
 194     ]);
 195
 196     function waitForProcessFinish()
 197     {
 198         var promiseResolve;
 199         var hasFinished;
 200         InspectorTest.addSniffer(WebInspector.Throttler.prototype, "_processCompletedForTests", onFinished);
 201         function onFinished()
 202         {
 203             hasFinished = true;
 204             if (promiseResolve)
 205                 promiseResolve();
 206         }
 207         return new Promise(function(success) {
 208             promiseResolve = success;
 209             if (hasFinished)
 210                 success();
 211         });
 212     }
 213
 214     function throttlerToRunningState()
 215     {
 216         assertThrottlerIdle();
 217         var process = ProcessMock.create("long operation");
 218         throttler.schedule(process.run);
 219         assertThrottlerTimeout();
 220         timeoutMock.fireAllTimers();
 221         return process;
 222     }
 223
 224     function assertThrottlerIdle()
 225     {
 226         var timeouts = timeoutMock.activeTimersTimeouts();
 227         if (timeouts.length !== 0) {
 228             InspectorTest.addResult("ERROR: throttler is not in idle state. Scheduled timers timeouts: [" + timeouts.sort().join(", ") + "]");
 229             InspectorTest.completeTest();
 230             return;
 231         }
 232         InspectorTest.addResult("Throttler is in IDLE state (doesn't have any timers set up)");
 233     }
 234
 235     function assertThrottlerTimeout()
 236     {
 237         var timeouts = timeoutMock.activeTimersTimeouts();
 238         if (timeouts.length === 0) {
 239             InspectorTest.addResult("ERROR: throttler is not in timeout state. Scheduled timers timeouts are empty!");
 240             InspectorTest.completeTest();
 241             return;
 242         }
 243         InspectorTest.addResult("Throttler is in TIMEOUT state. Scheduled timers timeouts: [" + timeouts.sort().join(", ") + "]");
 244     }
 245
 246     function logSchedule(operation, asSoonAsPossible)
 247     {
 248         InspectorTest.addResult("SCHEDULED: '" + operation.processName + "' asSoonAsPossible: " + asSoonAsPossible);
 249     }
 250 }
 251
 252 </script>
 253 </head>
 254
 255 <body onload="runTest()">
 256 <p>This test verifies throttler behavior.</p>
 257 </body>
 258 </html>