test.js

const tap = require('tap')
const Strings = require('./lib/index')

tap.test('normalizeLocale', t => {
  t.strictEqual(Strings.normalizeLocale(), undefined)
  t.strictEqual(Strings.normalizeLocale(null), undefined)
  t.strictEqual(Strings.normalizeLocale(''), undefined)
  t.strictEqual(Strings.normalizeLocale('en-US'), 'en-US')
  t.strictEqual(Strings.normalizeLocale('en_US'), 'en-US')

  t.strictEqual(Strings.normalizeLocale('fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5'), 'fr-CH')
  t.strictEqual(Strings.normalizeLocale('fr-CH,fr;q=0.9,en;q=0.8,de;q=0.7,*;q=0.5'), 'fr-CH')
  t.strictEqual(Strings.normalizeLocale('fr,fr-CH;q=0.9,en;q=0.8,de;q=0.7,*;q=0.5'), 'fr')

  t.strictEqual(Strings.normalizeLocale('fr ; q = 0.9 , en_US; q=1, en;q =1 ,*'), 'en-US')
  t.strictEqual(Strings.normalizeLocale('*,en'), 'en')
  t.strictEqual(Strings.normalizeLocale('*, en'), 'en')
  t.strictEqual(Strings.normalizeLocale('* ,en'), 'en')
  t.strictEqual(Strings.normalizeLocale('* ,en;q'), 'en')
  t.strictEqual(Strings.normalizeLocale('* ,en;q='), 'en')
  t.strictEqual(Strings.normalizeLocale('* ,en;q=0'), 'en')
  t.strictEqual(Strings.normalizeLocale('*'), undefined)

  t.strictEqual(Strings.normalizeLocale(['en;q=0.8', 'fr-CH, fr;q=0.9', 'de;q=0.7,*;q=0.5']), 'fr-CH')
  t.strictEqual(Strings.normalizeLocale(['*', '', null, undefined, 'en;q=0.8']), 'en')
  t.strictEqual(Strings.normalizeLocale(['*']), undefined)
  t.strictEqual(Strings.normalizeLocale([]), undefined)

  t.end()
})

tap.test('toUpper', t => {
  t.strictEqual(Strings.toUpper(), '')
  t.strictEqual(Strings.toUpper(null), '')
  t.strictEqual(Strings.toUpper(''), '')
  t.strictEqual(Strings.toUpper('abc'), 'ABC')
  t.strictEqual(Strings.toUpper('abc', 'en-US'), 'ABC')
  t.strictEqual(Strings.toUpper('abc', 'en_US'), 'ABC')
  t.strictEqual(Strings.toUpper('abc', 'invalid locale'), 'ABC')
  t.strictEqual(Strings.toUpper('abc', ['en-US', 'invalid locale']), 'ABC')
  t.strictEqual(Strings.toUpper('лександра'), 'ЛЕКСАНДРА')
  t.strictEqual(Strings.toUpper('łukasz'), 'ŁUKASZ')
  t.end()
})

tap.test('toLower', t => {
  t.strictEqual(Strings.toLower(), '')
  t.strictEqual(Strings.toLower(null), '')
  t.strictEqual(Strings.toLower(''), '')
  t.strictEqual(Strings.toLower('ABC'), 'abc')
  t.strictEqual(Strings.toLower('ABC', 'en-US'), 'abc')
  t.strictEqual(Strings.toLower('ABC', 'en_US'), 'abc')
  t.strictEqual(Strings.toLower('ABC', 'invalid locale'), 'abc')
  t.strictEqual(Strings.toLower('ABC', ['en-US', 'invalid locale']), 'abc')
  t.strictEqual(Strings.toLower('ЛЕКСАНДРА'), 'лександра')
  t.strictEqual(Strings.toLower('ŁUKASZ'), 'łukasz')
  t.end()
})

tap.test('toFirstLetterUpper', t => {
  t.strictEqual(Strings.toFirstLetterUpper(), '')
  t.strictEqual(Strings.toFirstLetterUpper(null), '')
  t.strictEqual(Strings.toFirstLetterUpper(''), '')
  t.strictEqual(Strings.toFirstLetterUpper('ABC'), 'ABC')
  t.strictEqual(Strings.toFirstLetterUpper('1bc'), '1bc')
  t.strictEqual(Strings.toFirstLetterUpper('abc'), 'Abc')
  t.strictEqual(Strings.toFirstLetterUpper('abc', 'en-US'), 'Abc')
  t.strictEqual(Strings.toFirstLetterUpper('abc', 'en_US'), 'Abc')
  t.strictEqual(Strings.toFirstLetterUpper('abc', 'invalid locale'), 'Abc')
  t.strictEqual(Strings.toFirstLetterUpper('abc', ['en-US', 'invalid locale']), 'Abc')
  t.strictEqual(Strings.toFirstLetterUpper('abc de'), 'Abc de')
  t.strictEqual(Strings.toFirstLetterUpper('a'), 'A')
  t.strictEqual(Strings.toFirstLetterUpper('ab'), 'Ab')
  t.strictEqual(Strings.toFirstLetterUpper('лександра'), 'Лександра')
  t.strictEqual(Strings.toFirstLetterUpper('łukasz'), 'Łukasz')
  t.end()
})

tap.test('isUpper', t => {
  t.strictEqual(Strings.isUpper(), false)
  t.strictEqual(Strings.isUpper(null), false)
  t.strictEqual(Strings.isUpper(''), false)
  t.strictEqual(Strings.isUpper('a'), false)
  t.strictEqual(Strings.isUpper('A'), true)
  t.strictEqual(Strings.isUpper('a', 'en-US'), false)
  t.strictEqual(Strings.isUpper('A', 'en-US'), true)
  t.strictEqual(Strings.isUpper('a', 'en_US'), false)
  t.strictEqual(Strings.isUpper('A', 'en_US'), true)
  t.strictEqual(Strings.isUpper('a', 'invalid locale'), false)
  t.strictEqual(Strings.isUpper('A', 'invalid locale'), true)
  t.strictEqual(Strings.isUpper('a', ['en-US', 'invalid locale']), false)
  t.strictEqual(Strings.isUpper('A', ['en-US', 'invalid locale']), true)
  t.strictEqual(Strings.isUpper('л'), false)
  t.strictEqual(Strings.isUpper('ł'), false)
  t.strictEqual(Strings.isUpper('Л'), true)
  t.strictEqual(Strings.isUpper('Ł'), true)
  t.end()
})

tap.test('toPlural', t => {
  t.strictEqual(Strings.toPlural(), '')
  t.strictEqual(Strings.toPlural(null), '')
  t.strictEqual(Strings.toPlural(''), '')
  t.strictEqual(Strings.toPlural('plan'), 'plans')
  t.strictEqual(Strings.toPlural('PLAN'), 'PLANS')
  t.strictEqual(Strings.toPlural('category'), 'categories')
  t.strictEqual(Strings.toPlural('CATEGORY'), 'CATEGORIES')
  t.strictEqual(Strings.toPlural('glass'), 'glasses')
  t.strictEqual(Strings.toPlural('GLASS'), 'GLASSES')
  t.strictEqual(Strings.toPlural('box'), 'boxes')
  t.strictEqual(Strings.toPlural('BOX'), 'BOXES')
  t.strictEqual(Strings.toPlural('batch'), 'batches')
  t.strictEqual(Strings.toPlural('BATCH'), 'BATCHES')

  t.strictEqual(Strings.toPlural('plan', {}), 'plans')
  t.strictEqual(Strings.toPlural('plan', { locale: undefined }), 'plans')
  t.strictEqual(Strings.toPlural('plan', { locale: null }), 'plans')

  t.strictEqual(Strings.toPlural('plan', { locale: 'en-US' }), 'plans')
  t.strictEqual(Strings.toPlural('plan', { locale: 'en_US' }), 'plans')
  t.strictEqual(Strings.toPlural('plan', { locale: 'invalid locale' }), 'plans')
  t.strictEqual(Strings.toPlural('plan', { locale: ['en-US', 'invalid locale'] }), 'plans')
  t.strictEqual(Strings.toPlural('PLAN', { locale: 'en-US' }), 'PLANS')
  t.strictEqual(Strings.toPlural('PLAN', { locale: 'en_US' }), 'PLANS')
  t.strictEqual(Strings.toPlural('PLAN', { locale: 'invalid locale' }), 'PLANS')
  t.strictEqual(Strings.toPlural('PLAN', { locale: ['en-US', 'invalid locale'] }), 'PLANS')

  t.strictEqual(Strings.toPlural('plan', { suffix: 'tain' }), 'plantain')
  t.strictEqual(Strings.toPlural('PLAN', { suffix: 'tain' }), 'PLANTAIN')

  t.strictEqual(Strings.toPlural('plan', { locale: 'en-US', suffix: 'tain' }), 'plantain')
  t.strictEqual(Strings.toPlural('PLAN', { locale: 'en-US', suffix: 'tain' }), 'PLANTAIN')
  t.strictEqual(Strings.toPlural('plan', { locale: 'en_US', suffix: 'tain' }), 'plantain')
  t.strictEqual(Strings.toPlural('PLAN', { locale: 'en_US', suffix: 'tain' }), 'PLANTAIN')
  t.strictEqual(Strings.toPlural('plan', { locale: 'invalid locale', suffix: 'tain' }), 'plantain')
  t.strictEqual(Strings.toPlural('PLAN', { locale: 'invalid locale', suffix: 'tain' }), 'PLANTAIN')
  t.strictEqual(Strings.toPlural('plan', { locale: ['en-US', 'invalid locale'], suffix: 'tain' }), 'plantain')

  t.end()
})

