import {
|
FeatureDetection,
|
MetadataComponentType,
|
MetadataType,
|
} from "../../Source/Cesium.js";
|
|
describe("Scene/MetadataComponentType", function () {
|
it("getMinimum", function () {
|
expect(MetadataComponentType.getMinimum(MetadataComponentType.INT8)).toBe(
|
-128
|
);
|
expect(MetadataComponentType.getMinimum(MetadataComponentType.UINT8)).toBe(
|
0
|
);
|
expect(MetadataComponentType.getMinimum(MetadataComponentType.INT16)).toBe(
|
-32768
|
);
|
expect(MetadataComponentType.getMinimum(MetadataComponentType.UINT16)).toBe(
|
0
|
);
|
expect(MetadataComponentType.getMinimum(MetadataComponentType.INT32)).toBe(
|
-2147483648
|
);
|
expect(MetadataComponentType.getMinimum(MetadataComponentType.UINT32)).toBe(
|
0
|
);
|
expect(
|
MetadataComponentType.getMinimum(MetadataComponentType.FLOAT32)
|
).toBe(-340282346638528859811704183484516925440.0);
|
expect(
|
MetadataComponentType.getMinimum(MetadataComponentType.FLOAT64)
|
).toBe(-Number.MAX_VALUE);
|
|
if (FeatureDetection.supportsBigInt()) {
|
expect(
|
MetadataComponentType.getMinimum(MetadataComponentType.INT64)
|
).toBe(
|
BigInt("-9223372036854775808") // eslint-disable-line
|
);
|
expect(
|
MetadataComponentType.getMinimum(MetadataComponentType.UINT64)
|
).toBe(
|
BigInt(0) // eslint-disable-line
|
);
|
}
|
});
|
|
it("getMinimum returns approximate number for INT64 when BigInt is not supported", function () {
|
spyOn(FeatureDetection, "supportsBigInt").and.returnValue(false);
|
expect(MetadataComponentType.getMinimum(MetadataComponentType.INT64)).toBe(
|
-Math.pow(2, 63)
|
);
|
});
|
|
it("getMinimum returns number for UINT64 when BigInt is not supported", function () {
|
spyOn(FeatureDetection, "supportsBigInt").and.returnValue(false);
|
expect(MetadataComponentType.getMinimum(MetadataComponentType.UINT64)).toBe(
|
0
|
);
|
});
|
|
it("getMinimum throws without type", function () {
|
expect(function () {
|
MetadataComponentType.getMinimum();
|
}).toThrowDeveloperError();
|
});
|
|
it("getMinimum throws if type is not a numeric type", function () {
|
expect(function () {
|
MetadataComponentType.getMinimum(MetadataComponentType.STRING);
|
}).toThrowDeveloperError();
|
});
|
|
it("getMaximum", function () {
|
expect(MetadataComponentType.getMaximum(MetadataComponentType.INT8)).toBe(
|
127
|
);
|
expect(MetadataComponentType.getMaximum(MetadataComponentType.UINT8)).toBe(
|
255
|
);
|
expect(MetadataComponentType.getMaximum(MetadataComponentType.INT16)).toBe(
|
32767
|
);
|
expect(MetadataComponentType.getMaximum(MetadataComponentType.UINT16)).toBe(
|
65535
|
);
|
expect(MetadataComponentType.getMaximum(MetadataComponentType.INT32)).toBe(
|
2147483647
|
);
|
expect(MetadataComponentType.getMaximum(MetadataComponentType.UINT32)).toBe(
|
4294967295
|
);
|
expect(
|
MetadataComponentType.getMaximum(MetadataComponentType.FLOAT32)
|
).toBe(340282346638528859811704183484516925440.0);
|
expect(
|
MetadataComponentType.getMaximum(MetadataComponentType.FLOAT64)
|
).toBe(Number.MAX_VALUE);
|
|
if (FeatureDetection.supportsBigInt()) {
|
expect(
|
MetadataComponentType.getMaximum(MetadataComponentType.INT64)
|
).toBe(
|
BigInt("9223372036854775807") // eslint-disable-line
|
);
|
expect(
|
MetadataComponentType.getMaximum(MetadataComponentType.UINT64)
|
).toBe(
|
BigInt("18446744073709551615") // eslint-disable-line
|
);
|
}
|
});
|
|
it("getMaximum returns approximate number for INT64 when BigInt is not supported", function () {
|
spyOn(FeatureDetection, "supportsBigInt").and.returnValue(false);
|
expect(MetadataComponentType.getMaximum(MetadataComponentType.INT64)).toBe(
|
Math.pow(2, 63) - 1
|
);
|
});
|
|
it("getMaximum returns approximate number for UINT64 when BigInt is not supported", function () {
|
spyOn(FeatureDetection, "supportsBigInt").and.returnValue(false);
|
expect(MetadataComponentType.getMaximum(MetadataComponentType.UINT64)).toBe(
|
Math.pow(2, 64) - 1
|
);
|
});
|
|
it("getMaximum throws without type", function () {
|
expect(function () {
|
MetadataComponentType.getMaximum();
|
}).toThrowDeveloperError();
|
});
|
|
it("getMaximum throws if type is not a numeric type", function () {
|
expect(function () {
|
MetadataComponentType.getMaximum(MetadataComponentType.STRING);
|
}).toThrowDeveloperError();
|
});
|
|
it("isNumericType", function () {
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.INT8)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.UINT8)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.INT16)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.UINT16)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.INT32)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.UINT32)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.INT64)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.UINT64)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.FLOAT32)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.FLOAT64)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.BOOLEAN)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.STRING)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isNumericType(MetadataComponentType.ENUM)
|
).toBe(false);
|
expect(MetadataComponentType.isNumericType(MetadataType.ARRAY)).toBe(false);
|
});
|
|
it("isNumericType throws without type", function () {
|
expect(function () {
|
MetadataComponentType.isNumericType();
|
}).toThrowDeveloperError();
|
});
|
|
it("isIntegerType", function () {
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.INT8)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.UINT8)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.INT16)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.UINT16)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.INT32)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.UINT32)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.INT64)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.UINT64)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.FLOAT32)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.FLOAT64)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.BOOLEAN)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.STRING)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isIntegerType(MetadataComponentType.ENUM)
|
).toBe(false);
|
expect(MetadataComponentType.isIntegerType(MetadataType.ARRAY)).toBe(false);
|
});
|
|
it("isIntegerType throws without type", function () {
|
expect(function () {
|
MetadataComponentType.isIntegerType();
|
}).toThrowDeveloperError();
|
});
|
|
it("isUnsignedIntegerType", function () {
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.INT8)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.UINT8)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.INT16)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.UINT16)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.INT32)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.UINT32)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.INT64)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.UINT64)
|
).toBe(true);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.FLOAT32)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.FLOAT64)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.BOOLEAN)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.STRING)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataComponentType.ENUM)
|
).toBe(false);
|
expect(
|
MetadataComponentType.isUnsignedIntegerType(MetadataType.ARRAY)
|
).toBe(false);
|
});
|
|
it("isUnsignedIntegerType throws without type", function () {
|
expect(function () {
|
MetadataComponentType.isUnsignedIntegerType();
|
}).toThrowDeveloperError();
|
});
|
|
it("normalizes signed integers", function () {
|
var signedTypes = ["INT8", "INT16", "INT32"];
|
for (var i = 0; i < signedTypes.length; ++i) {
|
var type = signedTypes[i];
|
var min = MetadataComponentType.getMinimum(MetadataComponentType[type]);
|
var max = MetadataComponentType.getMaximum(MetadataComponentType[type]);
|
var values = [min, min / 2, 0, max / 2, max];
|
var expectedResults = [-1.0, -0.5, 0.0, 0.5, 1.0];
|
for (var j = 0; j < values.length; ++j) {
|
var result = MetadataComponentType.normalize(values[j], type);
|
expect(result).toBe(expectedResults[j]);
|
}
|
}
|
});
|
|
it("normalizes unsigned integers", function () {
|
var unsignedTypes = ["UINT8", "UINT16", "UINT32"];
|
for (var i = 0; i < unsignedTypes.length; ++i) {
|
var type = unsignedTypes[i];
|
var max = MetadataComponentType.getMaximum(MetadataComponentType[type]);
|
var values = [0, max / 4, max / 2, max];
|
var expectedResults = [0.0, 0.25, 0.5, 1.0];
|
for (var j = 0; j < values.length; ++j) {
|
var result = MetadataComponentType.normalize(values[j], type);
|
expect(result).toBe(expectedResults[j]);
|
}
|
}
|
});
|
|
it("normalizes INT64 integers", function () {
|
if (!FeatureDetection.supportsBigInt()) {
|
return;
|
}
|
|
var min = MetadataComponentType.getMinimum(MetadataComponentType.INT64);
|
var max = MetadataComponentType.getMaximum(MetadataComponentType.INT64);
|
var values = [min, min / BigInt(2), 0, max / BigInt(2), max]; // eslint-disable-line
|
var expectedResults = [-1.0, -0.5, 0.0, 0.5, 1.0];
|
for (var j = 0; j < values.length; ++j) {
|
var result = MetadataComponentType.normalize(
|
values[j],
|
MetadataComponentType.INT64
|
);
|
expect(result).toBe(expectedResults[j]);
|
}
|
});
|
|
it("normalizes UINT64 integers", function () {
|
if (!FeatureDetection.supportsBigInt()) {
|
return;
|
}
|
|
var max = MetadataComponentType.getMaximum(MetadataComponentType.UINT64);
|
var values = [BigInt(0), max / BigInt(4), max / BigInt(2), max]; // eslint-disable-line
|
var expectedResults = [0.0, 0.25, 0.5, 1.0];
|
for (var j = 0; j < values.length; ++j) {
|
var result = MetadataComponentType.normalize(
|
values[j],
|
MetadataComponentType.UINT64
|
);
|
expect(result).toBe(expectedResults[j]);
|
}
|
});
|
|
it("normalize throws without value", function () {
|
expect(function () {
|
MetadataComponentType.normalize();
|
}).toThrowDeveloperError();
|
});
|
|
it("normalize throws without type", function () {
|
expect(function () {
|
MetadataComponentType.normalize(10.0);
|
}).toThrowDeveloperError();
|
});
|
|
it("normalize throws if value is not a number or BigInt", function () {
|
expect(function () {
|
MetadataComponentType.normalize("10", MetadataComponentType.INT16);
|
}).toThrowDeveloperError();
|
});
|
|
it("normalize throws if type is not an integer type", function () {
|
expect(function () {
|
MetadataComponentType.normalize(10.0, MetadataComponentType.STRING);
|
}).toThrowDeveloperError();
|
});
|
|
it("unnormalizes signed numbers", function () {
|
var signedTypes = ["INT8", "INT16", "INT32"];
|
for (var i = 0; i < signedTypes.length; ++i) {
|
var type = signedTypes[i];
|
var min = MetadataComponentType.getMinimum(MetadataComponentType[type]);
|
var max = MetadataComponentType.getMaximum(MetadataComponentType[type]);
|
var values = [-1.0, -0.5, 0.0, 0.5, 1.0];
|
var expectedResults = [min, min / 2, 0, max / 2, max];
|
for (var j = 0; j < values.length; ++j) {
|
var result = MetadataComponentType.unnormalize(values[j], type);
|
expect(result).toBe(expectedResults[j]);
|
}
|
}
|
});
|
|
it("unnormalizes unsigned numbers", function () {
|
var unsignedTypes = ["UINT8", "UINT16", "UINT32"];
|
for (var i = 0; i < unsignedTypes.length; ++i) {
|
var type = unsignedTypes[i];
|
var max = MetadataComponentType.getMaximum(MetadataComponentType[type]);
|
var values = [0.0, 0.25, 0.5, 1.0];
|
var expectedResults = [0, max / 4, max / 2, max];
|
for (var j = 0; j < values.length; ++j) {
|
var result = MetadataComponentType.unnormalize(values[j], type);
|
expect(result).toBe(expectedResults[j]);
|
}
|
}
|
});
|
|
it("unnormalizes INT64", function () {
|
if (!FeatureDetection.supportsBigInt()) {
|
return;
|
}
|
|
var min = MetadataComponentType.getMinimum(MetadataComponentType.INT64);
|
var max = MetadataComponentType.getMaximum(MetadataComponentType.INT64);
|
var values = [-1.0, -0.5, 0.0, 0.5, 1.0];
|
|
// Unnormalization is not always exact since it must be through Float64 math
|
// first, hence the + BigInt(1)
|
var expectedResults = [
|
min,
|
min / BigInt(2), // eslint-disable-line
|
BigInt(0), // eslint-disable-line
|
max / BigInt(2) + BigInt(1), // eslint-disable-line
|
max,
|
];
|
for (var i = 0; i < values.length; ++i) {
|
var result = MetadataComponentType.unnormalize(
|
values[i],
|
MetadataComponentType.INT64
|
);
|
expect(result).toBe(expectedResults[i]);
|
}
|
});
|
|
it("unnormalizes UINT64", function () {
|
if (!FeatureDetection.supportsBigInt()) {
|
return;
|
}
|
|
var max = MetadataComponentType.getMaximum(MetadataComponentType.UINT64);
|
var values = [0.0, 0.25, 0.5, 1.0];
|
|
// Unnormalization is not always exact since it must be through Float64 math
|
// first, hence the + BigInt(1)
|
var expectedResults = [
|
BigInt(0), // eslint-disable-line
|
max / BigInt(4) + BigInt(1), // eslint-disable-line
|
max / BigInt(2) + BigInt(1), // eslint-disable-line
|
max,
|
];
|
for (var i = 0; i < values.length; ++i) {
|
var result = MetadataComponentType.unnormalize(
|
values[i],
|
MetadataComponentType.UINT64
|
);
|
expect(result).toBe(expectedResults[i]);
|
}
|
});
|
|
it("unnormalize clamps values outside the range", function () {
|
expect(
|
MetadataComponentType.unnormalize(-1.1, MetadataComponentType.INT8)
|
).toBe(-128);
|
expect(
|
MetadataComponentType.unnormalize(-0.1, MetadataComponentType.UINT8)
|
).toBe(0);
|
expect(
|
MetadataComponentType.unnormalize(1.1, MetadataComponentType.INT8)
|
).toBe(127);
|
expect(
|
MetadataComponentType.unnormalize(1.1, MetadataComponentType.UINT8)
|
).toBe(255);
|
});
|
|
it("unnormalize throws without value", function () {
|
expect(function () {
|
MetadataComponentType.unnormalize();
|
}).toThrowDeveloperError();
|
});
|
|
it("unnormalize throws without type", function () {
|
expect(function () {
|
MetadataComponentType.unnormalize(10.0);
|
}).toThrowDeveloperError();
|
});
|
|
it("unnormalize throws if type is not an integer type", function () {
|
expect(function () {
|
MetadataComponentType.unnormalize(10.0, MetadataComponentType.STRING);
|
}).toThrowDeveloperError();
|
});
|
|
it("getSizeInBytes", function () {
|
expect(
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.INT8)
|
).toBe(1);
|
expect(
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.UINT8)
|
).toBe(1);
|
expect(
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.INT16)
|
).toBe(2);
|
expect(
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.UINT16)
|
).toBe(2);
|
expect(
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.INT32)
|
).toBe(4);
|
expect(
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.UINT32)
|
).toBe(4);
|
expect(
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.INT64)
|
).toBe(8);
|
expect(
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.UINT64)
|
).toBe(8);
|
expect(
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.FLOAT32)
|
).toBe(4);
|
expect(
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.FLOAT64)
|
).toBe(8);
|
});
|
|
it("getSizeInBytes throws without type", function () {
|
expect(function () {
|
MetadataComponentType.getSizeInBytes();
|
}).toThrowDeveloperError();
|
});
|
|
it("getSizeInBytes throws if type is not a numeric type", function () {
|
expect(function () {
|
MetadataComponentType.getSizeInBytes(MetadataComponentType.STRING);
|
}).toThrowDeveloperError();
|
});
|
});
|
