text: let { equal, is, throws } = require('uvu/assert')
  let { test } = require('uvu')
  
  let utils = require('../lib/utils')
  
  test('raises an error', () => {
    throws(() => {
      utils.error('A')
    }, 'A')
  })
  
  test('marks an error', () => {
    let error = null
    try {
      utils.error('A')
    } catch (e) {
      error = e
    }
  
    is(error.autoprefixer, true)
  })
  
  test('filters doubles in array', () => {
    equal(utils.uniq(['1', '1', '2', '3', '3']), ['1', '2', '3'])
  })
  
  test('removes note', () => {
    equal(utils.removeNote('-webkit- note'), '-webkit-')
    equal(utils.removeNote('-webkit-'), '-webkit-')
  })
  
  test('escapes RegExp symbols', () => {
    equal(utils.escapeRegexp('^[()\\]'), '\\^\\[\\(\\)\\\\\\]')
  })
  
  test('generates RegExp that finds tokens in CSS values', () => {
    let regexp = utils.regexp('foo')
    function check(string) {
      return string.match(regexp) !== null
    }
  
    is(check('foo'), true)
    is(check('Foo'), true)
    is(check('one, foo, two'), true)
    is(check('one(),foo(),two()'), true)
  
    equal('foo(), a, foo'.replace(regexp, '$1b$2'), 'bfoo(), a, bfoo')
  
    is(check('foob'), false)
    is(check('(foo)'), false)
    is(check('-a-foo'), false)
  })
  
  test('escapes string if needed', () => {
    let regexp = utils.regexp('(a|b)')
    function check(string) {
      return string.match(regexp) !== null
    }
  
    is(check('a'), false)
    is(check('(a|b)'), true)
  
    regexp = utils.regexp('(a|b)', false)
    is(check('a'), true)
    is(check('b'), true)
  })
  
  test('does save without changes', () => {
    let list = utils.editList('a,\nb, c', parsed => parsed)
    equal(list, 'a,\nb, c')
  })
  
  test('changes list', () => {
    let list = utils.editList('a, b', (parsed, edit) => {
      equal(parsed, ['a', 'b'])
      equal(edit, [])
      return ['1', '2']
    })
    equal(list, '1, 2')
  })
  
  test('saves comma', () => {
    let list = utils.editList('a,\nb', () => ['1', '2'])
    equal(list, '1,\n2')
  })
  
  test('parse one value', () => {
    let list = utils.editList('1', parsed => [parsed[0], '2'])
    equal(list, '1, 2')
  })
  
  test('splits simple selectors into an array', () => {
    let arr1 = utils.splitSelector('#foo.bar')
    let arr2 = utils.splitSelector('.foo, .bar')
    equal(arr1, [[['#foo', '.bar']]])
    equal(arr2, [[['.foo']], [['.bar']]])
  })
  
  test('splits complex selectors into an array', () => {
    let arr = utils.splitSelector(
      '#foo.bar .child-one.mod .child-two.mod, .baz, .hello'
    )
    equal(arr, [
      [
        ['#foo', '.bar'],
        ['.child-one', '.mod'],
        ['.child-two', '.mod']
      ],
      [['.baz']],
      [['.hello']]
    ])
  })
  
  test('detects numbers', () => {
    equal(utils.isPureNumber(42), true)
    equal(utils.isPureNumber('42'), true)
    equal(utils.isPureNumber('autoprefixer'), false)
    equal(utils.isPureNumber(''), false)
    equal(utils.isPureNumber({}), false)
    equal(utils.isPureNumber(undefined), false)
    equal(utils.isPureNumber(true), false)
  })
  
  test.run()
  