tap.test('formatInt', t => {
  t.strictEqual(Strings.formatInt(), 'NaN')
  t.strictEqual(Strings.formatInt(null), '0')
  t.strictEqual(Strings.formatInt(0), '0')
  t.strictEqual(Strings.formatInt(1), '1')
  t.strictEqual(Strings.formatInt(2), '2')
  t.strictEqual(Strings.formatInt(1234567), '1,234,567')
  t.strictEqual(Strings.formatInt('x'), 'NaN')
  t.strictEqual(Strings.formatInt('9e10'), '90,000,000,000')
  t.strictEqual(Strings.formatInt(Infinity), '∞')

  t.strictEqual(Strings.formatInt(null, 'en-US'), '0')
  t.strictEqual(Strings.formatInt(0, 'en-US'), '0')
  t.strictEqual(Strings.formatInt(1, 'en-US'), '1')
  t.strictEqual(Strings.formatInt(2, 'en-US'), '2')
  t.strictEqual(Strings.formatInt(1234567, 'en-US'), '1,234,567')
  t.strictEqual(Strings.formatInt('x', 'en-US'), 'NaN')
  t.strictEqual(Strings.formatInt('9e10', 'en-US'), '90,000,000,000')
  t.strictEqual(Strings.formatInt(Infinity, 'en-US'), '∞')

  t.strictEqual(Strings.formatInt(null, 'en_US'), '0')
  t.strictEqual(Strings.formatInt(0, 'en_US'), '0')
  t.strictEqual(Strings.formatInt(1, 'en_US'), '1')
  t.strictEqual(Strings.formatInt(2, 'en_US'), '2')
  t.strictEqual(Strings.formatInt(1234567, 'en_US'), '1,234,567')
  t.strictEqual(Strings.formatInt('x', 'en_US'), 'NaN')
  t.strictEqual(Strings.formatInt('9e10', 'en_US'), '90,000,000,000')
  t.strictEqual(Strings.formatInt(Infinity, 'en-US'), '∞')

  t.strictEqual(Strings.formatInt(null, 'invalid locale'), 'null')
  t.strictEqual(Strings.formatInt(0, 'invalid locale'), '0')
  t.strictEqual(Strings.formatInt(1, 'invalid locale'), '1')
  t.strictEqual(Strings.formatInt(2, 'invalid locale'), '2')
  t.strictEqual(Strings.formatInt(1234567, 'invalid locale'), '1234567')
  t.strictEqual(Strings.formatInt('x', 'invalid locale'), 'x')
  t.strictEqual(Strings.formatInt('9e10', 'invalid locale'), '9e10')
  t.strictEqual(Strings.formatInt(Infinity, 'invalid locale'), 'Infinity')

  t.strictEqual(Strings.formatInt(1234567, ['en_US', 'invalid locale']), '1,234,567')

  t.end()
})

