@gitlab/duo-ui 0.1.0 → 0.2.0

package/src/vendor/bootstrap-vue/src/utils/dom.spec.js

@@ -0,0 +1,291 @@
+import { mount } from '@vue/test-utils'
+import {
+  closest,
+  contains,
+  getAttr,
+  getStyle,
+  hasAttr,
+  hasClass,
+  isDisabled,
+  isElement,
+  matches,
+  select,
+  selectAll
+} from './dom'
+
+const template = `
+<div id="a" class="foo">
+  <div class="bar">
+    <span class="barspan foobar" style="color: red;"></span>
+  </div>
+  <div class="baz">
+    <button id="button1" aria-label="label">btn 1</button>
+    <button id="button2">btn 1</button>
+    <button id="button3" disabled>btn 1</button>
+  </div>
+</div>
+`
+const App = { template }
+
+describe('utils/dom', () => {
+  it('isElement() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+    expect(wrapper.find('div.foo').exists()).toBe(true)
+    expect(isElement(wrapper.element)).toBe(true)
+    expect(isElement(null)).toBe(false)
+    expect(isElement(App)).toBe(false)
+
+    wrapper.destroy()
+  })
+
+  it('isDisabled() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+
+    const $btns = wrapper.findAll('div.baz > button')
+    expect($btns).toBeDefined()
+    expect($btns.length).toBe(3)
+    expect(isDisabled($btns.at(0).element)).toBe(false)
+    expect(isDisabled($btns.at(1).element)).toBe(false)
+    expect(isDisabled($btns.at(2).element)).toBe(true)
+
+    wrapper.destroy()
+  })
+
+  it('hasClass() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+
+    const $span = wrapper.find('span.barspan')
+    expect($span).toBeDefined()
+    expect($span.exists()).toBe(true)
+    expect(hasClass($span.element, 'barspan')).toBe(true)
+    expect(hasClass($span.element, 'foobar')).toBe(true)
+    expect(hasClass($span.element, 'fizzle-rocks')).toBe(false)
+    expect(hasClass(null, 'foobar')).toBe(false)
+
+    wrapper.destroy()
+  })
+
+  it('contains() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+
+    const $span = wrapper.find('span.barspan')
+    expect($span).toBeDefined()
+    expect($span.exists()).toBe(true)
+    const $btn1 = wrapper.find('button#button1')
+    expect($btn1).toBeDefined()
+    expect($btn1.exists()).toBe(true)
+
+    expect(contains(wrapper.element, $span.element)).toBe(true)
+    expect(contains(wrapper.element, $btn1.element)).toBe(true)
+    expect(contains($span.element, $btn1.element)).toBe(false)
+    expect(contains(null, $btn1.element)).toBe(false)
+
+    wrapper.destroy()
+  })
+
+  it('closest() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+
+    const $btns = wrapper.findAll('div.baz > button')
+    expect($btns).toBeDefined()
+    expect($btns.length).toBe(3)
+
+    expect(closest('div.foo', $btns.at(0).element)).toBeDefined()
+    expect(closest('div.foo', $btns.at(0).element)).toBe(wrapper.element)
+    expect(closest('div.foo', null)).toBe(null)
+
+    const $baz = wrapper.find('div.baz')
+    expect($baz).toBeDefined()
+    expect($baz.exists()).toBe(true)
+    expect(closest('div.baz', $btns.at(0).element)).toBeDefined()
+    expect(closest('div.baz', $btns.at(0).element)).toBe($baz.element)
+    expect(closest('div.not-here', $btns.at(0).element)).toBe(null)
+    expect(closest('div.baz', $baz.element)).toBe(null)
+    expect(closest('div.baz', $baz.element, true)).toBe($baz.element)
+
+    wrapper.destroy()
+  })
+
+  it('matches() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+
+    const $btns = wrapper.findAll('div.baz > button')
+    expect($btns).toBeDefined()
+    expect($btns.length).toBe(3)
+
+    expect(matches($btns.at(0).element, 'button[disabled]')).toBe(false)
+    expect(matches($btns.at(1).element, 'button[disabled]')).toBe(false)
+    expect(matches($btns.at(2).element, 'button[disabled]')).toBe(true)
+    expect(matches($btns.at(0).element, 'div.baz button')).toBe(true)
+    expect(matches($btns.at(0).element, 'div.baz > button')).toBe(true)
+    expect(matches($btns.at(0).element, '.foo > div.baz > button')).toBe(true)
+    expect(matches($btns.at(0).element, 'div.foo button')).toBe(true)
+    expect(matches($btns.at(0).element, 'div.foo > button')).toBe(false)
+    expect(matches($btns.at(0).element, 'div.bar > button')).toBe(false)
+    expect(matches($btns.at(0).element, 'button#button1')).toBe(true)
+    expect(matches(null, 'div.foo')).toBe(false)
+
+    wrapper.destroy()
+  })
+
+  it('hasAttr() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+
+    const $btns = wrapper.findAll('div.baz > button')
+    expect($btns).toBeDefined()
+    expect($btns.length).toBe(3)
+
+    expect(hasAttr($btns.at(0).element, 'disabled')).toBe(false)
+    expect(hasAttr($btns.at(0).element, 'aria-label')).toBe(true)
+    expect(hasAttr($btns.at(1).element, 'disabled')).toBe(false)
+    expect(hasAttr($btns.at(2).element, 'disabled')).toBe(true)
+    expect(hasAttr($btns.at(2).element, 'role')).toBe(false)
+    expect(hasAttr(null, 'role')).toBe(null)
+
+    wrapper.destroy()
+  })
+
+  it('getAttr() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+
+    const $btns = wrapper.findAll('div.baz > button')
+    expect($btns).toBeDefined()
+    expect($btns.length).toBe(3)
+
+    expect(getAttr($btns.at(0).element, 'aria-label')).toBe('label')
+    expect(getAttr($btns.at(0).element, 'id')).toBe('button1')
+    expect(getAttr($btns.at(1).element, 'aria-label')).toBe(null)
+    expect(getAttr($btns.at(1).element, 'id')).toBe('button2')
+    expect(getAttr($btns.at(2).element, 'aria-label')).toBe(null)
+    expect(getAttr($btns.at(2).element, 'id')).toBe('button3')
+    expect(getAttr(null, 'role')).toBe(null)
+    expect(getAttr($btns.at(0).element, '')).toBe(null)
+    expect(getAttr($btns.at(0).element, undefined)).toBe(null)
+
+    wrapper.destroy()
+  })
+
+  it('getStyle() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+
+    const $span = wrapper.find('span.barspan')
+    expect($span).toBeDefined()
+    expect($span.exists()).toBe(true)
+    expect(getStyle($span.element, 'color')).toBe('red')
+    expect(getStyle($span.element, 'width')).toBe(null)
+    expect(getStyle(null, 'color')).toBe(null)
+
+    wrapper.destroy()
+  })
+
+  it('select() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+
+    const $btns = wrapper.findAll('div.baz > button')
+    expect($btns).toBeDefined()
+    expect($btns.length).toBe(3)
+
+    // With root element specified
+    expect(select('button', wrapper.element)).toBe($btns.at(0).element)
+    expect(select('button#button3', wrapper.element)).toBe($btns.at(2).element)
+    expect(select('span.not-here', wrapper.element)).toBe(null)
+
+    // Note: It appears that `vue-test-utils` is not detaching previous
+    //       app instances and elements once the test is complete!
+    expect(select('button')).not.toBe(null)
+    expect(select('button')).toBe($btns.at(0).element)
+    expect(select('button#button3')).not.toBe(null)
+    expect(select('button#button3')).toBe($btns.at(2).element)
+    expect(select('span.not-here')).toBe(null)
+
+    wrapper.destroy()
+  })
+
+  it('selectAll() works', async () => {
+    const wrapper = mount(App, {
+      attachTo: document.body
+    })
+
+    expect(wrapper).toBeDefined()
+
+    const $btns = wrapper.findAll('div.baz > button')
+    expect($btns).toBeDefined()
+    expect($btns.length).toBe(3)
+
+    // With root element specified
+    expect(Array.isArray(selectAll('button', wrapper.element))).toBe(true)
+    expect(selectAll('button', wrapper.element).length).toBe(3)
+    expect(selectAll('button', wrapper.element)[0]).toBe($btns.at(0).element)
+    expect(selectAll('button', wrapper.element)[1]).toBe($btns.at(1).element)
+    expect(selectAll('button', wrapper.element)[2]).toBe($btns.at(2).element)
+
+    expect(Array.isArray(selectAll('button.fake', wrapper.element))).toBe(true)
+    expect(selectAll('button.fake', wrapper.element).length).toBe(0)
+
+    expect(selectAll('div.baz button', wrapper.element).length).toBe(3)
+    expect(selectAll('div.baz button', wrapper.element)[0]).toBe($btns.at(0).element)
+    expect(selectAll('div.baz button', wrapper.element)[1]).toBe($btns.at(1).element)
+    expect(selectAll('div.baz button', wrapper.element)[2]).toBe($btns.at(2).element)
+
+    // Without root element specified (assumes document as root)
+    // Note: It appears that `vue-test-utils` is not detaching previous
+    //       app instances and elements once the test is complete!
+    expect(Array.isArray(selectAll('button'))).toBe(true)
+    expect(selectAll('button')).not.toEqual([])
+    expect(selectAll('button').length).toBe(3)
+    expect(selectAll('button')[0]).toBe($btns.at(0).element)
+    expect(selectAll('button')[1]).toBe($btns.at(1).element)
+    expect(selectAll('button')[2]).toBe($btns.at(2).element)
+
+    expect(Array.isArray(selectAll('button.fake'))).toBe(true)
+    expect(selectAll('button.fake').length).toBe(0)
+
+    expect(selectAll('div.baz button')).not.toEqual([])
+    expect(selectAll('div.baz button').length).toBe(3)
+    expect(selectAll('div.baz button')[0]).toBe($btns.at(0).element)
+    expect(selectAll('div.baz button')[1]).toBe($btns.at(1).element)
+    expect(selectAll('div.baz button')[2]).toBe($btns.at(2).element)
+
+    wrapper.destroy()
+  })
+})

