@acalcutt/maplibre-gl-native-test 5.0.1-pre.16 → 5.0.2-pre.1

package/maplibre-gl-js/test/integration/lib/expression.js

@@ -1,194 +0,0 @@
-import path from 'path';
-import * as diff from 'diff';
-import fs from 'fs';
-import harness from './harness';
-import compactStringify from 'json-stringify-pretty-compact';
-
-// we have to handle this edge case here because we have test fixtures for this
-// edge case, and we don't want UPDATE=1 to mess with them
-function stringify(v) {
-    let s = compactStringify(v);
-    // http://timelessrepo.com/json-isnt-a-javascript-subset
-    if (s.indexOf('\u2028') >= 0) {
-        s = s.replace(/\u2028/g, '\\u2028');
-    }
-    if (s.indexOf('\u2029') >= 0) {
-        s = s.replace(/\u2029/g, '\\u2029');
-    }
-    return s;
-}
-
-const decimalSigFigs = 6;
-
-function stripPrecision(x) {
-    // Intended for test output serialization:
-    // strips down to 6 decimal sigfigs but stops at decimal point
-    if (typeof x === 'number') {
-        if (x === 0) { return x; }
-
-        const multiplier = Math.pow(10,
-            Math.max(0,
-                     decimalSigFigs - Math.ceil(Math.log10(Math.abs(x)))));
-
-        // We strip precision twice in a row here to avoid cases where
-        // stripping an already stripped number will modify its value
-        // due to bad floating point precision luck
-        // eg `Math.floor(8.16598 * 100000) / 100000` -> 8.16597
-        const firstStrip = Math.floor(x * multiplier) / multiplier;
-        return Math.floor(firstStrip * multiplier) / multiplier;
-    } else if (typeof x !== 'object') {
-        return x;
-    } else if (Array.isArray(x)) {
-        return x.map(stripPrecision);
-    } else {
-        const stripped = {};
-        for (const key of Object.keys(x)) {
-            stripped[key] = stripPrecision(x[key]);
-        }
-        return stripped;
-    }
-}
-
-function deepEqual(a, b) {
-    if (typeof a !== typeof b)
-        return false;
-    if (typeof a === 'number') {
-        return stripPrecision(a) === stripPrecision(b);
-    }
-    if (a === null || b === null || typeof a !== 'object')
-        return a === b;
-
-    const ka = Object.keys(a);
-    const kb = Object.keys(b);
-
-    if (ka.length !== kb.length)
-        return false;
-
-    ka.sort();
-    kb.sort();
-
-    for (let i = 0; i < ka.length; i++)
-        if (ka[i] !== kb[i] || !deepEqual(a[ka[i]], b[ka[i]]))
-            return false;
-
-    return true;
-}
-
-/**
- * Run the expression suite.
- *
- * @param {string} implementation - identify the implementation under test; used to
- * deal with implementation-specific test exclusions and fudge-factors
- * @param {Object} options
- * @param {Array<string>} [options.tests] - array of test names to run; tests not in the array will be skipped
- * @param {Array<string>} [options.ignores] - array of test names to ignore.
- * @param {} runExpressionTest - a function that runs a single expression test fixture
- * @returns {undefined} terminates the process when testing is complete
- */
-export function run(implementation, options, runExpressionTest) {
-    const directory = path.join(__dirname, '../expression-tests');
-    options.fixtureFilename = 'test.json';
-    harness(directory, implementation, options, (fixture, params, done) => {
-        try {
-            const result = runExpressionTest(fixture, params);
-            const dir = path.join(directory, params.id);
-
-            if (process.env.UPDATE) {
-                fixture.expected = {
-                    compiled: result.compiled,
-                    outputs: stripPrecision(result.outputs),
-                    serialized: result.serialized
-                };
-
-                delete fixture.metadata;
-
-                fs.writeFile(path.join(dir, 'test.json'), `${stringify(fixture, null, 2)}\n`, done);
-                return;
-            }
-
-            const expected = fixture.expected;
-            const compileOk = deepEqual(result.compiled, expected.compiled);
-            const evalOk = compileOk && deepEqual(result.outputs, expected.outputs);
-
-            let recompileOk = true;
-            let roundTripOk = true;
-            let serializationOk = true;
-            if (expected.compiled.result !== 'error') {
-                serializationOk = compileOk && deepEqual(expected.serialized, result.serialized);
-                recompileOk = compileOk && deepEqual(result.recompiled, expected.compiled);
-                roundTripOk = recompileOk && deepEqual(result.roundTripOutputs, expected.outputs);
-            }
-
-            params.ok = compileOk && evalOk && recompileOk && roundTripOk && serializationOk;
-
-            const diffOutput = {
-                text: '',
-                html: ''
-            };
-
-            const diffJson = (label, expectedJson, actualJson) => {
-                let text = '';
-                let html = '';
-                diff.diffJson(expectedJson, actualJson)
-                    .forEach((hunk) => {
-                        if (hunk.added) {
-                            text += `+ ${hunk.value}`;
-                            html += `<ins>  ${hunk.value}</ins>`;
-                        } else if (hunk.removed) {
-                            text += `- ${hunk.value}`;
-                            html += `<del>  ${hunk.value}</del>`;
-                        } else {
-                            text += `  ${hunk.value}`;
-                            html += `<span>  ${hunk.value}</span>`;
-                        }
-                    });
-                if (text) {
-                    diffOutput.text += `${label}\n${text}`;
-                    diffOutput.html += `<h3>${label}</h3>\n${html}`;
-                }
-            };
-
-            if (!compileOk) {
-                diffJson('Compiled', expected.compiled, result.compiled);
-            }
-            if (compileOk && !serializationOk) {
-                diffJson('Serialized', expected.serialized, result.serialized);
-            }
-            if (compileOk && !recompileOk) {
-                diffJson('Serialized and re-compiled', expected.compiled, result.recompiled);
-            }
-
-            const diffOutputs = (testOutputs) => {
-                return expected.outputs.map((expectedOutput, i) => {
-                    if (!deepEqual(expectedOutput, testOutputs[i])) {
-                        return `f(${JSON.stringify(fixture.inputs[i])})\nExpected: ${JSON.stringify(expectedOutput)}\nActual: ${JSON.stringify(testOutputs[i])}`;
-                    }
-                    return false;
-                })
-                    .filter(Boolean)
-                    .join('\n');
-            };
-
-            if (compileOk && !evalOk) {
-                const differences = `Original\n${diffOutputs(result.outputs)}\n`;
-                diffOutput.text += differences;
-                diffOutput.html += differences;
-            }
-            if (recompileOk && !roundTripOk) {
-                const differences = `\nRoundtripped through serialize()\n${diffOutputs(result.roundTripOutputs)}\n`;
-                diffOutput.text += differences;
-                diffOutput.html += differences;
-            }
-
-            params.difference = diffOutput.html;
-            if (diffOutput.text) { console.log(diffOutput.text); }
-
-            params.expression = compactStringify(fixture.expression);
-            params.serialized = compactStringify(result.serialized);
-
-            done();
-        } catch (e) {
-            done(e);
-        }
-    });
-}

