public void ContainsWorks() { var arr = new Uint32Array(new uint[] { 3, 6, 2, 9, 5 }); Assert.True(arr.Contains(9), "9"); Assert.False(arr.Contains(1), "1"); }
public void ICollectionCopyTo() { ICollection <uint> l = new Uint32Array(new uint[] { 0, 1, 2 }); var a1 = new uint[3]; l.CopyTo(a1, 0); Assert.AreEqual(0, a1[0], "1.Element 0"); Assert.AreEqual(1, a1[1], "1.Element 1"); Assert.AreEqual(2, a1[2], "1.Element 2"); var a2 = new uint[5]; l.CopyTo(a2, 1); Assert.AreEqual(0, a2[0], "2.Element 0"); Assert.AreEqual(0, a2[1], "2.Element 1"); Assert.AreEqual(1, a2[2], "2.Element 2"); Assert.AreEqual(2, a2[3], "2.Element 3"); Assert.AreEqual(0, a2[4], "2.Element 4"); Assert.Throws <ArgumentNullException>(() => { l.CopyTo(null, 0); }, "3.null"); var a3 = new uint[2]; Assert.Throws <ArgumentException>(() => { l.CopyTo(a3, 0); }, "3.Short array"); var a4 = new uint[3]; Assert.Throws <ArgumentException>(() => { l.CopyTo(a4, 1); }, "3.Start index 1"); Assert.Throws <ArgumentOutOfRangeException>(() => { l.CopyTo(a4, -1); }, "3.Negative start index"); Assert.Throws <ArgumentException>(() => { l.CopyTo(a4, 3); }, "3.Start index 3"); }
public void IndexOfWorks() { var arr = new Uint32Array(new uint[] { 3, 6, 2, 9, 5 }); Assert.AreEqual(3, arr.IndexOf(9), "9"); Assert.AreEqual(-1, arr.IndexOf(1), "1"); }
public void CopyConstructorWorks() { var source = new Uint32Array(new uint[] { 3, 8, 4 }); var arr = new Uint32Array(source); Assert.IsTrue(arr != source, "New object"); Assert.IsTrue((object)arr is Uint32Array, "is Uint32Array"); AssertContent(arr, new[] { 3, 8, 4 }, "content"); }
public void SetNormalArrayWithOffsetWorks() { var arr = new Uint32Array(6); arr.Set(new uint[] { 3, 6, 7 }, 2); AssertContent(arr, new[] { 0, 0, 3, 6, 7, 0 }, "Content"); }
public ITypedArray CastNativeArray(object managedArray) { var arrayType = managedArray.GetType(); ITypedArray array; // Here are listed some JavaScript array types: // https://github.com/mono/mono/blob/a7f5952c69ae76015ccaefd4dfa8be2274498a21/sdks/wasm/bindings-test.cs if (arrayType == typeof(byte[])) { array = Uint8Array.From((byte[])managedArray); } else if (arrayType == typeof(float[])) { array = Float32Array.From((float[])managedArray); } else if (arrayType == typeof(ushort[])) { array = Uint16Array.From((ushort[])managedArray); } else if (arrayType == typeof(uint[])) { array = Uint32Array.From((uint[])managedArray); } else { throw new NotImplementedException(); } return(array); }
public void SetNormalArrayWorks() { var arr = new Uint32Array(4); arr.Set(new uint[] { 3, 6, 7 }); AssertContent(arr, new[] { 3, 6, 7, 0 }, "Content"); }
public void BufferPropertyWorks() { var buf = new ArrayBuffer(100); var arr = new Uint32Array(buf); Assert.True(arr.Buffer == buf, "Should be correct"); }
public static void Uint32ArrayFromArrayBuffer(Function objectPrototype) { Uint32Array from = new Uint32Array(new ArrayBuffer(40)); Assert.True(from.Length == 10); Assert.Equal("[object Uint32Array]", objectPrototype.Call(from)); }
public void ByteOffsetPropertyWorks() { var buf = new ArrayBuffer(100); var arr = new Uint32Array(buf, 32); Assert.AreEqual(32, arr.ByteOffset, "Should be correct"); }
public void LengthConstructorWorks() { var arr = new Uint32Array(13); Assert.True((object)arr is Uint32Array, "is Uint32Array"); Assert.AreEqual(13, arr.Length, "Length"); }
public void ArrayBufferWithOffsetConstructorWorks() { var buf = new ArrayBuffer(80); var arr = new Uint32Array(buf, 16); Assert.IsTrue((object)arr is Uint32Array); Assert.IsTrue(arr.Buffer == buf, "buffer"); Assert.AreEqual(arr.Length, 16, "length"); }
public static void Uint32ArrayFromSharedArrayBuffer(Function objectPrototype) { Uint32Array from = new Uint32Array(new SharedArrayBuffer(40)); Assert.Equal(10, from.Length); Assert.Equal("[object Uint32Array]", objectPrototype.Call(from)); }
public static void Uint32ArrayFrom(Function objectPrototype) { var array = new uint[50]; Uint32Array from = Uint32Array.From(array); Assert.Equal(50, from.Length); Assert.Equal("[object Uint32Array]", objectPrototype.Call(from)); }
public void IndexingWorks() { var arr = new Uint32Array(3); arr[1] = 42; AssertContent(arr, new[] { 0, 42, 0 }, "Content"); Assert.AreEqual(42, arr[1], "[1]"); }
public void SubarrayWithBeginWorks() { var source = new Uint32Array(10); var arr = source.SubArray(3); Assert.False(arr == source, "Should be a new array"); Assert.True(arr.Buffer == source.Buffer, "Should be the same buffer"); Assert.AreEqual(12, arr.ByteOffset, "ByteOffset should be correct"); }
public void CopyConstructorWorks() { var source = new Uint32Array(new uint[] { 3, 8, 4 }); var arr = new Uint32Array(source); Assert.True(arr != source, "New object"); Assert.True((object)arr is Uint32Array, "is Uint32Array"); AssertContent(arr, new[] { 3, 8, 4 }, "content"); }
public void ArrayBufferWithOffsetConstructorWorks() { var buf = new ArrayBuffer(80); var arr = new Uint32Array(buf, 16); Assert.True((object)arr is Uint32Array); Assert.True(arr.Buffer == buf, "buffer"); Assert.AreEqual(16, arr.Length, "length"); }
public void ArrayBufferConstructorWorks() { var buf = new ArrayBuffer(80); var arr = new Uint32Array(buf); Assert.IsTrue((object)arr is Uint32Array); Assert.IsTrue(arr.Buffer == buf, "buffer"); Assert.AreEqual(arr.Length, 20, "length"); }
public void ConstructorFromIntWorks() { var source = new uint[] { 3, 8, 4 }; var arr = new Uint32Array(source); Assert.IsTrue((object)arr != (object)source, "New object"); Assert.IsTrue((object)arr is Uint32Array, "is Uint32Array"); AssertContent(arr, new[] { 3, 8, 4 }, "content"); }
public void SubarrayWithBeginAndEndWorks() { var source = new Uint32Array(10); var arr = source.Subarray(3, 7); Assert.IsFalse(arr == source, "Should be a new array"); Assert.IsTrue(arr.Buffer == source.Buffer, "Should be the same buffer"); Assert.AreEqual(arr.ByteOffset, 12, "ByteOffset should be correct"); Assert.AreEqual(arr.Length, 4, "Length should be correct"); }
public void ForeachWorks() { var arr = new Uint32Array(new uint[] { 3, 6, 2, 9, 5 }); var l = new List <uint>(); foreach (var i in arr) { l.Add(i); } Assert.AreEqual(l, new[] { 3, 6, 2, 9, 5 }); }
public void GetEnumeratorWorks() { var arr = new Uint32Array(new uint[] { 3, 6, 2, 9, 5 }); var l = new List <uint>(); var enm = arr.GetEnumerator(); while (enm.MoveNext()) { l.Add(enm.Current); } Assert.AreEqual(l, new[] { 3, 6, 2, 9, 5 }); }
public void ForeachWorks_SPI_1401() { var arr = new Uint32Array(new uint[] { 3, 6, 2, 9, 5 }); var l = new List <uint>(); // #1401 foreach (var i in arr) { l.Add(i); } Assert.AreEqual(l.ToArray(), new[] { 3, 6, 2, 9, 5 }); }
private void AssertContent(Uint32Array actual, int[] expected, string message) { if (actual.Length != expected.Length) { Assert.Fail(message + ": Expected length " + expected.Length + ", actual: " + actual.Length); return; } for (int i = 0; i < expected.Length; i++) { if (actual[i] != expected[i]) { Assert.Fail(message + ": Position " + i + ": expected " + expected[i] + ", actual: " + actual[i]); return; } } Assert.IsTrue(true, message); }
private unsafe void EnsureArrayCapacity(int numBatchItems) #endif { int neededCapacity = 6 * numBatchItems; if (_index != null && neededCapacity <= _index.Length) { // Short circuit out of here because we have enough capacity. return; } var newIndex = new short[6 * numBatchItems]; int start = 0; if (_index != null) { _index.CopyTo(newIndex, 0); start = _index.Length / 6; } var indexPtr = (start * 6); for (var i = start; i < numBatchItems; i++, indexPtr += 6) { /* * TL TR * 0----1 0,1,2,3 = index offsets for vertex indices * | /| TL,TR,BL,BR are vertex references in SpriteBatchItem. * | / | * | / | * |/ | * 2----3 * BL BR */ // Triangle 1 newIndex[indexPtr + 0] = (i * 4 + 0).As <short>(); newIndex[indexPtr + 1] = (i * 4 + 1).As <short>(); newIndex[indexPtr + 2] = (i * 4 + 2).As <short>(); newIndex[indexPtr + 3] = (i * 4 + 1).As <short>(); newIndex[indexPtr + 4] = (i * 4 + 3).As <short>(); newIndex[indexPtr + 5] = (i * 4 + 2).As <short>(); } _index = newIndex; _vertexArray = new ArrayBuffer(4 * numBatchItems * 6 * 4); _vertexArrayF = new Float32Array(_vertexArray); _vertexArrayC = new Uint32Array(_vertexArray); }
public void TypePropertiesAreCorrect() { Assert.AreEqual(typeof(Uint32Array).FullName, "Uint32Array", "FullName"); var interfaces = typeof(Uint32Array).GetInterfaces(); Assert.AreEqual(interfaces.Length, 3, "Interface count should be 3"); Assert.IsTrue(interfaces.Contains(typeof(IEnumerable<uint>)), "Interfaces should contain IEnumerable<uint>"); Assert.IsTrue(interfaces.Contains(typeof(ICollection<uint>)), "Interfaces should contain ICollection<uint>"); Assert.IsTrue(interfaces.Contains(typeof(IList<uint>)), "Interfaces should contain IList<uint>"); object arr = new Uint32Array(0); Assert.IsTrue(arr is Uint32Array, "Is Uint32Array"); Assert.IsTrue(arr is IEnumerable<uint>, "Is IEnumerable<uint>"); Assert.IsTrue(arr is ICollection<uint>, "Is ICollection<uint>"); Assert.IsTrue(arr is IList<uint>, "Is IList<int>"); }
public void Uint32Array_indexed_setter_stores_and_retrieves_with_correct_signedness() { // In order to test all possible values for integers, we // need to create a buffer large enough to store them all, // except .NET won't allow arrays larger than Int32.MaxValue, // or 0x7FFFFFFF, which is only large enough to store // 0x1FFFFFFF 4-byte unsigned integers, with 3 extra bytes. // Creating four of these covers almost all 4-byte integers // starting from 0x00000000 all the way to 0xFFFFFFF7, // leaving a final check on values 0xFFFFFFF8-0xFFFFFFFF. // Unfortunately, not all machines are going to have // 2GB of contiguous RAM sitting around handy, and it may // not get fully GC'd in time for the next loop, so we'll // shrink the window even further still to 0x1FFFFFF, // which over 128 windows covers 0x00000000-0xFFFFFF7F, // leaving a final check on values 0xFFFFFF80-0xFFFFFFFF. int windowSize = 0x1FFFFFF; for (uint window = 0; window < 128; window++) { byte[] buf = new byte[windowSize * 4]; var u32winarr = new Uint32Array(buf, 0, 0); for (var i = 0; i < windowSize; i++) { u32winarr[i] = (uint)((window * windowSize) + i); } for (uint i = (uint)(window * windowSize), j = 0; j < windowSize; i++, j++) { Assert.AreEqual(u32winarr[(int)j], i); } } byte[] finalbuf = new byte[0x80 * 4]; var finalu32winarr = new Uint32Array(finalbuf, 0, 0); for (var i = 0; i < 0x80; i++) { finalu32winarr[i] = (uint)(((uint)128 * windowSize) + i); } for (uint i = (uint)(windowSize * 128), j = 0; j < 0x80; j++, i++) { Assert.AreEqual(finalu32winarr[(int)j], i); } }
private void AssertContent(Uint32Array actual, int[] expected, string message) { if (actual.Length != expected.Length) { Assert.Fail(message + ": Expected length " + expected.Length + ", actual: " + actual.Length); return; } for (int i = 0; i < expected.Length; i++) { if (actual[i] != expected[i]) { Assert.Fail(message + ": Position " + i + ": expected " + expected[i] + ", actual: " + actual[i]); return; } } Assert.True(true, message); }
public void TypePropertiesAreCorrect() { Assert.AreEqual(typeof(Uint32Array).FullName, "Uint32Array", "FullName"); var interfaces = typeof(Uint32Array).GetInterfaces(); Assert.AreEqual(interfaces.Length, 3, "Interface count should be 3"); Assert.IsTrue(interfaces.Contains(typeof(IEnumerable <uint>)), "Interfaces should contain IEnumerable<uint>"); Assert.IsTrue(interfaces.Contains(typeof(ICollection <uint>)), "Interfaces should contain ICollection<uint>"); Assert.IsTrue(interfaces.Contains(typeof(IList <uint>)), "Interfaces should contain IList<uint>"); object arr = new Uint32Array(0); Assert.IsTrue(arr is Uint32Array, "Is Uint32Array"); Assert.IsTrue(arr is IEnumerable <uint>, "Is IEnumerable<uint>"); Assert.IsTrue(arr is ICollection <uint>, "Is ICollection<uint>"); Assert.IsTrue(arr is IList <uint>, "Is IList<int>"); }
public static void TestUseCase(Assert assert) { assert.Expect(10); var array1 = new Int8Array(1); Bridge550.TestMethod(array1, "Int8Array", assert); var array2 = new Uint8Array(1); Bridge550.TestMethod(array2, "Uint8Array", assert); var array3 = new Uint8ClampedArray(1); Bridge550.TestMethod(array3, "Uint8ClampedArray", assert); var array4 = new Int16Array(1); Bridge550.TestMethod(array4, "Int16Array", assert); var array5 = new Uint16Array(1); Bridge550.TestMethod(array5, "Uint16Array", assert); var array6 = new Int32Array(1); Bridge550.TestMethod(array6, "Int32Array", assert); var array7 = new Uint32Array(1); Bridge550.TestMethod(array7, "Uint32Array", assert); var array8 = new Float32Array(1); Bridge550.TestMethod(array8, "Float32Array", assert); var array9 = new Float64Array(1); Bridge550.TestMethod(array9, "Float64Array", assert); var array10 = new DataView(array9.Buffer); Bridge550.TestMethod(array10, "DataView", assert); }
public void Uint32Array_indexed_setter_alters_source_buffer_contents_according_to_native_endianness() { byte[] buf = new byte[] { 0x00, 0x01, 0x02, 0x03 }; var u32arr = new Uint32Array(buf, 0); u32arr[0] = 2864434397; // 0xAABBCCDD, stored as [0xAA, 0xBB, 0xCC, 0xDD] on big endian archs and [0xDD, 0xCC, 0xBB, 0xAA] on little endian archs. if (BitConverter.IsLittleEndian) { Assert.AreEqual(buf[0], 0xDD); Assert.AreEqual(buf[1], 0xCC); Assert.AreEqual(buf[2], 0xBB); Assert.AreEqual(buf[3], 0xAA); } else { Assert.AreEqual(buf[3], 0xDD); Assert.AreEqual(buf[2], 0xCC); Assert.AreEqual(buf[1], 0xBB); Assert.AreEqual(buf[0], 0xAA); } }
private void BufferData <T>(int offsetInBytes, T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct { GenerateIfRequired(); var elementSizeInByte = (IndexElementSize == IndexElementSize.SixteenBits ? 2 : 4); var bufferSize = IndexCount * elementSizeInByte; gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo); GraphicsExtensions.CheckGLError(); if (options == SetDataOptions.Discard) { // By assigning NULL data to the buffer this gives a hint // to the device to discard the previous content. gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Int16Array(0), _isDynamic ? gl.STREAM_DRAW : gl.STATIC_DRAW); GraphicsExtensions.CheckGLError(); } if (elementSizeInByte == 2) { var arr = new Uint16Array((uint)elementCount); for (uint i = 0; i < elementCount; i++) { arr[i] = data[i + startIndex].As <ushort>(); } gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, offsetInBytes, arr); } else { var arr = new Uint32Array((uint)elementCount); for (uint i = 0; i < elementCount; i++) { arr[i] = data[i + startIndex].As <uint>(); } gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, offsetInBytes, arr); } GraphicsExtensions.CheckGLError(); }
public static IEnumerable <object[]> ArrayType_TestData() { _objectPrototype ??= new Function("return Object.prototype.toString;"); yield return(new object[] { _objectPrototype.Call(), "Uint8Array", Uint8Array.From(new byte[10]) }); yield return(new object[] { _objectPrototype.Call(), "Uint8ClampedArray", Uint8ClampedArray.From(new byte[10]) }); yield return(new object[] { _objectPrototype.Call(), "Int8Array", Int8Array.From(new sbyte[10]) }); yield return(new object[] { _objectPrototype.Call(), "Uint16Array", Uint16Array.From(new ushort[10]) }); yield return(new object[] { _objectPrototype.Call(), "Int16Array", Int16Array.From(new short[10]) }); yield return(new object[] { _objectPrototype.Call(), "Uint32Array", Uint32Array.From(new uint[10]) }); yield return(new object[] { _objectPrototype.Call(), "Int32Array", Int32Array.From(new int[10]) }); yield return(new object[] { _objectPrototype.Call(), "Float32Array", Float32Array.From(new float[10]) }); yield return(new object[] { _objectPrototype.Call(), "Float64Array", Float64Array.From(new double[10]) }); yield return(new object[] { _objectPrototype.Call(), "Array", new Array(10) }); }
public void ByteLengthPropertyWorks() { var arr = new Uint32Array(23); Assert.AreEqual(arr.ByteLength, 92, "Should be correct"); }
public void LengthConstructorWorks() { var arr = new Uint32Array(13); Assert.IsTrue((object)arr is Uint32Array, "is Uint32Array"); Assert.AreEqual(arr.Length, 13, "Length"); }
public void ForeachWorks() { var arr = new Uint32Array(new uint[] { 3, 6, 2, 9, 5 }); var l = new List<uint>(); foreach (var i in arr) { l.Add(i); } Assert.AreEqual(l, new[] { 3, 6, 2, 9, 5 }); }
public void LengthWorks() { var arr = new Uint32Array(13); Assert.AreEqual(arr.Length, 13, "Length"); }
public void IndexingWorks() { var arr = new Uint32Array(3); arr[1] = 42; AssertContent(arr, new[] { 0, 42, 0 }, "Content"); Assert.AreEqual(arr[1], 42, "[1]"); }
public void ContainsWorks() { var arr = new Uint32Array(new uint[] { 3, 6, 2, 9, 5 }); Assert.IsTrue (arr.Contains(9), "9"); Assert.IsFalse(arr.Contains(1), "1"); }
public void IndexOfWorks() { var arr = new Uint32Array(new uint[] { 3, 6, 2, 9, 5 }); Assert.AreEqual(arr.IndexOf(9), 3, "9"); Assert.AreEqual(arr.IndexOf(1), -1, "1"); }
public void ByteOffsetPropertyWorks() { var buf = new ArrayBuffer(100); var arr = new Uint32Array(buf, 32); Assert.AreEqual(arr.ByteOffset, 32, "Should be correct"); }
public void BufferPropertyWorks() { var buf = new ArrayBuffer(100); var arr = new Uint32Array(buf); Assert.IsTrue(arr.Buffer == buf, "Should be correct"); }
/// <summary> /// Creates a new Uint32Array out of the specified Uint32Array. /// </summary> /// <param name="typedArray">Uint32Array to use as initial contents to the new array.</param> public Uint32Array(Uint32Array typedArray) { }
public void GetEnumeratorWorks() { var arr = new Uint32Array(new uint[] { 3, 6, 2, 9, 5 }); var l = new List<uint>(); var enm = arr.GetEnumerator(); while (enm.MoveNext()) { l.Add(enm.Current); } Assert.AreEqual(l, new[] { 3, 6, 2, 9, 5 }); }