Changeset 1691

Timestamp:

06/24/10 00:38:40 (14 years ago)

Author:

dsimcha

Message:

Start improving std.range unittests. Lots of bugs found already.

Files:

• trunk/phobos/std/range.d (modified) (7 diffs)

trunk/phobos/std/range.d

@@ -24 +24 @@
-import std.contracts;
-import std.traits;
-import std.typecons;
-import std.typetuple;
-import std.algorithm;
-import std.functional;
-import std.conv;
-version(unittest)
-{
-    import std.container, std.conv, std.math, std.stdio;
+
+    // Used with the dummy ranges for testing higher order ranges.
+    enum RangeType {
+        Input,
+        Forward,
+        Bidirectional,
+        Random
+    }
+
+    enum Length {
+        Yes,
+        No
+    }
+
+    enum ReturnBy {
+        Reference,
+        Value
+    }
+
+    // Range that's useful for testing other higher order ranges,
+    // can be parametrized with attributes.  It just dumbs down an array of
+    // numbers 1..10.
+    struct DummyRange(ReturnBy _r, Length _l, RangeType _rt) {
+        // These enums are so that the template params are visible outside
+        // this instantiation.
+        enum r = _r;
+        enum l = _l;
+        enum rt = _rt;
+
+        uint[] arr = [1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U];
+
+        void reinit() {
+            // Workaround for DMD bug 4378
+            arr = [1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U];
+        }
+
+        void popFront() {
+            arr = arr[1..$];
+        }
+
+        @property bool empty() {
+            return arr.length == 0;
+        }
+
+        static if(r == ReturnBy.Reference) {
+            @property ref uint front() {
+                return arr[0];
+            }
+        } else {
+            @property uint front() {
+                return arr[0];
+            }
+        }
+
+        static if(rt >= RangeType.Forward) {
+            @property typeof(this) save() {
+                return this;
+            }
+        }
+
+        static if(rt >= RangeType.Bidirectional) {
+            void popBack() {
+                arr = arr[0..$ - 1];
+            }
+
+            static if(r == ReturnBy.Reference) {
+                @property ref uint back() {
+                    return arr[$ - 1];
+                }
+            } else {
+                @property uint back() {
+                    return arr[$ - 1];
+                }
+            }
+        }
+
+        static if(rt >= RangeType.Random) {
+            static if(r == ReturnBy.Reference) {
+                @property ref uint opIndex(size_t index) {
+                    return arr[index];
+                }
+            } else {
+                @property uint opIndex(size_t index) {
+                    return arr[index];
+                }
+            }
+        }
+
+        static if(l == Length.Yes) {
+            @property size_t length() {
+                return arr.length;
+            }
+        }
+    }
+
+    alias TypeTuple!(
+        DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Input),
+        DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Forward),
+        DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Bidirectional),
+        DummyRange!(ReturnBy.Reference, Length.Yes, RangeType.Random),
+        DummyRange!(ReturnBy.Reference, Length.No, RangeType.Input),
+        DummyRange!(ReturnBy.Reference, Length.No, RangeType.Forward),
+        DummyRange!(ReturnBy.Reference, Length.No, RangeType.Bidirectional),
+        DummyRange!(ReturnBy.Reference, Length.No, RangeType.Random),
+        DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Input),
+        DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Forward),
+        DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Bidirectional),
+        DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Random),
+        DummyRange!(ReturnBy.Value, Length.No, RangeType.Input),
+        DummyRange!(ReturnBy.Value, Length.No, RangeType.Forward),
+        DummyRange!(ReturnBy.Value, Length.No, RangeType.Bidirectional),
+        DummyRange!(ReturnBy.Value, Length.No, RangeType.Random)
+    ) AllDummyRanges;
+
+    alias TypeTuple!(1,2,3,4,5,6,7,8,9,0,11,12,13,14,15,16) DummyIndices;
-}
-
-/**
-Returns $(D true) if $(D R) is an input range. An input range must
-define the primitives $(D empty), $(D popFront), and $(D front). The
-following code should compile for any input range.
-
-----
-R r;             // can define a range object
-if (r.empty) {}  // can test for empty
@@ -619 +734 @@
-        assert(r.front == witness.front);
-        assert(r.back == witness.back);
-        assert(equal(r, witness));
-    }
-    test([ 1 ], [ 1 ]);
-    test([ 1, 2 ], [ 2, 1 ]);
-    test([ 1, 2, 3 ], [ 3, 2, 1 ]);
-    test([ 1, 2, 3, 4 ], [ 4, 3, 2, 1 ]);
-    test([ 1, 2, 3, 4, 5 ], [ 5, 4, 3, 2, 1 ]);
-    test([ 1, 2, 3, 4, 5, 6 ], [ 6, 5, 4, 3, 2, 1 ]);
+
+    foreach(DummyType; AllDummyRanges) {
+        static if(!isBidirectionalRange!DummyType) {
+            static assert(!__traits(compiles, Retro!DummyType));
+        } else {
+            DummyType dummyRange;
+            dummyRange.reinit();
+
+            auto myRetro = retro(dummyRange);
+            assert(myRetro.front == 10);
+            assert(myRetro.back == 1);
+
+            static if(isRandomAccessRange!DummyType && hasLength!DummyType) {
+                assert(myRetro[0] == myRetro.front);
+
+                static if(DummyType.r == ReturnBy.Reference) {
+                    myRetro[9]++;
+                    assert(dummyRange[0] == 2);
+                    myRetro.front++;
+                    assert(myRetro.front == 11);
+                    myRetro.back++;
+                    assert(myRetro.back == 3);
+                }
+            }
+        }
+    }
-}
-
-/**
-Iterates range $(D r) with stride $(D n). If the range is a
-random-access range, moves by indexing into the range; otehrwise,
-moves by successive calls to $(D popFront).
-
-Example:
-----
-int[] a = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ];
@@ -655 +796 @@
-        _n = n;
-        static if (hasLength!(R))
-        {
-            auto slack = _input.length % _n;
-            if (slack) slack--;
-            if (!slack) return;
-            static if (isRandomAccessRange!(R) && hasSlicing!(R))
-            {
-                _input = _input[0 .. _input.length - slack];
-            }
-
+ static if(isBidirectionalRange!(R))
-            {
-                foreach (i; 0 .. slack)
-                {
-                    if (_input.empty) break;
-                    _input.popBack;
-                }
-            }
-        }
-    }
-
-/**
-Returns $(D this).
- */
-
-
-
+
+
+
+
+
+
-    }
-
-/**
-Forwards to $(D _input.empty).
- */
-    bool empty()
-    {
-        return _input.empty;
-    }
-
@@ -704 +848 @@
-            foreach (i; 0 .. _n)
-            {
-                _input.popFront;
-                if (_input.empty) break;
-            }
-    }
-
-/**
-Forwards to $(D _input.popFront).
- */
-
+isBidirectionalRange!(R) && 
-        void popBack()
-        {
-            enforce(_input.length >= _n);
-            static if (isRandomAccessRange!(R) && hasSlicing!(R))
-            {
-                _input = _input[0 .. _input.length - _n];
-            }
-            else
-            {
-                foreach (i; 0 .. _n)
@@ -733 +877 @@
-Forwards to $(D _input.front).
- */
-    ref ElementType!(R) front()
-    {
-        return _input.front;
-    }
-
-/**
-Forwards to $(D _input.back) after getting rid of any slack items.
- */
-
-
-
+
+
+
+
+
+
-    }
-
-/**
-Forwards to $(D _input[_input.length - n + 1]). Defined only if $(D R)
-is a random access range and if $(D R) defines $(D R.length).
- */
-    static if (isRandomAccessRange!(R) && hasLength!(R))
-        ref ElementType!(R) opIndex(uint n)
-        {
-            return _input[_n * n];
@@ -781 +928 @@
-    void test(size_t n, int[] input, int[] witness)
-    {
-        assert(equal(stride(input, n), witness));
-    }
-    test(1, [], []);
-    int[] arr = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
-    test(1, arr, arr);
-    test(2, arr, [1, 3, 5, 7, 9]);
-    test(3, arr, [1, 4, 7, 10]);
-    test(4, arr, [1, 5, 9]);
+
+    foreach(DummyType; AllDummyRanges) {
+        static if(DummyType.r == ReturnBy.Reference) {
+            // Doesn't work yet w/o ref returns, see DMD bug 3294.
+            DummyType dummyRange;
+            dummyRange.reinit();
+
+            auto myStride = stride(dummyRange, 4);
+            assert(myStride.front == 1);
+            assert(equal(myStride, [1, 5, 9]));
+
+            static if(hasLength!DummyType) {
+                assert(myStride.length == 3);
+            }
+
+            static if(isBidirectionalRange!DummyType && hasLength!DummyType) {
+                assert(myStride.back == 9);
+            }
+
+            static if(isRandomAccessRange!DummyType && hasLength!DummyType) {
+                assert(myStride[0] == 1);
+                assert(myStride[1] == 5);
+                assert(myStride[2] == 9);
+            }
+        }
+    }
-}
-
-/**
-Spans multiple ranges in sequence. The function $(D chain) takes any
-number of ranges and returns a $(D Chain!(R1, R2,...)) object. The
-ranges may be different, but they must have the same element type. The
-result is a range that offers the $(D front), $(D popFront), and $(D empty)
-primitives. If all input ranges offer random access and $(D length),
-$(D Chain) offers them as well.
-
@@ -1631 +1804 @@
-/// Ditto
-Cycle!(R) cycle(R)(ref R input, size_t index = 0) if (isStaticArray!R)
-{
-    return Cycle!(R)(input, index);
-}
-
-unittest
-{
-    assert(equal(take(cycle([1, 2][]), 5), [ 1, 2, 1, 2, 1 ][]));
-    static assert(isForwardRange!(Cycle!(uint[])));
-
-    struct DummyRange {
-        uint num;
-        ref uint front() { return num;  }
-        void popFront() { num++;   }
-        @property bool empty() { return num >= 10; }
-        typeof(this) save() { return this; }
-    }
-    static assert(isForwardRange!(Cycle!(DummyRange)));
-
-    int[3] a = [ 1, 2, 3 ];
-    static assert(isStaticArray!(typeof(a)));
-    auto c = cycle(a);
-    assert(a.ptr == c._ptr);
-    assert(equal(take(cycle(a), 5), [ 1, 2, 3, 1, 2 ][]));
-    static assert(isForwardRange!(typeof(c)));
-}
-
-unittest // For infinite ranges