tap.test('pluralize', t => {
  t.strictEqual(Strings.pluralize(), '')
  t.strictEqual(Strings.pluralize(null), '')
  t.strictEqual(Strings.pluralize(''), '')
  t.strictEqual(Strings.pluralize(1), '')
  t.strictEqual(Strings.pluralize(0), '')
  t.strictEqual(Strings.pluralize(2), '')

  t.strictEqual(Strings.pluralize(1, null), '')
  t.strictEqual(Strings.pluralize(1, ''), '')

  t.strictEqual(Strings.pluralize(1, 'guy'), '1 guy')
  t.strictEqual(Strings.pluralize(0, 'guy'), '0 guies')
  t.strictEqual(Strings.pluralize(2, 'guy'), '2 guies')
  t.strictEqual(Strings.pluralize(1000, 'guy'), '1,000 guies')
  t.strictEqual(Strings.pluralize(1, 'GUY'), '1 GUY')
  t.strictEqual(Strings.pluralize(0, 'GUY'), '0 GUIES')
  t.strictEqual(Strings.pluralize(2, 'GUY'), '2 GUIES')
  t.strictEqual(Strings.pluralize(1000, 'GUY'), '1,000 GUIES')

  t.strictEqual(Strings.pluralize(1, 'guy', 's'), '1 guy')
  t.strictEqual(Strings.pluralize(0, 'guy', 's'), '0 guys')
  t.strictEqual(Strings.pluralize(2, 'guy', 's'), '2 guys')
  t.strictEqual(Strings.pluralize(1000, 'guy', 's'), '1,000 guys')
  t.strictEqual(Strings.pluralize(1, 'GUY', 's'), '1 GUY')
  t.strictEqual(Strings.pluralize(0, 'GUY', 's'), '0 GUYS')
  t.strictEqual(Strings.pluralize(2, 'GUY', 's'), '2 GUYS')
  t.strictEqual(Strings.pluralize(1000, 'GUY', 's'), '1,000 GUYS')

  t.strictEqual(Strings.pluralize(1, 'guy', {}), '1 guy')
  t.strictEqual(Strings.pluralize(2, 'guy', {}), '2 guies')

  t.strictEqual(Strings.pluralize(1, 'guy', { locale: 'en-US' }), '1 guy')
  t.strictEqual(Strings.pluralize(0, 'guy', { locale: 'en-US' }), '0 guies')
  t.strictEqual(Strings.pluralize(2, 'guy', { locale: 'en-US' }), '2 guies')
  t.strictEqual(Strings.pluralize(1000, 'guy', { locale: 'en-US' }), '1,000 guies')
  t.strictEqual(Strings.pluralize(1, 'GUY', { locale: 'en-US' }), '1 GUY')
  t.strictEqual(Strings.pluralize(0, 'GUY', { locale: 'en-US' }), '0 GUIES')
  t.strictEqual(Strings.pluralize(2, 'GUY', { locale: 'en-US' }), '2 GUIES')
  t.strictEqual(Strings.pluralize(1000, 'GUY', { locale: 'en-US' }), '1,000 GUIES')

  t.strictEqual(Strings.pluralize(1, 'guy', { locale: 'en_US' }), '1 guy')
  t.strictEqual(Strings.pluralize(0, 'guy', { locale: 'en_US' }), '0 guies')
  t.strictEqual(Strings.pluralize(2, 'guy', { locale: 'en_US' }), '2 guies')
  t.strictEqual(Strings.pluralize(1000, 'guy', { locale: 'en_US' }), '1,000 guies')
  t.strictEqual(Strings.pluralize(1, 'GUY', { locale: 'en_US' }), '1 GUY')
  t.strictEqual(Strings.pluralize(0, 'GUY', { locale: 'en_US' }), '0 GUIES')
  t.strictEqual(Strings.pluralize(2, 'GUY', { locale: 'en_US' }), '2 GUIES')
  t.strictEqual(Strings.pluralize(1000, 'GUY', { locale: 'en_US' }), '1,000 GUIES')

  t.strictEqual(Strings.pluralize(1, 'guy', { locale: 'invalid locale' }), '1 guy')
  t.strictEqual(Strings.pluralize(0, 'guy', { locale: 'invalid locale' }), '0 guies')
  t.strictEqual(Strings.pluralize(2, 'guy', { locale: 'invalid locale' }), '2 guies')
  t.strictEqual(Strings.pluralize(1000, 'guy', { locale: 'invalid locale' }), '1000 guies')
  t.strictEqual(Strings.pluralize(1, 'GUY', { locale: 'invalid locale' }), '1 GUY')
  t.strictEqual(Strings.pluralize(0, 'GUY', { locale: 'invalid locale' }), '0 GUIES')
  t.strictEqual(Strings.pluralize(2, 'GUY', { locale: 'invalid locale' }), '2 GUIES')
  t.strictEqual(Strings.pluralize(1000, 'GUY', { locale: 'invalid locale' }), '1000 GUIES')

  t.strictEqual(Strings.pluralize(1, 'guy', { suffix: 's' }), '1 guy')
  t.strictEqual(Strings.pluralize(0, 'guy', { suffix: 's' }), '0 guys')
  t.strictEqual(Strings.pluralize(2, 'guy', { suffix: 's' }), '2 guys')
  t.strictEqual(Strings.pluralize(1000, 'guy', { suffix: 's' }), '1,000 guys')
  t.strictEqual(Strings.pluralize(1, 'GUY', { suffix: 's' }), '1 GUY')
  t.strictEqual(Strings.pluralize(0, 'GUY', { suffix: 's' }), '0 GUYS')
  t.strictEqual(Strings.pluralize(2, 'GUY', { suffix: 's' }), '2 GUYS')
  t.strictEqual(Strings.pluralize(1000, 'GUY', { suffix: 's' }), '1,000 GUYS')

  t.strictEqual(Strings.pluralize(1, 'guy', { suffix: 's', locale: 'en-US' }), '1 guy')
  t.strictEqual(Strings.pluralize(0, 'guy', { suffix: 's', locale: 'en-US' }), '0 guys')
  t.strictEqual(Strings.pluralize(2, 'guy', { suffix: 's', locale: 'en-US' }), '2 guys')
  t.strictEqual(Strings.pluralize(1000, 'guy', { suffix: 's', locale: 'en-US' }), '1,000 guys')
  t.strictEqual(Strings.pluralize(1, 'GUY', { suffix: 's', locale: 'en-US' }), '1 GUY')
  t.strictEqual(Strings.pluralize(0, 'GUY', { suffix: 's', locale: 'en-US' }), '0 GUYS')
  t.strictEqual(Strings.pluralize(2, 'GUY', { suffix: 's', locale: 'en-US' }), '2 GUYS')
  t.strictEqual(Strings.pluralize(1000, 'GUY', { suffix: 's', locale: 'en-US' }), '1,000 GUYS')

  t.strictEqual(Strings.pluralize(1000, 'guy', { suffix: 's', locale: 'invalid locale' }), '1000 guys')
  t.strictEqual(Strings.pluralize(1000, 'GUY', { suffix: 's', locale: 'invalid locale' }), '1000 GUYS')

  t.strictEqual(Strings.pluralize(1000, 'guy', { suffix: 's', locale: ['en-US', 'invalid locale'] }), '1,000 guys')

  t.strictEqual(Strings.pluralize('2', 'plan'), '2 plans')
  t.strictEqual(Strings.pluralize('xyz', 'plan'), '0 plans')

  t.strictEqual(Strings.pluralize(1, 'person', { plural: 'people' }), '1 person')
  t.strictEqual(Strings.pluralize(1, 'person', { other: 'people' }), '1 person')
  t.strictEqual(Strings.pluralize(1000, 'person', { plural: 'people' }), '1,000 people')
  t.strictEqual(Strings.pluralize(1000, 'person', { other: 'people' }), '1,000 people')
  t.strictEqual(Strings.pluralize(1, 'PERSON', { plural: 'people' }), '1 PERSON')
  t.strictEqual(Strings.pluralize(1, 'PERSON', { other: 'people' }), '1 PERSON')
  t.strictEqual(Strings.pluralize(1000, 'PERSON', { plural: 'people' }), '1,000 people')
  t.strictEqual(Strings.pluralize(1000, 'PERSON', { other: 'people' }), '1,000 people')
  t.strictEqual(Strings.pluralize(1000, 'PERSON', { plural: 'PEOPLE' }), '1,000 PEOPLE')
  t.strictEqual(Strings.pluralize(1000, 'PERSON', { other: 'PEOPLE' }), '1,000 PEOPLE')

  t.strictEqual(Strings.pluralize(1, 'fly', { includeCount: false }), 'fly')
  t.strictEqual(Strings.pluralize(0, 'fly', { includeCount: false }), 'flies')
  t.strictEqual(Strings.pluralize(2, 'fly', { includeCount: false }), 'flies')
  t.strictEqual(Strings.pluralize(1, 'guy', { suffix: 's', includeCount: false }), 'guy')
  t.strictEqual(Strings.pluralize(0, 'guy', { suffix: 's', includeCount: false }), 'guys')
  t.strictEqual(Strings.pluralize(2, 'guy', { suffix: 's', includeCount: false }), 'guys')
  t.strictEqual(Strings.pluralize(1, 'needs', { plural: 'need', includeCount: false }), 'needs')
  t.strictEqual(Strings.pluralize(1, 'needs', { other: 'need', includeCount: false }), 'needs')
  t.strictEqual(Strings.pluralize(1000, 'needs', { plural: 'need', includeCount: false }), 'need')
  t.strictEqual(Strings.pluralize(1000, 'needs', { other: 'need', includeCount: false }), 'need')

  t.end()
})

tap.test('isVowel', t => {
  t.strictEqual(Strings.isVowel(), false)
  t.strictEqual(Strings.isVowel(null), false)
  t.strictEqual(Strings.isVowel(''), false)
  t.strictEqual(Strings.isVowel('s'), false)
  t.strictEqual(Strings.isVowel('S'), false)
  t.strictEqual(Strings.isVowel('a'), true)
  t.strictEqual(Strings.isVowel('A'), true)
  t.strictEqual(Strings.isVowel('e'), true)
  t.strictEqual(Strings.isVowel('E'), true)
  t.strictEqual(Strings.isVowel('i'), true)
  t.strictEqual(Strings.isVowel('I'), true)
  t.strictEqual(Strings.isVowel('o'), true)
  t.strictEqual(Strings.isVowel('O'), true)
  t.strictEqual(Strings.isVowel('u'), true)
  t.strictEqual(Strings.isVowel('U'), true)
  t.strictEqual(Strings.isVowel('y'), true)
  t.strictEqual(Strings.isVowel('Y'), true)
  t.strictEqual(Strings.isVowel('y', false), false)
  t.strictEqual(Strings.isVowel('Y', false), false)
  t.strictEqual(Strings.isVowel('abc'), true) // acts like "contains vowel"
  t.strictEqual(Strings.isVowel('cab'), true) // acts like "contains vowel"
  t.strictEqual(Strings.isVowel(0), false)
  t.strictEqual(Strings.isVowel(1), false)
  t.strictEqual(Strings.isVowel(2), false)
  t.end()
})

tap.test('startsWithVowel', t => {
  t.strictEqual(Strings.startsWithVowel(), false)
  t.strictEqual(Strings.startsWithVowel(null), false)
  t.strictEqual(Strings.startsWithVowel(''), false)
  t.strictEqual(Strings.startsWithVowel('sale'), false)
  t.strictEqual(Strings.startsWithVowel('Sale'), false)
  t.strictEqual(Strings.startsWithVowel('event'), true)
  t.strictEqual(Strings.startsWithVowel('Event'), true)
  t.strictEqual(Strings.startsWithVowel('yard'), false)
  t.strictEqual(Strings.startsWithVowel('Yard'), false)
  t.end()
})

tap.test('withArticle', t => {
  t.strictEqual(Strings.withArticle(), '')
  t.strictEqual(Strings.withArticle(null), '')
  t.strictEqual(Strings.withArticle(''), '')
  t.strictEqual(Strings.withArticle('sale'), 'a sale')
  t.strictEqual(Strings.withArticle('Sale'), 'A Sale')
  t.strictEqual(Strings.withArticle('event'), 'an event')
  t.strictEqual(Strings.withArticle('Event'), 'An Event')
  t.strictEqual(Strings.withArticle('sale', { consonant: 'the', vowel: 'the' }), 'the sale')
  t.strictEqual(Strings.withArticle('event', { consonant: 'the', vowel: 'the' }), 'the event')
  t.strictEqual(Strings.withArticle('Sale', { consonant: 'the', vowel: 'the' }), 'The Sale')
  t.strictEqual(Strings.withArticle('Event', { consonant: 'the', vowel: 'the' }), 'The Event')
  t.strictEqual(Strings.withArticle('yard'), 'a yard')
  t.strictEqual(Strings.withArticle('Yard'), 'A Yard')
  t.end()
})

