@fgv/ts-bcp47 5.1.0-2 → 5.1.0-4

package/dist/test/unit/bcp47/commonTestCases.js

@@ -0,0 +1,475 @@
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { GenericLanguageTagTest, allCanonicalTestKeys, allNonCanonicalTestKeys, allNonPreferredCanonicalKeys, allPreferredKeys, allTestKeys, allValidatingKeys } from './languageTagHelpers';
+const testCaseInit = [
+    {
+        description: 'valid canonical primary language',
+        from: 'en',
+        expected: [['en', allTestKeys]],
+        expectedDescription: [['English', allTestKeys]]
+    },
+    {
+        description: 'valid non-canonical primary language',
+        from: 'EN',
+        expected: [
+            ['EN', allNonCanonicalTestKeys],
+            ['en', allCanonicalTestKeys]
+        ]
+    },
+    {
+        description: 'valid but deprecated primary language',
+        from: 'in',
+        expected: [
+            ['in', [...allNonCanonicalTestKeys, ...allNonPreferredCanonicalKeys]],
+            ['id', allPreferredKeys]
+        ],
+        expectedDescription: [['Indonesian', allTestKeys]]
+    },
+    {
+        description: 'valid private primary language',
+        from: 'qpn',
+        expected: [['qpn', allTestKeys]],
+        expectedDescription: [['Private use', allTestKeys]]
+    },
+    {
+        description: 'invalid primary language',
+        from: 'ENG-US',
+        expected: [
+            ['ENG-US', ['default', 'wellFormed']],
+            ['eng-US', ['wellFormedCanonical']],
+            [/invalid language/i, allValidatingKeys]
+        ],
+        expectedDescription: [['ENG as spoken in United States', ['wellFormed']]]
+    },
+    {
+        description: 'valid canonical extlang',
+        from: 'zh-cmn',
+        expected: [
+            ['zh-cmn', [...allNonCanonicalTestKeys, ...allNonPreferredCanonicalKeys]],
+            ['cmn', allPreferredKeys]
+        ],
+        expectedDescription: [
+            ['Chinese / Mandarin Chinese', ['wellFormed']],
+            ['Mandarin Chinese', ['preferred']]
+        ]
+    },
+    {
+        description: 'valid canonical extlang with additional tags',
+        from: 'zh-cmn-CN-x-private',
+        expected: [
+            ['zh-cmn-CN-x-private', [...allNonCanonicalTestKeys, ...allNonPreferredCanonicalKeys]],
+            ['cmn-CN-x-private', allPreferredKeys]
+        ],
+        expectedDescription: [
+            ['Chinese / Mandarin Chinese as spoken in China (-x "private")', ['wellFormed']],
+            ['Mandarin Chinese as spoken in China (-x "private")', ['preferred']]
+        ]
+    },
+    {
+        description: 'valid non-canonical extlang',
+        from: 'ZH-Cmn',
+        expected: [
+            ['ZH-Cmn', allNonCanonicalTestKeys],
+            ['zh-cmn', allCanonicalTestKeys],
+            ['cmn', allPreferredKeys]
+        ]
+    },
+    {
+        description: 'invalid extlang',
+        from: 'zh-Han',
+        expected: [
+            ['zh-Han', ['default', 'wellFormed']],
+            ['zh-han', ['wellFormedCanonical']],
+            [/invalid extlang/i, allValidatingKeys]
+        ],
+        expectedDescription: [['Chinese / Han', ['wellFormed']]]
+    },
+    {
+        description: 'valid extlang with invalid prefix',
+        from: 'en-cmn-us',
+        expected: [
+            ['en-cmn-us', ['default', 'wellFormed', 'valid']],
+            ['en-cmn-US', ['wellFormedCanonical', 'validCanonical', 'preferred']],
+            [/invalid prefix/i, ['strictlyValid', 'strictlyValidCanonical', 'strictlyValidPreferred']]
+        ],
+        expectedDescription: [['English / Mandarin Chinese as spoken in United States', ['wellFormed']]]
+    },
+    {
+        description: 'multiple extlang',
+        from: 'zh-cmn-yue',
+        expected: [
+            ['zh-cmn-yue', ['default', 'wellFormed', 'wellFormedCanonical']],
+            [/multiple extlang/i, allValidatingKeys]
+        ],
+        expectedDescription: [['Chinese / Mandarin Chinese / Yue Chinese', ['wellFormed']]]
+    },
+    {
+        description: 'valid non-canonical, non-suppressed script',
+        from: 'zh-LATN',
+        expected: [
+            ['zh-LATN', allNonCanonicalTestKeys],
+            ['zh-Latn', allCanonicalTestKeys]
+        ],
+        expectedDescription: [['Chinese in Latin script', ['wellFormed', 'preferred']]]
+    },
+    {
+        description: 'valid non-canonical, suppressed script',
+        from: 'en-LATN',
+        expected: [
+            ['en-LATN', allNonCanonicalTestKeys],
+            ['en-Latn', allNonPreferredCanonicalKeys],
+            ['en', allPreferredKeys]
+        ],
+        expectedDescription: [
+            ['English in Latin script', ['wellFormed']],
+            ['English', ['preferred']]
+        ]
+    },
+    {
+        description: 'invalid script',
+        from: 'en-AaaA',
+        expected: [
+            ['en-AaaA', ['default', 'wellFormed']],
+            ['en-Aaaa', ['wellFormedCanonical']],
+            [/invalid script/i, allValidatingKeys]
+        ],
+        expectedDescription: [['English in AaaA script', ['wellFormed']]]
+    },
+    {
+        description: 'valid non-canonical iso3166-2 region',
+        from: 'en-aq',
+        expected: [
+            ['en-aq', allNonCanonicalTestKeys],
+            ['en-AQ', allCanonicalTestKeys]
+        ],
+        expectedDescription: [['English as spoken in Antarctica', ['wellFormed', 'preferred']]]
+    },
+    {
+        description: 'valid non-canonical UN M.49 region',
+        from: 'es-419',
+        expected: [['es-419', allTestKeys]],
+        expectedDescription: [['Spanish as spoken in Latin America and the Caribbean', allTestKeys]]
+    },
+    {
+        description: 'invalid region',
+        from: 'en-AJ',
+        expected: [
+            ['en-AJ', ['default', 'wellFormed', 'wellFormedCanonical']],
+            [/invalid region/i, allValidatingKeys]
+        ],
+        expectedDescription: [['English as spoken in AJ', ['wellFormed']]]
+    },
+    {
+        description: 'strictly valid non-canonical variant',
+        from: 'ca-Valencia',
+        expected: [
+            ['ca-Valencia', allNonCanonicalTestKeys],
+            ['ca-valencia', allCanonicalTestKeys]
+        ],
+        expectedDescription: [['Catalan (Valencian)', ['wellFormed']]]
+    },
+    {
+        description: 'not strictly-valid non-canonical variant',
+        from: 'fr-Valencia',
+        expected: [
+            ['fr-Valencia', ['default', 'wellFormed', 'valid']],
+            ['fr-valencia', ['wellFormedCanonical', 'validCanonical', 'preferred']],
+            [/invalid prefix/i, ['strictlyValid', 'strictlyValidCanonical', 'strictlyValidPreferred']]
+        ],
+        expectedDescription: [['French (Valencian)', ['wellFormed']]]
+    },
+    {
+        description: 'valid but deprecated region',
+        from: 'en-BU',
+        expected: [
+            ['en-BU', [...allNonCanonicalTestKeys, ...allNonPreferredCanonicalKeys]],
+            ['en-MM', allPreferredKeys]
+        ],
+        expectedDescription: [
+            ['English as spoken in Burma', ['wellFormed']],
+            ['English as spoken in Myanmar', ['preferred']]
+        ]
+    },
+    {
+        description: 'any prefix for variant with no registered prefix',
+        from: 'en-alalc97',
+        expected: [['en-alalc97', allTestKeys]],
+        expectedDescription: [['English (ALA-LC Romanization, 1997 edition)', ['wellFormed']]]
+    },
+    {
+        description: 'strictly valid with two variants',
+        from: 'SL-Rozaj-Lipaw',
+        expected: [
+            ['SL-Rozaj-Lipaw', allNonCanonicalTestKeys],
+            ['sl-rozaj-lipaw', allCanonicalTestKeys]
+        ],
+        expectedDescription: [['Slovenian (Resian) (The Lipovaz dialect of Resian)', ['wellFormed']]]
+    },
+    {
+        description: 'strictly valid with multiple variants',
+        from: 'SL-Rozaj-biske-1994',
+        expected: [
+            ['SL-Rozaj-biske-1994', allNonCanonicalTestKeys],
+            ['sl-rozaj-biske-1994', allCanonicalTestKeys]
+        ],
+        expectedDescription: [
+            [
+                'Slovenian (Resian) (The San Giorgio dialect of Resian) (Standardized Resian orthography)',
+                ['wellFormed']
+            ]
+        ]
+    },
+    {
+        description: 'not strictly valid with multiple variants',
+        from: 'SL-Rozaj-1996',
+        expected: [
+            ['SL-Rozaj-1996', ['default', 'wellFormed', 'valid']],
+            ['sl-rozaj-1996', ['wellFormedCanonical', 'validCanonical', 'preferred']],
+            [/invalid prefix/i, ['strictlyValid', 'strictlyValidCanonical', 'strictlyValidPreferred']]
+        ],
+        expectedDescription: [['Slovenian (Resian) (German orthography of 1996)', ['wellFormed']]]
+    },
+    {
+        description: 'invalid variant',
+        from: 'ca-ES-xyzzy',
+        expected: [
+            ['ca-ES-xyzzy', ['default', 'wellFormed', 'wellFormedCanonical']],
+            [/invalid variant/i, allValidatingKeys]
+        ],
+        expectedDescription: [['Catalan as spoken in Spain (xyzzy)', ['wellFormed']]]
+    },
+    {
+        description: 'invalid duplicate variant',
+        from: 'ca-valencia-valencia',
+        expected: [
+            ['ca-valencia-valencia', ['default', 'wellFormed', 'wellFormedCanonical']],
+            [/duplicate variant/i, allValidatingKeys]
+        ],
+        expectedDescription: [['Catalan (Valencian) (Valencian)', ['wellFormed']]]
+    },
+    {
+        description: 'valid extensions',
+        from: 'en-us-u-en-US-t-MT',
+        expected: [
+            ['en-us-u-en-US-t-MT', allNonCanonicalTestKeys],
+            ['en-US-u-en-US-t-mt', allCanonicalTestKeys]
+        ],
+        expectedDescription: [
+            [
+                'English as spoken in United States (Unicode Locale "en-US") (Specifying Transformed Content "MT")',
+                ['wellFormed']
+            ]
+        ]
+    },
+    {
+        description: 'invalid extension',
+        from: 'es-us-a-extend',
+        expected: [
+            ['es-us-a-extend', ['default', 'wellFormed']],
+            ['es-US-a-extend', ['wellFormedCanonical']],
+            [/invalid.*extension/i, allValidatingKeys]
+        ],
+        expectedDescription: [['Spanish as spoken in United States (-a "extend")', ['wellFormed']]]
+    },
+    {
+        description: 'duplicate extension',
+        from: 'es-us-u-US-u-GB',
+        expected: [
+            ['es-us-u-US-u-GB', ['default', 'wellFormed']],
+            ['es-US-u-us-u-gb', ['wellFormedCanonical']],
+            [/duplicate.*extension/i, allValidatingKeys]
+        ]
+    },
+    {
+        description: 'valid private-use subtag',
+        from: 'en-x-Pig-Latin',
+        expected: [
+            ['en-x-Pig-Latin', allNonCanonicalTestKeys],
+            ['en-x-pig-latin', allCanonicalTestKeys]
+        ],
+        expectedDescription: [
+            ['English (-x "Pig-Latin")', ['wellFormed']],
+            ['English (-x "pig-latin")', ['preferred']]
+        ]
+    },
+    {
+        description: 'valid extension and private use subtag',
+        from: 'en-US-u-us-x-test',
+        expected: [['en-US-u-us-x-test', allTestKeys]],
+        expectedDescription: [
+            ['English as spoken in United States (Unicode Locale "us") (-x "test")', ['wellFormed']]
+        ]
+    },
+    {
+        description: 'valid grandfathered tag with no preferredValue',
+        from: 'i-Mingo',
+        expected: [
+            ['i-Mingo', allNonCanonicalTestKeys],
+            ['i-mingo', allCanonicalTestKeys]
+        ],
+        expectedDescription: [
+            ['i-Mingo (grandfathered)', ['wellFormed']],
+            ['i-mingo (grandfathered)', ['preferred']]
+        ]
+    },
+    {
+        description: 'valid grandfathered tag with preferredValue',
+        from: 'art-lojban',
+        expected: [
+            ['art-lojban', [...allNonCanonicalTestKeys, ...allNonPreferredCanonicalKeys]],
+            ['jbo', allPreferredKeys]
+        ],
+        expectedDescription: [
+            ['art-lojban (grandfathered)', ['wellFormed']],
+            ['Lojban', ['preferred']]
+        ]
+    },
+    {
+        description: 'valid grandfathered tag with complex preferred value',
+        from: 'en-gb-oed',
+        expected: [
+            ['en-gb-oed', allNonCanonicalTestKeys],
+            ['en-GB-oed', allNonPreferredCanonicalKeys],
+            ['en-GB-oxendict', allPreferredKeys]
+        ],
+        expectedDescription: [
+            ['en-gb-oed (grandfathered)', ['wellFormed']],
+            ['English as spoken in United Kingdom (Oxford English Dictionary spelling)', ['preferred']]
+        ]
+    },
+    {
+        description: 'valid redundant tag with no preferredValue',
+        from: 'mn-Mong',
+        expected: [['mn-Mong', allTestKeys]],
+        expectedDescription: [['Mongolian in Mongolian script', allTestKeys]]
+    },
+    {
+        description: 'valid redundant tag with preferred value',
+        from: 'sgn-BR',
+        expected: [
+            ['sgn-BR', [...allNonCanonicalTestKeys, ...allNonPreferredCanonicalKeys]],
+            ['bzs', allPreferredKeys]
+        ],
+        expectedDescription: [
+            ['Sign languages as spoken in Brazil', ['wellFormed']],
+            ['Brazilian Sign Language', ['preferred']]
+        ]
+    },
+    {
+        description: 'invalid private tag',
+        from: 'x-thing-x-other-thing-x-last-thing',
+        expected: [[/malformed private-use/i, allTestKeys]]
+    },
+    {
+        description: 'completely private tag with multiple tags',
+        from: 'x-some-bunch-of-things',
+        expected: [
+            ['x-some-bunch-of-things', allNonCanonicalTestKeys],
+            ['x-some-bunch-OF-things', allCanonicalTestKeys]
+        ],
+        expectedDescription: [
+            ['(-x "some-bunch-of-things")', ['wellFormed']],
+            ['(-x "some-bunch-OF-things")', ['preferred']]
+        ]
+    }
+];
+const subtagsTestCaseInit = [
+    {
+        description: 'valid non-canonical tag with suppressed script',
+        from: {
+            primaryLanguage: 'en',
+            script: 'latn',
+            region: 'us',
+            privateUse: ['Non', 'Canon']
+        },
+        expected: [
+            ['en-latn-us-x-Non-Canon', ['default', 'wellFormed', 'valid', 'strictlyValid']],
+            ['en-Latn-US-x-non-canon', ['wellFormedCanonical', 'validCanonical', 'strictlyValidCanonical']],
+            ['en-US-x-non-canon', ['preferred', 'strictlyValidPreferred']]
+        ]
+    },
+    {
+        description: 'missing primary language',
+        from: {
+            extlangs: ['cmn', 'yue']
+        },
+        expected: [[/missing primary language/i, allTestKeys]]
+    },
+    {
+        // the grammar allows for up to three extlang tags but the specification reserves
+        // and forbids them, so two tags only fails for validating forms.
+        description: 'multiple extlang tags',
+        from: {
+            primaryLanguage: 'zh',
+            extlangs: ['cmn', 'yue']
+        },
+        expected: [
+            ['zh-cmn-yue', ['default', 'wellFormed', 'wellFormedCanonical']],
+            [/multiple extlang/, allValidatingKeys]
+        ]
+    },
+    {
+        // the grammar forbids > 3 extlang tags so this fails for all forms
+        description: 'too many extlang tags',
+        from: {
+            primaryLanguage: 'zh',
+            extlangs: ['cmn', 'yue', 'cdo', 'cjy']
+        },
+        expected: [[/too many extlang/, allTestKeys]]
+    },
+    {
+        description: 'invalid script tag',
+        from: {
+            primaryLanguage: 'en',
+            script: 'Xyzy'
+        },
+        expected: [
+            ['en-Xyzy', ['default', 'preferred', 'wellFormed', 'wellFormedCanonical']],
+            [/invalid script/i, allValidatingKeys]
+        ]
+    },
+    {
+        description: 'duplicate variant tags',
+        from: {
+            primaryLanguage: 'ca',
+            variants: ['valencia', 'Valencia']
+        },
+        expected: [
+            ['ca-valencia-Valencia', ['default', 'wellFormed']],
+            ['ca-valencia-valencia', ['wellFormedCanonical']],
+            [/duplicate variant/, allValidatingKeys]
+        ]
+    },
+    {
+        description: 'invalid grandfathered tag',
+        from: { grandfathered: 'i-dothraki' },
+        expected: [
+            ['i-dothraki', ['default', 'wellFormed', 'wellFormedCanonical']],
+            [/invalid grandfathered/i, [...allValidatingKeys]]
+        ]
+    }
+];
+// eslint-disable-next-line @rushstack/typedef-var
+export const tagTestCases = testCaseInit.map(GenericLanguageTagTest.mapInitToTestCases);
+// eslint-disable-next-line @rushstack/typedef-var
+export const subtagsTestCases = subtagsTestCaseInit.map(GenericLanguageTagTest.mapInitToTestCases);
+//# sourceMappingURL=commonTestCases.js.map

