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

46.15

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

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

import type {
  DeviceProps,
  CanvasContextProps,
  PresentationContextProps,
  PresentationContext,
  VertexArray,
  VertexArrayProps,
  BufferProps,
  ShaderProps,
  SamplerProps,
  TextureProps,
  ExternalTexture,
  ExternalTextureProps,
  FramebufferProps,
  RenderPipelineProps,
  ComputePipeline,
  ComputePipelineProps,
  CommandEncoderProps,
  TransformFeedbackProps,
  QuerySetProps
} from '@luma.gl/core';
import {Device, DeviceFeatures} from '@luma.gl/core';
import type {NullCommandBuffer} from './resources/null-command-buffer';

import {NullDeviceInfo} from './null-device-info';
import {NullDeviceLimits} from './null-device-features';
import {NullCanvasContext} from './null-canvas-context';
import {NullBuffer} from './resources/null-buffer';
import {NullFramebuffer} from './resources/null-framebuffer';
import {NullShader} from './resources/null-shader';
import {NullCommandEncoder} from './resources/null-command-encoder';
import {NullSampler} from './resources/null-sampler';
import {NullTexture} from './resources/null-texture';
import {NullRenderPass} from './resources/null-render-pass';
import {NullRenderPipeline} from './resources/null-render-pipeline';
import {NullVertexArray} from './resources/null-vertex-array';
import {NullTransformFeedback} from './resources/null-transform-feedback';
import {NullQuerySet} from './resources/null-query-set';
import {NullFence} from './resources/null-fence';

/** Do-nothing device implementation for testing */
export class NullDevice extends Device {
  static isSupported(): boolean {
    return true;
  }
  readonly type = 'null';
  readonly handle = null;

  readonly preferredColorFormat = 'rgba8unorm';
  readonly preferredDepthFormat = 'depth24plus';

  features: DeviceFeatures = new DeviceFeatures([], this.props._disabledFeatures);
  limits: NullDeviceLimits = new NullDeviceLimits();
  readonly info = NullDeviceInfo;

  readonly canvasContext: NullCanvasContext;
  override commandEncoder: NullCommandEncoder;

  readonly lost: Promise<{reason: 'destroyed'; message: string}>;

  constructor(props: DeviceProps) {
    super({...props, id: props.id || 'null-device'});

    const canvasContextProps = Device._getCanvasContextProps(props);
    this.canvasContext = new NullCanvasContext(this, canvasContextProps);
    this.lost = new Promise(resolve => {});
    this.commandEncoder = new NullCommandEncoder(this, {id: 'null-command-encoder'});
  }

  /**
   * Destroys the context
   * @note Has no effect for null contexts
   */
  destroy(): void {
    this.commandEncoder?.destroy();
  }

  get isLost(): boolean {
    return false;
  }

  // IMPLEMENTATION OF ABSTRACT DEVICE

  createCanvasContext(props: CanvasContextProps): NullCanvasContext {
    return new NullCanvasContext(this, props);
  }

  createPresentationContext(_props?: PresentationContextProps): PresentationContext {
    throw new Error('PresentationContext is not supported on NullDevice');
  }

  createBuffer(props: BufferProps | ArrayBuffer | ArrayBufferView): NullBuffer {
    const newProps = this._normalizeBufferProps(props);
    return new NullBuffer(this, newProps);
  }

  getDefaultRenderPass(): NullRenderPass {
    return new NullRenderPass(this, {});
  }

  createTexture(props: TextureProps): NullTexture {
    return new NullTexture(this, props);
  }

  createExternalTexture(props: ExternalTextureProps): ExternalTexture {
    throw new Error('createExternalTexture() not implemented'); // return new Program(props);
  }

  createSampler(props: SamplerProps): NullSampler {
    return new NullSampler(this, props);
  }

  createShader(props: ShaderProps): NullShader {
    return new NullShader(this, props);
  }

  createFramebuffer(props: FramebufferProps): NullFramebuffer {
    return new NullFramebuffer(this, props);
  }

  createVertexArray(props: VertexArrayProps): VertexArray {
    return new NullVertexArray(this, props);
  }

  createTransformFeedback(props: TransformFeedbackProps): NullTransformFeedback {
    return new NullTransformFeedback(this, props);
  }