package/src/vendor/bootstrap-vue/src/utils/events.spec.js

@@ -0,0 +1,41 @@
+import { HAS_PASSIVE_EVENT_SUPPORT } from '../constants/env'
+import { parseEventOptions } from './events'
+
+describe('utils/events', () => {
+  it('event options parsing works', async () => {
+    // JSDOM probably does not support passive mode
+    if (HAS_PASSIVE_EVENT_SUPPORT) {
+      // Converts boolean to object
+      expect(parseEventOptions(true)).toEqual({ capture: true })
+      expect(parseEventOptions(false)).toEqual({ capture: false })
+      expect(parseEventOptions()).toEqual({ capture: false })
+
+      // Parses object correctly (returns as-is)
+      expect(parseEventOptions({ capture: false })).toEqual({ capture: false })
+      expect(parseEventOptions({ capture: true })).toEqual({ capture: true })
+      expect(parseEventOptions({})).toEqual({})
+      expect(parseEventOptions({ capture: false, foobar: true })).toEqual({
+        capture: false,
+        foobar: true
+      })
+      expect(parseEventOptions({ capture: true, foobar: false })).toEqual({
+        capture: true,
+        foobar: false
+      })
+    } else {
+      // Converts non object to boolean
+      expect(parseEventOptions(true)).toEqual(true)
+      expect(parseEventOptions(false)).toEqual(false)
+      expect(parseEventOptions()).toEqual(false)
+      expect(parseEventOptions(null)).toEqual(false)
+      // Converts object to boolean
+      expect(parseEventOptions({ capture: false })).toEqual(false)
+      expect(parseEventOptions({ capture: true })).toEqual(true)
+      expect(parseEventOptions({})).toEqual(false)
+      expect(parseEventOptions({ capture: false, foobar: true })).toEqual(false)
+      expect(parseEventOptions({ capture: true, foobar: true })).toEqual(true)
+      expect(parseEventOptions({ foobar: true })).toEqual(false)
+      expect(parseEventOptions({ foobar: false })).toEqual(false)
+    }
+  })
+})

