@neurodevs/node-lsl 2.0.1 → 3.1.0

package/src/LslOutlet.ts

@@ -1,16 +1,17 @@
 import { SchemaError, assertOptions } from '@sprucelabs/schema'
-import LiblslImpl, { LslBindingsStreamInfo, LslSample } from './Liblsl'
+import LiblslImpl, { BoundOutlet, BoundStreamInfo, LslSample } from './Liblsl'
 
 export default class LslOutletImpl implements LslOutlet {
 	private outletOptions: LslOutletOptions
 	public static Class?: new (options: LslOutletOptions) => LslOutlet
-	private streamInfo: LslBindingsStreamInfo
+	private streamInfo: BoundStreamInfo
+	private outlet: BoundOutlet
 
 	protected constructor(options: LslOutletOptions) {
 		const { sampleRate, channelFormat } = assertOptions(options, [
 			'name',
 			'type',
-			'channelLabels',
+			'channelNames',
 			'sampleRate',
 			'channelFormat',
 			'sourceId',
@@ -22,10 +23,12 @@ export default class LslOutletImpl implements LslOutlet {
 
 		this.outletOptions = options
 
-		const { chunkSize, maxBuffered, channelLabels, ...streamInfoOptions } = this
+		const { chunkSize, maxBuffered, channelNames, ...streamInfoOptions } = this
 			.outletOptions as any
 
-		this.assertValidChannelCount(channelLabels.length)
+		const channelCount = channelNames.length
+
+		this.assertValidChannelCount(channelCount)
 		this.assertValidSampleRate(sampleRate)
 		this.assertValidChannelFormat(channelFormat)
 		this.assertValidChunkSize(chunkSize)
@@ -36,24 +39,38 @@ export default class LslOutletImpl implements LslOutlet {
 
 		this.streamInfo = this.lsl.createStreamInfo({
 			...streamInfoOptions,
-			channelCount: channelLabels.length,
-			channelFormat: CHANNEL_FORMATS.indexOf(this.outletOptions.channelFormat),
+			channelCount,
+			channelFormat: this.lookupChannelFormat(channelFormat),
 		})
 
-		this.lsl.appendChannelsToStreamInfo(
-			this.streamInfo,
-			channelLabels.map((label: string) => ({
+		this.lsl.appendChannelsToStreamInfo({
+			info: this.streamInfo,
+			channels: channelNames.map((label: string) => ({
 				label,
 				unit: this.outletOptions.unit,
 				type: this.outletOptions.type,
-			}))
-		)
+			})),
+		})
+
+		this.outlet = this.lsl.createOutlet({
+			info: this.streamInfo,
+			chunkSize: this.outletOptions.chunkSize,
+			maxBuffered: this.outletOptions.maxBuffered,
+		})
 	}
 
 	public static Outlet(options: LslOutletOptions) {
 		return new (this.Class ?? this)(options)
 	}
 
+	public pushSample(sample: LslSample) {
+		this.lsl.pushSample({ outlet: this.outlet, sample })
+	}
+
+	private lookupChannelFormat(channelFormat: ChannelFormat): number {
+		return CHANNEL_FORMATS.indexOf(channelFormat)
+	}
+
 	private assertValidMaxBufferred(maxBuffered: number) {
 		if (!this.isPositiveIntegerOrZero(maxBuffered)) {
 			throw new SchemaError({
@@ -100,8 +117,8 @@ export default class LslOutletImpl implements LslOutlet {
 		if (!this.isPositiveInteger(channelCount)) {
 			throw new SchemaError({
 				code: 'INVALID_PARAMETERS',
-				parameters: ['channelLabels'],
-				friendlyMessage: 'channelLabels must have 1 or more labels.',
+				parameters: ['channelNames'],
+				friendlyMessage: 'channelNames must have 1 or more labels.',
 			})
 		}
 	}
@@ -121,17 +138,6 @@ export default class LslOutletImpl implements LslOutlet {
 	private get lsl() {
 		return LiblslImpl.getInstance()
 	}
-
-	public pushSample(sample: LslSample) {
-		this.lsl.pushSample(
-			this.lsl.createOutlet({
-				info: this.streamInfo,
-				chunkSize: this.outletOptions.chunkSize,
-				maxBuffered: this.outletOptions.maxBuffered,
-			}),
-			sample
-		)
-	}
 }
 
 const CHANNEL_FORMATS = [
@@ -146,10 +152,15 @@ const CHANNEL_FORMATS = [
 ] as const
 
 export type ChannelFormat = (typeof CHANNEL_FORMATS)[number]
+
+export interface LslOutlet {
+	pushSample(sample: LslSample): void
+}
+
 export interface LslOutletOptions {
 	name: string
 	type: string
-	channelLabels: string[]
+	channelNames: string[]
 	sampleRate: number
 	channelFormat: ChannelFormat
 	sourceId: string
@@ -158,7 +169,3 @@ export interface LslOutletOptions {
 	chunkSize: number
 	maxBuffered: number
 }
-
-export interface LslOutlet {
-	pushSample(sample: LslSample): void
-}

package/src/__tests__/behavioral/LslOutlet.test.ts

@@ -9,10 +9,11 @@ import LiblslImpl, {
 	CreateOutletOptions,
 	CreateStreamInfoOptions,
 	Liblsl,
-	LslBindingsOutlet,
-	LslBindingsStreamInfo,
-	LslChannel,
+	BoundOutlet,
+	BoundStreamInfo,
 	LslSample,
+	AppendChannelsToStreamInfoOptions,
+	PushSampleOptions,
 } from '../../Liblsl'
 import LslOutlet, { ChannelFormat, LslOutletOptions } from '../../LslOutlet'
 
@@ -28,7 +29,7 @@ export const CHANNEL_FORMATS = [
 ] as const
 
 export default class LslOutletTest extends AbstractSpruceTest {
-	private static spyLsl: SpyLiblsl
+	private static spyLiblsl: SpyLiblsl
 	private static randomOutletOptions: LslOutletOptions
 	private static channelIdx: number
 
@@ -39,7 +40,7 @@ export default class LslOutletTest extends AbstractSpruceTest {
 		this.randomOutletOptions = {
 			name: generateId(),
 			type: generateId(),
-			channelLabels: new Array(randomInt(1, 10)).fill(generateId()),
+			channelNames: new Array(randomInt(1, 10)).fill(generateId()),
 			sampleRate: Math.random() * 10,
 			channelFormat: CHANNEL_FORMATS[this.channelIdx],
 			sourceId: generateId(),
@@ -49,19 +50,19 @@ export default class LslOutletTest extends AbstractSpruceTest {
 			maxBuffered: randomInt(0, 10),
 		}
 
-		this.spyLsl = new SpyLiblsl()
-		LiblslImpl.setInstance(this.spyLsl)
+		this.spyLiblsl = new SpyLiblsl()
+		LiblslImpl.setInstance(this.spyLiblsl)
 	}
 
 	@test()
-	protected static async throwsWhenMissingRequiredParameters() {
+	protected static async throwsWhenMissingRequiredParams() {
 		//@ts-ignore
 		const err = assert.doesThrow(() => new LslOutlet())
 		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
 			parameters: [
 				'name',
 				'type',
-				'channelLabels',
+				'channelNames',
 				'sampleRate',
 				'channelFormat',
 				'sourceId',
@@ -74,13 +75,8 @@ export default class LslOutletTest extends AbstractSpruceTest {
 	}
 
 	@test()
-	protected static async canCreateWithRequiredParams() {
-		this.Outlet()
-	}
-
-	@test()
-	protected static async throwsWithInvalidChannelCount() {
-		this.assertThrowsInvalidChannelLabels(0)
+	protected static async throwsWithInvalidChannelNames() {
+		this.assertThrowsInvalidChannelNames(0)
 	}
 
 	@test()
@@ -99,15 +95,7 @@ export default class LslOutletTest extends AbstractSpruceTest {
 	}
 
 	@test()
-	protected static async supportsAllKnownChannelFormats() {
-		const valid = CHANNEL_FORMATS
-		for (const format of valid) {
-			this.Outlet({ channelFormat: format as ChannelFormat })
-		}
-	}
-
-	@test()
-	protected static async throwWithInvalidChunkSize() {
+	protected static async throwsWithInvalidChunkSize() {
 		this.Outlet({ chunkSize: 0 })
 		this.assertThrowsInvalidChunkSize(-1)
 		this.assertThrowsInvalidChunkSize(-1.5)
@@ -122,56 +110,67 @@ export default class LslOutletTest extends AbstractSpruceTest {
 		this.assertThrowsInvalidMaxBuffered(1.5)
 	}
 
-	@test('pushing sample sends to lsl 1', [1])
-	@test('pushing sample sends to lsl 2', [1, 2])
-	protected static async pushingSampleSendsToLsl(sample: LslSample) {
+	@test()
+	protected static async supportsAllKnownChannelFormats() {
+		const valid = CHANNEL_FORMATS
+		for (const format of valid) {
+			this.Outlet({ channelFormat: format as ChannelFormat })
+		}
+	}
+
+	@test('pushing [1, 2] sample sends to LSL', [1, 2])
+	@test('pushing [1] sample sends to LSL', [1])
+	protected static async canPushSampleToLsl(sample: LslSample) {
 		this.pushSample(sample)
-		assert.isEqual(this.spyLsl.lastPushedOutlet, this.spyLsl.outlet)
-		assert.isEqualDeep(this.spyLsl.lastPushedSample, sample)
-		assert.isEqualDeep(this.spyLsl.lastOutletOptions, {
-			info: this.spyLsl.streamInfo,
+		assert.isEqual(
+			this.spyLiblsl.lastPushSampleOptions?.outlet,
+			this.spyLiblsl.outlet
+		)
+		assert.isEqualDeep(this.spyLiblsl.lastPushSampleOptions?.sample, sample)
+		assert.isEqualDeep(this.spyLiblsl.lastCreateOutletOptions, {
+			info: this.spyLiblsl.streamInfo,
 			chunkSize: this.randomOutletOptions.chunkSize,
 			maxBuffered: this.randomOutletOptions.maxBuffered,
 		})
 	}
 
 	@test()
-	protected static async constructionPassesCorrectOptionsToCreateStreamInfo() {
+	protected static async constructionCreatesStreamInfo() {
 		this.Outlet()
 
 		const { ...options } = this.randomOutletOptions as any
 
-		options.channelCount = options.channelLabels.length
+		options.channelCount = options.channelNames.length
 
 		delete options.manufacturer
 		delete options.unit
 		delete options.chunkSize
 		delete options.maxBuffered
-		delete options.channelLabels
+		delete options.channelNames
 
-		assert.isEqualDeep(this.spyLsl.lastStreamInfoOptions, {
+		assert.isEqualDeep(this.spyLiblsl.lastCreateStreamInfoOptions, {
 			...options,
 			channelFormat: this.channelIdx,
 		})
 	}
 
 	@test()
-	protected static async canOverrideClasInstantiatedInFactory() {
+	protected static async canOverrideClassInstantiatedInFactory() {
 		LslOutlet.Class = CheckingOutlet
 		const instance = this.Outlet()
 		assert.isInstanceOf(instance, CheckingOutlet)
 	}
 
-	@test('can add one label', [generateId()])
-	@test('can add two labels', [generateId(), generateId()])
+	@test('can add one label to channels', [generateId()])
+	@test('can add two labels to channels', [generateId(), generateId()])
 	protected static async appendsChannelsBasedOnCount(labels: string[]) {
 		const type = generateId()
 		const unit = generateId()
 
-		this.Outlet({ channelLabels: labels, type, unit })
+		this.Outlet({ channelNames: labels, type, unit })
 
-		assert.isEqualDeep(this.spyLsl.lastAppendChannelsToStreamInfo, {
-			info: this.spyLsl.streamInfo,
+		assert.isEqualDeep(this.spyLiblsl.lastAppendChannelsToStreamInfoOptions, {
+			info: this.spyLiblsl.streamInfo,
 			channels: labels.map((label) => ({
 				label,
 				type,
@@ -180,6 +179,16 @@ export default class LslOutletTest extends AbstractSpruceTest {
 		})
 	}
 
+	@test()
+	protected static async pushSampleShouldNotCreateMultipleOutlets() {
+		const outlet = this.Outlet()
+		outlet.pushSample([1])
+		outlet.pushSample([2])
+		outlet.pushSample([3])
+
+		assert.isEqual(this.spyLiblsl.createStreamInfoHitCount, 1)
+	}
+
 	private static pushSample(sample: LslSample) {
 		const outlet = this.Outlet()
 		outlet.pushSample(sample)
@@ -197,10 +206,10 @@ export default class LslOutletTest extends AbstractSpruceTest {
 		this.assertDoesThrowInvalidParameters({ sampleRate }, ['sampleRate'])
 	}
 
-	private static assertThrowsInvalidChannelLabels(count: number) {
+	private static assertThrowsInvalidChannelNames(count: number) {
 		this.assertDoesThrowInvalidParameters(
-			{ channelLabels: new Array(count).fill(generateId()) },
-			['channelLabels']
+			{ channelNames: new Array(count).fill(generateId()) },
+			['channelNames']
 		)
 	}
 
@@ -223,40 +232,34 @@ export default class LslOutletTest extends AbstractSpruceTest {
 }
 
 class SpyLiblsl implements Liblsl {
-	public lastPushedOutlet?: LslBindingsOutlet
-	public lastPushedSample?: LslSample
-	public lastOutletOptions?: CreateOutletOptions
-	public lastStreamInfoOptions?: CreateStreamInfoOptions
-	public outlet: LslBindingsOutlet = {} as LslBindingsOutlet
-	public streamInfo: LslBindingsStreamInfo = {} as LslBindingsStreamInfo
-	public lastAppendChannelsToStreamInfo?: {
-		info: LslBindingsStreamInfo
-		channels: LslChannel[]
-	}
-
-	public createStreamInfo(
-		options: CreateStreamInfoOptions
-	): LslBindingsStreamInfo {
-		this.lastStreamInfoOptions = options
+	public lastCreateStreamInfoOptions?: CreateStreamInfoOptions
+	public lastAppendChannelsToStreamInfoOptions?: AppendChannelsToStreamInfoOptions
+	public lastCreateOutletOptions?: CreateOutletOptions
+	public lastPushSampleOptions?: PushSampleOptions
+
+	public outlet: BoundOutlet = {} as BoundOutlet
+	public streamInfo: BoundStreamInfo = {} as BoundStreamInfo
+	public createStreamInfoHitCount = 0
+
+	public createStreamInfo(options: CreateStreamInfoOptions): BoundStreamInfo {
+		this.createStreamInfoHitCount++
+		this.lastCreateStreamInfoOptions = options
 		return this.streamInfo
 	}
+
 	public appendChannelsToStreamInfo(
-		info: LslBindingsStreamInfo,
-		channels: LslChannel[]
+		options: AppendChannelsToStreamInfoOptions
 	): void {
-		this.lastAppendChannelsToStreamInfo = {
-			info,
-			channels,
-		}
+		this.lastAppendChannelsToStreamInfoOptions = options
 	}
 
-	public createOutlet(options: CreateOutletOptions): LslBindingsOutlet {
-		this.lastOutletOptions = options
+	public createOutlet(options: CreateOutletOptions): BoundOutlet {
+		this.lastCreateOutletOptions = options
 		return this.outlet
 	}
-	public pushSample(outlet: LslBindingsOutlet, sample: LslSample): void {
-		this.lastPushedOutlet = outlet
-		this.lastPushedSample = sample
+
+	public pushSample(options: PushSampleOptions): void {
+		this.lastPushSampleOptions = options
 	}
 }
 

package/src/__tests__/implementation/Liblsl.test.ts

@@ -8,16 +8,17 @@ import AbstractSpruceTest, {
 import ArrayType from 'ref-array-napi'
 import ref from 'ref-napi'
 import LiblslImpl, {
-	CreateStreamInfoOptions,
-	LiblslBindings,
 	Liblsl,
-	LslSample,
+	LiblslBindings,
+	CreateStreamInfoOptions,
+	AppendChannelsToStreamInfoOptions,
 	CreateOutletOptions,
-	LslBindingsOutlet,
-	LslBindingsStreamInfo,
+	PushSampleOptions,
 	LslChannel,
-	LslBindingsDesc,
-	LslBindingsChild,
+	BoundOutlet,
+	BoundStreamInfo,
+	BoundDesc,
+	BoundChild,
 } from '../../Liblsl'
 
 export default class LiblslTest extends AbstractSpruceTest {
@@ -25,10 +26,10 @@ export default class LiblslTest extends AbstractSpruceTest {
 	private static libraryPath?: string
 	private static libraryOptions?: Record<string, any>
 	private static fakeBindings: LiblslBindings
-	private static fakeStreamInfo: LslBindingsStreamInfo
-	private static fakeOutlet: LslBindingsOutlet
-	private static fakeDesc: LslBindingsDesc
-	private static fakeChildNamedChannels: LslBindingsChild
+	private static fakeStreamInfo: BoundStreamInfo
+	private static fakeOutlet: BoundOutlet
+	private static fakeDesc: BoundDesc
+	private static fakeChildNamedChannels: BoundChild
 	private static createStreamInfoParams?: any[]
 	private static appendChildParams: any[] = []
 	private static createOutletParams?: any[]
@@ -36,8 +37,8 @@ export default class LiblslTest extends AbstractSpruceTest {
 	private static appendChildValueParams: any[]
 	private static localClock: number
 	private static shouldThrowWhenCreatingBindings: boolean
-	private static getDescriptionParams?: [LslBindingsStreamInfo]
-	private static fakeChildNamedChannel: LslBindingsChild
+	private static getDescriptionParams?: [BoundStreamInfo]
+	private static fakeChildNamedChannel: BoundChild
 	private static appendChildHitCount: number
 
 	protected static async beforeEach(): Promise<void> {
@@ -79,7 +80,7 @@ export default class LiblslTest extends AbstractSpruceTest {
 				return 0
 			},
 			lsl_local_clock: () => this.localClock,
-			lsl_get_desc: (info: LslBindingsStreamInfo) => {
+			lsl_get_desc: (info: BoundStreamInfo) => {
 				this.getDescriptionParams = [info]
 				return this.fakeDesc
 			},
@@ -108,12 +109,12 @@ export default class LiblslTest extends AbstractSpruceTest {
 			},
 		}
 
-		LiblslImpl.reset()
+		LiblslImpl.resetInstance()
 		this.lsl = LiblslImpl.getInstance()
 	}
 
 	@test()
-	protected static async throwsIfNoEnvSet() {
+	protected static async throwsWithMissingEnv() {
 		delete process.env.LIBLSL_PATH
 		const err = assert.doesThrow(() => new LiblslImpl())
 		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
@@ -122,7 +123,7 @@ export default class LiblslTest extends AbstractSpruceTest {
 	}
 
 	@test()
-	protected static async throwsHelpfulErrorWhenBindingsFailToLoad() {
+	protected static async throwsWhenBindingsFailToLoad() {
 		this.shouldThrowWhenCreatingBindings = true
 		const err = assert.doesThrow(() => new LiblslImpl())
 		errorAssert.assertError(err, 'FAILED_TO_LOAD_LIBLSL', {
@@ -130,6 +131,49 @@ export default class LiblslTest extends AbstractSpruceTest {
 		})
 	}
 
+	@test()
+	protected static throwsWhenCreateStreamInfoIsMissingRequiredParams() {
+		//@ts-ignore
+		const err = assert.doesThrow(() => this.lsl.createStreamInfo())
+		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+			parameters: [
+				'name',
+				'type',
+				'channelCount',
+				'sampleRate',
+				'channelFormat',
+				'sourceId',
+			],
+		})
+	}
+
+	@test()
+	protected static async throwsWhenAppendChannelsIsMissingRequiredParams() {
+		//@ts-ignore
+		const err = assert.doesThrow(() => this.lsl.appendChannelsToStreamInfo({}))
+		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+			parameters: ['info', 'channels'],
+		})
+	}
+
+	@test()
+	protected static async throwsWhenCreateOutletIsMissingRequiredParams() {
+		//@ts-ignore
+		const err = assert.doesThrow(() => this.lsl.createOutlet({}))
+		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+			parameters: ['info', 'chunkSize', 'maxBuffered'],
+		})
+	}
+
+	@test()
+	protected static async throwsWhenPushSampleIsMissingRequiredParams() {
+		//@ts-ignore
+		const err = assert.doesThrow(() => this.lsl.pushSample())
+		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+			parameters: ['outlet', 'sample'],
+		})
+	}
+
 	@test()
 	protected static async worksAsASingleton() {
 		const liblsl = LiblslImpl.getInstance()
@@ -172,23 +216,7 @@ export default class LiblslTest extends AbstractSpruceTest {
 	}
 
 	@test()
-	protected static createStreamInfoThrowsWithMissingRequiredParams() {
-		//@ts-ignore
-		const err = assert.doesThrow(() => this.lsl.createStreamInfo())
-		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-			parameters: [
-				'name',
-				'type',
-				'channelCount',
-				'sampleRate',
-				'channelFormat',
-				'sourceId',
-			],
-		})
-	}
-
-	@test()
-	protected static async canGetStreamInfoWithRequiredParams() {
+	protected static async canCreateStreamInfoWithRequiredParams() {
 		const options = this.generateRandomCreateStreamInfoOptions()
 		const actual = this.lsl.createStreamInfo(options)
 
@@ -196,15 +224,6 @@ export default class LiblslTest extends AbstractSpruceTest {
 		assert.isEqualDeep(this.createStreamInfoParams, Object.values(options))
 	}
 
-	@test()
-	protected static async createOutletThrowsWhenMissingRequiredParams() {
-		//@ts-ignore
-		const err = assert.doesThrow(() => this.lsl.createOutlet({}))
-		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-			parameters: ['info', 'chunkSize', 'maxBuffered'],
-		})
-	}
-
 	@test()
 	protected static async canCreateOutletWithRequiredParams() {
 		const info = this.createRandomStreamInfo()
@@ -219,37 +238,27 @@ export default class LiblslTest extends AbstractSpruceTest {
 	}
 
 	@test()
-	protected static async pushSampleThrowsWhenMissingRequiredParams() {
-		//@ts-ignore
-		const err = assert.doesThrow(() => this.lsl.pushSample())
-		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-			parameters: ['outlet', 'sample'],
-		})
-	}
-
-	@test()
-	protected static async pushSampleCallsBindings() {
+	protected static async canPushSampleWithRequiredParams() {
 		const expected = [1, 2, 3]
-		this.lsl.pushSample(this.fakeOutlet, expected)
+		const options = {
+			outlet: this.fakeOutlet,
+			sample: expected,
+		}
+		this.lsl.pushSample(options)
 		assert.isEqual(this.pushSampleParams?.[0], this.fakeOutlet)
 		assert.isEqual(this.pushSampleParams?.[1], expected)
 		assert.isEqual(this.pushSampleParams?.[2], this.localClock)
 	}
 
-	@test()
-	protected static async appendChannelsThrowsWithMissingParams() {
-		//@ts-ignore
-		const err = assert.doesThrow(() => this.lsl.appendChannelsToStreamInfo())
-		errorAssert.assertError(err, 'MISSING_PARAMETERS', {
-			parameters: ['info', 'channels'],
-		})
-	}
-
 	@test()
 	protected static async addingSingleChannelGetsDescription() {
 		const info = this.createRandomStreamInfo()
 		const channel: LslChannel = this.generateRandomChannelValues()
-		this.lsl.appendChannelsToStreamInfo(info, [channel])
+
+		this.lsl.appendChannelsToStreamInfo({
+			info,
+			channels: [channel],
+		})
 		assert.isEqual(this.getDescriptionParams?.[0], info)
 
 		assert.isEqual(this.appendChildParams?.[0][0], this.fakeDesc)
@@ -280,7 +289,10 @@ export default class LiblslTest extends AbstractSpruceTest {
 		const channel1 = this.generateRandomChannelValues()
 		const channel2 = this.generateRandomChannelValues()
 
-		this.lsl.appendChannelsToStreamInfo(info, [channel1, channel2])
+		this.lsl.appendChannelsToStreamInfo({
+			info,
+			channels: [channel1, channel2],
+		})
 
 		assert.isEqual(this.appendChildParams?.[2][0], this.fakeChildNamedChannels)
 		assert.isEqual(this.appendChildParams?.[2][1], 'channel')
@@ -290,6 +302,12 @@ export default class LiblslTest extends AbstractSpruceTest {
 		assert.isEqual(this.appendChildValueParams[5][2], channel2.type)
 	}
 
+	private static createRandomStreamInfo() {
+		return this.lsl.createStreamInfo(
+			this.generateRandomCreateStreamInfoOptions()
+		)
+	}
+
 	private static generateRandomChannelValues(): LslChannel {
 		return {
 			label: generateId(),
@@ -298,38 +316,32 @@ export default class LiblslTest extends AbstractSpruceTest {
 		}
 	}
 
-	private static createRandomStreamInfo() {
-		return this.lsl.createStreamInfo(
-			this.generateRandomCreateStreamInfoOptions()
-		)
-	}
-
 	private static generateRandomCreateStreamInfoOptions() {
 		return {
 			name: generateId(),
 			type: generateId(),
-			channelCount: randomInt(10),
-			sampleRate: randomInt(10),
-			channelFormat: randomInt(10),
+			channelCount: randomInt(1, 10),
+			sampleRate: randomInt(100),
+			channelFormat: randomInt(7),
 			sourceId: generateId(),
 		}
 	}
 }
 
 class FakeLiblsl implements Liblsl {
+	public createStreamInfo(_options: CreateStreamInfoOptions): BoundStreamInfo {
+		return {} as BoundStreamInfo
+	}
+
 	public appendChannelsToStreamInfo(
-		_info: LslBindingsStreamInfo,
-		_channels: LslChannel[]
+		_options: AppendChannelsToStreamInfoOptions
 	): void {}
-	public createOutlet(_options: CreateOutletOptions): LslBindingsOutlet {
-		return {} as LslBindingsOutlet
-	}
-	public createStreamInfo(
-		_options: CreateStreamInfoOptions
-	): LslBindingsStreamInfo {
-		return {} as LslBindingsStreamInfo
+
+	public createOutlet(_options: CreateOutletOptions): BoundOutlet {
+		return {} as BoundOutlet
 	}
-	public pushSample(_sample: LslSample): void {}
+
+	public pushSample(_options: PushSampleOptions): void {}
 }
 
 const streamInfo = ref.refType(ref.types.void)