  createQuerySet(props: QuerySetProps): NullQuerySet {
    return new NullQuerySet(this, props);
  }

  override createFence(): NullFence {
    return new NullFence(this);
  }

  createRenderPipeline(props: RenderPipelineProps): NullRenderPipeline {
    return new NullRenderPipeline(this, props);
  }

  createComputePipeline(props?: ComputePipelineProps): ComputePipeline {
    throw new Error('ComputePipeline not supported in WebGL');
  }

  override createCommandEncoder(props: CommandEncoderProps = {}): NullCommandEncoder {
    return new NullCommandEncoder(this, props);
  }

  submit(commandBuffer?: NullCommandBuffer): void {
    if (!commandBuffer) {
      commandBuffer = this.commandEncoder.finish({id: `${this.id}-default-command-buffer`});
      this.commandEncoder.destroy();
      this.commandEncoder = this.createCommandEncoder({id: `${this.id}-default-command-encoder`});
    }

    commandBuffer.destroy();
  }

  override setParametersWebGL(parameters: any): void {}

  override getParametersWebGL(parameters: any): any {}

  override withParametersWebGL(parameters: any, func: any): any {
    const {nocatch = true} = parameters;
    let value: any;
    if (nocatch) {
      // Avoid try catch to minimize stack size impact for safe execution paths
      return func();
    }
    // Wrap in a try-catch to ensure that parameters are restored on exceptions
    try {
      value = func();
    } catch {
      // ignore
    }
    return value;
  }

  override _getDeviceSpecificTextureFormatCapabilities(format: any): any {
    return format;
  }
}

