import { ComponentDatatype } from "../../Source/Cesium.js";
|
|
describe("Core/ComponentDatatype", function () {
|
it("fromTypedArray works", function () {
|
expect(ComponentDatatype.fromTypedArray(new Int8Array())).toBe(
|
ComponentDatatype.BYTE
|
);
|
expect(ComponentDatatype.fromTypedArray(new Uint8Array())).toBe(
|
ComponentDatatype.UNSIGNED_BYTE
|
);
|
expect(ComponentDatatype.fromTypedArray(new Int16Array())).toBe(
|
ComponentDatatype.SHORT
|
);
|
expect(ComponentDatatype.fromTypedArray(new Uint16Array())).toBe(
|
ComponentDatatype.UNSIGNED_SHORT
|
);
|
expect(ComponentDatatype.fromTypedArray(new Int32Array())).toBe(
|
ComponentDatatype.INT
|
);
|
expect(ComponentDatatype.fromTypedArray(new Uint32Array())).toBe(
|
ComponentDatatype.UNSIGNED_INT
|
);
|
expect(ComponentDatatype.fromTypedArray(new Float32Array())).toBe(
|
ComponentDatatype.FLOAT
|
);
|
expect(ComponentDatatype.fromTypedArray(new Float64Array())).toBe(
|
ComponentDatatype.DOUBLE
|
);
|
});
|
|
it("validate works", function () {
|
expect(ComponentDatatype.validate(ComponentDatatype.BYTE)).toBe(true);
|
expect(ComponentDatatype.validate(ComponentDatatype.UNSIGNED_BYTE)).toBe(
|
true
|
);
|
expect(ComponentDatatype.validate(ComponentDatatype.SHORT)).toBe(true);
|
expect(ComponentDatatype.validate(ComponentDatatype.UNSIGNED_SHORT)).toBe(
|
true
|
);
|
expect(ComponentDatatype.validate(ComponentDatatype.INT)).toBe(true);
|
expect(ComponentDatatype.validate(ComponentDatatype.UNSIGNED_INT)).toBe(
|
true
|
);
|
expect(ComponentDatatype.validate(ComponentDatatype.FLOAT)).toBe(true);
|
expect(ComponentDatatype.validate(ComponentDatatype.DOUBLE)).toBe(true);
|
expect(ComponentDatatype.validate(undefined)).toBe(false);
|
expect(ComponentDatatype.validate({})).toBe(false);
|
});
|
|
it("createTypedArray works with size", function () {
|
var typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.BYTE,
|
0
|
);
|
expect(typedArray).toBeInstanceOf(Int8Array);
|
expect(typedArray.length).toBe(0);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.UNSIGNED_BYTE,
|
1
|
);
|
expect(typedArray).toBeInstanceOf(Uint8Array);
|
expect(typedArray.length).toBe(1);
|
|
typedArray = ComponentDatatype.createTypedArray(ComponentDatatype.SHORT, 2);
|
expect(typedArray).toBeInstanceOf(Int16Array);
|
expect(typedArray.length).toBe(2);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.UNSIGNED_SHORT,
|
3
|
);
|
expect(typedArray).toBeInstanceOf(Uint16Array);
|
expect(typedArray.length).toBe(3);
|
|
typedArray = ComponentDatatype.createTypedArray(ComponentDatatype.INT, 4);
|
expect(typedArray).toBeInstanceOf(Int32Array);
|
expect(typedArray.length).toBe(4);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.UNSIGNED_INT,
|
5
|
);
|
expect(typedArray).toBeInstanceOf(Uint32Array);
|
expect(typedArray.length).toBe(5);
|
|
typedArray = ComponentDatatype.createTypedArray(ComponentDatatype.FLOAT, 6);
|
expect(typedArray).toBeInstanceOf(Float32Array);
|
expect(typedArray.length).toBe(6);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.DOUBLE,
|
7
|
);
|
expect(typedArray).toBeInstanceOf(Float64Array);
|
expect(typedArray.length).toBe(7);
|
});
|
|
it("createTypedArray works with values", function () {
|
var values = [34, 12, 4, 1];
|
var typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.BYTE,
|
values
|
);
|
expect(typedArray).toBeInstanceOf(Int8Array);
|
expect(typedArray).toEqual(values);
|
expect(typedArray.length).toBe(values.length);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.UNSIGNED_BYTE,
|
values
|
);
|
expect(typedArray).toBeInstanceOf(Uint8Array);
|
expect(typedArray).toEqual(values);
|
expect(typedArray.length).toBe(values.length);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.SHORT,
|
values
|
);
|
expect(typedArray).toBeInstanceOf(Int16Array);
|
expect(typedArray).toEqual(values);
|
expect(typedArray.length).toBe(values.length);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.UNSIGNED_SHORT,
|
values
|
);
|
expect(typedArray).toBeInstanceOf(Uint16Array);
|
expect(typedArray).toEqual(values);
|
expect(typedArray.length).toBe(values.length);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.INT,
|
values
|
);
|
expect(typedArray).toBeInstanceOf(Int32Array);
|
expect(typedArray).toEqual(values);
|
expect(typedArray.length).toBe(values.length);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.UNSIGNED_INT,
|
values
|
);
|
expect(typedArray).toBeInstanceOf(Uint32Array);
|
expect(typedArray).toEqual(values);
|
expect(typedArray.length).toBe(values.length);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.FLOAT,
|
values
|
);
|
expect(typedArray).toBeInstanceOf(Float32Array);
|
expect(typedArray).toEqual(values);
|
expect(typedArray.length).toBe(values.length);
|
|
typedArray = ComponentDatatype.createTypedArray(
|
ComponentDatatype.DOUBLE,
|
values
|
);
|
expect(typedArray).toBeInstanceOf(Float64Array);
|
expect(typedArray).toEqual(values);
|
expect(typedArray.length).toBe(values.length);
|
});
|
|
it("createArrayBufferView works", function () {
|
var buffer = new ArrayBuffer(100);
|
expect(
|
ComponentDatatype.createArrayBufferView(
|
ComponentDatatype.BYTE,
|
buffer,
|
0,
|
1
|
)
|
).toBeInstanceOf(Int8Array);
|
expect(
|
ComponentDatatype.createArrayBufferView(
|
ComponentDatatype.UNSIGNED_BYTE,
|
buffer,
|
0,
|
1
|
)
|
).toBeInstanceOf(Uint8Array);
|
expect(
|
ComponentDatatype.createArrayBufferView(
|
ComponentDatatype.SHORT,
|
buffer,
|
0,
|
1
|
)
|
).toBeInstanceOf(Int16Array);
|
expect(
|
ComponentDatatype.createArrayBufferView(
|
ComponentDatatype.UNSIGNED_SHORT,
|
buffer,
|
0,
|
1
|
)
|
).toBeInstanceOf(Uint16Array);
|
expect(
|
ComponentDatatype.createArrayBufferView(
|
ComponentDatatype.INT,
|
buffer,
|
0,
|
1
|
)
|
).toBeInstanceOf(Int32Array);
|
expect(
|
ComponentDatatype.createArrayBufferView(
|
ComponentDatatype.UNSIGNED_INT,
|
buffer,
|
0,
|
1
|
)
|
).toBeInstanceOf(Uint32Array);
|
expect(
|
ComponentDatatype.createArrayBufferView(
|
ComponentDatatype.FLOAT,
|
buffer,
|
0,
|
1
|
)
|
).toBeInstanceOf(Float32Array);
|
expect(
|
ComponentDatatype.createArrayBufferView(
|
ComponentDatatype.DOUBLE,
|
buffer,
|
0,
|
1
|
)
|
).toBeInstanceOf(Float64Array);
|
});
|
|
it("createTypedArray throws without type", function () {
|
expect(function () {
|
ComponentDatatype.createTypedArray(undefined, 1);
|
}).toThrowDeveloperError();
|
});
|
|
it("createTypedArray throws without length or values", function () {
|
expect(function () {
|
ComponentDatatype.createTypedArray(ComponentDatatype.FLOAT, undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("createArrayBufferView throws without type", function () {
|
var buffer = new ArrayBuffer(100);
|
expect(function () {
|
ComponentDatatype.createTypedArray(undefined, buffer, 0, 1);
|
}).toThrowDeveloperError();
|
});
|
|
it("createArrayBufferView throws with invalid type", function () {
|
var buffer = new ArrayBuffer(100);
|
expect(function () {
|
ComponentDatatype.createTypedArray({}, buffer, 0, 1);
|
}).toThrowDeveloperError();
|
});
|
|
it("createArrayBufferView throws without buffer", function () {
|
expect(function () {
|
ComponentDatatype.createTypedArray(
|
ComponentDatatype.BYTE,
|
undefined,
|
0,
|
1
|
);
|
}).toThrowDeveloperError();
|
});
|
|
it("fromName works", function () {
|
expect(ComponentDatatype.fromName("BYTE")).toEqual(ComponentDatatype.BYTE);
|
expect(ComponentDatatype.fromName("UNSIGNED_BYTE")).toEqual(
|
ComponentDatatype.UNSIGNED_BYTE
|
);
|
expect(ComponentDatatype.fromName("SHORT")).toEqual(
|
ComponentDatatype.SHORT
|
);
|
expect(ComponentDatatype.fromName("UNSIGNED_SHORT")).toEqual(
|
ComponentDatatype.UNSIGNED_SHORT
|
);
|
expect(ComponentDatatype.fromName("INT")).toEqual(ComponentDatatype.INT);
|
expect(ComponentDatatype.fromName("UNSIGNED_INT")).toEqual(
|
ComponentDatatype.UNSIGNED_INT
|
);
|
expect(ComponentDatatype.fromName("FLOAT")).toEqual(
|
ComponentDatatype.FLOAT
|
);
|
expect(ComponentDatatype.fromName("DOUBLE")).toEqual(
|
ComponentDatatype.DOUBLE
|
);
|
});
|
|
it("fromName throws without name", function () {
|
expect(function () {
|
ComponentDatatype.fromName();
|
}).toThrowDeveloperError();
|
});
|
});
|
