Changeset 1712

Timestamp:

07/03/10 21:42:27 (14 years ago)

Author:

dsimcha

Message:

More higher order range testing improvements.

Files:

• trunk/phobos/std/algorithm.d (modified) (2 diffs)
• trunk/phobos/std/range.d (modified) (6 diffs)

trunk/phobos/std/algorithm.d

@@ -265 +265 @@
-
-    auto repeatMap = map!"a"(repeat(1));
-    static assert(isInfinite!(typeof(repeatMap)));
-
-    auto intRange = map!"a"([1,2,3]);
-    static assert(isRandomAccessRange!(typeof(intRange)));
-
-    foreach(DummyType; AllDummyRanges) {
-        DummyType d;
-        auto m = map!"a * a"(d);
+
+        static assert(propagatesRangeType!(typeof(m), DummyType));
-        assert(equal(m, [1,4,9,16,25,36,49,64,81,100]));
-    }
-}
-
-// reduce
-/**
-Implements the homonym function (also known as $(D accumulate), $(D
-compress), $(D inject), or $(D foldl)) present in various programming
-languages of functional flavor. The call $(D reduce!(fun)(seed,
-range)) first assigns $(D seed) to an internal variable $(D result),
@@ -1827 +1829 @@
-                b.length - (b.length - 1) / 2);
-    }
-}
-
-unittest
-{
-    int[] a = [ -1, 0, 1, 2, 3, 4, 5 ];
-    int[] b = [ 1, 2, 3 ];
-    assert(find(a, b) == [ 1, 2, 3, 4, 5 ]);
-    assert(find(b, a).empty);
+
+    foreach(DummyType; AllDummyRanges) {
+        DummyType d;
+        auto findRes = find(d, 5);
+        assert(equal(findRes, [5,6,7,8,9,10]));
+    }
-}
-
-/// Ditto
-struct BoyerMooreFinder(alias pred, Range)
-{
-private:
-    size_t skip[];
-    int[ElementType!(Range)] occ;
-    Range needle;
-

trunk/phobos/std/range.d

@@ -147 +147 @@
-    ) AllDummyRanges;
-
-    alias TypeTuple!(1,2,3,4,5,6,7,8,9,0,11,12,13,14,15,16) DummyIndices;
-};
-
-version(unittest)
-{
-    import std.container, std.conv, std.math, std.stdio;
-
-    mixin(dummyRanges);
+
+    // Tests whether forward, bidirectional and random access properties are
+    // propagated properly from the base range(s) R to the higher order range
+    // H.  Useful in combination with DummyRange for testing several higher
+    // order ranges.
+    template propagatesRangeType(H, R...) {
+        static if(allSatisfy!(isRandomAccessRange, R)) {
+           enum bool propagatesRangeType = isRandomAccessRange!H;
+        } else static if(allSatisfy!(isBidirectionalRange, R)) {
+            enum bool propagatesRangeType = isBidirectionalRange!H;
+        } else static if(allSatisfy!(isForwardRange, R)) {
+            enum bool propagatesRangeType = isForwardRange!H;
+        } else {
+            enum bool propagatesRangeType = isInputRange!H;
+        }
+    }
+
+    template propagatesLength(H, R...) {
+        static if(allSatisfy!(hasLength, R)) {
+            enum bool propagatesLength = hasLength!H;
+        } else {
+            enum bool propagatesLength = !hasLength!H;
+        }
+    }
-}
-
-/**
-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
@@ -753 +777 @@
-    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);
+            static assert(propagatesRangeType!(typeof(myRetro), DummyType));
-            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++;
@@ -946 +971 @@
-    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 and 3894.
-            DummyType dummyRange;
-            dummyRange.reinit();
-
-            auto myStride = stride(dummyRange, 4);
+
+            // Should fail if no length and bidirectional b/c there's no way
+            // to know how much slack we have.
+            static if(hasLength!DummyType || !isBidirectionalRange!DummyType) {
+                static assert(propagatesRangeType!(typeof(myStride), DummyType));
+            }
-            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);
-            }
@@ -1250 +1281 @@
-        assert(c[3] == 42);
-    }
-
-    // Make sure bug 3311 is fixed.  ChainImpl should compile even if not all
-    // elements are mutable.
-    auto c = chain( iota(0, 10), iota(0, 10) );
-
-    // Check that chain at least instantiates and compiles with every possible
-    // pair of DummyRange types, in either order.
-
-
+
+
-//    foreach(DummyType1; AllDummyRanges) {
-//        DummyType1 dummy1;
-//        foreach(DummyType2; AllDummyRanges) {
-//            DummyType2 dummy2;
-//            auto myChain = chain(dummy1, dummy2);
+//
+//            static assert(
+//                propagatesRangeType!(typeof(myChain), DummyType1, DummyType2)
+//            );
+//
-//            assert(myChain.front == 1);
-//            foreach(i; 0..dummyLength) {
-//                myChain.popFront();
-//            }
-//            assert(myChain.front == 1);
+//
+//            static if(isBidirectionalRange!DummyType1 &&
+//                      isBidirectionalRange!DummyType2) {
+//                assert(myChain.back == 10);
+//            }
+//
+//            static if(isRandomAccessRange!DummyType1 &&
+//                      isRandomAccessRange!DummyType2) {
+//                assert(myChain[0] == 1);
+//            }
-//        }
-//    }
-
-}
-
-/**
-Iterates a random-access range starting from a given point and
-progressively extending left and right from that point. If no initial
-point is given, iteration starts from the middle of the
-range. Iteration spans the entire range.
-
-Example:
-----
@@ -1504 +1550 @@
-        }
-    }
-    else static if (hasLength!(R))
-    {
-        @property size_t length()
-        {
-            return min(_maxAvailable, original.length);
-        }
-    }
-
- && (hasLength!(R) || isInfinite!(R))
+
-    {
-        void popBack()
-        {
-            enforce(_maxAvailable > 0,
-                "Attempting to popBack() past the beginning of a "
-                ~ Take.stringof);
-            --_maxAvailable;
-        }
-
-        mixin(
-            (byRef ? "ref " : "")~
-            q{/+auto ref+/ ElementType back()
-            {
-                return original[this.length - 1];
-            }});
-
-
-
-
+
-        mixin(
-            (byRef ? "ref " : "")~
-            q{/+auto ref+/ ElementType opIndex(size_t index)
-            {
-                enforce(index < this.length,
-                    "Attempting to index out of the bounds of a "
-                    ~ Take.stringof);
-                return original[index];
-            }});
-    }
@@ -1578 +1621 @@
-    int[] arr1 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
-    auto s = take(arr1, 5);
-    assert(s.length == 5);
-    assert(s[4] == 5);
-    assert(equal(s, [ 1, 2, 3, 4, 5 ][]));
-    assert(equal(retro(s), [ 5, 4, 3, 2, 1 ][]));
-
-    foreach(DummyType; AllDummyRanges) {
-        DummyType dummy;
-        auto t = take(dummy, 5);
+        alias typeof(t) T;
+
+        static if(isRandomAccessRange!DummyType) {
+            static assert(isRandomAccessRange!T);
+            assert(t[4] == 5);
+        } else static if(isForwardRange!DummyType) {
+            static assert(isForwardRange!T);
+        }
+
+        // Bidirectional ranges can't be propagated properly if they don't
+        // also have random access.
+
-        assert(equal(t, [1,2,3,4,5]));
-    }
-}
-
-/**
-Eagerly advances $(D r) itself (not a copy) $(D n) times (by calling
-$(D r.popFront) $(D n) times). The pass of $(D r) into $(D popFrontN)
-is by reference, so the original range is affected. Completes in
-$(BIGOH 1) steps for ranges that support slicing, and in $(BIGOH n)
-time for all other ranges.