package/maplibre-gl-js/test/integration/lib/generate-fixture-json.js

@@ -1,120 +0,0 @@
-/* eslint-disable import/no-commonjs */
-const path = require('path');
-const fs = require('fs');
-const glob = require('glob');
-const localizeURLs = require('./localize-urls');
-
-const OUTPUT_FILE = 'fixtures.json';
-
-exports.generateFixtureJson = generateFixtureJson;
-exports.getAllFixtureGlobs = getAllFixtureGlobs;
-
-/**
- * Analyzes the contents of the specified `path.join(rootDirectory, suiteDirectory)`, and inlines
- * the contents into a single json file which can then be imported and built into a bundle
- * to be shipped to the browser.
- *
- * @param {string} rootDirectory
- * @param {string} suiteDirectory
- * @param {boolean} includeImages
- */
-function generateFixtureJson(rootDirectory, suiteDirectory, outputDirectory = 'test/integration/dist', includeImages = false) {
-    const globs = getAllFixtureGlobs(rootDirectory, suiteDirectory);
-    const jsonPaths = globs[0];
-    const imagePaths = globs[1];
-    //Extract the filedata into a flat dictionary
-    const allFiles = {};
-    let allPaths = glob.sync(jsonPaths);
-    if (includeImages) {
-        allPaths = allPaths.concat(glob.sync(imagePaths));
-    }
-
-    //A Set that stores test names that are malformed so they can be removed later
-    const malformedTests = {};
-
-    for (const fixturePath of allPaths) {
-        const testName = path.dirname(fixturePath);
-        const fileName = path.basename(fixturePath);
-        const extension = path.extname(fixturePath);
-        try {
-            if (extension === '.json') {
-                let json = parseJsonFromFile(fixturePath);
-
-                //Special case for style json which needs some preprocessing
-                if (fileName === 'style.json') {
-                    json = processStyle(testName, json);
-                }
-
-                allFiles[fixturePath] = json;
-            } else if (extension === '.png') {
-                allFiles[fixturePath] = pngToBase64Str(fixturePath);
-            } else {
-                throw new Error(`${extension} is incompatible , file path ${fixturePath}`);
-            }
-        } catch (e) {
-            console.log(`Error parsing file: ${fixturePath}`);
-            malformedTests[testName] = true;
-        }
-    }
-
-    // Re-nest by directory path, each directory path defines a testcase.
-    const result = {};
-    for (const fullPath in allFiles) {
-        const testName = path.dirname(fullPath).replace(rootDirectory, '');
-        //Skip if test is malformed
-        if (malformedTests[testName]) { continue; }
-
-        //Lazily initaialize an object to store each file wihin a particular testName
-        if (result[testName] == null) {
-            result[testName] = {};
-        }
-        //Trim extension from filename
-        const fileName = path.basename(fullPath, path.extname(fullPath));
-        result[testName][fileName] = allFiles[fullPath];
-    }
-
-    const outputStr = JSON.stringify(result, null, 4);
-    const outputPath = path.join(outputDirectory, OUTPUT_FILE);
-
-    return new Promise((resolve, reject) => {
-        fs.writeFile(outputPath, outputStr, {encoding: 'utf8'}, (err) => {
-            if (err) { reject(err); }
-
-            resolve();
-        });
-    });
-}
-
-function getAllFixtureGlobs(rootDirectory, suiteDirectory) {
-    const basePath = path.join(rootDirectory, suiteDirectory);
-    const jsonPaths = path.join(basePath, '/**/*.json');
-    const imagePaths = path.join(basePath, '/**/*.png');
-
-    return [jsonPaths, imagePaths];
-}
-
-function parseJsonFromFile(filePath) {
-    return JSON.parse(fs.readFileSync(filePath, {encoding: 'utf8'}));
-}
-
-function pngToBase64Str(filePath) {
-    return fs.readFileSync(filePath).toString('base64');
-}
-
-function processStyle(testName, style) {
-    const clone = JSON.parse(JSON.stringify(style));
-    // 7357 is testem's default port
-    localizeURLs(clone, 7357);
-
-    clone.metadata = clone.metadata || {};
-    clone.metadata.test = Object.assign({
-        testName,
-        width: 512,
-        height: 512,
-        pixelRatio: 1,
-        recycleMap: false,
-        allowed: 0.00015
-    }, clone.metadata.test);
-
-    return clone;
-}

