@neurodevs/node-lsl 17.1.1 → 18.1.0

package/build/__tests__/impl/LiblslAdapter.test.js

@@ -1,688 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { randomInt } from 'crypto';
-import { test, assert } from '@neurodevs/node-tdd';
-import { createPointer, DataType, unwrapPointer, } from 'ffi-rs';
-import LiblslAdapter from '../../impl/LiblslAdapter.js';
-import FakeLiblsl from '../../testDoubles/Liblsl/FakeLiblsl.js';
-import AbstractPackageTest from '../AbstractPackageTest.js';
-export default class LiblslAdapterTest extends AbstractPackageTest {
-    static instance;
-    static libraryPath;
-    static libraryOptions;
-    static fakeBindings;
-    static fakeStreamInfo;
-    static fakeOutlet;
-    static fakeInlet = {};
-    static fakeDesc;
-    static fakeChildNamedChannels;
-    static createStreamInfoParams;
-    static destroyStreamInfoParams;
-    static appendChildParams = [];
-    static createOutletParams;
-    static destroyOutletParams;
-    static createInletParams;
-    static flushInletParams;
-    static destroyInletParams;
-    static localClockParams;
-    static pushSampleFloatTimestampParams;
-    static pushSampleStringTimestampParams;
-    static appendChildValueParams;
-    static shouldThrowWhenCreatingBindings;
-    static getDescriptionParams;
-    static fakeChildNamedChannel;
-    static appendChildHitCount;
-    static ffiRsOpenOptions;
-    static ffiRsDefineOptions;
-    static ffiRsLoadOptions;
-    static async beforeEach() {
-        await super.beforeEach();
-        delete this.libraryPath;
-        delete this.libraryOptions;
-        delete this.createStreamInfoParams;
-        delete this.createOutletParams;
-        delete this.destroyOutletParams;
-        delete this.createInletParams;
-        delete this.destroyInletParams;
-        delete this.pushSampleFloatTimestampParams;
-        delete this.getDescriptionParams;
-        this.appendChildParams = [];
-        this.appendChildValueParams = [];
-        process.env.LIBLSL_PATH = this.generateId();
-        this.fakeStreamInfo = {};
-        this.fakeDesc = {};
-        this.fakeOutlet = {};
-        this.fakeChildNamedChannels = {};
-        this.fakeChildNamedChannel = {};
-        this.fakeBindings = this.FakeBindings();
-        this.shouldThrowWhenCreatingBindings = false;
-        this.appendChildHitCount = 0;
-        delete this.ffiRsOpenOptions;
-        LiblslAdapter.open = (options) => {
-            this.ffiRsOpenOptions = options;
-        };
-        LiblslAdapter.define = (options) => {
-            this.ffiRsDefineOptions = options;
-            if (this.shouldThrowWhenCreatingBindings) {
-                throw new Error('Failed to create bindings!');
-            }
-            return this.fakeBindings;
-        };
-        LiblslAdapter.load = (options) => {
-            this.ffiRsLoadOptions = options;
-            return this.fakeNumResolveResults;
-        };
-        LiblslAdapter.resetInstance();
-        this.instance = LiblslAdapter.getInstance();
-    }
-    static async createsInstance() {
-        assert.isTruthy(this.instance, 'Failed to create instance!');
-    }
-    static async throwsWhenBindingsFailToLoad() {
-        this.shouldThrowWhenCreatingBindings = true;
-        LiblslAdapter.resetInstance();
-        const err = assert.doesThrow(() => LiblslAdapter.getInstance());
-        assert.isTrue(err.message.includes(this.generateFailedMessage()), 'Did not receive the expected error!');
-    }
-    static async callsOpenOnFfiRs() {
-        assert.isEqualDeep(this.ffiRsOpenOptions, {
-            library: 'lsl',
-            path: process.env.LIBLSL_PATH,
-        });
-    }
-    static async worksAsASingleton() {
-        const liblsl = LiblslAdapter.getInstance();
-        //@ts-ignore
-        assert.isInstanceOf(liblsl, LiblslAdapter);
-    }
-    static async singletonIsTheSame() {
-        assert.isEqual(LiblslAdapter.getInstance(), LiblslAdapter.getInstance());
-    }
-    static canSetInstance() {
-        const fake = new FakeLiblsl();
-        LiblslAdapter.setInstance(fake);
-        assert.isEqual(LiblslAdapter.getInstance(), fake);
-    }
-    static async createsExpectedBindingsWithFfiRs() {
-        assert.isEqualDeep(this.ffiRsDefineOptions, {
-            lsl_create_streaminfo: {
-                library: 'lsl',
-                retType: DataType.External,
-                paramsType: [
-                    DataType.String,
-                    DataType.String,
-                    DataType.I32,
-                    DataType.Double,
-                    DataType.I32,
-                    DataType.String,
-                ],
-            },
-            lsl_destroy_streaminfo: {
-                library: 'lsl',
-                retType: DataType.Void,
-                paramsType: [DataType.External],
-            },
-            lsl_create_outlet: {
-                library: 'lsl',
-                retType: DataType.External,
-                paramsType: [DataType.External, DataType.I32, DataType.I32],
-            },
-            lsl_push_sample_ft: {
-                library: 'lsl',
-                retType: DataType.I32,
-                paramsType: [
-                    DataType.External,
-                    DataType.FloatArray,
-                    DataType.Double,
-                ],
-            },
-            lsl_push_sample_strt: {
-                library: 'lsl',
-                retType: DataType.I32,
-                paramsType: [
-                    DataType.External,
-                    DataType.StringArray,
-                    DataType.Double,
-                ],
-            },
-            lsl_destroy_outlet: {
-                library: 'lsl',
-                retType: DataType.Void,
-                paramsType: [DataType.External],
-            },
-            lsl_create_inlet: {
-                library: 'lsl',
-                retType: DataType.External,
-                paramsType: [
-                    DataType.External,
-                    DataType.I32,
-                    DataType.I32,
-                    DataType.I32,
-                ],
-            },
-            lsl_flush_inlet: {
-                library: 'lsl',
-                retType: DataType.I32,
-                paramsType: [DataType.External],
-            },
-            lsl_destroy_inlet: {
-                library: 'lsl',
-                retType: DataType.Void,
-                paramsType: [DataType.External],
-            },
-            lsl_get_desc: {
-                library: 'lsl',
-                retType: DataType.External,
-                paramsType: [DataType.External],
-            },
-            lsl_append_child: {
-                library: 'lsl',
-                retType: DataType.External,
-                paramsType: [DataType.External, DataType.String],
-            },
-            lsl_append_child_value: {
-                library: 'lsl',
-                retType: DataType.External,
-                paramsType: [
-                    DataType.External,
-                    DataType.String,
-                    DataType.String,
-                ],
-            },
-            lsl_local_clock: {
-                library: 'lsl',
-                retType: DataType.Double,
-                paramsType: [],
-            },
-        });
-    }
-    static async createsStreamInfoWithRequiredParams() {
-        const options = this.generateRandomCreateStreamInfoOptions();
-        const actual = this.instance.createStreamInfo(options);
-        assert.isEqual(actual, this.fakeStreamInfo);
-        assert.isEqualDeep(this.createStreamInfoParams, Object.values(options));
-    }
-    static async destroysStreamInfoWithBoundInfo() {
-        const info = this.createRandomStreamInfo();
-        this.instance.destroyStreamInfo({ info });
-        assert.isEqualDeep(this.destroyStreamInfoParams, [info], 'Did not call destroyStreamInfo with expected params!');
-    }
-    static async resolvesStreamInfoByProp() {
-        await this.resolveByProp();
-        assert.isEqualDeep(this.ffiRsLoadOptions, {
-            library: 'lsl',
-            funcName: 'lsl_resolve_byprop',
-            retType: DataType.I32,
-            paramsType: [
-                DataType.External,
-                DataType.I32,
-                DataType.String,
-                DataType.String,
-                DataType.I32,
-                DataType.Double,
-            ],
-            paramsValue: [
-                this.resultsBufferPtr,
-                this.maxResults,
-                this.prop,
-                this.value,
-                this.minResults,
-                this.timeoutMs / 1000,
-            ],
-            runInNewThread: true,
-        }, 'Did not call resolveByProp with expected params!');
-    }
-    static async resolveByPropAcceptsOptionalArgs() {
-        const minResults = randomInt(0, 10);
-        const timeoutMs = Math.random() * 1000;
-        await this.resolveByProp({
-            minResults,
-            timeoutMs,
-        });
-        assert.isEqualDeep({
-            minResults: this.ffiRsLoadOptions?.['paramsValue']?.[4],
-            timeoutMs: this.ffiRsLoadOptions?.['paramsValue']?.[5],
-        }, { minResults, timeoutMs: timeoutMs / 1000 }, 'Did not call resolveByProp with expected params!');
-    }
-    static async returnsHandlesForResolvedStreamInfos() {
-        LiblslAdapter.alloc = (size) => {
-            const buffer = Buffer.alloc(size);
-            for (let i = 0; i < this.fakeNumResolveResults; i++) {
-                const offset = i * this.bytesPerPointer;
-                buffer.writeBigUInt64LE(BigInt(i + 1), offset);
-            }
-            return buffer;
-        };
-        const expectedHandles = [];
-        for (let i = 0; i < this.fakeNumResolveResults; i++) {
-            expectedHandles.push(BigInt(i + 1));
-        }
-        const actualHandles = await this.resolveByProp();
-        const actual = actualHandles.map((h) => h.toString());
-        const expected = expectedHandles.map((h) => h.toString());
-        assert.isEqualDeep(actual, expected, 'Did not receive expected resolved stream info handles!');
-    }
-    static async createsOutletWithRequiredParams() {
-        const { options, outlet } = this.createRandomOutlet();
-        const expected = {
-            ...options,
-            maxBufferedMs: options.maxBufferedMs / 1000,
-        };
-        assert.isEqualDeep(this.createOutletParams, Object.values(expected));
-        assert.isEqual(outlet, this.fakeOutlet);
-    }
-    static async pushesFloatSample() {
-        const expected = [1.0, 2.0, 3.0];
-        const timestamp = randomInt(100);
-        const options = {
-            outlet: this.fakeOutlet,
-            sample: expected,
-            timestamp,
-        };
-        this.instance.pushSampleFloatTimestamp(options);
-        assert.isEqualDeep(this.pushSampleFloatTimestampParams, [
-            this.fakeOutlet,
-            expected,
-            timestamp,
-        ]);
-    }
-    static async pushesStringSample() {
-        const expected = [this.generateId()];
-        const timestamp = randomInt(100);
-        const options = {
-            outlet: this.fakeOutlet,
-            sample: expected,
-            timestamp,
-        };
-        this.instance.pushSampleStringTimestamp(options);
-        assert.isEqual(this.pushSampleStringTimestampParams?.[0], this.fakeOutlet);
-        assert.isEqualDeep(this.pushSampleStringTimestampParams?.[1], expected);
-        assert.isEqual(this.pushSampleStringTimestampParams?.[2], timestamp);
-    }
-    static async addingSingleChannelGetsDescription() {
-        const info = this.createRandomStreamInfo();
-        const channel = this.generateRandomChannelValues();
-        this.instance.appendChannelsToStreamInfo({
-            info,
-            channels: [channel],
-        });
-        assert.isEqualDeep(this.getDescriptionParams?.[0], [info]);
-        assert.isEqual(this.appendChildParams?.[0][0], this.fakeDesc);
-        assert.isEqual(this.appendChildParams?.[0][1], 'channels');
-        assert.isEqual(this.appendChildParams?.[1][0], this.fakeChildNamedChannels);
-        assert.isEqual(this.appendChildParams?.[1][1], 'channel');
-        assert.isLength(this.appendChildValueParams, 3);
-        for (let i = 0; i < 3; i++) {
-            const param = this.appendChildValueParams[i];
-            assert.isEqual(param[0], this.fakeChildNamedChannel);
-        }
-        assert.isEqual(this.appendChildValueParams[0][1], 'label');
-        assert.isEqual(this.appendChildValueParams[1][1], 'unit');
-        assert.isEqual(this.appendChildValueParams[2][1], 'type');
-        assert.isEqual(this.appendChildValueParams[0][2], channel.label);
-        assert.isEqual(this.appendChildValueParams[1][2], channel.units);
-        assert.isEqual(this.appendChildValueParams[2][2], channel.type);
-    }
-    static async addingMultpleChannelsAddsChildrenToChannelsChild() {
-        const info = this.createRandomStreamInfo();
-        const channel1 = this.generateRandomChannelValues();
-        const channel2 = this.generateRandomChannelValues();
-        this.instance.appendChannelsToStreamInfo({
-            info,
-            channels: [channel1, channel2],
-        });
-        assert.isEqual(this.appendChildParams?.[2][0], this.fakeChildNamedChannels);
-        assert.isEqual(this.appendChildParams?.[2][1], 'channel');
-        assert.isEqual(this.appendChildValueParams[3][2], channel2.label);
-        assert.isEqual(this.appendChildValueParams[4][2], channel2.units);
-        assert.isEqual(this.appendChildValueParams[5][2], channel2.type);
-    }
-    static async canDestroyOutlet() {
-        const outlet = this.createRandomOutlet();
-        const options = { outlet };
-        this.instance.destroyOutlet(options);
-        assert.isEqualDeep(this.destroyOutletParams, Object.values(options));
-    }
-    static async callingLocalClockTwiceReturnsDifferentTimestamps() {
-        const t1 = this.instance.localClock();
-        await this.wait(10);
-        const t2 = this.instance.localClock();
-        assert.isNotEqual(t1, t2);
-    }
-    static async localClockBindingReceivesEmptyArray() {
-        delete this.localClockParams;
-        this.instance.localClock();
-        assert.isEqualDeep(this.localClockParams, []);
-    }
-    static async defaultsToMacOsPath() {
-        delete process.env.LIBLSL_PATH;
-        LiblslAdapter.resetInstance();
-        this.instance = LiblslAdapter.getInstance();
-        assert.isEqual(this.ffiRsOpenOptions?.path, '/opt/homebrew/Cellar/lsl/1.16.2/lib/liblsl.1.16.2.dylib');
-    }
-    static async createInletWithRequiredParams() {
-        const { options, inlet } = this.createRandomInlet();
-        const { maxBufferedMs } = options;
-        const expected = {
-            ...options,
-            maxBufferedMs: maxBufferedMs / 1000,
-        };
-        const maxChunkSize = 0;
-        const shouldRecover = 1;
-        assert.isEqualDeep(this.createInletParams, [...Object.values(expected), maxChunkSize, shouldRecover], 'Did not call createInlet with expected params!');
-        assert.isEqual(inlet, this.fakeInlet, 'Did not receive expected inlet!');
-    }
-    static async pullSampleCallsBinding() {
-        const { inlet } = this.createRandomInlet();
-        const dataBuffer = Buffer.alloc(4 * this.channelCount);
-        const dataBufferElements = this.channelCount;
-        const timeout = 0.0;
-        const dataBufferPtr = unwrapPointer(createPointer({
-            paramsType: [DataType.U8Array],
-            paramsValue: [dataBuffer],
-        }))[0];
-        const errcodePtr = unwrapPointer(createPointer({
-            paramsType: [DataType.U8Array],
-            paramsValue: [new Int32Array(1)],
-        }))[0];
-        this.instance.pullSample({
-            inlet,
-            dataBufferPtr,
-            dataBufferElements,
-            timeout,
-            errcodePtr,
-        });
-        assert.isEqualDeep(this.ffiRsLoadOptions, {
-            library: 'lsl',
-            funcName: 'lsl_pull_sample_f',
-            retType: DataType.Double,
-            paramsType: [
-                DataType.External,
-                DataType.External,
-                DataType.I32,
-                DataType.Double,
-                DataType.External,
-            ],
-            paramsValue: [
-                inlet,
-                dataBufferPtr,
-                dataBufferElements,
-                timeout,
-                errcodePtr,
-            ],
-        }, 'Did not call pullSample with expected options!');
-    }
-    static async pullChunkCallsBinding() {
-        const { inlet } = this.createRandomInlet();
-        const dataBuffer = Buffer.alloc(4 * this.chunkSize * this.channelCount);
-        const timestampBuffer = Buffer.alloc(8 * this.chunkSize);
-        const dataBufferElements = this.chunkSize * this.channelCount;
-        const timestampBufferElements = this.chunkSize;
-        const timeout = 0.0;
-        const dataBufferPtr = unwrapPointer(createPointer({
-            paramsType: [DataType.U8Array],
-            paramsValue: [dataBuffer],
-        }))[0];
-        const timestampBufferPtr = unwrapPointer(createPointer({
-            paramsType: [DataType.U8Array],
-            paramsValue: [timestampBuffer],
-        }))[0];
-        const errcodePtr = unwrapPointer(createPointer({
-            paramsType: [DataType.U8Array],
-            paramsValue: [new Int32Array(1)],
-        }))[0];
-        this.instance.pullChunk({
-            inlet,
-            dataBufferPtr,
-            timestampBufferPtr,
-            dataBufferElements,
-            timestampBufferElements,
-            timeout,
-            errcodePtr,
-        });
-        assert.isEqualDeep(this.ffiRsLoadOptions, {
-            library: 'lsl',
-            funcName: 'lsl_pull_chunk_f',
-            retType: DataType.Double,
-            paramsType: [
-                DataType.External,
-                DataType.External,
-                DataType.External,
-                DataType.I32,
-                DataType.I32,
-                DataType.Double,
-                DataType.External,
-            ],
-            paramsValue: [
-                inlet,
-                dataBufferPtr,
-                timestampBufferPtr,
-                dataBufferElements,
-                timestampBufferElements,
-                timeout,
-                errcodePtr,
-            ],
-        }, 'Did not call pullChunk with expected options!');
-    }
-    static async flushInletCallsBinding() {
-        const { inlet } = this.createRandomInlet();
-        this.instance.flushInlet({ inlet });
-        assert.isEqualDeep(this.flushInletParams, [inlet], 'Should have called flushInlet with expected params!');
-    }
-    static async destroyInletCallsBinding() {
-        const { inlet } = this.createRandomInlet();
-        this.instance.destroyInlet({ inlet });
-        assert.isEqualDeep(this.destroyInletParams, [inlet], 'Should have called destroyInlet with expected params!');
-    }
-    static createRandomStreamInfo() {
-        return this.instance.createStreamInfo(this.generateRandomCreateStreamInfoOptions());
-    }
-    static async resolveByProp(options) {
-        return this.instance.resolveByProp({
-            prop: this.prop,
-            value: this.value,
-            minResults: this.minResults,
-            timeoutMs: this.timeoutMs,
-            ...options,
-        });
-    }
-    static createRandomOutlet() {
-        const options = this.createRandomOutletOptions();
-        const outlet = this.instance.createOutlet(options);
-        return { options, outlet };
-    }
-    static createRandomOutletOptions() {
-        const info = this.createRandomStreamInfo();
-        const options = {
-            info,
-            chunkSize: randomInt(10),
-            maxBufferedMs: randomInt(10),
-        };
-        return options;
-    }
-    static createRandomInlet() {
-        const options = this.createRandomInletOptions();
-        const inlet = this.instance.createInlet(options);
-        return { options, inlet };
-    }
-    static createRandomInletOptions() {
-        const info = this.createRandomStreamInfo();
-        const options = {
-            info,
-            maxBufferedMs: randomInt(10),
-        };
-        return options;
-    }
-    static generateRandomChannelValues() {
-        return {
-            label: this.generateId(),
-            type: this.generateId(),
-            units: this.generateId(),
-        };
-    }
-    static generateRandomCreateStreamInfoOptions() {
-        return {
-            name: this.generateId(),
-            type: this.generateId(),
-            channelCount: randomInt(1, 10),
-            sampleRateHz: randomInt(100),
-            channelFormat: randomInt(7),
-            sourceId: this.generateId(),
-        };
-    }
-    // resolveByProp
-    static maxResults = 1024;
-    static bytesPerPointer = 8;
-    static minResults = 1;
-    static timeoutMs = 1000;
-    static prop = this.generateId();
-    static value = this.generateId();
-    static fakeNumResolveResults = 2;
-    static resultsBuffer = Buffer.alloc(this.maxResults * this.bytesPerPointer);
-    static resultsBufferPtr = unwrapPointer(createPointer({
-        paramsType: [DataType.U8Array],
-        paramsValue: [this.resultsBuffer],
-    }))[0];
-    static generateFailedMessage() {
-        return `Loading the liblsl dylib failed! I tried to load it from ${process.env.LIBLSL_PATH}.`;
-    }
-    static FakeBindings() {
-        return {
-            lsl_create_streaminfo: (params) => {
-                this.createStreamInfoParams = params;
-                return this.fakeStreamInfo;
-            },
-            lsl_destroy_streaminfo: (params) => {
-                this.destroyStreamInfoParams = params;
-            },
-            lsl_create_outlet: (params) => {
-                this.createOutletParams = params;
-                return this.fakeOutlet;
-            },
-            lsl_push_sample_ft: (params) => {
-                this.pushSampleFloatTimestampParams = params;
-                return 0;
-            },
-            lsl_push_sample_strt: (params) => {
-                this.pushSampleStringTimestampParams = params;
-                return 0;
-            },
-            lsl_destroy_outlet: (params) => {
-                this.destroyOutletParams = params;
-            },
-            lsl_create_inlet: (params) => {
-                this.createInletParams = params;
-                return this.fakeInlet;
-            },
-            lsl_flush_inlet: (params) => {
-                this.flushInletParams = params;
-                return 0;
-            },
-            lsl_destroy_inlet: (params) => {
-                this.destroyInletParams = params;
-            },
-            lsl_local_clock: (params) => {
-                this.localClockParams = params;
-                return new Date().getTime();
-            },
-            lsl_get_desc: (info) => {
-                this.getDescriptionParams = [info];
-                return this.fakeDesc;
-            },
-            lsl_append_child: (params) => {
-                this.appendChildParams.push(params);
-                if (this.appendChildHitCount === 0) {
-                    this.appendChildHitCount++;
-                    return this.fakeChildNamedChannels;
-                }
-                return this.fakeChildNamedChannel;
-            },
-            lsl_append_child_value: (params) => {
-                this.appendChildValueParams.push(params);
-            },
-        };
-    }
-}
-__decorate([
-    test()
-], LiblslAdapterTest, "createsInstance", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "throwsWhenBindingsFailToLoad", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "callsOpenOnFfiRs", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "worksAsASingleton", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "singletonIsTheSame", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "canSetInstance", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "createsExpectedBindingsWithFfiRs", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "createsStreamInfoWithRequiredParams", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "destroysStreamInfoWithBoundInfo", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "resolvesStreamInfoByProp", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "resolveByPropAcceptsOptionalArgs", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "returnsHandlesForResolvedStreamInfos", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "createsOutletWithRequiredParams", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "pushesFloatSample", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "pushesStringSample", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "addingSingleChannelGetsDescription", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "addingMultpleChannelsAddsChildrenToChannelsChild", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "canDestroyOutlet", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "callingLocalClockTwiceReturnsDifferentTimestamps", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "localClockBindingReceivesEmptyArray", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "defaultsToMacOsPath", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "createInletWithRequiredParams", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "pullSampleCallsBinding", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "pullChunkCallsBinding", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "flushInletCallsBinding", null);
-__decorate([
-    test()
-], LiblslAdapterTest, "destroyInletCallsBinding", null);
-//# sourceMappingURL=LiblslAdapter.test.js.map