Regular expressions for case matching

CaseMatcher.kt

/**
 * Different case matchers
 *
 * @see <a href="https://en.wikipedia.org/wiki/Naming_convention_(programming)#Examples_of_multiple-word_identifier_formats">Examples of multiple word identifier formats</
 */
sealed class CaseMatcher(private val regex: Regex) {
    open fun notMatches(source: String?): Boolean {
        return !matches(source)
    }

    open fun matches(source: String?): Boolean {
        return source?.matches(regex) ?: false
    }

    override fun toString(): String {
        return "${this.javaClass.simpleName}('$regex')"
    }

    companion object {
        /**
         * Allows to parse input string and select appropriate case matcher
         *
         * @return case matcher mentioned in given string
         */
        fun get(requestedCase: String?): CaseMatcher? {
            if (requestedCase.isNullOrBlank()) {
                return null
            }

            return with(requestedCase) {
                when {
                    containsExcluding("flat", setOf("upper")) ||
                            containsAll("lower", "flat") -> LowerFlatCaseMatcher()
                    containsAll("upper", "flat") -> UpperFlatCaseMatcher()
                    containsExcluding("camel", setOf("upper", "snake")) ||
                            containsAll("lower", "camel") ||
                            containsAll("dromedary") -> LowerCamelCaseMatcher()
                    containsAll("upper", "camel") ||
                            containsAll("pascal") ||
                            containsAll("studly") -> UpperCamelCaseMatcher()
                    containsExcluding("snake", setOf("upper", "screaming", "camel")) ||
                            containsAll("lower", "snake") ||
                            containsAll("pothole") -> SnakeCaseMatcher()
                    containsAll("upper", "snake") ||
                            containsAll("screaming", "snake") ||
                            containsAll("macro") ||
                            containsAll("constant") -> ScreamingSnakeCaseMatcher()
                    containsAll("camel", "snake") -> CamelSnakeCaseMatcher()
                    containsExcluding("kebab", setOf("upper", "screaming")) ||
                            containsAll("lower", "kebab") ||
                            containsAll("dash") ||
                            containsAll("lisp") -> KebabCaseMatcher()
                    containsAll("upper", "kebab") ||
                            containsAll("screaming", "kebab") ||
                            containsAll("cobol") -> ScreamingKebabCaseMatcher()
                    containsAll("train") -> TrainCaseMatcher()
                    else -> null
                }
            }
        }

        /**
         * Test if current string contains only given word and does not have excluded words ignoring case
         */
        private fun String.containsExcluding(include: String, exclude: Set<String>): Boolean {
            exclude.forEach { tag ->
                if (this.contains(other = tag, ignoreCase = true)) {
                    return false
                }
            }

            return this.contains(other = include, ignoreCase = true)
        }

        /**
         * Test if current string contains all given words ignoring case
         */
        private fun String.containsAll(vararg tags: String): Boolean {
            if (tags.isEmpty()) {
                return false
            }

            return tags.toSet().all { tag ->
                this.contains(other = tag, ignoreCase = true)
            }
        }
    }
}

/**
 * Represents matching for flat case, e.g. 'flatcase'
 *
 * Can be also referred as: lower flat case
 */
class LowerFlatCaseMatcher : CaseMatcher(Regex("[a-z0-9]+"))

/**
 * Represents matching for upper flat case, e.g. 'UPPERFLATCASE'
 */
class UpperFlatCaseMatcher : CaseMatcher(Regex("[A-Z0-9]+"))

/**
 * Represents matching for camel case, e.g. 'camelCase'
 *
 * Can be also referred as: lower camel case, dromedary case
 */
class LowerCamelCaseMatcher : CaseMatcher(Regex("[a-z]+(?:[A-Z0-9]+[a-z0-9]+[A-Za-z0-9]*)*"))

/**
 * Represents matching for upper camel case, e.g. 'UpperCamelCase'
 *
 * Can be also referred as: pascal case, studly case
 */
class UpperCamelCaseMatcher : CaseMatcher(Regex("(?:[A-Z][a-z0-9]+)(?:[A-Z]+[a-z0-9]*)*"))

/**
 * Represents matching for snake case, e.g. 'snake_case'
 *
 * Can be also referred as: lower snake case, pothole case
 */
class SnakeCaseMatcher : CaseMatcher(Regex("[a-z0-9]+(?:_[a-z0-9]+)*"))

/**
 * Represents matching for screaming snake case, e.g. 'SCREAMING_SNAKE_CASE'
 *
 * Can be also referred as: upper snake case, macro case, constant case
 */
class ScreamingSnakeCaseMatcher : CaseMatcher(Regex("[A-Z0-9]+(?:_[A-Z0-9]+)*"))

/**
 * Represents matching for camel snake case, e.g. 'Camel_Snake_Case'
 */
class CamelSnakeCaseMatcher : CaseMatcher(Regex("[A-Z][a-z0-9]+(?:_[A-Z]+[a-z0-9]*)*"))

/**
 * Represents matching for kebab case, e.g. 'kebab-case'
 *
 * Can be also referred as: lower kebab case, dash case, lisp case
 */
class KebabCaseMatcher : CaseMatcher(Regex("[a-z0-9]+(?:-[a-z0-9]+)*"))

/**
 * Represents matching for screaming kebab case, e.g. 'SCREAMING-KEBAB-CASE'
 *
 * Can be also referred as: upper kebab case, cobol case
 */
class ScreamingKebabCaseMatcher : CaseMatcher(Regex("[A-Z0-9]+(?:-[A-Z0-9]+)*"))

/**
 * Represents matching for train case, e.g. 'Train-Case'
 */
class TrainCaseMatcher : CaseMatcher(Regex("[A-Z][a-z0-9]+(?:-[A-Z]+[a-z0-9]*)*"))

/**
 * Represents matching for custom regular expressions
 */
class CustomMatcher(regex: Regex) : CaseMatcher(regex)

CaseMatcherTest.kt

import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.Test

