v0.0.0

package.json

@@ -58,6 +58,7 @@
     "@babel/runtime-corejs3": "^7.18.3",
     "@flemist/copy-glob-flat": "^0.0.5",
     "@flemist/karma-custom-launcher": "^0.0.0",
+    "@flemist/test-variants": "^0.0.2",
     "@rollup/plugin-alias": "^3.1.9",
     "@rollup/plugin-babel": "^5.3.1",
     "@rollup/plugin-commonjs": "^22.0.0",

src/async/priority-queue/PriorityQueue.test.ts

@@ -1,7 +1,7 @@
 import {PriorityQueue} from './PriorityQueue'
 import {priorityCreate} from 'src/sync/priority'
 
-describe('helpers > PriorityQueue', function () {
+describe('priority-queue > PriorityQueue', function () {
   it('base', async function () {
     const queue = new PriorityQueue()
     const log = []

src/async/time-controller/contracts.ts

@@ -0,0 +1,6 @@
+export interface ITimeController {
+	now(): number
+	setTimeout(handler: () => void, timeout: number): number
+	clearTimeout(handle: number)
+}
+

src/async/time-controller/timeControllerDefault.ts

@@ -0,0 +1,17 @@
+import {ITimeController} from './contracts'
+
+export const timeControllerDefault: ITimeController = {
+  now: function now() {
+    return Date.now()
+  },
+  setTimeout: typeof window === 'undefined'
+    ? setTimeout
+    : function setTimeout() {
+      return setTimeout.apply(window, arguments)
+    },
+  clearTimeout: typeof window === 'undefined'
+    ? clearTimeout
+    : function clearTimeout() {
+      return clearTimeout.apply(window, arguments)
+    },
+}

src/async/time-controller/timeControllerMock.test.ts

@@ -0,0 +1,82 @@
+import {createTestVariantsSync} from '@flemist/test-variants'
+import {TimeControllerMock} from './timeControllerMock'
+import {ITimeController} from './contracts'
+import {timeControllerDefault} from './timeControllerDefault'
+
+describe('time-controller > timeControllerMock', function () {
+  function test({
+    timeController,
+    times,
+    postDelay,
+  }: {
+    timeController: ITimeController,
+    times: [start: number|null, timeout: number, abort: number|null][],
+    postDelay: number,
+  }) {
+    return new Promise<string[]>((resolve, reject) => {
+      const result: string[] = []
+      let timeMax = 0
+      for (let i = 0, len = times.length; i < len; i++) {
+        const time = times[i]
+        const index = i
+        timeMax = Math.max((time[0] || 0) + Math.max(time[1] || 0, time[2] || 0))
+
+        const start = () => {
+          const handle = timeController.setTimeout(() => {
+            result.push(`completed: ${index}`)
+          }, time[1])
+
+          if (time[2] != null) {
+            if (time[2] < 0) {
+              timeController.clearTimeout(handle)
+            }
+            else {
+              timeController.setTimeout(() => {
+                timeController.clearTimeout(handle)
+                result.push(`aborted: ${index}`)
+              }, time[2])
+            }
+          }
+        }
+
+        if (time[0] == null) {
+          start()
+        }
+        else {
+          timeController.setTimeout(start, time[0])
+        }
+      }
+
+      timeController.setTimeout(() => {
+        resolve(result)
+      }, timeMax + postDelay)
+    })
+  }
+
+  const testVariants = createTestVariantsSync(({
+    times,
+  }: {
+    times: [start: number|null, timeout: number, abort: number|null][],
+  }) => {
+    const timeController = new TimeControllerMock()
+    const actual = test({
+      timeController,
+      times,
+      postDelay: 100000000,
+    })
+    const expected = test({
+      timeController: timeControllerDefault,
+      times,
+      postDelay     : 100,
+    })
+    assert.deepStrictEqual(actual, expected)
+  })
+
+  it('base', async function () {
+    testVariants({
+      times: [
+        [[0, 0, null]],
+      ],
+    })
+  })
+})

src/async/time-controller/timeControllerMock.ts

@@ -0,0 +1,81 @@
+import {ITimeController} from './contracts'
+
+interface IHandler {
+	id: number,
+	time: number,
+	handler: () => void,
+}
+
+function compareHandlers(o1: IHandler, o2: IHandler): number {
+  if (o1.time > o2.time) {
+    return 1
+  }
+  if (o1.time < o2.time) {
+    return -1
+  }
+  if (o1.id > o2.id) {
+    return 1
+  }
+  if (o1.id < o2.id) {
+    return -1
+  }
+
+  throw new Error('Duplicate timing handlers')
+}
+
+export class TimeControllerMock implements ITimeController {
+  private _handlers: IHandler[] = []
+  private _now: number = 1
+  private _nextId: number = 0
+
+  addTime(time: number) {
+    this.setTime(this._now + time)
+  }
+
+  setTime(time: number) {
+    if (time <= 0) {
+      throw new Error(`time (${time} should be > 0)`)
+    }
+    const {_handlers, _now: now} = this
+
+    while (true) {
+      let minHandler: IHandler
+      for (const id in _handlers) {
+        if (Object.prototype.hasOwnProperty.call(_handlers, id)) {
+          const handler = _handlers[id]
+          if (handler.time <= time && (!minHandler || compareHandlers(handler, minHandler) < 0)) {
+            minHandler = handler
+          }
+        }
+      }
+
+      if (!minHandler) {
+        break
+      }
+
+      delete _handlers[minHandler.id]
+      this._now = minHandler.time
+      minHandler.handler()
+    }
+
+    this._now = time
+  }
+
+  now(): number {
+    return this._now
+  }
+
+  setTimeout(handler: () => void, timeout: number): number {
+    const id = this._nextId++
+    this._handlers[id] = {
+      id,
+      time: this._now + timeout,
+      handler,
+    }
+    return id
+  }
+
+  clearTimeout(handle: number) {
+    delete this._handlers[handle]
+  }
+}

src/async/time-limits/TimeLimit.ts

@@ -9,15 +9,18 @@ export class TimeLimit implements ITimeLimit {
   private readonly _maxCount: number
   private readonly _timeMs: number
   private readonly _priorityQueue: PriorityQueue
+  private readonly _setTimeout: (func: () => void, timeout?: number) => void
 
   constructor({
     maxCount,
     timeMs,
     priorityQueue,
+    setTimeout,
   }: {
     maxCount: number,
     timeMs: number,
     priorityQueue?: PriorityQueue,
+    setTimeout?: (func: () => void, timeout?: number) => void,
   }) {
     this._maxCount = maxCount
     this._timeMs = timeMs
@@ -72,7 +75,7 @@ export class TimeLimit implements ITimeLimit {
       return result
     }
     finally {
-      setTimeout(this._releaseFunc, this._timeMs)
+      this._setTimeout(this._releaseFunc, this._timeMs)
     }
   }
 }

src/async/time-limits/TimeLimits.test.ts

@@ -6,7 +6,7 @@ import {delay} from 'src/async/delay'
 import {PriorityQueue} from 'src/async/priority-queue'
 import {priorityCreate} from 'src/sync/priority'
 
-describe('helpers > TimeLimits', function () {
+describe('time-limits > TimeLimits', function () {
   this.timeout(300000)
   type Mode = 'sync' | 'async' | 'random'
 

src/sync/pairing-heap/PairingHeap.test.ts

@@ -87,7 +87,7 @@ class PairingHeapTester<TItem> {
   }
 }
 
-describe('helpers > PairingHeap', function () {
+describe('pairing-heap > PairingHeap', function () {
   this.timeout(6000000)
 
   let totalTests = 0

src/sync/priority/Priority.test.ts

@@ -1,6 +1,6 @@
 import {Priority, priorityCompare, priorityCreate} from './Priority'
 
-describe('helpers > Priority', function () {
+describe('priority > Priority', function () {
   function test(o1: Priority, o2: Priority, checkResult: -1 | 0 | 1) {
     let result = priorityCompare(o1, o2)
     assert.strictEqual(result, checkResult)