| module li_std_vector_runme; |
| |
| import tango.core.Exception; |
| import tango.io.Stdout; |
| import Integer = tango.text.convert.Integer; |
| import li_std_vector.li_std_vector; |
| import li_std_vector.DoubleVector; |
| import li_std_vector.IntVector; |
| import li_std_vector.IntPtrVector; |
| import li_std_vector.IntConstPtrVector; |
| import li_std_vector.RealVector; |
| import li_std_vector.Struct; |
| import li_std_vector.StructVector; |
| import li_std_vector.StructPtrVector; |
| import li_std_vector.StructConstPtrVector; |
| |
| const size_t SIZE = 20; |
| |
| void main() { |
| // Basic functionality tests. |
| { |
| auto vector = new IntVector(); |
| for (size_t i = 0; i < SIZE; ++i) { |
| vector ~= i * 10; |
| } |
| |
| if (vector.length != SIZE) { |
| throw new Exception("length test failed."); |
| } |
| |
| vector[0] = 200; |
| if (vector[0] != 200) { |
| throw new Exception("indexing test failed"); |
| } |
| vector[0] = 0 * 10; |
| |
| try { |
| vector[vector.length] = 777; |
| throw new Exception("out of range test failed"); |
| } catch (NoSuchElementException) { |
| } |
| |
| foreach (i, value; vector) { |
| if (value != (i * 10)) { |
| throw new Exception("foreach test failed, i: " ~ Integer.toString(i)); |
| } |
| } |
| |
| vector.clear(); |
| if (vector.size != 0) { |
| throw new Exception("clear test failed"); |
| } |
| } |
| |
| // Slice tests. |
| { |
| auto dVector = new DoubleVector(); |
| for (size_t i = 0; i < SIZE; ++i) { |
| dVector ~= i * 10.1f; |
| } |
| |
| double[] dArray = dVector[]; |
| foreach (i, value; dArray) { |
| if (dVector[i] != value) { |
| throw new Exception("slice test 1 failed, i: " ~ Integer.toString(i)); |
| } |
| } |
| |
| |
| auto sVector = new StructVector(); |
| for (size_t i = 0; i < SIZE; i++) { |
| sVector ~= new Struct(i / 10.0); |
| } |
| |
| Struct[] array = sVector[]; |
| |
| for (size_t i = 0; i < SIZE; i++) { |
| // Make sure that a shallow copy has been made. |
| void* aPtr = Struct.swigGetCPtr(array[i]); |
| void* vPtr = Struct.swigGetCPtr(sVector[i]); |
| if (aPtr != vPtr) { |
| throw new Exception("slice test 2 failed, i: " ~ |
| Integer.toString(i)); |
| } |
| } |
| } |
| |
| // remove() tests. |
| { |
| auto iVector = new IntVector(); |
| for (int i = 0; i < SIZE; i++) { |
| iVector ~= i; |
| } |
| |
| iVector.remove(iVector.length - 1); |
| iVector.remove(SIZE / 2); |
| iVector.remove(0); |
| |
| try { |
| iVector.remove(iVector.size); |
| throw new Exception("remove test failed"); |
| } catch (NoSuchElementException) { |
| } |
| } |
| |
| // Capacity tests. |
| { |
| auto dv = new DoubleVector(10); |
| if ((dv.capacity != 10) || (dv.length != 0)) { |
| throw new Exception("constructor setting capacity test failed"); |
| } |
| |
| // TODO: Is this really required (and spec'ed) behavior? |
| dv.capacity = 20; |
| if (dv.capacity != 20) { |
| throw new Exception("capacity test 1 failed"); |
| } |
| |
| dv ~= 1.11; |
| try { |
| dv.capacity = dv.length - 1; |
| throw new Exception("capacity test 2 failed"); |
| } catch (IllegalArgumentException) { |
| } |
| } |
| |
| // Test the methods being wrapped. |
| { |
| auto iv = new IntVector(); |
| for (int i=0; i<4; i++) { |
| iv ~= i; |
| } |
| |
| double x = average(iv); |
| x += average(new IntVector([1, 2, 3, 4])); |
| RealVector rv = half(new RealVector([10.0f, 10.5f, 11.0f, 11.5f])); |
| |
| auto dv = new DoubleVector(); |
| for (size_t i = 0; i < SIZE; i++) { |
| dv ~= i / 2.0; |
| } |
| halve_in_place(dv); |
| |
| RealVector v0 = vecreal(new RealVector()); |
| float flo = 123.456f; |
| v0 ~= flo; |
| flo = v0[0]; |
| |
| IntVector v1 = vecintptr(new IntVector()); |
| IntPtrVector v2 = vecintptr(new IntPtrVector()); |
| IntConstPtrVector v3 = vecintconstptr(new IntConstPtrVector()); |
| |
| v1 ~= 123; |
| v2.clear(); |
| v3.clear(); |
| |
| StructVector v4 = vecstruct(new StructVector()); |
| StructPtrVector v5 = vecstructptr(new StructPtrVector()); |
| StructConstPtrVector v6 = vecstructconstptr(new StructConstPtrVector()); |
| |
| v4 ~= new Struct(123); |
| v5 ~= new Struct(123); |
| v6 ~= new Struct(123); |
| } |
| |
| // Test vectors of pointers. |
| { |
| auto vector = new StructPtrVector(); |
| for (size_t i = 0; i < SIZE; i++) { |
| vector ~= new Struct(i / 10.0); |
| } |
| |
| Struct[] array = vector[]; |
| |
| for (size_t i = 0; i < SIZE; i++) { |
| // Make sure that a shallow copy has been made. |
| void* aPtr = Struct.swigGetCPtr(array[i]); |
| void* vPtr = Struct.swigGetCPtr(vector[i]); |
| if (aPtr != vPtr) { |
| throw new Exception("StructPtrVector test 1 failed, i: " ~ |
| Integer.toString(i)); |
| } |
| } |
| } |
| |
| // Test vectors of const pointers. |
| { |
| auto vector = new StructConstPtrVector(); |
| for (size_t i = 0; i < SIZE; i++) { |
| vector ~= new Struct(i / 10.0); |
| } |
| |
| Struct[] array = vector[]; |
| |
| for (size_t i = 0; i < SIZE; i++) { |
| // Make sure that a shallow copy has been made. |
| void* aPtr = Struct.swigGetCPtr(array[i]); |
| void* vPtr = Struct.swigGetCPtr(vector[i]); |
| if (aPtr != vPtr) { |
| throw new Exception("StructConstPtrVector test 1 failed, i: " ~ |
| Integer.toString(i)); |
| } |
| } |
| } |
| |
| // Test vectors destroyed via dispose(). |
| { |
| { |
| scope vector = new StructVector(); |
| vector ~= new Struct(0.0); |
| vector ~= new Struct(11.1); |
| } |
| { |
| scope vector = new DoubleVector(); |
| vector ~= 0.0; |
| vector ~= 11.1; |
| } |
| } |
| } |