@malloydata/malloy 0.0.80-dev230830211713 → 0.0.80-dev230903192621

package/dist/lang/test/expressions.spec.js

@@ -0,0 +1,415 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_1 = require("../../model");
+const test_translator_1 = require("./test-translator");
+require("./parse-expects");
+describe('expressions', () => {
+    describe('timeframes', () => {
+        const timeframes = [
+            'second',
+            'minute',
+            'hour',
+            'day',
+            'week',
+            'month',
+            'quarter',
+            'year',
+        ];
+        test.each(timeframes.map(x => [x]))('truncate %s', unit => {
+            expect(new test_translator_1.BetaExpression(`ats.${unit}`)).toParse();
+        });
+        // mtoy todo units missing: implement, or document
+        const diffable = ['second', 'minute', 'hour', 'day'];
+        test.each(diffable.map(x => [x]))('timestamp difference - %s', unit => {
+            expect(new test_translator_1.BetaExpression(`${unit}(@2021 to ats)`)).toParse();
+        });
+        test.each(diffable.map(x => [x]))('timestamp difference - %s', unit => {
+            expect(new test_translator_1.BetaExpression(`${unit}(ats to @2030)`)).toParse();
+        });
+    });
+    test('field name', () => {
+        expect((0, test_translator_1.expr) `astr`).toTranslate();
+    });
+    test('function call', () => {
+        expect((0, test_translator_1.expr) `concat('foo')`).toTranslate();
+    });
+    describe('operators', () => {
+        test('addition', () => {
+            expect((0, test_translator_1.expr) `42 + 7`).toTranslate();
+        });
+        test('subtraction', () => {
+            expect((0, test_translator_1.expr) `42 - 7`).toTranslate();
+        });
+        test('multiplication', () => {
+            expect((0, test_translator_1.expr) `42 * 7`).toTranslate();
+        });
+        test('mod', () => {
+            expect((0, test_translator_1.expr) `42 % 7`).toTranslate();
+        });
+        test('division', () => {
+            expect((0, test_translator_1.expr) `42 / 7`).toTranslate();
+        });
+        test('unary negation', () => {
+            expect((0, test_translator_1.expr) `- ai`).toTranslate();
+        });
+        test('equal', () => {
+            expect((0, test_translator_1.expr) `42 = 7`).toTranslate();
+        });
+        test('not equal', () => {
+            expect((0, test_translator_1.expr) `42 != 7`).toTranslate();
+        });
+        test('greater than', () => {
+            expect((0, test_translator_1.expr) `42 > 7`).toTranslate();
+        });
+        test('greater than or equal', () => {
+            expect((0, test_translator_1.expr) `42 >= 7`).toTranslate();
+        });
+        test('less than or equal', () => {
+            expect((0, test_translator_1.expr) `42 <= 7`).toTranslate();
+        });
+        test('less than', () => {
+            expect((0, test_translator_1.expr) `42 < 7`).toTranslate();
+        });
+        test('match', () => {
+            expect((0, test_translator_1.expr) `'forty-two' ~ 'fifty-four'`).toTranslate();
+        });
+        test('not match', () => {
+            expect((0, test_translator_1.expr) `'forty-two' !~ 'fifty-four'`).toTranslate();
+        });
+        test('apply', () => {
+            expect((0, test_translator_1.expr) `'forty-two' ? 'fifty-four'`).toTranslate();
+        });
+        test('not', () => {
+            expect((0, test_translator_1.expr) `not true`).toTranslate();
+        });
+        test('and', () => {
+            expect((0, test_translator_1.expr) `true and false`).toTranslate();
+        });
+        test('or', () => {
+            expect((0, test_translator_1.expr) `true or false`).toTranslate();
+        });
+        test('null-check (??)', () => {
+            expect((0, test_translator_1.expr) `ai ?? 7`).toTranslate();
+        });
+        test('coalesce type mismatch', () => {
+            expect(new test_translator_1.BetaExpression('ai ?? @2003')).translationToFailWith('Mismatched types for coalesce (number, date)');
+        });
+        test('disallow date OP number', () => {
+            expect(new test_translator_1.BetaExpression('@2001 = 7')).translationToFailWith('Cannot compare a date to a number');
+        });
+        test('disallow date OP timestamp', () => {
+            expect(new test_translator_1.BetaExpression('ad = ats')).translationToFailWith('Cannot compare a date to a timestamp');
+        });
+        test('disallow interval from date to timestamp', () => {
+            expect(new test_translator_1.BetaExpression('days(ad to ats)')).translationToFailWith('Cannot measure from date to timestamp');
+        });
+        test('comparison promotes date literal to timestamp', () => {
+            expect((0, test_translator_1.expr) `@2001 = ats`).toTranslate();
+        });
+        test('can apply range to date', () => {
+            expect((0, test_translator_1.expr) `ad ? @2001 for 1 day`).toTranslate();
+        });
+        const noOffset = ['second', 'minute', 'hour'];
+        test.each(noOffset.map(x => [x]))('disallow date delta %s', unit => {
+            expect(new test_translator_1.BetaExpression(`ad + 10 ${unit}s`)).translationToFailWith(`Cannot offset date by ${unit}`);
+        });
+        test('apply with parens', () => {
+            expect((0, test_translator_1.expr) `ai ? (> 1 & < 100)`).toTranslate();
+        });
+    });
+    test('filtered measure', () => {
+        expect((0, test_translator_1.expr) `acount {? astr = 'why?' }`).toTranslate();
+    });
+    test('filtered ungrouped aggregate', () => {
+        expect(`
+        query: a -> {
+          group_by: ai
+          aggregate: x is all(avg(ai)) { where: true }
+        }
+      `).toTranslate();
+    });
+    test('shortcut filtered measure m4warning', () => {
+        expect(`
+      ##! m4warnings
+      run: a -> {
+        group_by: ai
+        aggregate: x is avg(ai) {? astr = 'why?' }
+      }
+    `).toTranslateWithWarnings('Filter shortcut `{? condition }` is deprecated; use `{ where: condition } instead');
+    });
+    test('correctly flags filtered scalar', () => {
+        const e = new test_translator_1.BetaExpression('ai { where: true }');
+        expect(e).translationToFailWith('Filtered expression requires an aggregate computation');
+    });
+    test('correctly flags filtered analytic', () => {
+        expect((0, test_translator_1.markSource) `
+        query: a -> {
+          group_by: ai
+          calculate: l is lag(ai) { where: true }
+        }
+      `).translationToFailWith('Filtered expression requires an aggregate computation');
+    });
+    describe('aggregate forms', () => {
+        test('count', () => {
+            expect((0, test_translator_1.expr) `count()`).toTranslate();
+        });
+        test('count distinct', () => {
+            expect((0, test_translator_1.expr) `count(distinct astr)`).toTranslate();
+        });
+        test('join.count()', () => {
+            expect((0, test_translator_1.expr) `b.count()`).toTranslate();
+        });
+        for (const f of ['sum', 'min', 'max', 'avg']) {
+            const fOfT = `${f}(af)`;
+            test(fOfT, () => {
+                expect(new test_translator_1.BetaExpression(fOfT)).toTranslate();
+            });
+            if (f !== 'min' && f !== 'max') {
+                const joinDot = `b.af.${f}()`;
+                test(joinDot, () => {
+                    expect(new test_translator_1.BetaExpression(joinDot)).toTranslate();
+                });
+                const joinAgg = `b.${f}(af)`;
+                test(joinAgg, () => {
+                    expect(new test_translator_1.BetaExpression(joinAgg)).toTranslate();
+                });
+            }
+        }
+    });
+    describe('pick statements', () => {
+        test('full', () => {
+            expect((0, test_translator_1.expr) `
+        pick 'the answer' when ai = 42
+        pick 'the questionable answer' when ai = 54
+        else 'random'
+    `).toTranslate();
+        });
+        test('applied', () => {
+            expect((0, test_translator_1.expr) `
+        astr ?
+          pick 'the answer' when = '42'
+          pick 'the questionable answer' when = '54'
+          else 'random'
+    `).toTranslate();
+        });
+        test('filtering', () => {
+            expect((0, test_translator_1.expr) `astr ? pick 'missing value' when NULL`).toTranslate();
+        });
+        test('null branch with else', () => {
+            expect("astr ? pick null when = '42' else 3").toReturnType('number');
+        });
+        test('null branch no else', () => {
+            expect("astr ? pick null when = '42'").toReturnType('string');
+        });
+        test('null branch no apply', () => {
+            expect('pick null when 1 = 1 else 3').toReturnType('number');
+        });
+        test('tiering', () => {
+            expect((0, test_translator_1.expr) `
+      ai ?
+        pick 1 when < 10
+        pick 10 when < 100
+        pick 100 when < 1000
+        else 10000
+  `).toTranslate();
+        });
+        test('transforming', () => {
+            expect((0, test_translator_1.expr) `
+        ai ?
+          pick 'small' when < 10
+          pick 'medium' when < 100
+          else 'large'
+    `).toTranslate();
+        });
+        test('when single values', () => {
+            expect((0, test_translator_1.expr) `
+        ai ?
+          pick 'one' when 1
+          else 'a lot'
+      `).toTranslate();
+        });
+        test('n-ary without else', () => {
+            expect(`
+        source: na is a + { dimension: d is
+          pick 7 when true and true
+        }
+      `).translationToFailWith("pick incomplete, missing 'else'");
+        });
+        test('n-ary with mismatch when clauses', () => {
+            expect((0, test_translator_1.markSource) `
+        source: na is a + { dimension: d is
+          pick 7 when true and true
+          pick '7' when true or true
+          else 7
+        }
+      `).translationToFailWith("pick type 'string', expected 'number'");
+        });
+        test('n-ary with mismatched else clause', () => {
+            expect((0, test_translator_1.markSource) `
+        source: na is a + { dimension: d is
+          pick 7 when true and true
+          else '7'
+        }
+      `).translationToFailWith("else type 'string', expected 'number'");
+        });
+        test('applied else mismatch', () => {
+            expect((0, test_translator_1.markSource) `
+        source: na is a + { dimension: d is
+          7 ? pick 7 when 7 else 'not seven'
+        }
+      `).translationToFailWith("else type 'string', expected 'number'");
+        });
+        test('applied default mismatch', () => {
+            expect((0, test_translator_1.markSource) `
+        source: na is a + { dimension: d is
+          7 ? pick 'seven' when 7
+        }
+      `).translationToFailWith("pick default type 'number', expected 'string'");
+        });
+        test('applied when mismatch', () => {
+            expect((0, test_translator_1.markSource) `
+        source: na is a + { dimension: d is
+          7 ? pick 'seven' when 7 pick 6 when 6
+        }
+      `).translationToFailWith("pick type 'number', expected 'string'");
+        });
+    });
+    test('paren and applied div', () => {
+        var _a, _b;
+        const modelSrc = 'query: z is a -> { group_by: x is 1+(3/4) }';
+        const m = new test_translator_1.TestTranslator(modelSrc);
+        expect(m).toTranslate();
+        const queryDef = (_b = (_a = m.translate()) === null || _a === void 0 ? void 0 : _a.translated) === null || _b === void 0 ? void 0 : _b.modelDef.contents['z'];
+        expect(queryDef).toBeDefined();
+        expect(queryDef === null || queryDef === void 0 ? void 0 : queryDef.type).toBe('query');
+        if (queryDef && queryDef.type === 'query') {
+            const x = queryDef.pipeline[0].fields[0];
+            if (typeof x !== 'string' &&
+                !(0, model_1.isFilteredAliasedName)(x) &&
+                (0, model_1.isFieldTypeDef)(x) &&
+                x.type === 'number' &&
+                x.e) {
+                expect(x).toMatchObject({
+                    'e': [
+                        {
+                            'function': 'numberLiteral',
+                            'literal': '1',
+                            'type': 'dialect',
+                        },
+                        // TODO not sure why there are TWO sets of parentheses... A previous version of this test
+                        // just checked that there were ANY parens, so that went under the radar. Not fixing now.
+                        '+((',
+                        {
+                            'denominator': [
+                                {
+                                    'function': 'numberLiteral',
+                                    'literal': '4',
+                                    'type': 'dialect',
+                                },
+                            ],
+                            'function': 'div',
+                            'numerator': [
+                                {
+                                    'function': 'numberLiteral',
+                                    'literal': '3',
+                                    'type': 'dialect',
+                                },
+                            ],
+                            'type': 'dialect',
+                        },
+                        '))',
+                    ],
+                });
+            }
+            else {
+                fail('expression with parens compiled oddly');
+            }
+        }
+    });
+    test.each([
+        ['ats', 'timestamp'],
+        ['ad', 'date'],
+        ['ai', 'number'],
+        ['astr', 'string'],
+        ['abool', 'boolean'],
+    ])('Can compare field %s (type %s) to NULL', (name, _datatype) => {
+        expect((0, test_translator_1.expr) `${name} = NULL`).toTranslate();
+    });
+});
+describe('unspported fields in schema', () => {
+    test('unsupported reference in result allowed', () => {
+        const uModel = new test_translator_1.TestTranslator('query: a->{ group_by: aun }');
+        expect(uModel).toTranslate();
+    });
+    test('unsupported reference can be compared to NULL', () => {
+        const uModel = new test_translator_1.TestTranslator('query: a->{ where: aun != NULL; project: * }');
+        expect(uModel).toTranslate();
+    });
+    test('flag unsupported equality', () => {
+        // because we don't know if the two unsupported types are comparable
+        const uModel = new test_translator_1.TestTranslator('query: ab->{ where: aun = b.aun  project: * }');
+        expect(uModel).translationToFailWith('Unsupported type not allowed in expression');
+    });
+    test('flag unsupported compare', () => {
+        // because we don't know if the two unsupported types are comparable
+        const uModel = new test_translator_1.TestTranslator('query: ab->{ where: aun > b.aun  project: * }');
+        expect(uModel).translationToFailWith('Unsupported type not allowed in expression');
+    });
+    test('allow unsupported equality when raw types match', () => {
+        const uModel = new test_translator_1.TestTranslator('query: ab->{ where: aweird = b.aweird  project: * }');
+        expect(uModel).toTranslate();
+    });
+    test('flag not applied to unsupported', () => {
+        const uModel = new test_translator_1.TestTranslator('source: x is a { dimension: notUn is not aun }');
+        expect(uModel).translationToFailWith("'not' Can't use type unsupported");
+    });
+    test('allow unsupported to be cast', () => {
+        const uModel = new test_translator_1.TestTranslator('source: x is a { dimension: notUn is aun::string }');
+        expect(uModel).toTranslate();
+    });
+    describe('cast', () => {
+        // The "+ 1"s are there to make sure the result is of type 'number'
+        test('sql cast', () => {
+            expect((0, test_translator_1.expr) `ai::'integer' + 1`).toTranslate();
+            expect((0, test_translator_1.expr) `ai::"integer" + 1`).toTranslate();
+            expect((0, test_translator_1.expr) `ai::"""integer""" + 1`).toTranslate();
+        });
+        test('sql safe cast', () => {
+            expect((0, test_translator_1.expr) `astr:::'integer' + 1`).toTranslate();
+            expect((0, test_translator_1.expr) `astr:::"integer" + 1`).toTranslate();
+            expect((0, test_translator_1.expr) `astr:::"""integer""" + 1`).toTranslate();
+        });
+        test('malloy cast', () => {
+            expect((0, test_translator_1.expr) `astr::number + 1`).toTranslate();
+        });
+        test('malloy safe cast', () => {
+            expect((0, test_translator_1.expr) `astr:::number + 1`).toTranslate();
+        });
+        test('sql cast illegal type name', () => {
+            expect((0, test_translator_1.expr) `astr::"stuff 'n' things"`).translationToFailWith("Cast type `stuff 'n' things` is invalid for standardsql dialect");
+        });
+    });
+});
+//# sourceMappingURL=expressions.spec.js.map

