mirror of
https://github.com/fluencelabs/assemblyscript
synced 2025-07-30 21:52:18 +00:00
Implement TypedArray#map (#365)
* Also cleans up TypedArray#reduce/reduceRight test cases * Also fixes the (what needs to be) overloads on Uint8ClampedArray
This commit is contained in:
jtenner
Daniel Wirtz
File diff suppressed because it is too large
Load Diff
@@ -227,8 +227,8 @@ assert(multisubarr3.byteLength === 3);
|
||||
|
||||
/**
|
||||
* Reduce test suite:
|
||||
* Each function is designed to test a simple sum reduction. In each test it initialized the tested
|
||||
* typedarray, and sets the values manually. Then it calls `TypedArray.prototype.reduce` with a
|
||||
* The reduce test is designed to test a simple sum reduction. In each test it instantiates the
|
||||
* tested typedarray, and sets the values manually. Then it calls `TypedArray.prototype.reduce` with a
|
||||
* single sum arrow function reduction. For each reduction, it verifies the `self` parameter is the
|
||||
* instantiated array, the index is the correct index, and it increments the testIndex variable.
|
||||
* Finally, it asserts the value is 6.
|
||||
@@ -236,367 +236,86 @@ assert(multisubarr3.byteLength === 3);
|
||||
* TODO: When function closure support is added, remove the function comments to fully verify the
|
||||
* tests work.
|
||||
*/
|
||||
function reduceInt8ArrayTest(): void {
|
||||
var array: Int8Array = new Int8Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<i8>((acc: i8, val: i8, index: i32, self: Int8Array): i8 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceUint8ArrayTest(): void {
|
||||
var array: Uint8Array = new Uint8Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<u8>((acc: u8, val: u8, index: i32, self: Uint8Array): u8 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceUint8ClampedArrayTest(): void {
|
||||
var array: Uint8ClampedArray = new Uint8ClampedArray(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<u8>((acc: u8, val: u8, index: i32, self: Uint8ClampedArray): u8 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceInt16ArrayTest(): void {
|
||||
var array: Int16Array = new Int16Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<i16>((acc: i16, val: i16, index: i32, self: Int16Array): i16 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceUint16ArrayTest(): void {
|
||||
var array: Uint16Array = new Uint16Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<u16>((acc: u16, val: u16, index: i32, self: Uint16Array): u16 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceInt32ArrayTest(): void {
|
||||
var array: Int32Array = new Int32Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<i32>((acc: i32, val: i32, index: i32, self: Int32Array): i32 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceUint32ArrayTest(): void {
|
||||
var array: Uint32Array = new Uint32Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<u32>((acc: u32, val: u32, index: i32, self: Uint32Array): u32 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceInt64ArrayTest(): void {
|
||||
var array: Int64Array = new Int64Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<i64>((acc: i64, val: i64, index: i32, self: Int64Array): i64 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceUint64ArrayTest(): void {
|
||||
var array: Uint64Array = new Uint64Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<u64>((acc: u64, val: u64, index: i32, self: Uint64Array): u64 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceFloat32ArrayTest(): void {
|
||||
var array: Float32Array = new Float32Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<f32>((acc: f32, val: f32, index: i32, self: Float32Array): f32 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceFloat64ArrayTest(): void {
|
||||
var array: Float64Array = new Float64Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 0;
|
||||
var result = array.reduce<f64>((acc: f64, val: f64, index: i32, self: Float64Array): f64 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// ++testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
reduceInt8ArrayTest();
|
||||
reduceUint8ArrayTest();
|
||||
reduceUint8ClampedArrayTest();
|
||||
reduceInt16ArrayTest();
|
||||
reduceUint16ArrayTest();
|
||||
reduceInt32ArrayTest();
|
||||
reduceUint32ArrayTest();
|
||||
reduceInt64ArrayTest();
|
||||
reduceUint64ArrayTest();
|
||||
reduceFloat32ArrayTest();
|
||||
reduceFloat64ArrayTest();
|
||||
|
||||
/**
|
||||
* ReduceRight test suite:
|
||||
* Each function is designed to test a simple sum reduction. In each test it initialized the tested
|
||||
* typedarray, and sets the values manually. Then it calls `TypedArray.prototype.reduceRight` with a
|
||||
* single sum arrow function reduction. For each reduction, it verifies the `self` parameter is the
|
||||
* instantiated array, the index is the correct index, and it increments the testIndex variable.
|
||||
* Finally, it asserts the value is 6.
|
||||
*
|
||||
* TODO: When function closure support is added, remove the function comments to fully verify the
|
||||
* tests work.
|
||||
*/
|
||||
function reduceRightInt8ArrayTest(): void {
|
||||
var array: Int8Array = new Int8Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
function testReduce<ArrayType, T>(): void {
|
||||
var array: ArrayType = instantiate<ArrayType>(3);
|
||||
array[0] = <T>1;
|
||||
array[1] = <T>2;
|
||||
array[2] = <T>3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<i8>((acc: i8, val: i8, index: i32, self: Int8Array): i8 => {
|
||||
var result = array.reduce<T>((acc: T, val: T, index: i32, self: ArrayType): T => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
assert(result == <T>6);
|
||||
}
|
||||
|
||||
function reduceRightUint8ArrayTest(): void {
|
||||
var array: Uint8Array = new Uint8Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
testReduce<Int8Array, i8>();
|
||||
testReduce<Uint8Array, u8>();
|
||||
testReduce<Uint8ClampedArray, u8>();
|
||||
testReduce<Int16Array, i16>();
|
||||
testReduce<Uint16Array, u16>();
|
||||
testReduce<Int32Array, i32>();
|
||||
testReduce<Uint32Array, u32>();
|
||||
testReduce<Int64Array, i64>();
|
||||
testReduce<Uint64Array, u64>();
|
||||
testReduce<Float32Array, f32>();
|
||||
testReduce<Float64Array, f64>();
|
||||
|
||||
function testReduceRight<ArrayType, T>(): void {
|
||||
var array: ArrayType = instantiate<ArrayType>(3);
|
||||
array[0] = <T>1;
|
||||
array[1] = <T>2;
|
||||
array[2] = <T>3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<u8>((acc: u8, val: u8, index: i32, self: Uint8Array): u8 => {
|
||||
var result = array.reduceRight<T>((acc: T, val: T, index: i32, self: ArrayType): T => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
assert(result == <T>6);
|
||||
}
|
||||
|
||||
function reduceRightUint8ClampedArrayTest(): void {
|
||||
var array: Uint8ClampedArray = new Uint8ClampedArray(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<u8>((acc: u8, val: u8, index: i32, self: Uint8ClampedArray): u8 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
testReduceRight<Int8Array, i8>();
|
||||
testReduceRight<Uint8Array, u8>();
|
||||
testReduceRight<Uint8ClampedArray, u8>();
|
||||
testReduceRight<Int16Array, i16>();
|
||||
testReduceRight<Uint16Array, u16>();
|
||||
testReduceRight<Int32Array, i32>();
|
||||
testReduceRight<Uint32Array, u32>();
|
||||
testReduceRight<Int64Array, i64>();
|
||||
testReduceRight<Uint64Array, u64>();
|
||||
testReduceRight<Float32Array, f32>();
|
||||
testReduceRight<Float64Array, f64>();
|
||||
|
||||
function testArrayMap<ArrayType extends TypedArray<T>, T>(): void {
|
||||
var source: ArrayType = instantiate<ArrayType>(3);
|
||||
source[0] = <T>1;
|
||||
source[1] = <T>2;
|
||||
source[2] = <T>3;
|
||||
// var testIndex: i32 = 0;
|
||||
var result = source.map((value: T, index: i32, self: ArrayType): T => {
|
||||
// assert(self == source);
|
||||
// assert(testIndex == testIndex);
|
||||
// testIndex++;
|
||||
return value * value;
|
||||
});
|
||||
assert(result[0] == <T>1);
|
||||
assert(result[1] == <T>4);
|
||||
assert(result[2] == <T>9);
|
||||
}
|
||||
|
||||
function reduceRightInt16ArrayTest(): void {
|
||||
var array: Int16Array = new Int16Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<i16>((acc: i16, val: i16, index: i32, self: Int16Array): i16 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceRightUint16ArrayTest(): void {
|
||||
var array: Uint16Array = new Uint16Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<u16>((acc: u16, val: u16, index: i32, self: Uint16Array): u16 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceRightInt32ArrayTest(): void {
|
||||
var array: Int32Array = new Int32Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<i32>((acc: i32, val: i32, index: i32, self: Int32Array): i32 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceRightUint32ArrayTest(): void {
|
||||
var array: Uint32Array = new Uint32Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<u32>((acc: u32, val: u32, index: i32, self: Uint32Array): u32 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceRightInt64ArrayTest(): void {
|
||||
var array: Int64Array = new Int64Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<i64>((acc: i64, val: i64, index: i32, self: Int64Array): i64 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceRightUint64ArrayTest(): void {
|
||||
var array: Uint64Array = new Uint64Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<u64>((acc: u64, val: u64, index: i32, self: Uint64Array): u64 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceRightFloat32ArrayTest(): void {
|
||||
var array: Float32Array = new Float32Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<f32>((acc: f32, val: f32, index: i32, self: Float32Array): f32 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
function reduceRightFloat64ArrayTest(): void {
|
||||
var array: Float64Array = new Float64Array(3);
|
||||
array[0] = 1;
|
||||
array[1] = 2;
|
||||
array[2] = 3;
|
||||
// var testindex: i32 = 2;
|
||||
var result = array.reduceRight<f64>((acc: f64, val: f64, index: i32, self: Float64Array): f64 => {
|
||||
// assert(testindex == index);
|
||||
// assert(array == self);
|
||||
// --testindex;
|
||||
return acc + val;
|
||||
}, 0);
|
||||
assert(result == 6);
|
||||
}
|
||||
|
||||
reduceRightInt8ArrayTest();
|
||||
reduceRightUint8ArrayTest();
|
||||
reduceRightUint8ClampedArrayTest();
|
||||
reduceRightInt16ArrayTest();
|
||||
reduceRightUint16ArrayTest();
|
||||
reduceRightInt32ArrayTest();
|
||||
reduceRightUint32ArrayTest();
|
||||
reduceRightInt64ArrayTest();
|
||||
reduceRightUint64ArrayTest();
|
||||
reduceRightFloat32ArrayTest();
|
||||
reduceRightFloat64ArrayTest();
|
||||
testArrayMap<Int8Array, i8>();
|
||||
testArrayMap<Uint8Array, u8>();
|
||||
testArrayMap<Uint8ClampedArray, u8>();
|
||||
testArrayMap<Int16Array, i16>();
|
||||
testArrayMap<Uint16Array, u16>();
|
||||
testArrayMap<Int32Array, i32>();
|
||||
testArrayMap<Uint32Array, u32>();
|
||||
testArrayMap<Int64Array, i64>();
|
||||
testArrayMap<Uint64Array, u64>();
|
||||
testArrayMap<Float32Array, f32>();
|
||||
testArrayMap<Float64Array, f64>();
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user