tap.test('abbreviate', t => {
  t.strictEqual(Strings.abbreviate(), '')
  t.strictEqual(Strings.abbreviate(null), '')
  t.strictEqual(Strings.abbreviate(''), '')
  t.strictEqual(Strings.abbreviate('one'), 'one')
  t.strictEqual(Strings.abbreviate('one', 2), 'on')
  t.strictEqual(Strings.abbreviate('one', '2'), 'on')
  t.strictEqual(Strings.abbreviate('one', 4), 'one')
  t.strictEqual(Strings.abbreviate('one', '4'), 'one')
  t.strictEqual(Strings.abbreviate('one', 'x'), 'one')
  t.strictEqual(Strings.abbreviate('one', null), 'one')
  t.strictEqual(Strings.abbreviate('one two'), 'ot')
  t.strictEqual(Strings.abbreviate('one two three'), 'ott')
  t.strictEqual(Strings.abbreviate('One Two Three'), 'OTT')
  t.strictEqual(Strings.abbreviate('One  Two  Three'), 'OTT')
  t.strictEqual(Strings.abbreviate(' One  Two  Three '), 'OTT')
  t.strictEqual(Strings.abbreviate('gross-margin'), 'gm')
  t.strictEqual(Strings.abbreviate('gross_margin'), 'gm')
  t.strictEqual(Strings.abbreviate('gross+margin'), 'gm')
  t.strictEqual(Strings.abbreviate('gross.margin'), 'gm')
  t.strictEqual(Strings.abbreviate('gross,margin'), 'gm')
  t.strictEqual(Strings.abbreviate('AMOUNT'), 'AMT')
  t.strictEqual(Strings.abbreviate('AMOUNT', 2), 'AM')
  t.strictEqual(Strings.abbreviate('AMOUNT', 5), 'AMNT')
  t.strictEqual(Strings.abbreviate('AMOUNT', 0), 'AMT')
  t.strictEqual(Strings.abbreviate('AMOUNT', -1), 'AMT')
  t.strictEqual(Strings.abbreviate('MARGIN'), 'MGN')
  t.strictEqual(Strings.abbreviate('REPORT'), 'RPT')
  t.strictEqual(Strings.abbreviate('MEMBER'), 'MBR')
  t.strictEqual(Strings.abbreviate('PAYMENT'), 'PMT')
  t.strictEqual(Strings.abbreviate('COMMISSION'), 'COM')
  t.strictEqual(Strings.abbreviate('BONUS'), 'BNS')
  t.strictEqual(Strings.abbreviate('VOLUME'), 'VOL')
  t.strictEqual(Strings.abbreviate('Volume', 6), 'Volume')
  t.strictEqual(Strings.abbreviate('annual'), 'ann')
  t.strictEqual(Strings.abbreviate('contract'), 'cnt')
  t.strictEqual(Strings.abbreviate('value'), 'val')
  t.strictEqual(Strings.abbreviate('extended'), 'ext')
  t.strictEqual(Strings.abbreviate('annual', 4), 'annl')
  t.strictEqual(Strings.abbreviate('contract', 4), 'cntr')
  t.strictEqual(Strings.abbreviate('revenue'), 'rev')
  t.end()
})

const strings = {
  [Strings.GROSS_MARGIN]: {
    singular: 'Profit',
    plural: 'Profit'
  },
  [Strings.PLAN]: 'Program',
  [Strings.QUOTA]: {
    one: 'Plan',
    other: 'Plans'
  },
  [Strings.REPORT]: {
    one: 'report',
    other: 'reports'
  }
}
const invalidKey = 'invalid_key'