package/maplibre-gl-js/test/integration/lib/harness.js

@@ -1,210 +0,0 @@
-/* eslint-disable no-process-exit */
-
-import path from 'path';
-import fs from 'fs';
-import glob from 'glob';
-import {shuffle} from 'shuffle-seed';
-import {queue} from 'd3';
-import colors from 'chalk';
-import template from 'lodash.template';
-import createServer from './server';
-
-export default function (directory, implementation, options, run) {
-    const q = queue(1);
-    const server = createServer();
-
-    const tests = options.tests || [];
-    const ignores = options.ignores || {};
-
-    let sequence = glob.sync(`**/${options.fixtureFilename || 'style.json'}`, {cwd: directory})
-        .map(fixture => {
-            const id = path.dirname(fixture);
-            const style = require(path.join(directory, fixture));
-
-            server.localizeURLs(style);
-
-            style.metadata = style.metadata || {};
-            style.metadata.test = Object.assign({
-                id,
-                ignored: ignores[`${path.basename(directory)}/${id}`],
-                width: 512,
-                height: 512,
-                pixelRatio: 1,
-                recycleMap: options.recycleMap || false,
-                allowed: 0.00015
-            }, style.metadata.test);
-
-            return style;
-        })
-        .filter(style => {
-            const test = style.metadata.test;
-
-            if (tests.length !== 0 && !tests.some(t => test.id.indexOf(t) !== -1)) {
-                return false;
-            }
-
-            if (implementation === 'native' && process.env.BUILDTYPE !== 'Debug' && test.id.match(/^debug\//)) {
-                console.log(colors.gray(`* skipped ${test.id}`));
-                return false;
-            }
-
-            if (/^skip/.test(test.ignored)) {
-                console.log(colors.gray(`* skipped ${test.id} (${test.ignored})`));
-                return false;
-            }
-
-            return true;
-        });
-
-    if (options.shuffle) {
-        console.log(colors.white(`* shuffle seed: `) + colors.bold(`${options.seed}`));
-        sequence = shuffle(sequence, options.seed);
-    }
-
-    q.defer(server.listen);
-
-    sequence.forEach(style => {
-        q.defer((callback) => {
-            const test = style.metadata.test;
-
-            try {
-                run(style, test, handleResult);
-            } catch (error) {
-                handleResult(error);
-            }
-
-            function handleResult (error) {
-                if (error) {
-                    test.error = error;
-                }
-
-                if (test.ignored && !test.ok) {
-                    test.color = '#9E9E9E';
-                    test.status = 'ignored failed';
-                    console.log(colors.white(`* ignore ${test.id} (${test.ignored})`));
-                } else if (test.ignored) {
-                    test.color = '#E8A408';
-                    test.status = 'ignored passed';
-                    console.log(colors.yellow(`* ignore ${test.id} (${test.ignored})`));
-                } else if (test.error) {
-                    test.color = 'red';
-                    test.status = 'errored';
-                    console.log(colors.red(`* errored ${test.id}`));
-                } else if (!test.ok) {
-                    test.color = 'red';
-                    test.status = 'failed';
-                    console.log(colors.red(`* failed ${test.id}`));
-                } else {
-                    test.color = 'green';
-                    test.status = 'passed';
-                    console.log(colors.green(`* passed ${test.id}`));
-                }
-
-                callback(null, test);
-            }
-        });
-    });
-
-    q.defer(server.close);
-
-    q.awaitAll((err, results) => {
-        if (err) {
-            console.error(err);
-            setTimeout(() => { process.exit(-1); }, 0);
-            return;
-        }
-
-        const tests = results.slice(1, -1);
-
-        if (process.env.UPDATE) {
-            console.log(`Updated ${tests.length} tests.`);
-            process.exit(0);
-        }
-
-        let passedCount = 0,
-            ignoreCount = 0,
-            ignorePassCount = 0,
-            failedCount = 0,
-            erroredCount = 0;
-
-        tests.forEach((test) => {
-            if (test.ignored && !test.ok) {
-                ignoreCount++;
-            } else if (test.ignored) {
-                ignorePassCount++;
-            } else if (test.error) {
-                erroredCount++;
-            } else if (!test.ok) {
-                failedCount++;
-            } else {
-                passedCount++;
-            }
-        });
-
-        const totalCount = passedCount + ignorePassCount + ignoreCount + failedCount + erroredCount;
-
-        if (passedCount > 0) {
-            console.log(colors.green('%d passed (%s%)'),
-                passedCount, (100 * passedCount / totalCount).toFixed(1));
-        }
-
-        if (ignorePassCount > 0) {
-            console.log(colors.yellow('%d passed but were ignored (%s%)'),
-                ignorePassCount, (100 * ignorePassCount / totalCount).toFixed(1));
-        }
-
-        if (ignoreCount > 0) {
-            console.log(colors.white('%d ignored (%s%)'),
-                ignoreCount, (100 * ignoreCount / totalCount).toFixed(1));
-        }
-
-        if (failedCount > 0) {
-            console.log(colors.red('%d failed (%s%)'),
-                failedCount, (100 * failedCount / totalCount).toFixed(1));
-        }
-
-        if (erroredCount > 0) {
-            console.log(colors.red('%d errored (%s%)'),
-                erroredCount, (100 * erroredCount / totalCount).toFixed(1));
-        }
-
-        const resultsTemplate = template(fs.readFileSync(path.join(__dirname, '..', 'results.html.tmpl'), 'utf8'));
-        const itemTemplate = template(fs.readFileSync(path.join(directory, 'result_item.html.tmpl'), 'utf8'));
-
-        const stats = {};
-        for (const test of tests) {
-            stats[test.status] = (stats[test.status] || 0) + 1;
-        }
-
-        const unsuccessful = tests.filter(test =>
-            test.status === 'failed' || test.status === 'errored');
-
-        const resultsShell = resultsTemplate({unsuccessful, tests, stats, shuffle: options.shuffle, seed: options.seed})
-            .split('<!-- results go here -->');
-
-        const p = path.join(directory, options.recycleMap ? 'index-recycle-map.html' : 'index.html');
-        const out = fs.createWriteStream(p);
-
-        const q = queue(1);
-        q.defer(write, out, resultsShell[0]);
-        for (const test of tests) {
-            q.defer(write, out, itemTemplate({r: test, hasFailedTests: unsuccessful.length > 0}));
-        }
-        q.defer(write, out, resultsShell[1]);
-        q.await(() => {
-            out.end();
-            out.on('close', () => {
-                console.log(`Results at: ${p}`);
-                process.exit((failedCount + erroredCount) === 0 ? 0 : 1);
-            });
-        });
-    });
-}
-
-function write(stream, data, cb) {
-    if (!stream.write(data)) {
-        stream.once('drain', cb);
-    } else {
-        process.nextTick(cb);
-    }
-}

package/maplibre-gl-js/test/integration/lib/json-diff.js

@@ -1,37 +0,0 @@
-import diff from 'diff';
-
-export function generateDiffLog(expected, actual) {
-    return diff.diffJson(expected, actual).map((hunk) => {
-        if (hunk.added) {
-            return `+ ${hunk.value}`;
-        } else if (hunk.removed) {
-            return `- ${hunk.value}`;
-        } else {
-            return `  ${hunk.value}`;
-        }
-    }).join('');
-}
-
-export function deepEqual(a, b) {
-    if (typeof a !== typeof b)
-        return false;
-    if (typeof a === 'number')
-        return Math.abs(a - b) < 1e-10;
-    if (a === null || typeof a !== 'object')
-        return a === b;
-
-    const ka = Object.keys(a);
-    const kb = Object.keys(b);
-
-    if (ka.length !== kb.length)
-        return false;
-
-    ka.sort();
-    kb.sort();
-
-    for (let i = 0; i < ka.length; i++)
-        if (ka[i] !== kb[i] || !deepEqual(a[ka[i]], b[ka[i]]))
-            return false;
-
-    return true;
-}

package/maplibre-gl-js/test/integration/lib/localize-urls.js

@@ -1,102 +0,0 @@
-/* eslint-disable import/no-commonjs */
-const path = require('path');
-const fs = require('fs');
-const colors = require('chalk');
-
-module.exports = function localizeURLs(style, port) {
-    localizeStyleURLs(style, port);
-    if (style.metadata && style.metadata.test && style.metadata.test.operations) {
-        style.metadata.test.operations.forEach((op) => {
-            if (op[0] === 'addSource') {
-                localizeSourceURLs(op[2], port);
-            } else if (op[0] === 'setStyle') {
-                if (typeof op[1] === 'object') {
-                    localizeStyleURLs(op[1], port);
-                    return;
-                }
-
-                let styleJSON;
-                try {
-                    const relativePath = op[1].replace(/^local:\/\//, '');
-                    if (relativePath.startsWith('mapbox-gl-styles')) {
-                        styleJSON = fs.readFileSync(path.join(path.dirname(require.resolve('mapbox-gl-styles')), '..', relativePath));
-                    } else {
-                        styleJSON = fs.readFileSync(path.join(__dirname, '..', relativePath));
-                    }
-                } catch (error) {
-                    console.log(colors.blue(`* ${error}`));
-                    return;
-                }
-
-                try {
-                    styleJSON = JSON.parse(styleJSON);
-                } catch (error) {
-                    console.log(colors.blue(`* Error while parsing ${op[1]}: ${error}`));
-                    return;
-                }
-
-                localizeStyleURLs(styleJSON, port);
-
-                op[1] = styleJSON;
-                op[2] = {diff: false};
-            }
-        });
-    }
-};
-
-function localizeURL(url, port) {
-    return url.replace(/^local:\/\//, `http://localhost:${port}/`);
-}
-
-function localizeMapboxSpriteURL(url, port) {
-    return url.replace(/^mapbox:\/\//, `http://localhost:${port}/`);
-}
-
-function localizeMapboxFontsURL(url, port) {
-    return url.replace(/^mapbox:\/\/fonts/, `http://localhost:${port}/glyphs`);
-}
-
-function localizeMapboxTilesURL(url, port) {
-    return url.replace(/^mapbox:\/\//, `http://localhost:${port}/tiles/`);
-}
-
-function localizeMapboxTilesetURL(url, port) {
-    return url.replace(/^mapbox:\/\//, `http://localhost:${port}/tilesets/`);
-}
-
-function localizeSourceURLs(source, port) {
-    for (const tile in source.tiles) {
-        source.tiles[tile] = localizeMapboxTilesURL(source.tiles[tile], port);
-        source.tiles[tile] = localizeURL(source.tiles[tile], port);
-    }
-
-    if (source.urls) {
-        source.urls = source.urls.map((url) => localizeMapboxTilesetURL(url, port));
-        source.urls = source.urls.map((url) => localizeURL(url, port));
-    }
-
-    if (source.url) {
-        source.url = localizeMapboxTilesetURL(source.url, port);
-        source.url = localizeURL(source.url, port);
-    }
-
-    if (source.data && typeof source.data == 'string') {
-        source.data = localizeURL(source.data, port);
-    }
-}
-
-function localizeStyleURLs (style, port) {
-    for (const source in style.sources) {
-        localizeSourceURLs(style.sources[source], port);
-    }
-
-    if (style.sprite) {
-        style.sprite = localizeMapboxSpriteURL(style.sprite, port);
-        style.sprite = localizeURL(style.sprite, port);
-    }
-
-    if (style.glyphs) {
-        style.glyphs = localizeMapboxFontsURL(style.glyphs, port);
-        style.glyphs = localizeURL(style.glyphs, port);
-    }
-}