class CaseMatcherTest {
    @Test
    internal fun creationTest() {
        assertNull(CaseMatcher.get(null), "Null must result in null matcher")
        assertNull(CaseMatcher.get(""), "Empty string must result in null matcher")
        assertNull(CaseMatcher.get("   "), "Blank string must result in null matcher")


        assertNull(CaseMatcher.get("lower"), "Insufficient information must result in null matcher")
        assertNull(CaseMatcher.get("upper"), "Insufficient information must result in null matcher")
        assertNull(CaseMatcher.get("screaming"), "Insufficient information must result in null matcher")


        assertEquals(LowerFlatCaseMatcher::class.java, CaseMatcher.get("lower flat")?.javaClass)
        assertEquals(LowerFlatCaseMatcher::class.java, CaseMatcher.get("loWer_Flat-case")?.javaClass)
        assertEquals(LowerFlatCaseMatcher::class.java, CaseMatcher.get("flat")?.javaClass)
        assertEquals(LowerFlatCaseMatcher::class.java, CaseMatcher.get("flAt-case")?.javaClass)

        assertEquals(UpperFlatCaseMatcher::class.java, CaseMatcher.get("upper flat")?.javaClass)
        assertEquals(UpperFlatCaseMatcher::class.java, CaseMatcher.get("uppEr-fLAt-case")?.javaClass)

        assertEquals(LowerCamelCaseMatcher::class.java, CaseMatcher.get("lower camel")?.javaClass)
        assertEquals(LowerCamelCaseMatcher::class.java, CaseMatcher.get("lOWer-Camel-case")?.javaClass)
        assertEquals(LowerCamelCaseMatcher::class.java, CaseMatcher.get("dromedary")?.javaClass)
        assertEquals(LowerCamelCaseMatcher::class.java, CaseMatcher.get("droMEdary-case")?.javaClass)
        assertEquals(LowerCamelCaseMatcher::class.java, CaseMatcher.get("camel")?.javaClass)
        assertEquals(LowerCamelCaseMatcher::class.java, CaseMatcher.get("CaMEl-case")?.javaClass)

        assertEquals(UpperCamelCaseMatcher::class.java, CaseMatcher.get("upper camel")?.javaClass)
        assertEquals(UpperCamelCaseMatcher::class.java, CaseMatcher.get("uPper-cameL-case")?.javaClass)
        assertEquals(UpperCamelCaseMatcher::class.java, CaseMatcher.get("pascal")?.javaClass)
        assertEquals(UpperCamelCaseMatcher::class.java, CaseMatcher.get("Pascal-case")?.javaClass)
        assertEquals(UpperCamelCaseMatcher::class.java, CaseMatcher.get("studly")?.javaClass)
        assertEquals(UpperCamelCaseMatcher::class.java, CaseMatcher.get("sTUDly-case")?.javaClass)

        assertEquals(SnakeCaseMatcher::class.java, CaseMatcher.get("lower snake")?.javaClass)
        assertEquals(SnakeCaseMatcher::class.java, CaseMatcher.get("loWEr snAke-case")?.javaClass)
        assertEquals(SnakeCaseMatcher::class.java, CaseMatcher.get("pothole")?.javaClass)
        assertEquals(SnakeCaseMatcher::class.java, CaseMatcher.get("pOTHOLe-Case")?.javaClass)
        assertEquals(SnakeCaseMatcher::class.java, CaseMatcher.get("snake")?.javaClass)
        assertEquals(SnakeCaseMatcher::class.java, CaseMatcher.get("snAke_CASE")?.javaClass)

        assertEquals(ScreamingSnakeCaseMatcher::class.java, CaseMatcher.get("upper snake")?.javaClass)
        assertEquals(ScreamingSnakeCaseMatcher::class.java, CaseMatcher.get("uPPer-sNake-caSE")?.javaClass)
        assertEquals(ScreamingSnakeCaseMatcher::class.java, CaseMatcher.get("screaming snake")?.javaClass)
        assertEquals(ScreamingSnakeCaseMatcher::class.java, CaseMatcher.get("SCREAMING_SNAKE-case")?.javaClass)
        assertEquals(ScreamingSnakeCaseMatcher::class.java, CaseMatcher.get("macro")?.javaClass)
        assertEquals(ScreamingSnakeCaseMatcher::class.java, CaseMatcher.get("Macro case")?.javaClass)
        assertEquals(ScreamingSnakeCaseMatcher::class.java, CaseMatcher.get("constant")?.javaClass)
        assertEquals(ScreamingSnakeCaseMatcher::class.java, CaseMatcher.get("CONSTAnt-cASE")?.javaClass)

        assertEquals(CamelSnakeCaseMatcher::class.java, CaseMatcher.get("camel snake")?.javaClass)
        assertEquals(CamelSnakeCaseMatcher::class.java, CaseMatcher.get("cAMEl=snAKE-case")?.javaClass)

        assertEquals(KebabCaseMatcher::class.java, CaseMatcher.get("lower kebab")?.javaClass)
        assertEquals(KebabCaseMatcher::class.java, CaseMatcher.get("lower-kebab-case")?.javaClass)
        assertEquals(KebabCaseMatcher::class.java, CaseMatcher.get("dash")?.javaClass)
        assertEquals(KebabCaseMatcher::class.java, CaseMatcher.get("DASh-case")?.javaClass)
        assertEquals(KebabCaseMatcher::class.java, CaseMatcher.get("lisp")?.javaClass)
        assertEquals(KebabCaseMatcher::class.java, CaseMatcher.get("LISP_CASE")?.javaClass)
        assertEquals(KebabCaseMatcher::class.java, CaseMatcher.get("kebab")?.javaClass)
        assertEquals(KebabCaseMatcher::class.java, CaseMatcher.get("keBAB-CASE")?.javaClass)

        assertEquals(ScreamingKebabCaseMatcher::class.java, CaseMatcher.get("upper kebab")?.javaClass)
        assertEquals(ScreamingKebabCaseMatcher::class.java, CaseMatcher.get("UPPER-kebab-case")?.javaClass)
        assertEquals(ScreamingKebabCaseMatcher::class.java, CaseMatcher.get("screaming kebab")?.javaClass)
        assertEquals(ScreamingKebabCaseMatcher::class.java, CaseMatcher.get("SCREAMING_kebab-CASE")?.javaClass)
        assertEquals(ScreamingKebabCaseMatcher::class.java, CaseMatcher.get("cobol")?.javaClass)
        assertEquals(ScreamingKebabCaseMatcher::class.java, CaseMatcher.get("COBOL case")?.javaClass)

        assertEquals(TrainCaseMatcher::class.java, CaseMatcher.get("train")?.javaClass)
        assertEquals(TrainCaseMatcher::class.java, CaseMatcher.get("TRAIn-case")?.javaClass)
    }