tap.test('static get', t => {
  t.strictEqual(Strings.get(), '')
  t.strictEqual(Strings.get(null), '')
  t.strictEqual(Strings.get(''), '')

  // 1st arg string as key (only works for default values)
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN), 'Gross Margin')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(Strings.get(invalidKey), '')

  // two interchangeable args: strings object and key string
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN), 'Profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings), 'Profit')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings), 'Annual Contract Value')
  t.strictEqual(Strings.get(strings, invalidKey), '')
  t.strictEqual(Strings.get(invalidKey, strings), '')

  // 3rd arg boolean for plural
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, false), 'Profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, false), 'Profit')
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, true), 'Profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, true), 'Profit')
  t.strictEqual(Strings.get(strings, Strings.PLAN, false), 'Program')
  t.strictEqual(Strings.get(Strings.PLAN, strings, false), 'Program')
  t.strictEqual(Strings.get(strings, Strings.PLAN, true), 'Programs')
  t.strictEqual(Strings.get(Strings.PLAN, strings, true), 'Programs')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, false), 'Plan')
  t.strictEqual(Strings.get(Strings.QUOTA, strings, false), 'Plan')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, true), 'Plans')
  t.strictEqual(Strings.get(Strings.QUOTA, strings, true), 'Plans')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, false), 'Annual Contract Value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, false), 'Annual Contract Value')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, true), 'Annual Contract Value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, true), 'Annual Contract Value')
  t.strictEqual(Strings.get(strings, invalidKey, false), '')
  t.strictEqual(Strings.get(invalidKey, strings, false), '')
  t.strictEqual(Strings.get(strings, invalidKey, true), '')
  t.strictEqual(Strings.get(invalidKey, strings, true), '')

  // 3rd arg number as count
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, 1), 'Profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, 1), 'Profit')
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, 0), 'Profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, 0), 'Profit')
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, 2), 'Profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, 2), 'Profit')
  t.strictEqual(Strings.get(strings, Strings.PLAN, 1), 'Program')
  t.strictEqual(Strings.get(Strings.PLAN, strings, 1), 'Program')
  t.strictEqual(Strings.get(strings, Strings.PLAN, 0), 'Programs')
  t.strictEqual(Strings.get(Strings.PLAN, strings, 0), 'Programs')
  t.strictEqual(Strings.get(strings, Strings.PLAN, 2), 'Programs')
  t.strictEqual(Strings.get(Strings.PLAN, strings, 2), 'Programs')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, 1), 'Plan')
  t.strictEqual(Strings.get(Strings.QUOTA, strings, 1), 'Plan')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, 0), 'Plans')
  t.strictEqual(Strings.get(Strings.QUOTA, strings, 0), 'Plans')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, 2), 'Plans')
  t.strictEqual(Strings.get(Strings.QUOTA, strings, 2), 'Plans')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, 1), 'Annual Contract Value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, 1), 'Annual Contract Value')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, 0), 'Annual Contract Value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, 0), 'Annual Contract Value')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, 2), 'Annual Contract Value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, 2), 'Annual Contract Value')
  t.strictEqual(Strings.get(strings, invalidKey, 1), '')
  t.strictEqual(Strings.get(invalidKey, strings, 1), '')
  t.strictEqual(Strings.get(strings, invalidKey, 0), '')
  t.strictEqual(Strings.get(invalidKey, strings, 0), '')
  t.strictEqual(Strings.get(strings, invalidKey, 2), '')
  t.strictEqual(Strings.get(invalidKey, strings, 2), '')

  // 3rd arg object as opts with plural boolean and lc boolean
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, { plural: false, lc: true }), 'profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, { plural: false, lc: true }), 'profit')
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, { plural: true, lc: true }), 'profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, { plural: true, lc: true }), 'profit')
  t.strictEqual(Strings.get(strings, Strings.PLAN, { plural: false, lc: true }), 'program')
  t.strictEqual(Strings.get(Strings.PLAN, strings, { plural: false, lc: true }), 'program')
  t.strictEqual(Strings.get(strings, Strings.PLAN, { plural: true, lc: true }), 'programs')
  t.strictEqual(Strings.get(Strings.PLAN, strings, { plural: true, lc: true }), 'programs')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { plural: false, lc: true }), 'plan')
  t.strictEqual(Strings.get(Strings.QUOTA, strings, { plural: false, lc: true }), 'plan')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { plural: true, lc: true }), 'plans')
  t.strictEqual(Strings.get(Strings.QUOTA, strings, { plural: true, lc: true }), 'plans')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, { plural: false, lc: true }), 'annual contract value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, { plural: false, lc: true }), 'annual contract value')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, { plural: true, lc: true }), 'annual contract value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, { plural: true, lc: true }), 'annual contract value')
  t.strictEqual(Strings.get(strings, invalidKey, { plural: false, lc: true }), '')
  t.strictEqual(Strings.get(invalidKey, strings, { plural: false, lc: true }), '')
  t.strictEqual(Strings.get(strings, invalidKey, { plural: true, lc: true }), '')
  t.strictEqual(Strings.get(invalidKey, strings, { plural: true, lc: true }), '')

  // 3rd arg object as opts with plural boolean and flu boolean
  t.strictEqual(Strings.get(strings, Strings.REPORT, { plural: false, flu: true }), 'Report')
  t.strictEqual(Strings.get(Strings.REPORT, strings, { plural: false, flu: true }), 'Report')
  t.strictEqual(Strings.get(strings, Strings.REPORT, { plural: true, flu: true }), 'Reports')
  t.strictEqual(Strings.get(Strings.REPORT, strings, { plural: true, flu: true }), 'Reports')
  t.strictEqual(Strings.get(strings, Strings.REPORT, { plural: false, flu: false }), 'report')
  t.strictEqual(Strings.get(Strings.REPORT, strings, { plural: false, flu: false }), 'report')
  t.strictEqual(Strings.get(strings, Strings.REPORT, { plural: true, flu: false }), 'reports')
  t.strictEqual(Strings.get(Strings.REPORT, strings, { plural: true, flu: false }), 'reports')
  t.strictEqual(Strings.get(strings, invalidKey, { plural: false, flu: true }), '')
  t.strictEqual(Strings.get(invalidKey, strings, { plural: false, flu: true }), '')
  t.strictEqual(Strings.get(strings, invalidKey, { plural: true, flu: true }), '')
  t.strictEqual(Strings.get(invalidKey, strings, { plural: true, flu: true }), '')

  // 3rd arg opts object with count number and locale string
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, { count: 1, locale: 'en-US' }), 'Profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, { count: 1, locale: 'en_US' }), 'Profit')
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, { count: 0, locale: 'en_US' }), 'Profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, { count: 0, locale: 'en-US' }), 'Profit')
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, { count: 2, locale: 'en_US' }), 'Profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, { count: 2, locale: 'en-US' }), 'Profit')
  t.strictEqual(Strings.get(strings, Strings.PLAN, { count: 1, locale: 'en-US' }), 'Program')
  t.strictEqual(Strings.get(Strings.PLAN, strings, { count: 1, locale: 'en_US' }), 'Program')
  t.strictEqual(Strings.get(strings, Strings.PLAN, { count: 0, locale: 'en_US' }), 'Programs')
  t.strictEqual(Strings.get(Strings.PLAN, strings, { count: 0, locale: 'en-US' }), 'Programs')
  t.strictEqual(Strings.get(strings, Strings.PLAN, { count: 2, locale: 'en_US' }), 'Programs')
  t.strictEqual(Strings.get(Strings.PLAN, strings, { count: 2, locale: 'en-US' }), 'Programs')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { count: 1, locale: 'en-US' }), 'Plan')
  t.strictEqual(Strings.get(Strings.QUOTA, strings, { count: 1, locale: 'en_US' }), 'Plan')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { count: 0, locale: 'en_US' }), 'Plans')
  t.strictEqual(Strings.get(Strings.QUOTA, strings, { count: 0, locale: 'en-US' }), 'Plans')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { count: 2, locale: 'en_US' }), 'Plans')
  t.strictEqual(Strings.get(Strings.QUOTA, strings, { count: 2, locale: 'en-US' }), 'Plans')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, { count: 1, locale: 'en-US' }), 'Annual Contract Value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, { count: 1, locale: 'en_US' }), 'Annual Contract Value')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, { count: 0, locale: 'en_US' }), 'Annual Contract Value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, { count: 0, locale: 'en-US' }), 'Annual Contract Value')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, { count: 2, locale: 'en_US' }), 'Annual Contract Value')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, { count: 2, locale: 'en-US' }), 'Annual Contract Value')
  t.strictEqual(Strings.get(strings, invalidKey, { count: 1, locale: 'en-US' }), '')
  t.strictEqual(Strings.get(invalidKey, strings, { count: 1, locale: 'en_US' }), '')
  t.strictEqual(Strings.get(strings, invalidKey, { count: 0, locale: 'en_US' }), '')
  t.strictEqual(Strings.get(invalidKey, strings, { count: 0, locale: 'en-US' }), '')
  t.strictEqual(Strings.get(strings, invalidKey, { count: 2, locale: 'en_US' }), '')
  t.strictEqual(Strings.get(invalidKey, strings, { count: 2, locale: 'en-US' }), '')

  t.strictEqual(Strings.get(strings, Strings.PLAN, { count: 2, locale: ['en_US', 'invalid locale'] }), 'Programs')

  // 3rd arg opts object with uc boolean and abbrev boolean
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, { uc: true, abbrev: true }), 'PFT')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, { uc: true, abbrev: true }), 'PFT')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, { uc: true, abbrev: true }), 'ACV')
  t.strictEqual(Strings.get(Strings.ANNUAL_CONTRACT_VALUE, strings, { uc: true, abbrev: true }), 'ACV')
  t.strictEqual(Strings.get(strings, invalidKey, { uc: true, abbrev: true }), '')
  t.strictEqual(Strings.get(invalidKey, strings, { uc: true, abbrev: true }), '')

  // suffix to customize auto-pluralization
  t.strictEqual(Strings.get(null, 'guy', { count: 2, suffix: 's', strict: false }), 'guys')
  t.strictEqual(Strings.get('guy', null, { count: 2, suffix: 's', strict: false }), 'guys')

  // min/max
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, { min: 3, max: 6 }), 'Profit') // max here means no abbreviation necessary
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, strings, { min: 3, max: 6 }), 'Profit')
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, { min: 3, max: 5 }), 'Pft')
  t.strictEqual(Strings.get(strings, Strings.GROSS_MARGIN, { min: 4, max: 5 }), 'Prft')
  t.strictEqual(Strings.get(strings, Strings.ANNUAL_CONTRACT_VALUE, { min: 4, max: 5 }), 'ACV') // min does not apply to multi-word abbreviations
  t.strictEqual(Strings.get(strings, Strings.PLAN, { min: 3, max: 6 }), 'Prg')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { min: 3, max: 6, count: 1 }), 'Plan')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { min: 3, max: 6, count: 2 }), 'Plans')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { min: 3, max: 3, count: 1 }), 'Pln')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { min: 3, max: 3, count: 2 }), 'Pln')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { min: 4, max: 4, count: 2 }), 'Plns')

  // includeCount option
  t.strictEqual(Strings.get(strings, Strings.SALE, { count: 1, includeCount: true }), '1 Sale')
  t.strictEqual(Strings.get(strings, Strings.SALE, { count: 0, includeCount: true }), '0 Sales')
  t.strictEqual(Strings.get(strings, Strings.SALE, { count: 1234, includeCount: true }), '1,234 Sales')
  t.strictEqual(Strings.get(null, 'guy', { count: 1, includeCount: true, suffix: 's', strict: false }), '1 guy')
  t.strictEqual(Strings.get(null, 'guy', { count: 0, includeCount: true, suffix: 's', strict: false }), '0 guys')
  t.strictEqual(Strings.get(null, 'guy', { count: 12345, includeCount: true, suffix: 's', strict: false }), '12,345 guys')
  t.strictEqual(Strings.get(strings, Strings.SALE, { count: 1, includeCount: true, uc: true, abbrev: true }), '1 SAL')
  t.strictEqual(Strings.get(strings, Strings.SALE, { count: 0, includeCount: true, uc: true, abbrev: true }), '0 SLS')
  t.strictEqual(Strings.get(strings, Strings.SALE, { count: 123456, includeCount: true, uc: true, abbrev: true }), '123,456 SLS')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { count: 1, includeCount: true, lc: true }), '1 plan')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { count: 0, includeCount: true, lc: true }), '0 plans')
  t.strictEqual(Strings.get(strings, Strings.QUOTA, { count: 1234567, includeCount: true, lc: true }), '1,234,567 plans')
  t.strictEqual(Strings.get(strings, Strings.PLAN, { count: 1, includeCount: true, min: 6, max: 6 }), '1 Prgrm')
  t.strictEqual(Strings.get(strings, Strings.PLAN, { count: 0, includeCount: true, min: 6, max: 6 }), '0 Prgrms')
  t.strictEqual(Strings.get(strings, Strings.PLAN, { count: 123, includeCount: true, min: 6, max: 6 }), '123 Prgrms')
  // includeCount ignored if count is not given
  t.strictEqual(Strings.get(strings, Strings.PRODUCT, { plural: true, includeCount: true, lc: true }), 'products')
  // includeCount ignored if count is not a number
  t.strictEqual(Strings.get(strings, Strings.SALE, { count: '1234', includeCount: true }), 'Sale')
  // includeCount can also be false
  t.strictEqual(Strings.get(strings, Strings.SALE, { count: 1, includeCount: false }), 'Sale')
  t.strictEqual(Strings.get(strings, Strings.SALE, { count: 0, includeCount: false }), 'Sales')
  t.strictEqual(Strings.get(strings, Strings.SALE, { count: 1234, includeCount: false }), 'Sales')

  // withArticle
  t.strictEqual(Strings.get(strings, Strings.ADJUSTMENT, { withArticle: true }), 'An Adjustment')
  t.strictEqual(Strings.get(strings, Strings.SALE, { withArticle: true }), 'A Sale')
  t.strictEqual(Strings.get(strings, Strings.ADJUSTMENT, { withArticle: true, lc: true }), 'an adjustment')
  t.strictEqual(Strings.get(strings, Strings.SALE, { withArticle: true, lc: true }), 'a sale')
  t.strictEqual(Strings.get(strings, Strings.ADJUSTMENT, { withArticle: true, consonant: 'the', vowel: 'the' }), 'The Adjustment')
  t.strictEqual(Strings.get(strings, Strings.SALE, { withArticle: true, consonant: 'the', vowel: 'the' }), 'The Sale')
  t.strictEqual(Strings.get(strings, Strings.ADJUSTMENT, { withArticle: true, lc: true, consonant: 'the', vowel: 'the' }), 'the adjustment')
  t.strictEqual(Strings.get(strings, Strings.SALE, { withArticle: true, lc: true, consonant: 'the', vowel: 'the' }), 'the sale')

  const p = {
    person: {
      plural: 'people'
    }
  }
  t.strictEqual(Strings.get(p, 'person', { count: 1, strict: false }), 'person') // strict=false will fallback to key as singular
  t.strictEqual(Strings.get(p, 'person', { count: 2 }), 'people')

  // strings object supports wrapper
  const wrapper = {
    locale: 'en_US',
    strings
  }
  t.strictEqual(Strings.get(wrapper, Strings.GROSS_MARGIN), 'Profit')
  t.strictEqual(Strings.get(Strings.GROSS_MARGIN, wrapper), 'Profit')

  t.end()
})