1	// luma.gl
2	// SPDX-License-Identifier: MIT
3	// Copyright (c) vis.gl contributors
4
5	import type {
6	DeviceProps,
7	CanvasContextProps,
8	PresentationContextProps,
9	PresentationContext,
10	VertexArray,
11	VertexArrayProps,
12	BufferProps,
13	ShaderProps,
14	SamplerProps,
15	TextureProps,
16	ExternalTexture,
17	ExternalTextureProps,
18	FramebufferProps,
19	RenderPipelineProps,
20	ComputePipeline,
21	ComputePipelineProps,
22	CommandEncoderProps,
23	TransformFeedbackProps,
24	QuerySetProps
25	} from '@luma.gl/core';
26	import {Device, DeviceFeatures} from '@luma.gl/core';
27	import type {NullCommandBuffer} from './resources/null-command-buffer';
28
29	import {NullDeviceInfo} from './null-device-info';
30	import {NullDeviceLimits} from './null-device-features';
31	import {NullCanvasContext} from './null-canvas-context';
32	import {NullBuffer} from './resources/null-buffer';
33	import {NullFramebuffer} from './resources/null-framebuffer';
34	import {NullShader} from './resources/null-shader';
35	import {NullCommandEncoder} from './resources/null-command-encoder';
36	import {NullSampler} from './resources/null-sampler';
37	import {NullTexture} from './resources/null-texture';
38	import {NullRenderPass} from './resources/null-render-pass';
39	import {NullRenderPipeline} from './resources/null-render-pipeline';
40	import {NullVertexArray} from './resources/null-vertex-array';
41	import {NullTransformFeedback} from './resources/null-transform-feedback';
42	import {NullQuerySet} from './resources/null-query-set';
43	import {NullFence} from './resources/null-fence';
44
45	/** Do-nothing device implementation for testing */
46	export class NullDevice extends Device {
47	static isSupported(): boolean {
48	return true;	×
49	}
50	readonly type = 'null';	10✔
51	readonly handle = null;	10✔
52
53	readonly preferredColorFormat = 'rgba8unorm';	10✔
54	readonly preferredDepthFormat = 'depth24plus';	10✔
55
56	features: DeviceFeatures = new DeviceFeatures([], this.props._disabledFeatures);	10✔
57	limits: NullDeviceLimits = new NullDeviceLimits();	10✔
58	readonly info = NullDeviceInfo;	10✔
59
60	readonly canvasContext: NullCanvasContext;
61	override commandEncoder: NullCommandEncoder;
62
63	readonly lost: Promise<{reason: 'destroyed'; message: string}>;
64
65	constructor(props: DeviceProps) {
66	super({...props, id: props.id \|\| 'null-device'});	10✔
67
68	const canvasContextProps = Device._getCanvasContextProps(props);	10✔
69	this.canvasContext = new NullCanvasContext(this, canvasContextProps);	10✔
70	this.lost = new Promise(resolve => {});	10✔
71	this.commandEncoder = new NullCommandEncoder(this, {id: 'null-command-encoder'});	10✔
72	}
73
74	/**
75	* Destroys the context
76	* @note Has no effect for null contexts
77	*/
78	destroy(): void {
79	this.commandEncoder?.destroy();	×
80	}
81
82	get isLost(): boolean {
83	return false;	×
84	}
85
86	// IMPLEMENTATION OF ABSTRACT DEVICE
87
88	createCanvasContext(props: CanvasContextProps): NullCanvasContext {
89	return new NullCanvasContext(this, props);	×
90	}
91
92	createPresentationContext(_props?: PresentationContextProps): PresentationContext {
93	throw new Error('PresentationContext is not supported on NullDevice');	1✔
94	}
95
96	createBuffer(props: BufferProps \| ArrayBuffer \| ArrayBufferView): NullBuffer {
97	const newProps = this._normalizeBufferProps(props);	13✔
98	return new NullBuffer(this, newProps);	13✔
99	}
100
101	getDefaultRenderPass(): NullRenderPass {
102	return new NullRenderPass(this, {});	×
103	}
104
105	createTexture(props: TextureProps): NullTexture {
106	return new NullTexture(this, props);	8✔
107	}
108
109	createExternalTexture(props: ExternalTextureProps): ExternalTexture {
110	throw new Error('createExternalTexture() not implemented'); // return new Program(props);	×
111	}
112
113	createSampler(props: SamplerProps): NullSampler {
114	return new NullSampler(this, props);	×
115	}
116
117	createShader(props: ShaderProps): NullShader {
118	return new NullShader(this, props);	×
119	}
120
121	createFramebuffer(props: FramebufferProps): NullFramebuffer {
122	return new NullFramebuffer(this, props);	×
123	}
124
125	createVertexArray(props: VertexArrayProps): VertexArray {
126	return new NullVertexArray(this, props);	×
127	}
128
129	createTransformFeedback(props: TransformFeedbackProps): NullTransformFeedback {
130	return new NullTransformFeedback(this, props);	×
131	}
132
133	createQuerySet(props: QuerySetProps): NullQuerySet {
134	return new NullQuerySet(this, props);	×
135	}
136
137	override createFence(): NullFence {
138	return new NullFence(this);	1✔
139	}
140
141	createRenderPipeline(props: RenderPipelineProps): NullRenderPipeline {
142	return new NullRenderPipeline(this, props);	×
143	}
144
145	createComputePipeline(props?: ComputePipelineProps): ComputePipeline {
146	throw new Error('ComputePipeline not supported in WebGL');	×
147	}
148
149	override createCommandEncoder(props: CommandEncoderProps = {}): NullCommandEncoder {	1✔
150	return new NullCommandEncoder(this, props);	1✔
151	}
152
153	submit(commandBuffer?: NullCommandBuffer): void {
154	if (!commandBuffer) {	1!
155	commandBuffer = this.commandEncoder.finish({id: `${this.id}-default-command-buffer`});	×
156	this.commandEncoder.destroy();	×
157	this.commandEncoder = this.createCommandEncoder({id: `${this.id}-default-command-encoder`});	×
158	}
159
160	commandBuffer.destroy();	1✔
161	}
162
163	override setParametersWebGL(parameters: any): void {}
164
165	override getParametersWebGL(parameters: any): any {}
166
167	override withParametersWebGL(parameters: any, func: any): any {
168	const {nocatch = true} = parameters;	×
169	let value: any;
170	if (nocatch) {	×
171	// Avoid try catch to minimize stack size impact for safe execution paths
172	return func();	×
173	}
174	// Wrap in a try-catch to ensure that parameters are restored on exceptions
175	try {	×
176	value = func();	×
177	} catch {
178	// ignore
179	}
180	return value;	×
181	}
182
183	override _getDeviceSpecificTextureFormatCapabilities(format: any): any {
184	return format;	×
185	}
186	}

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