7103756207

Committed 05 Dec 2023 04:35PM UTC coverage: 76.781% (+0.5%) from 76.294%

Build # 7103756207

Build Type

Pull #1859

github

Committed by

web-flow

Commit Message

Merge 036006b59 into 38b58964a

Pull Request Pull Request #1859: Fix `babel-plugin-inline-webgl-constants`

Run Details

1862 of 2482 branches covered (0.0%)

Branch coverage included in aggregate %.

27 of 42 new or added lines in 4 files covered. (64.29%)

133 existing lines in 4 files now uncovered.

35125 of 45690 relevant lines covered (76.88%)

43.22 hits per line

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

85.71

/modules/core-tests/test/adapter/resources/buffer.spec.ts

// luma.gl, MIT license
// Copyright (c) vis.gl contributors

import {Buffer} from '@luma.gl/core';
import {GL} from '@luma.gl/constants';
import test from 'tape-promise/tape';

import {getWebGLTestDevices} from '@luma.gl/test-utils';

test('Buffer#constructor/delete', t => {
  for (const device of getWebGLTestDevices()) {
    const buffer = device.createBuffer({usage: Buffer.VERTEX});
    t.ok(buffer.handle, `${device.info.type} Buffer construction successful`);

    buffer.destroy();
    t.ok(!buffer.handle, `${device.info.type} Buffer.destroy() successful`);

    buffer.destroy();
    t.ok(!buffer.handle, `${device.info.type} repeated Buffer.destroy() successful`);
  }
  t.end();
});

test('Buffer#constructor offset and size', t => {
  const data = new Float32Array([1, 2, 3]);

  for (const device of getWebGLTestDevices()) {
    let buffer = device.createBuffer({data, byteOffset: 8});
    let expectedData = new Float32Array([0, 0, 1, 2, 3]);
    t.equal(
      buffer.byteLength,
      expectedData.byteLength,
      `${device.info.type} Buffer byteLength set properly`
    );

    if (device.isWebGL2) {
      const receivedData = buffer.getData();
      t.deepEqual(
        receivedData,
        expectedData,
        `${device.info.type} Buffer constructor offsets data`
      );
    }

    buffer = device.createBuffer({data, byteLength: data.byteLength + 12});
    expectedData = new Float32Array([1, 2, 3, 0, 0, 0]);
    t.equal(
      buffer.byteLength,
      expectedData.byteLength,
      `${device.info.type} Buffer byteLength set properly`
    );
    if (device.isWebGL2) {
      const receivedData = buffer.getData();
      t.deepEqual(
        receivedData,
        expectedData,
        `${device.info.type} Buffer constructor sets buffer data`
      );
    }

    buffer = device.createBuffer({data, byteOffset: 8, byteLength: data.byteLength + 12});
    expectedData = new Float32Array([0, 0, 1, 2, 3, 0]);
    t.equal(
      buffer.byteLength,
      expectedData.byteLength,
      `${device.info.type} Buffer byteLength set properly`
    );

    if (device.isWebGL2) {
      const receivedData = buffer.getData();
      t.deepEqual(
        receivedData,
        expectedData,
        `${device.info.type} Buffer constructor sets buffer byteLength and offsets data`
      );
    }
  }
  t.end();
});

test('Buffer#bind/unbind', t => {
  for (const device of getWebGLTestDevices()) {
    const buffer = device.createBuffer({usage: Buffer.VERTEX});
    device.gl.bindBuffer(buffer.glTarget, buffer.handle);
    t.ok(buffer instanceof Buffer, `${device.info.type} Buffer bind/unbind successful`);
    device.gl.bindBuffer(buffer.glTarget, null);
    buffer.destroy();
  }
  t.end();
});

test('Buffer#construction', t => {
  for (const device of getWebGLTestDevices()) {
    let buffer;

    buffer = device.createBuffer({usage: Buffer.VERTEX, data: new Float32Array([1, 2, 3])});
    t.ok(
      buffer.glTarget === GL.ARRAY_BUFFER,
      `${device.info.type} Buffer(ARRAY_BUFFER) successful`
    );
    buffer.destroy();

    // TODO - buffer could check for integer ELEMENT_ARRAY_BUFFER types
    buffer = device.createBuffer({usage: Buffer.INDEX, data: new Float32Array([1, 2, 3])});
    t.ok(
      buffer.glTarget === GL.ELEMENT_ARRAY_BUFFER,
      `${device.info.type} Buffer(ELEMENT_ARRAY_BUFFER) successful`
    );

    buffer.destroy();
  }

  t.end();
});