tap.test('static getSingular', t => {
  t.strictEqual(Strings.getSingular(), '')
  t.strictEqual(Strings.getSingular(null), '')
  t.strictEqual(Strings.getSingular(''), '')
  t.strictEqual(Strings.getSingular(Strings.GROSS_MARGIN), 'Gross Margin')
  t.strictEqual(Strings.getSingular(Strings.UNIT), 'Unit')

  t.strictEqual(Strings.getSingular(strings, Strings.GROSS_MARGIN), 'Profit')
  t.strictEqual(Strings.getSingular(Strings.GROSS_MARGIN, strings), 'Profit')
  t.strictEqual(Strings.getSingular(strings, Strings.PLAN), 'Program')
  t.strictEqual(Strings.getSingular(Strings.PLAN, strings), 'Program')
  t.strictEqual(Strings.getSingular(strings, Strings.QUOTA), 'Plan')
  t.strictEqual(Strings.getSingular(Strings.QUOTA, strings), 'Plan')
  t.strictEqual(Strings.getSingular(strings, Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(Strings.getSingular(Strings.ANNUAL_CONTRACT_VALUE, strings), 'Annual Contract Value')
  t.strictEqual(Strings.getSingular(strings, invalidKey), '')
  t.strictEqual(Strings.getSingular(invalidKey, strings), '')

  t.strictEqual(Strings.getSingular(strings, Strings.GROSS_MARGIN, { lc: true }), 'profit')
  t.strictEqual(Strings.getSingular(Strings.GROSS_MARGIN, strings, { lc: true }), 'profit')
  t.strictEqual(Strings.getSingular(strings, Strings.PLAN, { lc: true }), 'program')
  t.strictEqual(Strings.getSingular(Strings.PLAN, strings, { lc: true }), 'program')
  t.strictEqual(Strings.getSingular(strings, Strings.ANNUAL_CONTRACT_VALUE, { lc: true, abbrev: true }), 'acv')
  t.strictEqual(Strings.getSingular(Strings.ANNUAL_CONTRACT_VALUE, strings, { lc: true, abbrev: true }), 'acv')
  t.strictEqual(Strings.getSingular(strings, Strings.REPORT, { flu: true }), 'Report')
  t.strictEqual(Strings.getSingular(Strings.REPORT, strings, { flu: true }), 'Report')

  t.end()
})

tap.test('static getPlural', t => {
  t.strictEqual(Strings.getPlural(), '')
  t.strictEqual(Strings.getPlural(null), '')
  t.strictEqual(Strings.getPlural(''), '')
  t.strictEqual(Strings.getPlural(Strings.GROSS_MARGIN), 'Gross Margin')
  t.strictEqual(Strings.getPlural(Strings.UNIT), 'Units')

  t.strictEqual(Strings.getPlural(strings, Strings.GROSS_MARGIN), 'Profit')
  t.strictEqual(Strings.getPlural(Strings.GROSS_MARGIN, strings), 'Profit')
  t.strictEqual(Strings.getPlural(strings, Strings.PLAN), 'Programs')
  t.strictEqual(Strings.getPlural(Strings.PLAN, strings), 'Programs')
  t.strictEqual(Strings.getPlural(strings, Strings.QUOTA), 'Plans')
  t.strictEqual(Strings.getPlural(Strings.QUOTA, strings), 'Plans')
  t.strictEqual(Strings.getPlural(strings, Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(Strings.getPlural(Strings.ANNUAL_CONTRACT_VALUE, strings), 'Annual Contract Value')
  t.strictEqual(Strings.getPlural(strings, invalidKey), '')
  t.strictEqual(Strings.getPlural(invalidKey, strings), '')

  t.strictEqual(Strings.getPlural(strings, Strings.GROSS_MARGIN, { lc: true }), 'profit')
  t.strictEqual(Strings.getPlural(Strings.GROSS_MARGIN, strings, { lc: true }), 'profit')
  t.strictEqual(Strings.getPlural(strings, Strings.PLAN, { lc: true }), 'programs')
  t.strictEqual(Strings.getPlural(Strings.PLAN, strings, { lc: true }), 'programs')
  t.strictEqual(Strings.getPlural(strings, Strings.ANNUAL_CONTRACT_VALUE, { lc: true, abbrev: true }), 'acv')
  t.strictEqual(Strings.getPlural(Strings.ANNUAL_CONTRACT_VALUE, strings, { lc: true, abbrev: true }), 'acv')
  t.strictEqual(Strings.getPlural(strings, Strings.REPORT, { flu: true }), 'Reports')
  t.strictEqual(Strings.getPlural(Strings.REPORT, strings, { flu: true }), 'Reports')

  t.end()
})

tap.test('instance get', t => {
  const d = Strings.wrap()
  const s = Strings.wrap(strings)

  t.strictEqual(d.get(), '')
  t.strictEqual(s.get(), '')
  t.strictEqual(d.get(null), '')
  t.strictEqual(s.get(null), '')
  t.strictEqual(d.get(''), '')
  t.strictEqual(s.get(''), '')

  // 1st arg string as key
  t.strictEqual(d.get(Strings.GROSS_MARGIN), 'Gross Margin')
  t.strictEqual(s.get(Strings.GROSS_MARGIN), 'Profit')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(d.get(invalidKey), '')
  t.strictEqual(s.get(invalidKey), '')

  // 2nd arg plural boolean
  t.strictEqual(d.get(Strings.GROSS_MARGIN, false), 'Gross Margin')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, false), 'Profit')
  t.strictEqual(d.get(Strings.GROSS_MARGIN, true), 'Gross Margin')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, true), 'Profit')
  t.strictEqual(d.get(Strings.PLAN, false), 'Plan')
  t.strictEqual(s.get(Strings.PLAN, false), 'Program')
  t.strictEqual(d.get(Strings.PLAN, true), 'Plans')
  t.strictEqual(s.get(Strings.PLAN, true), 'Programs')
  t.strictEqual(d.get(Strings.QUOTA, false), 'Quota')
  t.strictEqual(s.get(Strings.QUOTA, false), 'Plan')
  t.strictEqual(d.get(Strings.QUOTA, true), 'Quotas')
  t.strictEqual(s.get(Strings.QUOTA, true), 'Plans')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, false), 'Annual Contract Value')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, false), 'Annual Contract Value')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, true), 'Annual Contract Value')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, true), 'Annual Contract Value')
  t.strictEqual(d.get(invalidKey, false), '')
  t.strictEqual(s.get(invalidKey, false), '')
  t.strictEqual(d.get(invalidKey, true), '')
  t.strictEqual(s.get(invalidKey, true), '')

  // 2nd arg count number
  t.strictEqual(d.get(Strings.GROSS_MARGIN, 1), 'Gross Margin')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, 1), 'Profit')
  t.strictEqual(d.get(Strings.GROSS_MARGIN, 0), 'Gross Margin')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, 0), 'Profit')
  t.strictEqual(d.get(Strings.GROSS_MARGIN, 2), 'Gross Margin')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, 2), 'Profit')
  t.strictEqual(d.get(Strings.PLAN, 1), 'Plan')
  t.strictEqual(s.get(Strings.PLAN, 1), 'Program')
  t.strictEqual(d.get(Strings.PLAN, 0), 'Plans')
  t.strictEqual(s.get(Strings.PLAN, 0), 'Programs')
  t.strictEqual(d.get(Strings.PLAN, 2), 'Plans')
  t.strictEqual(s.get(Strings.PLAN, 2), 'Programs')
  t.strictEqual(d.get(Strings.QUOTA, 1), 'Quota')
  t.strictEqual(s.get(Strings.QUOTA, 1), 'Plan')
  t.strictEqual(d.get(Strings.QUOTA, 0), 'Quotas')
  t.strictEqual(s.get(Strings.QUOTA, 0), 'Plans')
  t.strictEqual(d.get(Strings.QUOTA, 2), 'Quotas')
  t.strictEqual(s.get(Strings.QUOTA, 2), 'Plans')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, 1), 'Annual Contract Value')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, 1), 'Annual Contract Value')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, 0), 'Annual Contract Value')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, 0), 'Annual Contract Value')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, 2), 'Annual Contract Value')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, 2), 'Annual Contract Value')
  t.strictEqual(d.get(invalidKey, 1), '')
  t.strictEqual(s.get(invalidKey, 1), '')
  t.strictEqual(d.get(invalidKey, 0), '')
  t.strictEqual(s.get(invalidKey, 0), '')
  t.strictEqual(d.get(invalidKey, 2), '')
  t.strictEqual(s.get(invalidKey, 2), '')

  // 2nd arg opts object with plural boolean and uc boolean
  t.strictEqual(d.get(Strings.GROSS_MARGIN, { plural: false, uc: true }), 'GROSS MARGIN')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, { plural: false, uc: true }), 'PROFIT')
  t.strictEqual(d.get(Strings.GROSS_MARGIN, { plural: true, uc: true }), 'GROSS MARGIN')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, { plural: true, uc: true }), 'PROFIT')
  t.strictEqual(d.get(Strings.PLAN, { plural: false, uc: true }), 'PLAN')
  t.strictEqual(s.get(Strings.PLAN, { plural: false, uc: true }), 'PROGRAM')
  t.strictEqual(d.get(Strings.PLAN, { plural: true, uc: true }), 'PLANS')
  t.strictEqual(s.get(Strings.PLAN, { plural: true, uc: true }), 'PROGRAMS')
  t.strictEqual(d.get(Strings.QUOTA, { plural: false, uc: true }), 'QUOTA')
  t.strictEqual(s.get(Strings.QUOTA, { plural: false, uc: true }), 'PLAN')
  t.strictEqual(d.get(Strings.QUOTA, { plural: true, uc: true }), 'QUOTAS')
  t.strictEqual(s.get(Strings.QUOTA, { plural: true, uc: true }), 'PLANS')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, { plural: false, uc: true }), 'ANNUAL CONTRACT VALUE')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, { plural: false, uc: true }), 'ANNUAL CONTRACT VALUE')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, { plural: true, uc: true }), 'ANNUAL CONTRACT VALUE')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, { plural: true, uc: true }), 'ANNUAL CONTRACT VALUE')
  t.strictEqual(d.get(invalidKey, { plural: false, uc: true }), '')
  t.strictEqual(s.get(invalidKey, { plural: false, uc: true }), '')
  t.strictEqual(d.get(invalidKey, { plural: true, uc: true }), '')
  t.strictEqual(s.get(invalidKey, { plural: true, uc: true }), '')

  // 2nd arg opts object with count number and lc boolean
  t.strictEqual(d.get(Strings.GROSS_MARGIN, { count: 1, lc: true }), 'gross margin')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, { count: 1, lc: true }), 'profit')
  t.strictEqual(d.get(Strings.GROSS_MARGIN, { count: 0, lc: true }), 'gross margin')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, { count: 0, lc: true }), 'profit')
  t.strictEqual(d.get(Strings.GROSS_MARGIN, { count: 2, lc: true }), 'gross margin')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, { count: 2, lc: true }), 'profit')
  t.strictEqual(d.get(Strings.PLAN, { count: 1, lc: true }), 'plan')
  t.strictEqual(s.get(Strings.PLAN, { count: 1, lc: true }), 'program')
  t.strictEqual(d.get(Strings.PLAN, { count: 0, lc: true }), 'plans')
  t.strictEqual(s.get(Strings.PLAN, { count: 0, lc: true }), 'programs')
  t.strictEqual(d.get(Strings.PLAN, { count: 2, lc: true }), 'plans')
  t.strictEqual(s.get(Strings.PLAN, { count: 2, lc: true }), 'programs')
  t.strictEqual(d.get(Strings.QUOTA, { count: 1, lc: true }), 'quota')
  t.strictEqual(s.get(Strings.QUOTA, { count: 1, lc: true }), 'plan')
  t.strictEqual(d.get(Strings.QUOTA, { count: 0, lc: true }), 'quotas')
  t.strictEqual(s.get(Strings.QUOTA, { count: 0, lc: true }), 'plans')
  t.strictEqual(d.get(Strings.QUOTA, { count: 2, lc: true }), 'quotas')
  t.strictEqual(s.get(Strings.QUOTA, { count: 2, lc: true }), 'plans')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, { count: 1, lc: true }), 'annual contract value')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, { count: 1, lc: true }), 'annual contract value')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, { count: 0, lc: true }), 'annual contract value')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, { count: 0, lc: true }), 'annual contract value')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, { count: 2, lc: true }), 'annual contract value')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, { count: 2, lc: true }), 'annual contract value')
  t.strictEqual(d.get(invalidKey, { count: 1, lc: true }), '')
  t.strictEqual(s.get(invalidKey, { count: 1, lc: true }), '')
  t.strictEqual(d.get(invalidKey, { count: 0, lc: true }), '')
  t.strictEqual(s.get(invalidKey, { count: 0, lc: true }), '')
  t.strictEqual(d.get(invalidKey, { count: 2, lc: true }), '')
  t.strictEqual(s.get(invalidKey, { count: 2, lc: true }), '')

  // 2nd arg opts object with abbrev boolean
  t.strictEqual(d.get(Strings.GROSS_MARGIN, { abbrev: true }), 'GM')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, { abbrev: true }), 'Pft')
  t.strictEqual(d.get(Strings.ANNUAL_CONTRACT_VALUE, { abbrev: true }), 'ACV')
  t.strictEqual(s.get(Strings.ANNUAL_CONTRACT_VALUE, { abbrev: true }), 'ACV')
  t.strictEqual(d.get(Strings.TRANSACTION_DATE, { abbrev: true }), 'TD')

  // 2rd arg object as opts with plural boolean and flu boolean
  t.strictEqual(d.get(Strings.REPORT, { plural: false, flu: true }), 'Report')
  t.strictEqual(s.get(Strings.REPORT, { plural: false, flu: true }), 'Report')
  t.strictEqual(d.get(Strings.REPORT, { plural: true, flu: true }), 'Reports')
  t.strictEqual(s.get(Strings.REPORT, { plural: true, flu: true }), 'Reports')
  t.strictEqual(d.get(Strings.REPORT, { plural: false, flu: false }), 'Report')
  t.strictEqual(s.get(Strings.REPORT, { plural: false, flu: false }), 'report')
  t.strictEqual(d.get(Strings.REPORT, { plural: true, flu: false }), 'Reports')
  t.strictEqual(s.get(Strings.REPORT, { plural: true, flu: false }), 'reports')
  t.strictEqual(d.get(invalidKey, strings, { plural: false, flu: true }), '')
  t.strictEqual(s.get(invalidKey, strings, { plural: false, flu: true }), '')
  t.strictEqual(d.get(invalidKey, strings, { plural: true, flu: true }), '')
  t.strictEqual(s.get(invalidKey, strings, { plural: true, flu: true }), '')

  // min/max
  t.strictEqual(d.get(Strings.GROSS_MARGIN, { min: 3, max: 6 }), 'GM') // min not used for mult-word
  t.strictEqual(s.get(Strings.GROSS_MARGIN, { min: 3, max: 6 }), 'Profit') // max allows for full value
  t.strictEqual(s.get(Strings.GROSS_MARGIN, { min: 3, max: 5 }), 'Pft')
  t.strictEqual(s.get(Strings.GROSS_MARGIN, { min: 4, max: 5 }), 'Prft')

  t.end()
})