package/dist/lang/test/literals.spec.js

@@ -0,0 +1,274 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_translator_1 = require("./test-translator");
+const parse_utils_1 = require("../parse-utils");
+require("./parse-expects");
+const granular_result_1 = require("../ast/types/granular-result");
+describe('literals', () => {
+    test('integer', () => {
+        expect((0, test_translator_1.expr) `42`).toTranslate();
+    });
+    test('string', () => {
+        const m = new test_translator_1.BetaExpression("'forty two'");
+        expect(m).toTranslate();
+        const m42 = m.generated().value[0];
+        expect(m42).toMatchObject({ literal: 'forty two' });
+    });
+    test('string with quoted quote', () => {
+        const str = "'Isn" + '\\' + "'t this nice'";
+        expect(new test_translator_1.BetaExpression(str)).toTranslate();
+    });
+    test('string with quoted backslash', () => {
+        const str = "'Is " + '\\' + '\\' + " nice'";
+        expect(new test_translator_1.BetaExpression(str)).toTranslate();
+    });
+    const literalTimes = [
+        ['@1960', 'date', 'year', { literal: '1960-01-01' }],
+        ['@1960-Q2', 'date', 'quarter', { literal: '1960-04-01' }],
+        ['@1960-06', 'date', 'month', { literal: '1960-06-01' }],
+        ['@1960-06-26-WK', 'date', 'week', { literal: '1960-06-26' }],
+        ['@1960-06-30', 'date', 'day', { literal: '1960-06-30' }],
+        ['@1960-06-30 10', 'timestamp', 'hour', { literal: '1960-06-30 10:00:00' }],
+        [
+            '@1960-06-30 10:30',
+            'timestamp',
+            'minute',
+            { literal: '1960-06-30 10:30:00' },
+        ],
+        [
+            '@1960-06-30 10:30:00',
+            'timestamp',
+            undefined,
+            { literal: '1960-06-30 10:30:00' },
+        ],
+        [
+            '@1960-06-30 10:30:00.123',
+            'timestamp',
+            undefined,
+            { literal: '1960-06-30 10:30:00.123' },
+        ],
+        [
+            '@1960-06-30T10:30:00',
+            'timestamp',
+            undefined,
+            { literal: '1960-06-30 10:30:00' },
+        ],
+        [
+            '@1960-06-30 10:30:00[America/Los_Angeles]',
+            'timestamp',
+            undefined,
+            {
+                literal: '1960-06-30 10:30:00',
+                timezone: 'America/Los_Angeles',
+            },
+        ],
+    ];
+    test.each(literalTimes)('%s', (expr, timeType, timeframe, result) => {
+        const exprModel = new test_translator_1.BetaExpression(expr);
+        expect(exprModel).toTranslate();
+        const ir = exprModel.generated();
+        expect(ir.dataType).toEqual(timeType);
+        if (timeframe) {
+            expect((0, granular_result_1.isGranularResult)(ir)).toBeTruthy();
+            if ((0, granular_result_1.isGranularResult)(ir)) {
+                expect(ir.timeframe).toEqual(timeframe);
+            }
+        }
+        else {
+            expect((0, granular_result_1.isGranularResult)(ir)).toBeFalsy();
+        }
+        expect(ir.value[0]).toEqual(expect.objectContaining(result));
+    });
+    const morphicLiterals = [
+        ['@1960', '1960-01-01 00:00:00'],
+        ['@1960-Q2', '1960-04-01 00:00:00'],
+        ['@1960-06', '1960-06-01 00:00:00'],
+        ['@1960-06-26-Wk', '1960-06-26 00:00:00'],
+        ['@1960-06-30', '1960-06-30 00:00:00'],
+        ['@1960-06-30 00:00', undefined],
+    ];
+    test.each(morphicLiterals)('morphic value for %s is %s', (expr, morphic) => {
+        const exprModel = new test_translator_1.BetaExpression(expr);
+        expect(exprModel).toTranslate();
+        const ir = exprModel.generated();
+        const morphTo = ir.morphic && ir.morphic['timestamp'];
+        if (morphic) {
+            expect(morphTo).toBeDefined();
+            if (morphTo) {
+                expect(morphTo[0]).toEqual(expect.objectContaining({ literal: morphic }));
+            }
+        }
+        else {
+            expect(morphTo).toBeUndefined();
+        }
+    });
+    test('minute+locale', () => {
+        expect((0, test_translator_1.expr) `@1960-06-30 10:30[America/Los_Angeles]`).toTranslate();
+    });
+    test('second 8601', () => {
+        expect((0, test_translator_1.expr) `@1960-06-30T10:30:31`).toTranslate();
+    });
+    test('null', () => {
+        expect((0, test_translator_1.expr) `null`).toTranslate();
+    });
+    test('now', () => {
+        expect((0, test_translator_1.expr) `now`).toTranslate();
+    });
+    test('true', () => {
+        expect((0, test_translator_1.expr) `true`).toTranslate();
+    });
+    test('false', () => {
+        expect((0, test_translator_1.expr) `false`).toTranslate();
+    });
+    test('regex', () => {
+        expect((0, test_translator_1.expr) `r'RegularExpression'`).toTranslate();
+    });
+    describe('quote comprehension inside strings', () => {
+        test('\\b', () => {
+            expect((0, parse_utils_1.parseString)('\\b')).toEqual('\b');
+        });
+        test('\\f', () => {
+            expect((0, parse_utils_1.parseString)('\\f')).toEqual('\f');
+        });
+        test('\\n', () => {
+            expect((0, parse_utils_1.parseString)('\\n')).toEqual('\n');
+        });
+        test('\\r', () => {
+            expect((0, parse_utils_1.parseString)('\\r')).toEqual('\r');
+        });
+        test('\\t', () => {
+            expect((0, parse_utils_1.parseString)('\\t')).toEqual('\t');
+        });
+        test('unicode ?', () => {
+            expect((0, parse_utils_1.parseString)('\\u003f')).toEqual('?');
+            expect((0, parse_utils_1.parseString)('\\u003F')).toEqual('?');
+        });
+        test('normal stuff', () => {
+            expect((0, parse_utils_1.parseString)('normal stuff')).toEqual('normal stuff');
+        });
+        test('stuff & nonsense', () => {
+            expect((0, parse_utils_1.parseString)('stuff \\u0026 nonsense')).toEqual('stuff & nonsense');
+        });
+        test('one thing\\nnext thing', () => {
+            expect((0, parse_utils_1.parseString)('one thing\\nnext thing')).toEqual('one thing\nnext thing');
+        });
+        test('quote stripping works', () => {
+            expect((0, parse_utils_1.parseString)('|42|', '|')).toEqual('42');
+        });
+    });
+    describe('string parsing in language', () => {
+        const tz = 'America/Mexico_City';
+        test('multi-line indent increasing', () => {
+            const checking = new test_translator_1.BetaExpression(`"""
+          left
+            mid
+              right
+        """`);
+            expect(checking).toTranslate();
+            const v = checking.generated().value[0];
+            expect(v).toMatchObject({ literal: '\nleft\n  mid\n    right\n' });
+        });
+        test('multi-line indent decreasing', () => {
+            const checking = new test_translator_1.BetaExpression(`"""
+              right
+            mid
+          left
+        """`);
+            expect(checking).toTranslate();
+            const v = checking.generated().value[0];
+            expect(v).toMatchObject({ literal: '\n    right\n  mid\nleft\n' });
+        });
+        test('multi-line indent keep', () => {
+            const checking = new test_translator_1.BetaExpression('"""right\n  mid\nleft"""');
+            expect(checking).toTranslate();
+            const v = checking.generated().value[0];
+            expect(v).toMatchObject({ literal: 'right\n  mid\nleft' });
+        });
+        test('timezone single quote', () => {
+            const m = new test_translator_1.TestTranslator(`run: a-> {timezone: '${tz}'; project: *}`);
+            expect(m).toParse();
+        });
+        test('timezone double quote', () => {
+            const m = new test_translator_1.TestTranslator(`run: a-> {timezone: "${tz}"; project: *}`);
+            expect(m).toParse();
+        });
+        test('timezone triple quote', () => {
+            const m = new test_translator_1.TestTranslator(`run: a->{timezone: """${tz}"""; project: *}`);
+            expect(m).toParse();
+        });
+        test('timezone with illegal query', () => {
+            expect(`run: a->{timezone: """${tz}%{ab->aturtle}"""; project: *}`).translationToFailWith('%{ query } illegal in this string');
+        });
+        test('table single quote', () => {
+            const m = new test_translator_1.TestTranslator("source: n is bigquery.table('n')");
+            expect(m).toParse();
+        });
+        test('table double quote', () => {
+            const m = new test_translator_1.TestTranslator('source: n is bigquery.table("n")');
+            expect(m).toParse();
+        });
+        test('table triple quote', () => {
+            const m = new test_translator_1.TestTranslator('source: n is bigquery.table("""n""")');
+            expect(m).toParse();
+        });
+        test('sql single quote', () => {
+            const m = new test_translator_1.TestTranslator("source: n is bigquery.sql('n')");
+            expect(m).toParse();
+        });
+        test('sql double quote', () => {
+            const m = new test_translator_1.TestTranslator('source: n is bigquery.sql("n")');
+            expect(m).toParse();
+        });
+        test('sql triple quote', () => {
+            const m = new test_translator_1.TestTranslator('source: n is bigquery.sql("""n""")');
+            expect(m).toParse();
+        });
+        test('import single quote', () => {
+            const m = new test_translator_1.TestTranslator("import 'a'");
+            expect(m).toParse();
+        });
+        test('import double quote', () => {
+            const m = new test_translator_1.TestTranslator('import "a"');
+            expect(m).toParse();
+        });
+        test('import triple quote', () => {
+            const m = new test_translator_1.TestTranslator('import """a"""');
+            expect(m).toParse();
+        });
+        test('literal single quote', () => {
+            const x = new test_translator_1.BetaExpression("'x'");
+            expect(x).toParse();
+        });
+        test('literal double quote', () => {
+            const x = new test_translator_1.BetaExpression('"x"');
+            expect(x).toParse();
+        });
+        test('literal triple quote', () => {
+            const x = new test_translator_1.BetaExpression('"""x"""');
+            expect(x).toParse();
+        });
+    });
+});
+//# sourceMappingURL=literals.spec.js.map