test('Buffer#write', t => {
  const data = new Float32Array([1, 2, 3]);
  for (const device of getWebGLTestDevices()) {
    const buffer = device.createBuffer({usage: Buffer.VERTEX, byteLength: 12});
    buffer.write(data);
    if (device.isWebGL2) {
      t.deepEqual(
        buffer.getData(),
        data,
        `${device.info.type} Buffer.subData(ARRAY_BUFFER) stores correct bytes`
      );
    } else {
      t.ok(buffer instanceof Buffer, `${device.info.type} Buffer.subData(ARRAY_BUFFER) successful`);
    }
    buffer.destroy();

    // TODO - this seems to be testing that usage is correctly observed, move up
    // buffer = device.createBuffer({usage: Buffer.VERTEX, data: new Float32Array([1, 2, 3])});
    // buffer.write(new Float32Array([1, 2, 3]));
    // t.ok(buffer instanceof Buffer, `${device.info.type} Buffer.subData(ARRAY_BUFFER) successful`);
    // buffer.destroy();

    // buffer = device.createBuffer({usage: Buffer.INDEX}).write(new Float32Array([1, 2, 3]));
    // t.ok(
    //   buffer instanceof Buffer,
    //   `${device.info.type} buffer.initialize(ELEMENT_ARRAY_BUFFER) successful`
    // );
    // buffer.destroy();
  }
  t.end();
});

/*
test('Buffer#getData', t => {
  for (const device of getWebGLTestDevices()) {
    if (!gl2) {
      t.comment('WebGL2 not available, skipping tests');
      t.end();
      return;
    }

    let data = new Float32Array([1, 2, 3]);
    let buffer = device.createBuffer({data});

    let receivedData = buffer.getData();
    let expectedData = new Float32Array([1, 2, 3]);
    t.deepEqual(data, receivedData, 'Buffer.getData: default parameters successful');

    receivedData = buffer.getData({
      dstData: new Float32Array(2),
      srcByteOffset: Float32Array.BYTES_PER_ELEMENT
    });
    expectedData = new Float32Array([2, 3]);
    t.deepEqual(expectedData, receivedData, "Buffer.getData: with 'dstData' parameter successful");

    receivedData = buffer.getData({
      srcByteOffset: Float32Array.BYTES_PER_ELEMENT,
      dstOffset: 2
    });
    expectedData = new Float32Array([0, 0, 2, 3]);
    t.deepEqual(expectedData, receivedData, 'Buffer.getData: with src/dst offsets successful');

    // NOTE: when source and dst offsets are specified, 'length' needs to be set so that
    // source buffer access is not outof bounds, otherwise 'getBufferSubData' will throw exception.
    receivedData = buffer.getData({
      srcByteOffset: Float32Array.BYTES_PER_ELEMENT * 2,
      dstOffset: 1,
      length: 1
    });
    expectedData = new Float32Array([0, 3]);
    t.deepEqual(
      expectedData,
      receivedData,
      'Buffer.getData: with src/dst offsets and length successful'
    );

    // @ts-expect-error
    data = new Uint8Array([128, 255, 1]);
    buffer = device.createBuffer({data});

    receivedData = buffer.getData();
    t.deepEqual(data, receivedData, 'Buffer.getData: Uint8Array + default parameters successful');
  }
  t.end();
});
*/

