update tests

test/event.js

@@ -1,21 +1,20 @@
 import { expect } from 'chai'
 
 import { Event } from '../src'
-import { createTestFunction } from './util'
 
 describe('Event', () => {
-  it('wait event', createTestFunction(async () => {
+  it('wait event', async () => {
     let event = new Event()
     setTimeout(::event.set, 1)
     let signaled = await event.wait()
     expect(signaled).to.be.true
-  }))
+  })
 
-  it('wait event return false', createTestFunction(async () => {
+  it('wait event return false', async () => {
     let event = new Event()
     let signaled = await event.wait(1)
     expect(signaled).to.be.false
-  }))
+  })
 
   it('isSet', () => {
     let event = new Event()

test/semaphore.js

@@ -1,7 +1,6 @@
 import { expect } from 'chai'
 
 import { Semaphore } from '../src'
-import { createTestFunction } from './util'
 
 function runTests (Promise) {
   async function getLockedSemaphore () {
@@ -12,46 +11,46 @@ function runTests (Promise) {
   }
 
   describe('blocking is false', () => {
-    it('semaphore is unlocked', createTestFunction(async () => {
+    it('semaphore is unlocked', async () => {
       let semaphore = new Semaphore(1)
       let isAcquired = await semaphore.acquire({blocking: false})
       expect(isAcquired).to.be.true
-    }))
+    })
 
-    it('semaphore already locked', createTestFunction(async () => {
+    it('semaphore already locked', async () => {
       let semaphore = await getLockedSemaphore()
       let isAcquired = await semaphore.acquire({blocking: false})
       expect(isAcquired).to.be.false
-    }))
+    })
   })
 
   describe('timeout is not Infinity', () => {
-    it('rejected by timeout', createTestFunction(async () => {
+    it('rejected by timeout', async () => {
       let semaphore = await getLockedSemaphore()
       let startTime = Date.now()
       let isAcquired = await semaphore.acquire({timeout: 100})
       expect(isAcquired).to.be.false
       expect(Date.now() - startTime).to.be.at.least(99)
-    }))
+    })
   })
 
   it('release unlocked semaphore', () => {
     let semaphore = new Semaphore(1)
     expect(::semaphore.release).to.not.throw()
   })
 
-  it('wait for acquire', createTestFunction(async () => {
+  it('wait for acquire', async () => {
     let semaphore = await getLockedSemaphore()
     let startTime = Date.now()
     setTimeout(() => { semaphore.release() }, 100)
 
     let isAcquired = await semaphore.acquire()
     expect(isAcquired).to.be.true
     expect(Date.now() - startTime).to.be.at.least(99)
-  }))
+  })
 
   describe('withLock', () => {
-    it('executed', createTestFunction(async () => {
+    it('executed', async () => {
       let semaphore = new Semaphore(1)
 
       let f1 = async () => {
@@ -70,13 +69,13 @@ function runTests (Promise) {
       }
 
       await* [f1(), f2()]
-    }))
+    })
 
-    it('already locked', createTestFunction(async () => {
+    it('already locked', async () => {
       let semaphore = await getLockedSemaphore()
       let result = await semaphore.withLock(() => {}, {blocking: false})
       expect(result[0]).to.be.false
-    }))
+    })
   })
 }