    @Test
    internal fun testLowerFlatCaseMatcher() {
        val matcher = LowerFlatCaseMatcher()

        assertFalse(matcher.matches(null), "Nulls must not match")
        assertFalse(matcher.matches(""), "Empty strings must not match")
        assertFalse(matcher.matches("    "), "Blank strings must not match")

        assertTrue(matcher.matches(OneWordLowerFlatCaseFormat), "One lower flat case word must match")
        assertTrue(matcher.matches(OneWordLowerFlatCaseFormatNumbers), "One lower flat case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormat), "Two lower flat case words must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatNumbers), "Two lower flat case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatAbbreviation), "Two lower flat case words with abbreviation must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatMiddleAbbreviation), "Two lower flat case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperFlatCaseFormat), "One upper flat case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperFlatCaseFormatNumbers), "One upper flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormat), "Two upper flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatNumbers), "Two upper flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatAbbreviation), "Two upper flat case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatMiddleAbbreviation), "Two upper flat case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordLowerCamelCaseFormat), "One lower camel case word must match")
        assertTrue(matcher.matches(OneWordLowerCamelCaseFormatNumbers), "One lower camel case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormat), "Two lower camel case words must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatNumbers), "Two lower camel case words with numbers must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatAbbreviation), "Two lower camel case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatMiddleAbbreviation), "Two lower camel case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperCamelCaseFormat), "One upper camel case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperCamelCaseFormatNumbers), "One upper camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormat), "Two upper camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatNumbers), "Two upper camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatAbbreviation), "Two upper camel case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatMiddleAbbreviation), "Two upper camel case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordSnakeCaseFormat), "One snake case word must match")
        assertTrue(matcher.matches(OneWordSnakeCaseFormatNumbers), "One snake case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormat), "Two snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatNumbers), "Two snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatAbbreviation), "Two snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatMiddleAbbreviation), "Two snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormat), "One screaming snake case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormatNumbers), "One screaming snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormat), "Two screaming snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatNumbers), "Two screaming snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatAbbreviation), "Two screaming snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation), "Two screaming snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormat), "One camel snake case word must NOT match")
        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormatNumbers), "One camel snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormat), "Two camel snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatNumbers), "Two camel snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatAbbreviation), "Two camel snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatMiddleAbbreviation), "Two camel snake case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordKebabCaseFormat), "One kebab case word must match")
        assertTrue(matcher.matches(OneWordKebabCaseFormatNumbers), "One kebab case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormat), "Two kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatNumbers), "Two kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatAbbreviation), "Two kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatMiddleAbbreviation), "Two kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormat), "One screaming kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormatNumbers), "One screaming kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormat), "Two screaming kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatNumbers), "Two screaming kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatAbbreviation), "Two screaming kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatMiddleAbbreviation), "Two screaming kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordTrainCaseFormat), "One train case word must NOT match")
        assertFalse(matcher.matches(OneWordTrainCaseFormatNumbers), "One train case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormat), "Two train case words must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatNumbers), "Two train case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatAbbreviation), "Two train case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatMiddleAbbreviation), "Two train case words with abbreviation in the middle must NOT match")
    }

    @Test
    internal fun testUpperFlatCaseMatcher() {
        val matcher = UpperFlatCaseMatcher()

        assertFalse(matcher.matches(null), "Nulls must not match")
        assertFalse(matcher.matches(""), "Empty strings must not match")
        assertFalse(matcher.matches("    "), "Blank strings must not match")

        assertFalse(matcher.matches(OneWordLowerFlatCaseFormat), "One lower flat case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerFlatCaseFormatNumbers), "One lower flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormat), "Two lower flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatNumbers), "Two lower flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatAbbreviation), "Two lower flat case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatMiddleAbbreviation), "Two lower flat case words with abbreviation in the middle must match")

        assertTrue(matcher.matches(OneWordUpperFlatCaseFormat), "One upper flat case word must match")
        assertTrue(matcher.matches(OneWordUpperFlatCaseFormatNumbers), "One upper flat case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormat), "Two upper flat case words must match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormatNumbers), "Two upper flat case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormatAbbreviation), "Two upper flat case words with abbreviation must NOT match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormatMiddleAbbreviation), "Two upper flat case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordLowerCamelCaseFormat), "One lower camel case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerCamelCaseFormatNumbers), "One lower camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormat), "Two lower camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatNumbers), "Two lower camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatAbbreviation), "Two lower camel case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatMiddleAbbreviation), "Two lower camel case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperCamelCaseFormat), "One upper camel case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperCamelCaseFormatNumbers), "One upper camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormat), "Two upper camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatNumbers), "Two upper camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatAbbreviation), "Two upper camel case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatMiddleAbbreviation), "Two upper camel case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordSnakeCaseFormat), "One snake case word must NOT match")
        assertFalse(matcher.matches(OneWordSnakeCaseFormatNumbers), "One snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormat), "Two snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatNumbers), "Two snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatAbbreviation), "Two snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatMiddleAbbreviation), "Two snake case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordScreamingSnakeCaseFormat), "One screaming snake case word must match")
        assertTrue(matcher.matches(OneWordScreamingSnakeCaseFormatNumbers), "One screaming snake case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormat), "Two screaming snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatNumbers), "Two screaming snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatAbbreviation), "Two screaming snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation), "Two screaming snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormat), "One camel snake case word must NOT match")
        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormatNumbers), "One camel snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormat), "Two camel snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatNumbers), "Two camel snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatAbbreviation), "Two camel snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatMiddleAbbreviation), "Two camel snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordKebabCaseFormat), "One kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordKebabCaseFormatNumbers), "One kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormat), "Two kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatNumbers), "Two kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatAbbreviation), "Two kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatMiddleAbbreviation), "Two kebab case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordScreamingKebabCaseFormat), "One screaming kebab case word must match")
        assertTrue(matcher.matches(OneWordScreamingKebabCaseFormatNumbers), "One screaming kebab case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormat), "Two screaming kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatNumbers), "Two screaming kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatAbbreviation), "Two screaming kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatMiddleAbbreviation), "Two screaming kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordTrainCaseFormat), "One train case word must NOT match")
        assertFalse(matcher.matches(OneWordTrainCaseFormatNumbers), "One train case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormat), "Two train case words must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatNumbers), "Two train case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatAbbreviation), "Two train case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatMiddleAbbreviation), "Two train case words with abbreviation in the middle must NOT match")
    }

    @Test
    internal fun testLowerCamelCaseMatcher() {
        val matcher = LowerCamelCaseMatcher()

        assertFalse(matcher.matches(null), "Nulls must not match")
        assertFalse(matcher.matches(""), "Empty strings must not match")
        assertFalse(matcher.matches("    "), "Blank strings must not match")

        assertTrue(matcher.matches(OneWordLowerFlatCaseFormat), "One lower flat case word must match")
        assertTrue(matcher.matches(OneWordLowerFlatCaseFormatNumbers), "One lower flat case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormat), "Two lower flat case words must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatNumbers), "Two lower flat case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatAbbreviation), "Two lower flat case words with abbreviation must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatMiddleAbbreviation), "Two lower flat case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperFlatCaseFormat), "One upper flat case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperFlatCaseFormatNumbers), "One upper flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormat), "Two upper flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatNumbers), "Two upper flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatAbbreviation), "Two upper flat case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatMiddleAbbreviation), "Two upper flat case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordLowerCamelCaseFormat), "One lower camel case word must match")
        assertTrue(matcher.matches(OneWordLowerCamelCaseFormatNumbers), "One lower camel case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsLowerCamelCaseFormat), "Two lower camel case words must match")
        assertTrue(matcher.matches(TwoWordsLowerCamelCaseFormatNumbers), "Two lower camel case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsLowerCamelCaseFormatAbbreviation), "Two lower camel case words with abbreviation must match")
        assertTrue(matcher.matches(TwoWordsLowerCamelCaseFormatMiddleAbbreviation), "Two lower camel case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperCamelCaseFormat), "One upper camel case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperCamelCaseFormatNumbers), "One upper camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormat), "Two upper camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatNumbers), "Two upper camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatAbbreviation), "Two upper camel case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatMiddleAbbreviation), "Two upper camel case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordSnakeCaseFormat), "One snake case word must match")
        assertTrue(matcher.matches(OneWordSnakeCaseFormatNumbers), "One snake case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormat), "Two snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatNumbers), "Two snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatAbbreviation), "Two snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatMiddleAbbreviation), "Two snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormat), "One screaming snake case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormatNumbers), "One screaming snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormat), "Two screaming snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatNumbers), "Two screaming snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatAbbreviation), "Two screaming snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation), "Two screaming snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormat), "One camel snake case word must NOT match")
        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormatNumbers), "One camel snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormat), "Two camel snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatNumbers), "Two camel snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatAbbreviation), "Two camel snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatMiddleAbbreviation), "Two camel snake case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordKebabCaseFormat), "One kebab case word must match")
        assertTrue(matcher.matches(OneWordKebabCaseFormatNumbers), "One kebab case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormat), "Two kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatNumbers), "Two kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatAbbreviation), "Two kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatMiddleAbbreviation), "Two kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormat), "One screaming kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormatNumbers), "One screaming kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormat), "Two screaming kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatNumbers), "Two screaming kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatAbbreviation), "Two screaming kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatMiddleAbbreviation), "Two screaming kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordTrainCaseFormat), "One train case word must NOT match")
        assertFalse(matcher.matches(OneWordTrainCaseFormatNumbers), "One train case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormat), "Two train case words must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatNumbers), "Two train case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatAbbreviation), "Two train case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatMiddleAbbreviation), "Two train case words with abbreviation in the middle must NOT match")
    }

    @Test
    internal fun testUpperCamelCaseMatcher() {
        val matcher = UpperCamelCaseMatcher()

        assertFalse(matcher.matches(null), "Nulls must not match")
        assertFalse(matcher.matches(""), "Empty strings must not match")
        assertFalse(matcher.matches("    "), "Blank strings must not match")

        assertFalse(matcher.matches(OneWordLowerFlatCaseFormat), "One lower flat case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerFlatCaseFormatNumbers), "One lower flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormat), "Two lower flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatNumbers), "Two lower flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatAbbreviation), "Two lower flat case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatMiddleAbbreviation), "Two lower flat case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperFlatCaseFormat), "One upper flat case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperFlatCaseFormatNumbers), "One upper flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormat), "Two upper flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatNumbers), "Two upper flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatAbbreviation), "Two upper flat case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatMiddleAbbreviation), "Two upper flat case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordLowerCamelCaseFormat), "One lower camel case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerCamelCaseFormatNumbers), "One lower camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormat), "Two lower camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatNumbers), "Two lower camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatAbbreviation), "Two lower camel case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatMiddleAbbreviation), "Two lower camel case words with abbreviation in the middle must match")

        assertTrue(matcher.matches(OneWordUpperCamelCaseFormat), "One upper camel case word must match")
        assertTrue(matcher.matches(OneWordUpperCamelCaseFormatNumbers), "One upper camel case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsUpperCamelCaseFormat), "Two upper camel case words must match")
        assertTrue(matcher.matches(TwoWordsUpperCamelCaseFormatNumbers), "Two upper camel case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsUpperCamelCaseFormatAbbreviation), "Two upper camel case words with abbreviation must NOT match")
        assertTrue(matcher.matches(TwoWordsUpperCamelCaseFormatMiddleAbbreviation), "Two upper camel case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordSnakeCaseFormat), "One snake case word must NOT match")
        assertFalse(matcher.matches(OneWordSnakeCaseFormatNumbers), "One snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormat), "Two snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatNumbers), "Two snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatAbbreviation), "Two snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatMiddleAbbreviation), "Two snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormat), "One screaming snake case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormatNumbers), "One screaming snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormat), "Two screaming snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatNumbers), "Two screaming snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatAbbreviation), "Two screaming snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation), "Two screaming snake case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordCamelSnakeCaseFormat), "One camel snake case word must match")
        assertTrue(matcher.matches(OneWordCamelSnakeCaseFormatNumbers), "One camel snake case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormat), "Two camel snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatNumbers), "Two camel snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatAbbreviation), "Two camel snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatMiddleAbbreviation), "Two camel snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordKebabCaseFormat), "One kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordKebabCaseFormatNumbers), "One kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormat), "Two kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatNumbers), "Two kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatAbbreviation), "Two kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatMiddleAbbreviation), "Two kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormat), "One screaming kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormatNumbers), "One screaming kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormat), "Two screaming kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatNumbers), "Two screaming kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatAbbreviation), "Two screaming kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatMiddleAbbreviation), "Two screaming kebab case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordTrainCaseFormat), "One train case word must match")
        assertTrue(matcher.matches(OneWordTrainCaseFormatNumbers), "One train case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormat), "Two train case words must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatNumbers), "Two train case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatAbbreviation), "Two train case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatMiddleAbbreviation), "Two train case words with abbreviation in the middle must NOT match")
    }

    @Test
    internal fun testSnakeCaseMatcher() {
        val matcher = SnakeCaseMatcher()

        assertFalse(matcher.matches(null), "Nulls must not match")
        assertFalse(matcher.matches(""), "Empty strings must not match")
        assertFalse(matcher.matches("    "), "Blank strings must not match")

        assertTrue(matcher.matches(OneWordLowerFlatCaseFormat), "One lower flat case word must match")
        assertTrue(matcher.matches(OneWordLowerFlatCaseFormatNumbers), "One lower flat case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormat), "Two lower flat case words must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatNumbers), "Two lower flat case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatAbbreviation), "Two lower flat case words with abbreviation must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatMiddleAbbreviation), "Two lower flat case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperFlatCaseFormat), "One upper flat case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperFlatCaseFormatNumbers), "One upper flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormat), "Two upper flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatNumbers), "Two upper flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatAbbreviation), "Two upper flat case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatMiddleAbbreviation), "Two upper flat case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordLowerCamelCaseFormat), "One lower camel case word must match")
        assertTrue(matcher.matches(OneWordLowerCamelCaseFormatNumbers), "One lower camel case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormat), "Two lower camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatNumbers), "Two lower camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatAbbreviation), "Two lower camel case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatMiddleAbbreviation), "Two lower camel case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperCamelCaseFormat), "One upper camel case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperCamelCaseFormatNumbers), "One upper camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormat), "Two upper camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatNumbers), "Two upper camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatAbbreviation), "Two upper camel case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatMiddleAbbreviation), "Two upper camel case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordSnakeCaseFormat), "One snake case word must match")
        assertTrue(matcher.matches(OneWordSnakeCaseFormatNumbers), "One snake case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsSnakeCaseFormat), "Two snake case words must match")
        assertTrue(matcher.matches(TwoWordsSnakeCaseFormatNumbers), "Two snake case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsSnakeCaseFormatAbbreviation), "Two snake case words with abbreviation must NOT match")
        assertTrue(matcher.matches(TwoWordsSnakeCaseFormatMiddleAbbreviation), "Two snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormat), "One screaming snake case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormatNumbers), "One screaming snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormat), "Two screaming snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatNumbers), "Two screaming snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatAbbreviation), "Two screaming snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation), "Two screaming snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormat), "One camel snake case word must NOT match")
        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormatNumbers), "One camel snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormat), "Two camel snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatNumbers), "Two camel snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatAbbreviation), "Two camel snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatMiddleAbbreviation), "Two camel snake case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordKebabCaseFormat), "One kebab case word must match")
        assertTrue(matcher.matches(OneWordKebabCaseFormatNumbers), "One kebab case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormat), "Two kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatNumbers), "Two kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatAbbreviation), "Two kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatMiddleAbbreviation), "Two kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormat), "One screaming kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormatNumbers), "One screaming kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormat), "Two screaming kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatNumbers), "Two screaming kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatAbbreviation), "Two screaming kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatMiddleAbbreviation), "Two screaming kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordTrainCaseFormat), "One train case word must NOT match")
        assertFalse(matcher.matches(OneWordTrainCaseFormatNumbers), "One train case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormat), "Two train case words must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatNumbers), "Two train case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatAbbreviation), "Two train case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatMiddleAbbreviation), "Two train case words with abbreviation in the middle must NOT match")
    }

    @Test
    internal fun testScreamingSnakeCaseMatcher() {
        val matcher = ScreamingSnakeCaseMatcher()

        assertFalse(matcher.matches(null), "Nulls must not match")
        assertFalse(matcher.matches(""), "Empty strings must not match")
        assertFalse(matcher.matches("    "), "Blank strings must not match")

        assertFalse(matcher.matches(OneWordLowerFlatCaseFormat), "One lower flat case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerFlatCaseFormatNumbers), "One lower flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormat), "Two lower flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatNumbers), "Two lower flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatAbbreviation), "Two lower flat case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatMiddleAbbreviation), "Two lower flat case words with abbreviation in the middle must match")

        assertTrue(matcher.matches(OneWordUpperFlatCaseFormat), "One upper flat case word must match")
        assertTrue(matcher.matches(OneWordUpperFlatCaseFormatNumbers), "One upper flat case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormat), "Two upper flat case words must match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormatNumbers), "Two upper flat case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormatAbbreviation), "Two upper flat case words with abbreviation must NOT match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormatMiddleAbbreviation), "Two upper flat case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordLowerCamelCaseFormat), "One lower camel case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerCamelCaseFormatNumbers), "One lower camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormat), "Two lower camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatNumbers), "Two lower camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatAbbreviation), "Two lower camel case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatMiddleAbbreviation), "Two lower camel case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperCamelCaseFormat), "One upper camel case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperCamelCaseFormatNumbers), "One upper camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormat), "Two upper camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatNumbers), "Two upper camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatAbbreviation), "Two upper camel case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatMiddleAbbreviation), "Two upper camel case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordSnakeCaseFormat), "One snake case word must NOT match")
        assertFalse(matcher.matches(OneWordSnakeCaseFormatNumbers), "One snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormat), "Two snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatNumbers), "Two snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatAbbreviation), "Two snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatMiddleAbbreviation), "Two snake case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordScreamingSnakeCaseFormat), "One screaming snake case word must match")
        assertTrue(matcher.matches(OneWordScreamingSnakeCaseFormatNumbers), "One screaming snake case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsScreamingSnakeCaseFormat), "Two screaming snake case words must match")
        assertTrue(matcher.matches(TwoWordsScreamingSnakeCaseFormatNumbers), "Two screaming snake case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsScreamingSnakeCaseFormatAbbreviation), "Two screaming snake case words with abbreviation must NOT match")
        assertTrue(matcher.matches(TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation), "Two screaming snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormat), "One camel snake case word must NOT match")
        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormatNumbers), "One camel snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormat), "Two camel snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatNumbers), "Two camel snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatAbbreviation), "Two camel snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatMiddleAbbreviation), "Two camel snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordKebabCaseFormat), "One kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordKebabCaseFormatNumbers), "One kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormat), "Two kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatNumbers), "Two kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatAbbreviation), "Two kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatMiddleAbbreviation), "Two kebab case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordScreamingKebabCaseFormat), "One screaming kebab case word must match")
        assertTrue(matcher.matches(OneWordScreamingKebabCaseFormatNumbers), "One screaming kebab case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormat), "Two screaming kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatNumbers), "Two screaming kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatAbbreviation), "Two screaming kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatMiddleAbbreviation), "Two screaming kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordTrainCaseFormat), "One train case word must NOT match")
        assertFalse(matcher.matches(OneWordTrainCaseFormatNumbers), "One train case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormat), "Two train case words must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatNumbers), "Two train case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatAbbreviation), "Two train case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatMiddleAbbreviation), "Two train case words with abbreviation in the middle must NOT match")
    }

    @Test
    internal fun testCamelSnakeCaseMatcher() {
        val matcher = CamelSnakeCaseMatcher()

        assertFalse(matcher.matches(null), "Nulls must not match")
        assertFalse(matcher.matches(""), "Empty strings must not match")
        assertFalse(matcher.matches("    "), "Blank strings must not match")

        assertFalse(matcher.matches(OneWordLowerFlatCaseFormat), "One lower flat case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerFlatCaseFormatNumbers), "One lower flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormat), "Two lower flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatNumbers), "Two lower flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatAbbreviation), "Two lower flat case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatMiddleAbbreviation), "Two lower flat case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperFlatCaseFormat), "One upper flat case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperFlatCaseFormatNumbers), "One upper flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormat), "Two upper flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatNumbers), "Two upper flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatAbbreviation), "Two upper flat case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatMiddleAbbreviation), "Two upper flat case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordLowerCamelCaseFormat), "One lower camel case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerCamelCaseFormatNumbers), "One lower camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormat), "Two lower camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatNumbers), "Two lower camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatAbbreviation), "Two lower camel case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatMiddleAbbreviation), "Two lower camel case words with abbreviation in the middle must match")

        assertTrue(matcher.matches(OneWordUpperCamelCaseFormat), "One upper camel case word must match")
        assertTrue(matcher.matches(OneWordUpperCamelCaseFormatNumbers), "One upper camel case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormat), "Two upper camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatNumbers), "Two upper camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatAbbreviation), "Two upper camel case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatMiddleAbbreviation), "Two upper camel case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordSnakeCaseFormat), "One snake case word must NOT match")
        assertFalse(matcher.matches(OneWordSnakeCaseFormatNumbers), "One snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormat), "Two snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatNumbers), "Two snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatAbbreviation), "Two snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatMiddleAbbreviation), "Two snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormat), "One screaming snake case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormatNumbers), "One screaming snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormat), "Two screaming snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatNumbers), "Two screaming snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatAbbreviation), "Two screaming snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation), "Two screaming snake case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordCamelSnakeCaseFormat), "One camel snake case word must match")
        assertTrue(matcher.matches(OneWordCamelSnakeCaseFormatNumbers), "One camel snake case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsCamelSnakeCaseFormat), "Two camel snake case words must match")
        assertTrue(matcher.matches(TwoWordsCamelSnakeCaseFormatNumbers), "Two camel snake case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsCamelSnakeCaseFormatAbbreviation), "Two camel snake case words with abbreviation must NOT match")
        assertTrue(matcher.matches(TwoWordsCamelSnakeCaseFormatMiddleAbbreviation), "Two camel snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordKebabCaseFormat), "One kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordKebabCaseFormatNumbers), "One kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormat), "Two kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatNumbers), "Two kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatAbbreviation), "Two kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatMiddleAbbreviation), "Two kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormat), "One screaming kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormatNumbers), "One screaming kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormat), "Two screaming kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatNumbers), "Two screaming kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatAbbreviation), "Two screaming kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatMiddleAbbreviation), "Two screaming kebab case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordTrainCaseFormat), "One train case word must match")
        assertTrue(matcher.matches(OneWordTrainCaseFormatNumbers), "One train case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormat), "Two train case words must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatNumbers), "Two train case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatAbbreviation), "Two train case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatMiddleAbbreviation), "Two train case words with abbreviation in the middle must NOT match")
    }

    @Test
    internal fun testKebabCaseMatcher() {
        val matcher = KebabCaseMatcher()

        assertFalse(matcher.matches(null), "Nulls must not match")
        assertFalse(matcher.matches(""), "Empty strings must not match")
        assertFalse(matcher.matches("    "), "Blank strings must not match")

        assertTrue(matcher.matches(OneWordLowerFlatCaseFormat), "One lower flat case word must match")
        assertTrue(matcher.matches(OneWordLowerFlatCaseFormatNumbers), "One lower flat case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormat), "Two lower flat case words must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatNumbers), "Two lower flat case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatAbbreviation), "Two lower flat case words with abbreviation must match")
        assertTrue(matcher.matches(TwoWordsLowerFlatCaseFormatMiddleAbbreviation), "Two lower flat case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperFlatCaseFormat), "One upper flat case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperFlatCaseFormatNumbers), "One upper flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormat), "Two upper flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatNumbers), "Two upper flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatAbbreviation), "Two upper flat case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatMiddleAbbreviation), "Two upper flat case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordLowerCamelCaseFormat), "One lower camel case word must match")
        assertTrue(matcher.matches(OneWordLowerCamelCaseFormatNumbers), "One lower camel case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormat), "Two lower camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatNumbers), "Two lower camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatAbbreviation), "Two lower camel case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatMiddleAbbreviation), "Two lower camel case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperCamelCaseFormat), "One upper camel case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperCamelCaseFormatNumbers), "One upper camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormat), "Two upper camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatNumbers), "Two upper camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatAbbreviation), "Two upper camel case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatMiddleAbbreviation), "Two upper camel case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordSnakeCaseFormat), "One snake case word must match")
        assertTrue(matcher.matches(OneWordSnakeCaseFormatNumbers), "One snake case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormat), "Two snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatNumbers), "Two snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatAbbreviation), "Two snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatMiddleAbbreviation), "Two snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormat), "One screaming snake case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormatNumbers), "One screaming snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormat), "Two screaming snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatNumbers), "Two screaming snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatAbbreviation), "Two screaming snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation), "Two screaming snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormat), "One camel snake case word must NOT match")
        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormatNumbers), "One camel snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormat), "Two camel snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatNumbers), "Two camel snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatAbbreviation), "Two camel snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatMiddleAbbreviation), "Two camel snake case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordKebabCaseFormat), "One kebab case word must match")
        assertTrue(matcher.matches(OneWordKebabCaseFormatNumbers), "One kebab case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsKebabCaseFormat), "Two kebab case words must match")
        assertTrue(matcher.matches(TwoWordsKebabCaseFormatNumbers), "Two kebab case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsKebabCaseFormatAbbreviation), "Two kebab case words with abbreviation must NOT match")
        assertTrue(matcher.matches(TwoWordsKebabCaseFormatMiddleAbbreviation), "Two kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormat), "One screaming kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormatNumbers), "One screaming kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormat), "Two screaming kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatNumbers), "Two screaming kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatAbbreviation), "Two screaming kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatMiddleAbbreviation), "Two screaming kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordTrainCaseFormat), "One train case word must NOT match")
        assertFalse(matcher.matches(OneWordTrainCaseFormatNumbers), "One train case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormat), "Two train case words must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatNumbers), "Two train case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatAbbreviation), "Two train case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatMiddleAbbreviation), "Two train case words with abbreviation in the middle must NOT match")
    }

    @Test
    internal fun testScreamingKebabCaseMatcher() {
        val matcher = ScreamingKebabCaseMatcher()

        assertFalse(matcher.matches(null), "Nulls must not match")
        assertFalse(matcher.matches(""), "Empty strings must not match")
        assertFalse(matcher.matches("    "), "Blank strings must not match")

        assertFalse(matcher.matches(OneWordLowerFlatCaseFormat), "One lower flat case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerFlatCaseFormatNumbers), "One lower flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormat), "Two lower flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatNumbers), "Two lower flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatAbbreviation), "Two lower flat case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatMiddleAbbreviation), "Two lower flat case words with abbreviation in the middle must match")

        assertTrue(matcher.matches(OneWordUpperFlatCaseFormat), "One upper flat case word must match")
        assertTrue(matcher.matches(OneWordUpperFlatCaseFormatNumbers), "One upper flat case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormat), "Two upper flat case words must match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormatNumbers), "Two upper flat case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormatAbbreviation), "Two upper flat case words with abbreviation must NOT match")
        assertTrue(matcher.matches(TwoWordsUpperFlatCaseFormatMiddleAbbreviation), "Two upper flat case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordLowerCamelCaseFormat), "One lower camel case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerCamelCaseFormatNumbers), "One lower camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormat), "Two lower camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatNumbers), "Two lower camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatAbbreviation), "Two lower camel case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatMiddleAbbreviation), "Two lower camel case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperCamelCaseFormat), "One upper camel case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperCamelCaseFormatNumbers), "One upper camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormat), "Two upper camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatNumbers), "Two upper camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatAbbreviation), "Two upper camel case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatMiddleAbbreviation), "Two upper camel case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordSnakeCaseFormat), "One snake case word must NOT match")
        assertFalse(matcher.matches(OneWordSnakeCaseFormatNumbers), "One snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormat), "Two snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatNumbers), "Two snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatAbbreviation), "Two snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatMiddleAbbreviation), "Two snake case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordScreamingSnakeCaseFormat), "One screaming snake case word must match")
        assertTrue(matcher.matches(OneWordScreamingSnakeCaseFormatNumbers), "One screaming snake case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormat), "Two screaming snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatNumbers), "Two screaming snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatAbbreviation), "Two screaming snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation), "Two screaming snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormat), "One camel snake case word must NOT match")
        assertFalse(matcher.matches(OneWordCamelSnakeCaseFormatNumbers), "One camel snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormat), "Two camel snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatNumbers), "Two camel snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatAbbreviation), "Two camel snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatMiddleAbbreviation), "Two camel snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordKebabCaseFormat), "One kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordKebabCaseFormatNumbers), "One kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormat), "Two kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatNumbers), "Two kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatAbbreviation), "Two kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatMiddleAbbreviation), "Two kebab case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordScreamingKebabCaseFormat), "One screaming kebab case word must match")
        assertTrue(matcher.matches(OneWordScreamingKebabCaseFormatNumbers), "One screaming kebab case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsScreamingKebabCaseFormat), "Two screaming kebab case words must match")
        assertTrue(matcher.matches(TwoWordsScreamingKebabCaseFormatNumbers), "Two screaming kebab case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsScreamingKebabCaseFormatAbbreviation), "Two screaming kebab case words with abbreviation must NOT match")
        assertTrue(matcher.matches(TwoWordsScreamingKebabCaseFormatMiddleAbbreviation), "Two screaming kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordTrainCaseFormat), "One train case word must NOT match")
        assertFalse(matcher.matches(OneWordTrainCaseFormatNumbers), "One train case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormat), "Two train case words must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatNumbers), "Two train case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatAbbreviation), "Two train case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsTrainCaseFormatMiddleAbbreviation), "Two train case words with abbreviation in the middle must NOT match")
    }

    @Test
    internal fun testTrainCaseMatcher() {
        val matcher = TrainCaseMatcher()

        assertFalse(matcher.matches(null), "Nulls must not match")
        assertFalse(matcher.matches(""), "Empty strings must not match")
        assertFalse(matcher.matches("    "), "Blank strings must not match")

        assertFalse(matcher.matches(OneWordLowerFlatCaseFormat), "One lower flat case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerFlatCaseFormatNumbers), "One lower flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormat), "Two lower flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatNumbers), "Two lower flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatAbbreviation), "Two lower flat case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerFlatCaseFormatMiddleAbbreviation), "Two lower flat case words with abbreviation in the middle must match")

        assertFalse(matcher.matches(OneWordUpperFlatCaseFormat), "One upper flat case word must NOT match")
        assertFalse(matcher.matches(OneWordUpperFlatCaseFormatNumbers), "One upper flat case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormat), "Two upper flat case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatNumbers), "Two upper flat case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatAbbreviation), "Two upper flat case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperFlatCaseFormatMiddleAbbreviation), "Two upper flat case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordLowerCamelCaseFormat), "One lower camel case word must NOT match")
        assertFalse(matcher.matches(OneWordLowerCamelCaseFormatNumbers), "One lower camel case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormat), "Two lower camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatNumbers), "Two lower camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatAbbreviation), "Two lower camel case words with abbreviation must match")
        assertFalse(matcher.matches(TwoWordsLowerCamelCaseFormatMiddleAbbreviation), "Two lower camel case words with abbreviation in the middle must match")

        assertTrue(matcher.matches(OneWordUpperCamelCaseFormat), "One upper camel case word must match")
        assertTrue(matcher.matches(OneWordUpperCamelCaseFormatNumbers), "One upper camel case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormat), "Two upper camel case words must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatNumbers), "Two upper camel case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatAbbreviation), "Two upper camel case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsUpperCamelCaseFormatMiddleAbbreviation), "Two upper camel case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordSnakeCaseFormat), "One snake case word must NOT match")
        assertFalse(matcher.matches(OneWordSnakeCaseFormatNumbers), "One snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormat), "Two snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatNumbers), "Two snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatAbbreviation), "Two snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsSnakeCaseFormatMiddleAbbreviation), "Two snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormat), "One screaming snake case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingSnakeCaseFormatNumbers), "One screaming snake case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormat), "Two screaming snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatNumbers), "Two screaming snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatAbbreviation), "Two screaming snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation), "Two screaming snake case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordCamelSnakeCaseFormat), "One camel snake case word must match")
        assertTrue(matcher.matches(OneWordCamelSnakeCaseFormatNumbers), "One camel snake case word with numbers must match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormat), "Two camel snake case words must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatNumbers), "Two camel snake case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatAbbreviation), "Two camel snake case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsCamelSnakeCaseFormatMiddleAbbreviation), "Two camel snake case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordKebabCaseFormat), "One kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordKebabCaseFormatNumbers), "One kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormat), "Two kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatNumbers), "Two kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatAbbreviation), "Two kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsKebabCaseFormatMiddleAbbreviation), "Two kebab case words with abbreviation in the middle must NOT match")

        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormat), "One screaming kebab case word must NOT match")
        assertFalse(matcher.matches(OneWordScreamingKebabCaseFormatNumbers), "One screaming kebab case word with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormat), "Two screaming kebab case words must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatNumbers), "Two screaming kebab case words with numbers must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatAbbreviation), "Two screaming kebab case words with abbreviation must NOT match")
        assertFalse(matcher.matches(TwoWordsScreamingKebabCaseFormatMiddleAbbreviation), "Two screaming kebab case words with abbreviation in the middle must NOT match")

        assertTrue(matcher.matches(OneWordTrainCaseFormat), "One train case word must match")
        assertTrue(matcher.matches(OneWordTrainCaseFormatNumbers), "One train case word with numbers must match")
        assertTrue(matcher.matches(TwoWordsTrainCaseFormat), "Two train case words must match")
        assertTrue(matcher.matches(TwoWordsTrainCaseFormatNumbers), "Two train case words with numbers must match")
        assertTrue(matcher.matches(TwoWordsTrainCaseFormatAbbreviation), "Two train case words with abbreviation must NOT match")
        assertTrue(matcher.matches(TwoWordsTrainCaseFormatMiddleAbbreviation), "Two train case words with abbreviation in the middle must NOT match")
    }

    companion object {
        const val OneWordLowerFlatCaseFormat = "oneword"
        const val OneWordLowerFlatCaseFormatNumbers = "oneword123"
        const val TwoWordsLowerFlatCaseFormat = "twowords"
        const val TwoWordsLowerFlatCaseFormatNumbers = "twowords456"
        const val TwoWordsLowerFlatCaseFormatAbbreviation = "twowordsabc"
        const val TwoWordsLowerFlatCaseFormatMiddleAbbreviation = "twoabcwords"

        const val OneWordUpperFlatCaseFormat = "ONEWORD"
        const val OneWordUpperFlatCaseFormatNumbers = "ONEWORD123"
        const val TwoWordsUpperFlatCaseFormat = "TWOWORDS"
        const val TwoWordsUpperFlatCaseFormatNumbers = "TWOWORDS456"
        const val TwoWordsUpperFlatCaseFormatAbbreviation = "TWOWORDSABC"
        const val TwoWordsUpperFlatCaseFormatMiddleAbbreviation = "TWOABCWORDS"

        const val OneWordLowerCamelCaseFormat = "oneword"
        const val OneWordLowerCamelCaseFormatNumbers = "oneword123"
        const val TwoWordsLowerCamelCaseFormat = "twoWords"
        const val TwoWordsLowerCamelCaseFormatNumbers = "twoWords456"
        const val TwoWordsLowerCamelCaseFormatAbbreviation = "twoWordsABC"
        const val TwoWordsLowerCamelCaseFormatMiddleAbbreviation = "twoABCWords"

        const val OneWordUpperCamelCaseFormat = "Oneword"
        const val OneWordUpperCamelCaseFormatNumbers = "Oneword123"
        const val TwoWordsUpperCamelCaseFormat = "TwoWords"
        const val TwoWordsUpperCamelCaseFormatNumbers = "TwoWords456"
        const val TwoWordsUpperCamelCaseFormatAbbreviation = "TwoWordsABC"
        const val TwoWordsUpperCamelCaseFormatMiddleAbbreviation = "TwoABCWords"

        const val OneWordSnakeCaseFormat = "oneword"
        const val OneWordSnakeCaseFormatNumbers = "oneword123"
        const val TwoWordsSnakeCaseFormat = "two_words"
        const val TwoWordsSnakeCaseFormatNumbers = "two_words456"
        const val TwoWordsSnakeCaseFormatAbbreviation = "two_words_abc"
        const val TwoWordsSnakeCaseFormatMiddleAbbreviation = "two_abc_words"

        const val OneWordScreamingSnakeCaseFormat = "ONEWORD"
        const val OneWordScreamingSnakeCaseFormatNumbers = "ONEWORD123"
        const val TwoWordsScreamingSnakeCaseFormat = "TWO_WORDS"
        const val TwoWordsScreamingSnakeCaseFormatNumbers = "TWO_WORDS456"
        const val TwoWordsScreamingSnakeCaseFormatAbbreviation = "TWO_WORDS_ABC"
        const val TwoWordsScreamingSnakeCaseFormatMiddleAbbreviation = "TWO_ABC_WORDS"

        const val OneWordCamelSnakeCaseFormat = "Oneword"
        const val OneWordCamelSnakeCaseFormatNumbers = "Oneword123"
        const val TwoWordsCamelSnakeCaseFormat = "Two_Words"
        const val TwoWordsCamelSnakeCaseFormatNumbers = "Two_Words456"
        const val TwoWordsCamelSnakeCaseFormatAbbreviation = "Two_Words_ABC"
        const val TwoWordsCamelSnakeCaseFormatMiddleAbbreviation = "Two_ABC_Words"

        const val OneWordKebabCaseFormat = "oneword"
        const val OneWordKebabCaseFormatNumbers = "oneword123"
        const val TwoWordsKebabCaseFormat = "two-words"
        const val TwoWordsKebabCaseFormatNumbers = "two-words456"
        const val TwoWordsKebabCaseFormatAbbreviation = "two-words-abc"
        const val TwoWordsKebabCaseFormatMiddleAbbreviation = "two-abc-words"

        const val OneWordScreamingKebabCaseFormat = "ONEWORD"
        const val OneWordScreamingKebabCaseFormatNumbers = "ONEWORD123"
        const val TwoWordsScreamingKebabCaseFormat = "TWO-WORDS"
        const val TwoWordsScreamingKebabCaseFormatNumbers = "TWO-WORDS456"
        const val TwoWordsScreamingKebabCaseFormatAbbreviation = "TWO-WORDS-ABC"
        const val TwoWordsScreamingKebabCaseFormatMiddleAbbreviation = "TWO-ABC-WORDS"

        const val OneWordTrainCaseFormat = "Oneword"
        const val OneWordTrainCaseFormatNumbers = "Oneword123"
        const val TwoWordsTrainCaseFormat = "Two-Words"
        const val TwoWordsTrainCaseFormatNumbers = "Two-Words456"
        const val TwoWordsTrainCaseFormatAbbreviation = "Two-Words-ABC"
        const val TwoWordsTrainCaseFormatMiddleAbbreviation = "Two-ABC-Words"
    }
}