1	// luma.gl, MIT license	1✔
2	// Copyright (c) vis.gl contributors	1✔
3		1✔
4	import {Buffer} from '@luma.gl/core';	1✔
5	import {GL} from '@luma.gl/constants';	1✔
6	import test from 'tape-promise/tape';	1✔
7		1✔
8	import {getWebGLTestDevices} from '@luma.gl/test-utils';	1✔
9		1✔
10	test('Buffer#constructor/delete', t => {	1✔
11	for (const device of getWebGLTestDevices()) {	1✔
12	const buffer = device.createBuffer({usage: Buffer.VERTEX});	1✔
13	t.ok(buffer.handle, `${device.info.type} Buffer construction successful`);	1✔
14		1✔
15	buffer.destroy();	1✔
16	t.ok(!buffer.handle, `${device.info.type} Buffer.destroy() successful`);	1✔
17		1✔
18	buffer.destroy();	1✔
19	t.ok(!buffer.handle, `${device.info.type} repeated Buffer.destroy() successful`);	1✔
20	}	1✔
21	t.end();	1✔
22	});	1✔
23		1✔
24	test('Buffer#constructor offset and size', t => {	1✔
25	const data = new Float32Array([1, 2, 3]);	1✔
26		1✔
27	for (const device of getWebGLTestDevices()) {	1✔
28	let buffer = device.createBuffer({data, byteOffset: 8});	1✔
29	let expectedData = new Float32Array([0, 0, 1, 2, 3]);	1✔
30	t.equal(	1✔
31	buffer.byteLength,	1✔
32	expectedData.byteLength,	1✔
33	`${device.info.type} Buffer byteLength set properly`	1✔
34	);	1✔
35		1✔
36	if (device.isWebGL2) {	1!
UNCOV 37	const receivedData = buffer.getData();	×
38	t.deepEqual(	×
39	receivedData,	×
40	expectedData,	×
41	`${device.info.type} Buffer constructor offsets data`	×
42	);	×
43	}	×
44		1✔
45	buffer = device.createBuffer({data, byteLength: data.byteLength + 12});	1✔
46	expectedData = new Float32Array([1, 2, 3, 0, 0, 0]);	1✔
47	t.equal(	1✔
48	buffer.byteLength,	1✔
49	expectedData.byteLength,	1✔
50	`${device.info.type} Buffer byteLength set properly`	1✔
51	);	1✔
52	if (device.isWebGL2) {	1!
UNCOV 53	const receivedData = buffer.getData();	×
54	t.deepEqual(	×
55	receivedData,	×
56	expectedData,	×
57	`${device.info.type} Buffer constructor sets buffer data`	×
58	);	×
59	}	×
60		1✔
61	buffer = device.createBuffer({data, byteOffset: 8, byteLength: data.byteLength + 12});	1✔
62	expectedData = new Float32Array([0, 0, 1, 2, 3, 0]);	1✔
63	t.equal(	1✔
64	buffer.byteLength,	1✔
65	expectedData.byteLength,	1✔
66	`${device.info.type} Buffer byteLength set properly`	1✔
67	);	1✔
68		1✔
69	if (device.isWebGL2) {	1!
UNCOV 70	const receivedData = buffer.getData();	×
71	t.deepEqual(	×
72	receivedData,	×
73	expectedData,	×
74	`${device.info.type} Buffer constructor sets buffer byteLength and offsets data`	×
75	);	×
76	}	×
77	}	1✔
78	t.end();	1✔
79	});	1✔
80		1✔
81	test('Buffer#bind/unbind', t => {	1✔
82	for (const device of getWebGLTestDevices()) {	1✔
83	const buffer = device.createBuffer({usage: Buffer.VERTEX});	1✔
84	device.gl.bindBuffer(buffer.glTarget, buffer.handle);	1✔
85	t.ok(buffer instanceof Buffer, `${device.info.type} Buffer bind/unbind successful`);	1✔
86	device.gl.bindBuffer(buffer.glTarget, null);	1✔
87	buffer.destroy();	1✔
88	}	1✔
89	t.end();	1✔
90	});	1✔
91		1✔
92	test('Buffer#construction', t => {	1✔
93	for (const device of getWebGLTestDevices()) {	1✔
94	let buffer;	1✔
95		1✔
96	buffer = device.createBuffer({usage: Buffer.VERTEX, data: new Float32Array([1, 2, 3])});	1✔
97	t.ok(	1✔
98	buffer.glTarget === GL.ARRAY_BUFFER,	1✔
99	`${device.info.type} Buffer(ARRAY_BUFFER) successful`	1✔
100	);	1✔
101	buffer.destroy();	1✔
102		1✔
103	// TODO - buffer could check for integer ELEMENT_ARRAY_BUFFER types	1✔
104	buffer = device.createBuffer({usage: Buffer.INDEX, data: new Float32Array([1, 2, 3])});	1✔
105	t.ok(	1✔
106	buffer.glTarget === GL.ELEMENT_ARRAY_BUFFER,	1✔
107	`${device.info.type} Buffer(ELEMENT_ARRAY_BUFFER) successful`	1✔
108	);	1✔
109		1✔
110	buffer.destroy();	1✔
111	}	1✔
112		1✔
113	t.end();	1✔
114	});	1✔
115		1✔
116	test('Buffer#write', t => {	1✔
117	const data = new Float32Array([1, 2, 3]);	1✔
118	for (const device of getWebGLTestDevices()) {	1✔
119	const buffer = device.createBuffer({usage: Buffer.VERTEX, byteLength: 12});	1✔
120	buffer.write(data);	1✔
121	if (device.isWebGL2) {	1!
UNCOV 122	t.deepEqual(	×
UNCOV 123	buffer.getData(),	×
UNCOV 124	data,	×
UNCOV 125	`${device.info.type} Buffer.subData(ARRAY_BUFFER) stores correct bytes`	×
UNCOV 126	);	×
127	} else {	1✔
128	t.ok(buffer instanceof Buffer, `${device.info.type} Buffer.subData(ARRAY_BUFFER) successful`);	1✔
129	}	1✔
130	buffer.destroy();	1✔
131		1✔
132	// TODO - this seems to be testing that usage is correctly observed, move up	1✔
133	// buffer = device.createBuffer({usage: Buffer.VERTEX, data: new Float32Array([1, 2, 3])});	1✔
134	// buffer.write(new Float32Array([1, 2, 3]));	1✔
135	// t.ok(buffer instanceof Buffer, `${device.info.type} Buffer.subData(ARRAY_BUFFER) successful`);	1✔
136	// buffer.destroy();	1✔
137		1✔
138	// buffer = device.createBuffer({usage: Buffer.INDEX}).write(new Float32Array([1, 2, 3]));	1✔
139	// t.ok(	1✔
140	// buffer instanceof Buffer,	1✔
141	// `${device.info.type} buffer.initialize(ELEMENT_ARRAY_BUFFER) successful`	1✔
142	// );	1✔
143	// buffer.destroy();	1✔
144	}	1✔
145	t.end();	1✔
146	});	1✔
147		1✔
148	/*	1✔
149	test('Buffer#getData', t => {	1✔
150	for (const device of getWebGLTestDevices()) {	1✔
151	if (!gl2) {	1✔
152	t.comment('WebGL2 not available, skipping tests');	1✔
153	t.end();	1✔
154	return;	1✔
155	}	1✔
156		1✔
157	let data = new Float32Array([1, 2, 3]);	1✔
158	let buffer = device.createBuffer({data});	1✔
159		1✔
160	let receivedData = buffer.getData();	1✔
161	let expectedData = new Float32Array([1, 2, 3]);	1✔
162	t.deepEqual(data, receivedData, 'Buffer.getData: default parameters successful');	1✔
163		1✔
164	receivedData = buffer.getData({	1✔
165	dstData: new Float32Array(2),	1✔
166	srcByteOffset: Float32Array.BYTES_PER_ELEMENT	1✔
167	});	1✔
168	expectedData = new Float32Array([2, 3]);	1✔
169	t.deepEqual(expectedData, receivedData, "Buffer.getData: with 'dstData' parameter successful");	1✔
170		1✔
171	receivedData = buffer.getData({	1✔
172	srcByteOffset: Float32Array.BYTES_PER_ELEMENT,	1✔
173	dstOffset: 2	1✔
174	});	1✔
175	expectedData = new Float32Array([0, 0, 2, 3]);	1✔
176	t.deepEqual(expectedData, receivedData, 'Buffer.getData: with src/dst offsets successful');	1✔
177		1✔
178	// NOTE: when source and dst offsets are specified, 'length' needs to be set so that	1✔
179	// source buffer access is not outof bounds, otherwise 'getBufferSubData' will throw exception.	1✔
180	receivedData = buffer.getData({	1✔
181	srcByteOffset: Float32Array.BYTES_PER_ELEMENT * 2,	1✔
182	dstOffset: 1,	1✔
183	length: 1	1✔
184	});	1✔
185	expectedData = new Float32Array([0, 3]);	1✔
186	t.deepEqual(	1✔
187	expectedData,	1✔
188	receivedData,	1✔
189	'Buffer.getData: with src/dst offsets and length successful'	1✔
190	);	1✔
191		1✔
192	// @ts-expect-error	1✔
193	data = new Uint8Array([128, 255, 1]);	1✔
194	buffer = device.createBuffer({data});	1✔
195		1✔
196	receivedData = buffer.getData();	1✔
197	t.deepEqual(data, receivedData, 'Buffer.getData: Uint8Array + default parameters successful');	1✔
198	}	1✔
199	t.end();	1✔
200	});	1✔
201	*/	1✔

visgl / luma.gl / 7103756207

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