# Code coverage report for ./../tap/lib/synonyms.js

## Statements: 94.74% (18 / 19) Branches: 75% (3 / 4) Functions: 100% (4 / 4) Lines: 94.74% (18 / 19) Ignored: none

All files » ./../tap/lib/ » synonyms.js

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92

    9

    9
    9
    126
    126
    126
    846
    846

    126

    9

    9
    846
    846
    603
    603
    783

    846

    9

     // A list of all the synonyms of assert methods.
    // In addition to these, multi-word camelCase are also synonymized to
    // all lowercase and snake_case
    module.exports = multiword({
      ok: ['true', 'assert'],
      notOk: ['false', 'assertNot'],

      error: ['ifError', 'ifErr'],
      throws: ['throw'],
      doesNotThrow: ['notThrow'],

      // exactly the same.  ===
      equal: [
        'equals', 'isEqual', 'is', 'strictEqual', 'strictEquals', 'strictIs',
        'isStrict', 'isStrictly'
      ],

      // not equal.  !==
      not: [
        'inequal', 'notEqual', 'notEquals', 'notStrictEqual', 'notStrictEquals',
        'isNotEqual', 'isNot', 'doesNotEqual', 'isInequal'
      ],

      // deep equivalence.  == for scalars
      same: [
        'equivalent', 'looseEqual', 'looseEquals', 'deepEqual',
        'deepEquals', 'isLoose', 'looseIs', 'isEquivalent'
      ],

      // deep inequivalence. != for scalars
      notSame: [
        'inequivalent', 'looseInequal', 'notDeep', 'deepInequal',
        'notLoose', 'looseNot', 'notEquivalent', 'isNotDeepEqual',
        'isNotDeeply', 'notDeepEqual', 'isInequivalent',
        'isNotEquivalent'
      ],

      // deep equivalence, === for scalars
      strictSame: [
        'strictEquivalent', 'strictDeepEqual', 'sameStrict', 'deepIs',
        'isDeeply', 'isDeep', 'strictDeepEquals'
      ],

      // deep inequivalence, !== for scalars
      strictNotSame: [
        'strictInequivalent', 'strictDeepInequal', 'notSameStrict', 'deepNot',
        'notDeeply', 'strictDeepInequals', 'notStrictSame'
      ],

      // found has the fields in wanted, string matches regexp
      match: [
        'has', 'hasFields', 'matches', 'similar', 'like', 'isLike',
        'includes', 'include', 'isSimilar'
      ],

      notMatch: [
        'dissimilar', 'unsimilar', 'notSimilar', 'unlike', 'isUnlike',
        'notLike', 'isNotLike', 'doesNotHave', 'isNotSimilar', 'isDissimilar'
      ],

      type: [
        'isa', 'isA'
      ]
    })

    function multiword (obj) {
      for (var i in obj) {
        var list = obj[i]
        var res = [ multiword_(i) ].concat(list.map(multiword_))
        res = res.reduce(function (set, i) {
          set.push.apply(set, i)
          return set
        }, [])
        obj[i] = res
      }
      return obj
    }

    function multiword_ (str) {
      var res = [ str ]
      if (str.match(/[A-Z]/)) {
        res.push(str.toLowerCase())
        res.push(str.replace(/[A-Z]/g, function ($0) {
          return '_' + $0.toLowerCase()
        }))
      }
      return res
    }

    Iif (require.main === module)
      console.log(module.exports)