package/src/vendor/bootstrap-vue/src/utils/get.spec.js

@@ -0,0 +1,109 @@
+import { get } from './get'
+
+describe('get', () => {
+  it('handles invalid values gracefully', async () => {
+    expect(get(null, '')).toBe(null)
+    expect(get({}, null)).toBe(null)
+    expect(get({}, '')).toBe(null)
+    expect(get({}, 'a')).toBe(null)
+    expect(get({}, [])).toBe(null)
+    expect(get({ a: 'b' }, 'b')).toBe(null)
+    expect(get({ a: { c: 'd' } }, 'a.d')).toBe(null)
+  })
+
+  it('returns expected default value', async () => {
+    expect(get(null, '')).toBe(null)
+    expect(get({}, null, undefined)).toBe(null)
+    expect(get({}, '', true)).toBe(true)
+    expect(get({}, 'a', '')).toBe('')
+    expect(get({}, [], 0)).toBe(0)
+    expect(get({ a: 'b' }, 'b', {})).toEqual({})
+    expect(get({ a: { c: 'd' } }, 'a.d', [])).toEqual([])
+    expect(get({ a: { c: undefined } }, 'a.c')).toBe(null)
+    expect(get({ a: 0, b: false }, 'c')).toBe(null)
+  })
+
+  it('returns expected value', async () => {
+    const obj1 = { a: 'b' }
+    const obj2 = { a: { b: { c: { d: 'e' } } } }
+    const obj3 = { a: [{ b: 'c' }] }
+    const obj4 = { a: [[{ b: 'c' }], [{ d: { e: ['f'] } }]] }
+    const obj5 = { a: { b: 0, c: '', d: false } }
+    const obj6 = { a: 0, b: false }
+
+    expect(get(obj1, 'a')).toBe('b')
+    expect(get(obj1, ['a'])).toBe('b')
+    expect(get(obj2, 'a.b.c.d')).toBe('e')
+    expect(get(obj2, ['a', 'b', 'c', 'd'])).toBe('e')
+    expect(get(obj3, 'a[0].b')).toBe('c')
+    expect(get(obj3, ['a', 0, 'b'])).toBe('c')
+    expect(get(obj4, 'a[1][0].d.e[0]')).toBe('f')
+    expect(get(obj4, ['a', 1, 0, 'd', 'e', 0])).toBe('f')
+    expect(get(obj4, ['a[1]', 0, 'd', 'e[0]'])).toBe('f')
+    expect(get(obj5, 'a.b')).toBe(0)
+    expect(get(obj5, 'a.c')).toBe('')
+    expect(get(obj5, 'a.d')).toBe(false)
+    expect(get(obj6, 'a')).toBe(0)
+    expect(get(obj6, 'b')).toBe(false)
+  })
+
+  it('handles when field name has dot', async () => {
+    // https://github.com/bootstrap-vue/bootstrap-vue/issues/2762
+    const obj1 = {
+      'a.b': 'foo',
+      a: { b: 'fiz' },
+      c: 'bar',
+      d: { e: 'baz' },
+      f: { 'g.h': 'faz' },
+      'i.j.k': 'fuz'
+    }
+    const obj2 = {
+      a: { b: 'fiz' },
+      c: 'bar',
+      d: { e: 'baz' }
+    }
+
+    expect(get(obj1, 'a.b')).toBe('foo')
+    expect(get(obj1, 'c')).toBe('bar')
+    expect(get(obj1, 'd.e')).toBe('baz')
+    expect(get(obj1, 'f.g.h', 'zzz')).toBe('zzz')
+    expect(get(obj1, 'f.g.h')).toBe(null)
+    expect(get(obj1, 'f.g', 'zzz')).toBe('zzz')
+    expect(get(obj1, 'f.g')).toBe(null)
+    expect(get(obj1, 'i.j.k')).toBe('fuz')
+    expect(get(obj1, 'i.j', 'zzz')).toBe('zzz')
+    expect(get(obj1, 'i.j')).toBe(null)
+
+    expect(get({ a: 'b' }, '...', true)).toBe(true)
+    expect(get({ a: 'b' }, '...')).toBe(null)
+
+    expect(get(obj2, 'a.b')).toBe('fiz')
+    expect(get(obj2, 'c')).toBe('bar')
+    expect(get(obj2, 'd.e')).toBe('baz')
+  })
+
+  it('handles when field value is not array or object', async () => {
+    // https://github.com/bootstrap-vue/bootstrap-vue/issues/2807
+    const obj1 = {
+      a: { b: 'c' },
+      b: [{ c: 'd' }],
+      c: { d: { e: 'f' } },
+      d: [{ e: [{ f: 'g' }] }]
+    }
+    const obj2 = {
+      a: null,
+      b: undefined,
+      c: 0,
+      d: [null]
+    }
+
+    expect(get(obj1, 'a.b')).toBe('c')
+    expect(get(obj2, 'a.b')).toBe(null)
+    expect(get(obj1, 'b[0].c')).toBe('d')
+    expect(get(obj2, 'b[0].c')).toBe(null)
+    expect(get(obj1, 'c.d.e')).toBe('f')
+    expect(get(obj2, 'c.d.e')).toBe(null)
+    expect(get(obj1, 'd[0].e[0].f')).toBe('g')
+    expect(get(obj2, 'd[0].e[0].f')).toBe(null)
+  })
+})