tap.test('instance getSingular', t => {
  const d = Strings.wrap()
  const s = Strings.wrap(strings)

  t.strictEqual(d.getSingular(), '')
  t.strictEqual(s.getSingular(), '')
  t.strictEqual(d.getSingular(null), '')
  t.strictEqual(s.getSingular(null), '')
  t.strictEqual(d.getSingular(''), '')
  t.strictEqual(s.getSingular(''), '')

  t.strictEqual(d.getSingular(Strings.GROSS_MARGIN), 'Gross Margin')
  t.strictEqual(s.getSingular(Strings.GROSS_MARGIN), 'Profit')
  t.strictEqual(d.getSingular(Strings.PLAN), 'Plan')
  t.strictEqual(s.getSingular(Strings.PLAN), 'Program')
  t.strictEqual(d.getSingular(Strings.QUOTA), 'Quota')
  t.strictEqual(s.getSingular(Strings.QUOTA), 'Plan')
  t.strictEqual(d.getSingular(Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(s.getSingular(Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(d.getSingular(invalidKey), '')
  t.strictEqual(s.getSingular(invalidKey), '')

  t.strictEqual(d.getSingular(Strings.GROSS_MARGIN, { uc: true }), 'GROSS MARGIN')
  t.strictEqual(s.getSingular(Strings.GROSS_MARGIN, { uc: true }), 'PROFIT')
  t.strictEqual(d.getSingular(Strings.GROSS_MARGIN, { uc: true, abbrev: true }), 'GM')
  t.strictEqual(s.getSingular(Strings.GROSS_MARGIN, { uc: true, abbrev: true }), 'PFT')

  t.strictEqual(d.getSingular(Strings.REPORT, { flu: true }), 'Report')
  t.strictEqual(s.getSingular(Strings.REPORT, { flu: true }), 'Report')

  t.end()
})

tap.test('instance getPlural', t => {
  const d = Strings.wrap()
  const s = Strings.wrap(strings)

  t.strictEqual(d.getPlural(), '')
  t.strictEqual(s.getPlural(), '')
  t.strictEqual(d.getPlural(null), '')
  t.strictEqual(s.getPlural(null), '')
  t.strictEqual(d.getPlural(''), '')
  t.strictEqual(s.getPlural(''), '')

  t.strictEqual(d.getPlural(Strings.GROSS_MARGIN), 'Gross Margin')
  t.strictEqual(s.getPlural(Strings.GROSS_MARGIN), 'Profit')
  t.strictEqual(d.getPlural(Strings.PLAN), 'Plans')
  t.strictEqual(s.getPlural(Strings.PLAN), 'Programs')
  t.strictEqual(d.getPlural(Strings.QUOTA), 'Quotas')
  t.strictEqual(s.getPlural(Strings.QUOTA), 'Plans')
  t.strictEqual(d.getPlural(Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(s.getPlural(Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(d.getPlural(invalidKey), '')
  t.strictEqual(s.getPlural(invalidKey), '')

  t.strictEqual(d.getPlural(Strings.PLAN, { lc: true }), 'plans')
  t.strictEqual(s.getPlural(Strings.PLAN, { lc: true }), 'programs')

  t.strictEqual(d.getPlural(Strings.REPORT, { flu: true }), 'Reports')
  t.strictEqual(s.getPlural(Strings.REPORT, { flu: true }), 'Reports')

  t.end()
})

tap.test('extra cases', t => {
  const w = Strings.wrap({
    locale: ['en-US,en-AU;q=0.8', '*'],
    strings: {
      [Strings.PRODUCT]: {
        singular: 'Product'
      },
      [Strings.CATEGORY]: {
        one: 'Category'
      },
      [Strings.UNIT]: {}
    }
  })
  t.strictEqual(w.getPlural(Strings.PRODUCT), 'Products')
  t.strictEqual(w.getPlural(Strings.CATEGORY), 'Categories')
  t.strictEqual(w.getPlural(Strings.UNIT), '')
  t.end()
})

tap.test('defaults', t => {
  const d = Strings.wrap()

  // kpis
  t.strictEqual(d.getSingular(Strings.GROSS_MARGIN), 'Gross Margin')
  t.strictEqual(d.getPlural(Strings.GROSS_MARGIN), 'Gross Margin')
  t.strictEqual(d.getSingular(Strings.GROSS_MARGIN, { abbrev: true }), 'GM')
  t.strictEqual(d.getSingular(Strings.EXTENDED_AMOUNT), 'Extended Amount')
  t.strictEqual(d.getPlural(Strings.EXTENDED_AMOUNT), 'Extended Amount')
  t.strictEqual(d.getSingular(Strings.EXTENDED_AMOUNT, { abbrev: true }), 'EA')
  t.strictEqual(d.getSingular(Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(d.getPlural(Strings.ANNUAL_CONTRACT_VALUE), 'Annual Contract Value')
  t.strictEqual(d.getSingular(Strings.ANNUAL_CONTRACT_VALUE, { abbrev: true }), 'ACV')
  t.strictEqual(d.getSingular(Strings.VOLUME), 'Volume')
  t.strictEqual(d.getPlural(Strings.VOLUME), 'Volume')
  t.strictEqual(d.getSingular(Strings.VOLUME, { abbrev: true }), 'Vol')
  t.strictEqual(d.getSingular(Strings.UNIT), 'Unit')
  t.strictEqual(d.getPlural(Strings.UNIT), 'Units')
  t.strictEqual(d.getSingular(Strings.UNIT, { abbrev: true }), 'Unt')

  // others
  t.strictEqual(d.getSingular(Strings.PRODUCT), 'Product')
  t.strictEqual(d.getPlural(Strings.PRODUCT), 'Products')
  t.strictEqual(d.getSingular(Strings.CATEGORY), 'Category')
  t.strictEqual(d.getPlural(Strings.CATEGORY), 'Categories')
  t.strictEqual(d.getSingular(Strings.PLAN), 'Plan')
  t.strictEqual(d.getPlural(Strings.PLAN), 'Plans')
  t.strictEqual(d.getSingular(Strings.QUOTA), 'Quota')
  t.strictEqual(d.getPlural(Strings.QUOTA), 'Quotas')
  t.strictEqual(d.getSingular(Strings.RULE), 'Rule')
  t.strictEqual(d.getPlural(Strings.RULE), 'Rules')
  t.strictEqual(d.getSingular(Strings.SALE), 'Sale')
  t.strictEqual(d.getPlural(Strings.SALE), 'Sales')
  t.strictEqual(d.getSingular(Strings.TRANSACTION_DATE), 'Transaction Date')
  t.strictEqual(d.getPlural(Strings.TRANSACTION_DATE), 'Transaction Dates')
  t.strictEqual(d.getSingular(Strings.COMPENSATION), 'Compensation')
  t.strictEqual(d.getPlural(Strings.COMPENSATION), 'Compensation')
  t.strictEqual(d.getSingular(Strings.REPORT), 'Report')
  t.strictEqual(d.getPlural(Strings.REPORT), 'Reports')
  t.strictEqual(d.getSingular(Strings.DRAFT), 'Draft')
  t.strictEqual(d.getPlural(Strings.DRAFT), 'Draft')
  t.strictEqual(d.getSingular(Strings.PUBLISHED), 'Published')
  t.strictEqual(d.getPlural(Strings.PUBLISHED), 'Published')
  t.strictEqual(d.getSingular(Strings.CLOSED), 'Closed')
  t.strictEqual(d.getPlural(Strings.CLOSED), 'Closed')
  t.strictEqual(d.getSingular(Strings.DISPUTE), 'Dispute')
  t.strictEqual(d.getPlural(Strings.DISPUTE), 'Disputes')
  t.strictEqual(d.getSingular(Strings.MEMBER), 'Member')
  t.strictEqual(d.getPlural(Strings.MEMBER), 'Members')
  t.strictEqual(d.getSingular(Strings.REP), 'Rep')
  t.strictEqual(d.getPlural(Strings.REP), 'Reps')
  t.strictEqual(d.getSingular(Strings.TEAM), 'Team')
  t.strictEqual(d.getPlural(Strings.TEAM), 'Teams')
  t.strictEqual(d.getSingular(Strings.ADJUSTMENT), 'Adjustment')
  t.strictEqual(d.getPlural(Strings.ADJUSTMENT), 'Adjustments')
  t.strictEqual(d.getSingular(Strings.BATCH), 'Batch')
  t.strictEqual(d.getPlural(Strings.BATCH), 'Batches')

  t.end()
})