@neurodevs/ndx-native 0.0.1

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

@@ -0,0 +1,750 @@
+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 shouldThrowWhenCreatingBindings;
+    static fakeInfoHandle;
+    static fakeOutletHandle;
+    static fakeInletHandle = {};
+    static fakeDescHandle;
+    static fakeChildHandle;
+    static fakeChildNamedChannel;
+    static createStreamInfoParams;
+    static destroyStreamInfoParams;
+    static appendChildParams = [];
+    static appendChildValueParams;
+    static appendChildHitCount;
+    static getDescriptionParams;
+    static getChannelCountParams;
+    static createOutletParams;
+    static pushSampleFloatTimestampParams;
+    static pushSampleStringTimestampParams;
+    static destroyOutletParams;
+    static createInletParams;
+    static flushInletParams;
+    static destroyInletParams;
+    static localClockParams;
+    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;
+        delete this.getChannelCountParams;
+        this.appendChildParams = [];
+        this.appendChildValueParams = [];
+        process.env.LIBLSL_PATH = this.generateId();
+        this.fakeInfoHandle = {};
+        this.fakeDescHandle = {};
+        this.fakeOutletHandle = {};
+        this.fakeChildHandle = {};
+        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_inlet_flush: {
+                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_get_channel_count: {
+                library: 'lsl',
+                retType: DataType.I32,
+                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.fakeInfoHandle);
+        assert.isEqualDeep(this.createStreamInfoParams, Object.values(options));
+    }
+    static async destroyStreamInfoPasses() {
+        const infoHandle = this.createRandomInfoHandle();
+        this.instance.destroyStreamInfo({ infoHandle });
+        assert.isEqualDeep(this.destroyStreamInfoParams, [infoHandle], '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, i) => (i + 1).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, outletHandle } = this.createRandomOutlet();
+        const expected = {
+            ...options,
+            maxBufferedMs: options.maxBufferedMs / 1000,
+        };
+        assert.isEqualDeep(this.createOutletParams, Object.values(expected));
+        assert.isEqual(outletHandle, this.fakeOutletHandle);
+    }
+    static async pushesFloatSample() {
+        const expected = [1.0, 2.0, 3.0];
+        const timestamp = randomInt(100);
+        const options = {
+            outletHandle: this.fakeOutletHandle,
+            sample: expected,
+            timestamp,
+        };
+        this.instance.pushSampleFloatTimestamp(options);
+        assert.isEqualDeep(this.pushSampleFloatTimestampParams, [
+            this.fakeOutletHandle,
+            expected,
+            timestamp,
+        ]);
+    }
+    static async pushesStringSample() {
+        const expected = [this.generateId()];
+        const timestamp = randomInt(100);
+        const options = {
+            outletHandle: this.fakeOutletHandle,
+            sample: expected,
+            timestamp,
+        };
+        this.instance.pushSampleStringTimestamp(options);
+        assert.isEqual(this.pushSampleStringTimestampParams?.[0], this.fakeOutletHandle);
+        assert.isEqualDeep(this.pushSampleStringTimestampParams?.[1], expected);
+        assert.isEqual(this.pushSampleStringTimestampParams?.[2], timestamp);
+    }
+    static async addingSingleChannelGetsDescription() {
+        const infoHandle = this.createRandomInfoHandle();
+        const channel = this.generateRandomChannelValues();
+        this.instance.appendChannelsToStreamInfo({
+            infoHandle,
+            channels: [channel],
+        });
+        assert.isEqualDeep(this.getDescriptionParams?.[0], [infoHandle]);
+        assert.isEqual(this.appendChildParams?.[0][0], this.fakeDescHandle);
+        assert.isEqual(this.appendChildParams?.[0][1], 'channels');
+        assert.isEqual(this.appendChildParams?.[1][0], this.fakeChildHandle);
+        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 infoHandle = this.createRandomInfoHandle();
+        const channel1 = this.generateRandomChannelValues();
+        const channel2 = this.generateRandomChannelValues();
+        this.instance.appendChannelsToStreamInfo({
+            infoHandle,
+            channels: [channel1, channel2],
+        });
+        assert.isEqual(this.appendChildParams?.[2][0], this.fakeChildHandle);
+        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 { outletHandle } = this.createRandomOutlet();
+        const options = { outletHandle };
+        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, inletHandle } = 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(inletHandle, this.fakeInletHandle, 'Did not receive expected inlet!');
+    }
+    static async getsChannelCountFromInfoHandle() {
+        const infoHandle = this.createRandomInfoHandle();
+        const channelCount = this.instance.getChannelCount({ infoHandle });
+        assert.isEqual(channelCount, this.channelCount);
+    }
+    static async openStreamCallsBinding() {
+        const { inletHandle } = this.createRandomInlet();
+        const timeoutMs = randomInt(1000);
+        const errorCodePtr = unwrapPointer(createPointer({
+            paramsType: [DataType.U8Array],
+            paramsValue: [new Int32Array(1)],
+        }))[0];
+        await this.instance.openStream({
+            inletHandle,
+            timeoutMs,
+            errorCodePtr,
+        });
+        assert.isEqualDeep(this.ffiRsLoadOptions, {
+            library: 'lsl',
+            funcName: 'lsl_open_stream',
+            retType: DataType.Void,
+            paramsType: [
+                DataType.External,
+                DataType.Double,
+                DataType.External,
+            ],
+            paramsValue: [inletHandle, timeoutMs / 1000, errorCodePtr],
+            runInNewThread: true,
+        }, 'Did not call openStream with expected options!');
+    }
+    static async closeStreamCallsBinding() {
+        const { inletHandle } = this.createRandomInlet();
+        this.instance.closeStream({
+            inletHandle,
+        });
+        assert.isEqualDeep(this.ffiRsLoadOptions, {
+            library: 'lsl',
+            funcName: 'lsl_close_stream',
+            retType: DataType.Void,
+            paramsType: [DataType.External],
+            paramsValue: [inletHandle],
+        }, 'Did not call closeStream with expected options!');
+    }
+    static async pullSampleCallsBinding() {
+        const { inletHandle } = this.createRandomInlet();
+        const sampleBuffer = Buffer.alloc(4 * this.channelCount);
+        const sampleBufferElements = this.channelCount;
+        const timeoutMs = 0.0;
+        const sampleBufferPtr = unwrapPointer(createPointer({
+            paramsType: [DataType.U8Array],
+            paramsValue: [sampleBuffer],
+        }))[0];
+        const errorCodePtr = unwrapPointer(createPointer({
+            paramsType: [DataType.U8Array],
+            paramsValue: [new Int32Array(1)],
+        }))[0];
+        this.instance.pullSample({
+            inletHandle,
+            sampleBufferPtr,
+            sampleBufferElements,
+            timeoutMs,
+            errorCodePtr,
+        });
+        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: [
+                inletHandle,
+                sampleBufferPtr,
+                sampleBufferElements,
+                timeoutMs,
+                errorCodePtr,
+            ],
+        }, 'Did not call pullSample with expected options!');
+    }
+    static async pullChunkCallsBinding() {
+        const { inletHandle } = this.createRandomInlet();
+        const sampleBuffer = Buffer.alloc(4 * this.chunkSize * this.channelCount);
+        const timestampBuffer = Buffer.alloc(8 * this.chunkSize);
+        const sampleBufferElements = this.chunkSize * this.channelCount;
+        const timestampBufferElements = this.chunkSize;
+        const timeoutMs = 0.0;
+        const sampleBufferPtr = unwrapPointer(createPointer({
+            paramsType: [DataType.U8Array],
+            paramsValue: [sampleBuffer],
+        }))[0];
+        const timestampBufferPtr = unwrapPointer(createPointer({
+            paramsType: [DataType.U8Array],
+            paramsValue: [timestampBuffer],
+        }))[0];
+        const errorCodePtr = unwrapPointer(createPointer({
+            paramsType: [DataType.U8Array],
+            paramsValue: [new Int32Array(1)],
+        }))[0];
+        this.instance.pullChunk({
+            inletHandle,
+            sampleBufferPtr,
+            timestampBufferPtr,
+            sampleBufferElements,
+            timestampBufferElements,
+            timeoutMs,
+            errorCodePtr,
+        });
+        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: [
+                inletHandle,
+                sampleBufferPtr,
+                timestampBufferPtr,
+                sampleBufferElements,
+                timestampBufferElements,
+                timeoutMs,
+                errorCodePtr,
+            ],
+        }, 'Did not call pullChunk with expected options!');
+    }
+    static async flushInletCallsBinding() {
+        const { inletHandle } = this.createRandomInlet();
+        this.instance.flushInlet({ inletHandle });
+        assert.isEqualDeep(this.flushInletParams, [inletHandle], 'Should have called flushInlet with expected params!');
+    }
+    static async destroyInletCallsBinding() {
+        const { inletHandle } = this.createRandomInlet();
+        this.instance.destroyInlet({ inletHandle });
+        assert.isEqualDeep(this.destroyInletParams, [inletHandle], 'Should have called destroyInlet with expected params!');
+    }
+    static createRandomInfoHandle() {
+        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 outletHandle = this.instance.createOutlet(options);
+        return { options, outletHandle };
+    }
+    static createRandomOutletOptions() {
+        const infoHandle = this.createRandomInfoHandle();
+        return {
+            infoHandle,
+            chunkSize: randomInt(10),
+            maxBufferedMs: randomInt(10),
+        };
+    }
+    static createRandomInlet() {
+        const options = this.createRandomInletOptions();
+        const inletHandle = this.instance.createInlet(options);
+        return { options, inletHandle };
+    }
+    static createRandomInletOptions() {
+        const infoHandle = this.createRandomInfoHandle();
+        return {
+            infoHandle,
+            maxBufferedMs: randomInt(10),
+        };
+    }
+    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 resultsBufferRef = createPointer({
+        paramsType: [DataType.U8Array],
+        paramsValue: [this.resultsBuffer],
+    });
+    static resultsBufferPtr = unwrapPointer(this.resultsBufferRef)[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.fakeInfoHandle;
+            },
+            lsl_destroy_streaminfo: (params) => {
+                this.destroyStreamInfoParams = params;
+            },
+            lsl_create_outlet: (params) => {
+                this.createOutletParams = params;
+                return this.fakeOutletHandle;
+            },
+            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.fakeInletHandle;
+            },
+            lsl_inlet_flush: (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_channel_count: (info) => {
+                this.getChannelCountParams = [info];
+                return this.channelCount;
+            },
+            lsl_get_desc: (info) => {
+                this.getDescriptionParams = [info];
+                return this.fakeDescHandle;
+            },
+            lsl_append_child: (params) => {
+                this.appendChildParams.push(params);
+                if (this.appendChildHitCount === 0) {
+                    this.appendChildHitCount++;
+                    return this.fakeChildHandle;
+                }
+                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, "destroyStreamInfoPasses", 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, "getsChannelCountFromInfoHandle", null);
+__decorate([
+    test()
+], LiblslAdapterTest, "openStreamCallsBinding", null);
+__decorate([
+    test()
+], LiblslAdapterTest, "closeStreamCallsBinding", 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