package/src/vendor/bootstrap-vue/src/utils/inspect.spec.js

@@ -0,0 +1,251 @@
+import {
+  toType,
+  toRawType,
+  toRawTypeLC,
+  isUndefined,
+  isNull,
+  isUndefinedOrNull,
+  isFunction,
+  isBoolean,
+  isString,
+  isNumber,
+  isNumeric,
+  isPrimitive,
+  isDate,
+  isEvent,
+  isRegExp,
+  isPromise
+} from './inspect'
+
+describe('utils/inspect', () => {
+  it('toType()', async () => {
+    expect(toType(123)).toEqual('number')
+    expect(toType('123')).toEqual('string')
+    expect(toType(true)).toEqual('boolean')
+    expect(toType({})).toEqual('object')
+    expect(toType([])).toEqual('object')
+    expect(toType(/abc/)).toEqual('object')
+    expect(toType(() => {})).toEqual('function')
+    expect(toType(Date)).toEqual('function')
+    expect(toType(new Date())).toEqual('object')
+    expect(toType(undefined)).toEqual('undefined')
+    expect(toType(null)).toEqual('object')
+  })
+
+  it('toRawType()', async () => {
+    expect(toRawType(123)).toEqual('Number')
+    expect(toRawType('123')).toEqual('String')
+    expect(toRawType(true)).toEqual('Boolean')
+    expect(toRawType({})).toEqual('Object')
+    expect(toRawType([])).toEqual('Array')
+    expect(toRawType(/abc/)).toEqual('RegExp')
+    expect(toRawType(() => {})).toEqual('Function')
+    expect(toRawType(Date)).toEqual('Function')
+    expect(toRawType(new Date())).toEqual('Date')
+    expect(toRawType(undefined)).toEqual('Undefined')
+    expect(toRawType(null)).toEqual('Null')
+  })
+
+  it('toRawTypeLC()', async () => {
+    expect(toRawTypeLC(123)).toEqual('number')
+    expect(toRawTypeLC('123')).toEqual('string')
+    expect(toRawTypeLC(true)).toEqual('boolean')
+    expect(toRawTypeLC({})).toEqual('object')
+    expect(toRawTypeLC([])).toEqual('array')
+    expect(toRawTypeLC(/abc/)).toEqual('regexp')
+    expect(toRawTypeLC(() => {})).toEqual('function')
+    expect(toRawTypeLC(Date)).toEqual('function')
+    expect(toRawTypeLC(new Date())).toEqual('date')
+    expect(toRawTypeLC(undefined)).toEqual('undefined')
+    expect(toRawTypeLC(null)).toEqual('null')
+  })
+
+  it('isUndefined()', async () => {
+    expect(isUndefined(123)).toEqual(false)
+    expect(isUndefined('123')).toEqual(false)
+    expect(isUndefined(true)).toEqual(false)
+    expect(isUndefined({})).toEqual(false)
+    expect(isUndefined([])).toEqual(false)
+    expect(isUndefined(/abc/)).toEqual(false)
+    expect(isUndefined(() => {})).toEqual(false)
+    expect(isUndefined(Date)).toEqual(false)
+    expect(isUndefined(new Date())).toEqual(false)
+    expect(isUndefined(undefined)).toEqual(true)
+    expect(isUndefined(null)).toEqual(false)
+  })
+
+  it('isNull()', async () => {
+    expect(isNull(123)).toEqual(false)
+    expect(isNull('123')).toEqual(false)
+    expect(isNull(true)).toEqual(false)
+    expect(isNull({})).toEqual(false)
+    expect(isNull([])).toEqual(false)
+    expect(isNull(/abc/)).toEqual(false)
+    expect(isNull(() => {})).toEqual(false)
+    expect(isNull(Date)).toEqual(false)
+    expect(isNull(new Date())).toEqual(false)
+    expect(isNull(undefined)).toEqual(false)
+    expect(isNull(null)).toEqual(true)
+  })
+
+  it('isUndefinedOrNull()', async () => {
+    expect(isUndefinedOrNull(123)).toEqual(false)
+    expect(isUndefinedOrNull('123')).toEqual(false)
+    expect(isUndefinedOrNull(true)).toEqual(false)
+    expect(isUndefinedOrNull({})).toEqual(false)
+    expect(isUndefinedOrNull([])).toEqual(false)
+    expect(isUndefinedOrNull(/abc/)).toEqual(false)
+    expect(isUndefinedOrNull(() => {})).toEqual(false)
+    expect(isUndefinedOrNull(Date)).toEqual(false)
+    expect(isUndefinedOrNull(new Date())).toEqual(false)
+    expect(isUndefinedOrNull(undefined)).toEqual(true)
+    expect(isUndefinedOrNull(null)).toEqual(true)
+  })
+
+  it('isFunction()', async () => {
+    expect(isFunction(123)).toEqual(false)
+    expect(isFunction('123')).toEqual(false)
+    expect(isFunction(true)).toEqual(false)
+    expect(isFunction({})).toEqual(false)
+    expect(isFunction([])).toEqual(false)
+    expect(isFunction(/abc/)).toEqual(false)
+    expect(isFunction(() => {})).toEqual(true)
+    expect(isFunction(Date)).toEqual(true)
+    expect(isFunction(new Date())).toEqual(false)
+    expect(isFunction(undefined)).toEqual(false)
+    expect(isFunction(null)).toEqual(false)
+  })
+
+  it('isBoolean()', async () => {
+    expect(isBoolean(123)).toEqual(false)
+    expect(isBoolean('123')).toEqual(false)
+    expect(isBoolean(true)).toEqual(true)
+    expect(isBoolean({})).toEqual(false)
+    expect(isBoolean([])).toEqual(false)
+    expect(isBoolean(/abc/)).toEqual(false)
+    expect(isBoolean(() => {})).toEqual(false)
+    expect(isBoolean(Date)).toEqual(false)
+    expect(isBoolean(new Date())).toEqual(false)
+    expect(isBoolean(undefined)).toEqual(false)
+    expect(isBoolean(null)).toEqual(false)
+  })
+
+  it('isString()', async () => {
+    expect(isString(123)).toEqual(false)
+    expect(isString('123')).toEqual(true)
+    expect(isString(true)).toEqual(false)
+    expect(isString({})).toEqual(false)
+    expect(isString([])).toEqual(false)
+    expect(isString(/abc/)).toEqual(false)
+    expect(isString(() => {})).toEqual(false)
+    expect(isString(Date)).toEqual(false)
+    expect(isString(new Date())).toEqual(false)
+    expect(isString(undefined)).toEqual(false)
+    expect(isString(null)).toEqual(false)
+  })
+
+  it('isNumber()', async () => {
+    expect(isNumber(123)).toEqual(true)
+    expect(isNumber(123.5)).toEqual(true)
+    expect(isNumber('123')).toEqual(false)
+    expect(isNumber(true)).toEqual(false)
+    expect(isNumber({})).toEqual(false)
+    expect(isNumber([])).toEqual(false)
+    expect(isNumber(/abc/)).toEqual(false)
+    expect(isNumber(() => {})).toEqual(false)
+    expect(isNumber(Date)).toEqual(false)
+    expect(isNumber(new Date())).toEqual(false)
+    expect(isNumber(undefined)).toEqual(false)
+    expect(isNumber(null)).toEqual(false)
+  })
+
+  it('isNumeric()', async () => {
+    expect(isNumeric(123)).toEqual(true)
+    expect(isNumeric(123.5)).toEqual(true)
+    expect(isNumeric('123')).toEqual(true)
+    expect(isNumeric('123.5')).toEqual(true)
+    expect(isNumeric('123,5')).toEqual(false)
+    expect(isNumeric(true)).toEqual(false)
+    expect(isNumeric({})).toEqual(false)
+    expect(isNumeric([])).toEqual(false)
+    expect(isNumeric(/abc/)).toEqual(false)
+    expect(isNumeric(() => {})).toEqual(false)
+    expect(isNumeric(Date)).toEqual(false)
+    expect(isNumeric(new Date())).toEqual(false)
+    expect(isNumeric(undefined)).toEqual(false)
+    expect(isNumeric(null)).toEqual(false)
+  })
+
+  it('isPrimitive()', async () => {
+    expect(isPrimitive(123)).toEqual(true)
+    expect(isPrimitive('123')).toEqual(true)
+    expect(isPrimitive(true)).toEqual(true)
+    expect(isPrimitive({})).toEqual(false)
+    expect(isPrimitive([])).toEqual(false)
+    expect(isPrimitive(/abc/)).toEqual(false)
+    expect(isPrimitive(() => {})).toEqual(false)
+    expect(isPrimitive(Date)).toEqual(false)
+    expect(isPrimitive(new Date())).toEqual(false)
+    expect(isPrimitive(undefined)).toEqual(false)
+    expect(isPrimitive(null)).toEqual(false)
+  })
+
+  it('isDate()', async () => {
+    expect(isDate(123)).toEqual(false)
+    expect(isDate('123')).toEqual(false)
+    expect(isDate(true)).toEqual(false)
+    expect(isDate({})).toEqual(false)
+    expect(isDate([])).toEqual(false)
+    expect(isDate(/abc/)).toEqual(false)
+    expect(isDate(() => {})).toEqual(false)
+    expect(isDate(Date)).toEqual(false)
+    expect(isDate(new Date())).toEqual(true)
+    expect(isDate(undefined)).toEqual(false)
+    expect(isDate(null)).toEqual(false)
+  })
+
+  it('isEvent()', async () => {
+    expect(isEvent(123)).toEqual(false)
+    expect(isEvent('123')).toEqual(false)
+    expect(isEvent(true)).toEqual(false)
+    expect(isEvent({})).toEqual(false)
+    expect(isEvent([])).toEqual(false)
+    expect(isEvent(/abc/)).toEqual(false)
+    expect(isEvent(() => {})).toEqual(false)
+    expect(isEvent(Date)).toEqual(false)
+    expect(isEvent(new Date())).toEqual(false)
+    expect(isEvent(Event)).toEqual(false)
+    expect(isEvent(new Event('click'))).toEqual(true)
+    expect(isEvent(undefined)).toEqual(false)
+    expect(isEvent(null)).toEqual(false)
+  })
+
+  it('isRegExp()', async () => {
+    expect(isRegExp(123)).toEqual(false)
+    expect(isRegExp('123')).toEqual(false)
+    expect(isRegExp(true)).toEqual(false)
+    expect(isRegExp({})).toEqual(false)
+    expect(isRegExp([])).toEqual(false)
+    expect(isRegExp(/abc/)).toEqual(true)
+    expect(isRegExp(() => {})).toEqual(false)
+    expect(isRegExp(Date)).toEqual(false)
+    expect(isRegExp(new Date())).toEqual(false)
+    expect(isRegExp(undefined)).toEqual(false)
+    expect(isRegExp(null)).toEqual(false)
+  })
+
+  it('isPromise()', async () => {
+    expect(isPromise(123)).toEqual(false)
+    expect(isPromise('123')).toEqual(false)
+    expect(isPromise(true)).toEqual(false)
+    expect(isPromise({})).toEqual(false)
+    expect(isPromise([])).toEqual(false)
+    expect(isPromise(/abc/)).toEqual(false)
+    expect(isPromise(() => {})).toEqual(false)
+    expect(isPromise(Date)).toEqual(false)
+    expect(isPromise(new Date())).toEqual(false)
+    expect(isPromise(undefined)).toEqual(false)
+    expect(isPromise(null)).toEqual(false)
+    expect(isPromise({ then() {}, catch() {} })).toEqual(true)
+  })
+})