package/dist/test/unit/bcp47/languageTagHelpers.js

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import '@fgv/ts-utils-jest';
+export const allTestKeys = [
+    'default',
+    'wellFormed',
+    'wellFormedCanonical',
+    'valid',
+    'validCanonical',
+    'preferred',
+    'strictlyValid',
+    'strictlyValidCanonical',
+    'strictlyValidPreferred'
+];
+export const allNonCanonicalTestKeys = ['default', 'wellFormed', 'valid', 'strictlyValid'];
+export const allCanonicalTestKeys = [
+    'wellFormedCanonical',
+    'validCanonical',
+    'preferred',
+    'strictlyValidCanonical',
+    'strictlyValidPreferred'
+];
+export const allNonPreferredCanonicalKeys = [
+    'wellFormedCanonical',
+    'validCanonical',
+    'strictlyValidCanonical'
+];
+export const allPreferredKeys = ['preferred', 'strictlyValidPreferred'];
+export const allValidatingKeys = [
+    'valid',
+    'validCanonical',
+    'strictlyValid',
+    'strictlyValidCanonical',
+    'strictlyValidPreferred',
+    'preferred'
+];
+export class GenericLanguageTagTest {
+    constructor(init) {
+        this.description = init.description;
+        this.from = init.from;
+        this.expected = {};
+        for (const value of init.expected) {
+            for (const key of value[1]) {
+                this.expected[key] = value[0];
+            }
+        }
+        if (init.expectedDescription) {
+            this.expectedDescription = {};
+            for (const value of init.expectedDescription) {
+                for (const key of value[1]) {
+                    this.expectedDescription[key] = value[0];
+                }
+            }
+        }
+        else {
+            this.expectedDescription = undefined;
+        }
+    }
+    static mapInitToTestCases(init) {
+        return new GenericLanguageTagTest(init);
+    }
+}
+const optionsByKey = {
+    default: undefined,
+    wellFormed: { validity: 'well-formed', normalization: 'none' },
+    wellFormedCanonical: { validity: 'well-formed', normalization: 'canonical' },
+    valid: { validity: 'valid', normalization: 'none' },
+    validCanonical: { validity: 'valid', normalization: 'canonical' },
+    preferred: { validity: 'valid', normalization: 'preferred' },
+    strictlyValid: { validity: 'strictly-valid', normalization: 'none' },
+    strictlyValidCanonical: { validity: 'strictly-valid', normalization: 'canonical' },
+    strictlyValidPreferred: { validity: 'strictly-valid', normalization: 'preferred' }
+};
+export class TagTestCaseFactoryBase {
+    emitOne(gtc, which) {
+        const tc = this._construct(gtc, which);
+        return tc.expected ? [tc.description, tc] : undefined;
+    }
+    emit(which, all) {
+        if (Array.isArray(which)) {
+            return all.flatMap((gtc) => {
+                return which
+                    .map((w) => this.emitOne(gtc, w))
+                    .filter((tc) => tc !== undefined);
+            });
+        }
+        return (all
+            .map((gtc) => this.emitOne(gtc, which))
+            /* c8 ignore next 1 - defensive filter for test helper, array path covers same logic */
+            .filter((tc) => tc !== undefined));
+    }
+}
+export class GenericTagTestCaseFactory extends TagTestCaseFactoryBase {
+    constructor(construct) {
+        super();
+        this._construct = construct;
+    }
+}
+export class SimpleTagTestCaseBase {
+    constructor(gtc, which) {
+        var _a;
+        this.from = gtc.from;
+        this.options = optionsByKey[which];
+        const expected = gtc.expected[which];
+        this.expected = this._getExpectedValue(which, gtc, expected);
+        this.expectedDescription = (_a = gtc.expectedDescription) === null || _a === void 0 ? void 0 : _a[which];
+        const target = this._getTestTarget(which, gtc);
+        if (this.isSuccessTest) {
+            this.description = this._getSuccessTestDescription(target, gtc.from, gtc.description);
+        }
+        else if (this.isFailureTest) {
+            this.description = this._getFailureTestDescription(target, gtc.from, gtc.description);
+        }
+        else {
+            this.description = this._getIgnoredTestDescription(target, gtc.from, gtc.description);
+        }
+    }
+    get isSuccessTest() {
+        return !this.isFailureTest && !this.isIgnoredTest;
+    }
+    get isFailureTest() {
+        return this.expected instanceof RegExp;
+    }
+    get isIgnoredTest() {
+        return this.expected === undefined;
+    }
+    _getExpectedValue(__which, __gtc, expected) {
+        return expected;
+    }
+    _getTestTarget(which, __gtc) {
+        return which;
+    }
+    _getSuccessTestDescription(testTarget, from, description) {
+        if (typeof from !== 'string') {
+            const fromDesc = JSON.stringify(from, undefined, 2);
+            return `${testTarget} succeeds for "${description}" with "${this.expected}" (${fromDesc})`;
+        }
+        return `${testTarget} succeeds for "${from}" with "${this.expected}" (${description})`;
+    }
+    _getFailureTestDescription(testTarget, from, description) {
+        if (typeof from === 'string') {
+            return `${testTarget} fails for "${from}" with "${this.expected}" (${description})`;
+        }
+        else {
+            const fromDesc = JSON.stringify(from, undefined, 2);
+            return `${testTarget} fails for "${description}" with "${this.expected}" (${fromDesc})`;
+        }
+    }
+    _getIgnoredTestDescription(testTarget, from, description) {
+        if (typeof from === 'string') {
+            return `${testTarget} "${from}" ignored due to expected value {${description}})`;
+        }
+        else {
+            const fromDesc = JSON.stringify(from, undefined, 2);
+            return `${testTarget} "${description}" ignored due to expected value {${fromDesc})`;
+        }
+    }
+}
+//# sourceMappingURL=languageTagHelpers.js.map