23357510199

Committed 20 Mar 2026 06:40PM UTC coverage: 58.158% (+5.9%) from 52.213%

Build # 23357510199

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Run tests on src instead of dist (#2555)

Coverage Stats

3021 of 6029 branches covered (50.11%)

Branch coverage included in aggregate %.

7102 of 11377 relevant lines covered (62.42%)

243.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.0

/modules/test-utils/src/null-device/resources/null-buffer.ts

// luma.gl
// SPDX-License-Identifier: MIT
// Copyright (c) vis.gl contributors

import {Buffer, type BufferProps, type BufferMapCallback} from '@luma.gl/core';
import {type NullDevice} from '../null-device';

export class NullBuffer extends Buffer {
  device: NullDevice;
  readonly handle: 'null' | null = 'null';

  byteLength: number;
  private _storage: ArrayBuffer;

  constructor(device: NullDevice, props: BufferProps = {}) {
    super(device, props);
    this.device = device;

    const byteOffset = props.byteOffset || 0;
    const byteLength = props.byteLength ?? (props.data ? props.data.byteLength + byteOffset : 0);

    this.byteLength = byteLength;
    this._storage = new ArrayBuffer(byteLength);

    // If initial data is provided, copy it in
    if (props.data) {
      this.write(props.data, byteOffset);
    }

    this.trackAllocatedMemory(byteLength);
  }

  override destroy(): void {
    if (!this.destroyed) {
      super.destroy();
      this.trackDeallocatedMemory();
      // @ts-expect-error
      this.handle = null;
      // Clear internal storage
      this._storage = new ArrayBuffer(0);
    }
  }

  write(data: ArrayBufferLike | ArrayBufferView, byteOffset: number = 0): void {
    const source = ArrayBuffer.isView(data)
      ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
      : new Uint8Array(data);
    const target = new Uint8Array(this._storage, byteOffset, source.byteLength);

    if (byteOffset + source.byteLength > this.byteLength) {
      throw new RangeError(`NullBuffer.write(): write would overflow buffer`);
    }

    target.set(source);
    this._setDebugData(data, byteOffset, source.byteLength);
  }

  async mapAndWriteAsync(
    callback: BufferMapCallback<void>,
    byteOffset = 0,
    byteLength = this.byteLength - byteOffset
  ): Promise<void> {
    const view = new Uint8Array(this._storage, byteOffset, byteLength);
    const tempBuffer = new Uint8Array(view.length); // safe scratch copy
    callback(tempBuffer.buffer, 'copied');
    view.set(tempBuffer);
    this._setDebugData(view, byteOffset, byteLength);
  }

  async readAsync(byteOffset = 0, byteLength?: number): Promise<Uint8Array> {
    byteLength = byteLength ?? this.byteLength - byteOffset;

    if (byteOffset + byteLength > this.byteLength) {
      throw new RangeError(`NullBuffer.readAsync(): read would overflow buffer`);
    }

    const view = new Uint8Array(this._storage, byteOffset, byteLength);
    return new Uint8Array(view); // return a copy
  }

  async mapAndReadAsync<T>(
    callback: BufferMapCallback<T>,
    byteOffset = 0,
    byteLength = this.byteLength - byteOffset
  ): Promise<T> {
    const view = new Uint8Array(this._storage, byteOffset, byteLength);
    const copy = new Uint8Array(view); // copy to protect memory
    return callback(copy.buffer, 'copied');
  }

  readSyncWebGL(): Uint8Array {
    throw new Error('NullBuffer.readSyncWebGL() not implemented');
  }
}

1	// luma.gl
2	// SPDX-License-Identifier: MIT
3	// Copyright (c) vis.gl contributors
4
5	import {Buffer, type BufferProps, type BufferMapCallback} from '@luma.gl/core';
6	import {type NullDevice} from '../null-device';
7
8	export class NullBuffer extends Buffer {
9	device: NullDevice;
10	readonly handle: 'null' \| null = 'null';	13✔
11
12	byteLength: number;
13	private _storage: ArrayBuffer;
14
15	constructor(device: NullDevice, props: BufferProps = {}) {	13✔
16	super(device, props);	13✔
17	this.device = device;	13✔
18
19	const byteOffset = props.byteOffset \|\| 0;	13✔
20	const byteLength = props.byteLength ?? (props.data ? props.data.byteLength + byteOffset : 0);	13✔
21
22	this.byteLength = byteLength;	13✔
23	this._storage = new ArrayBuffer(byteLength);	13✔
24
25	// If initial data is provided, copy it in
26	if (props.data) {	13✔
27	this.write(props.data, byteOffset);	7✔
28	}
29
30	this.trackAllocatedMemory(byteLength);	13✔
31	}
32
33	override destroy(): void {
34	if (!this.destroyed) {	12✔
35	super.destroy();	11✔
36	this.trackDeallocatedMemory();	11✔
37	// @ts-expect-error
38	this.handle = null;	11✔
39	// Clear internal storage
40	this._storage = new ArrayBuffer(0);	11✔
41	}
42	}
43
44	write(data: ArrayBufferLike \| ArrayBufferView, byteOffset: number = 0): void {	8✔
45	const source = ArrayBuffer.isView(data)	8!
46	? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
47	: new Uint8Array(data);
48	const target = new Uint8Array(this._storage, byteOffset, source.byteLength);	8✔
49
50	if (byteOffset + source.byteLength > this.byteLength) {	8!
51	throw new RangeError(`NullBuffer.write(): write would overflow buffer`);	×
52	}
53
54	target.set(source);	8✔
55	this._setDebugData(data, byteOffset, source.byteLength);	8✔
56	}
57
58	async mapAndWriteAsync(
59	callback: BufferMapCallback<void>,
60	byteOffset = 0,	2✔
61	byteLength = this.byteLength - byteOffset	2✔
62	): Promise<void> {
63	const view = new Uint8Array(this._storage, byteOffset, byteLength);	2✔
64	const tempBuffer = new Uint8Array(view.length); // safe scratch copy	2✔
65	callback(tempBuffer.buffer, 'copied');	2✔
66	view.set(tempBuffer);	2✔
67	this._setDebugData(view, byteOffset, byteLength);	2✔
68	}
69
70	async readAsync(byteOffset = 0, byteLength?: number): Promise<Uint8Array> {	12✔
71	byteLength = byteLength ?? this.byteLength - byteOffset;	12✔
72
73	if (byteOffset + byteLength > this.byteLength) {	12!
74	throw new RangeError(`NullBuffer.readAsync(): read would overflow buffer`);	×
75	}
76
77	const view = new Uint8Array(this._storage, byteOffset, byteLength);	12✔
78	return new Uint8Array(view); // return a copy	12✔
79	}
80
81	async mapAndReadAsync<T>(
82	callback: BufferMapCallback<T>,
83	byteOffset = 0,	2✔
84	byteLength = this.byteLength - byteOffset	2✔
85	): Promise<T> {
86	const view = new Uint8Array(this._storage, byteOffset, byteLength);	2✔
87	const copy = new Uint8Array(view); // copy to protect memory	2✔
88	return callback(copy.buffer, 'copied');	2✔
89	}
90
91	readSyncWebGL(): Uint8Array {
92	throw new Error('NullBuffer.readSyncWebGL() not implemented');	×
93	}
94	}

visgl / luma.gl / 23357510199

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous