Changeset 1694

Timestamp:

06/25/10 03:06:54 (14 years ago)

Author:

dsimcha

Message:

More unittest improvements and wholesale fixing/cleanup for std.range.

Files:

• trunk/docsrc/changelog.dd (modified) (1 diff)
• trunk/phobos/std/range.d (modified) (10 diffs)

trunk/docsrc/changelog.dd

@@ -13 +13 @@
-    $(LI $(BUGZILLA 978): std.utf's toUTF* functions accept some invalid and reject some valid UTF)
-    $(LI $(BUGZILLA 996): Error in doc on implicit conversion between pointer and array)
-    $(LI $(BUGZILLA 2275): std.utf.toUTF16z() should return const(wchar)*)
-    $(LI $(BUGZILLA 2872): Length, opIndex for Map)
-    $(LI $(BUGZILLA 3202): std.math.pow cause dead loop)
-    $(LI $(BUGZILLA 3355): std.string.cmp works incorrectly for mixed-type and different-length strings)
-    $(LI $(BUGZILLA 3386): to!bool(string) is not implemented)
-    $(LI $(BUGZILLA 3436): std.functional.compose with only one function)
-    $(LI $(BUGZILLA 3439): std.range.Sequence.opIndex not consistent after calling popFront().)
-    $(LI $(BUGZILLA 3447): std.file uses unconventional file permissions)
+    $(LI $(BUGZILLA 3874): std.range.stride assumes a bidirectional input range)
-    $(LI $(BUGZILLA 3937): os.path.dirname fails on absolute path)
-    $(LI $(BUGZILLA 3961): Error with to!(somestruct))
-    $(LI $(BUGZILLA 4109): (reopened) writeln doesn't work with empty static array)
-    $(LI $(BUGZILLA 4171): std.random.uniform does not work for a range of characters)
-    $(LI $(BUGZILLA 4260): windows & basename)
+    $(LI $(BUGZILLA 4305): Take, Chain on top of ranges w/o moveFront() )
-    $(LI $(BUGZILLA 4327): std.container.Array.Range.~this() tries to call free(T[]))
-    $(LI $(BUGZILLA 4362): std.range.repeat and cycle do not have a .save() method
-    $(LI $(BUGZILLA 4363): std.algorithm.Until is not a forward range)
-    )
-)
-
-<div id=version>
-$(UL
-    $(NEW 048)
-    $(NEW 047)

trunk/phobos/std/range.d

@@ -119 +119 @@
-            }
-        }
-
-        static if(l == Length.Yes) {
-            @property size_t length() {
-                return arr.length;
-            }
-        }
-    }
-
+    enum dummyLength = 10;
+
-    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),
-
-
+
-    ) 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.
-
@@ -347 +347 @@
-compilation) are assumed to be the following ($(D r) is an object of
-type $(D R)):
-$(UL $(LI $(D r.opIndex(n)) returns a reference to the $(D n)th
-element in the range.))
- */
-template isRandomAccessRange(R)
-{
-    enum bool isRandomAccessRange =
-        (isBidirectionalRange!(R) || isInfinite!(R))
-        && is(typeof(R.init[1]))
-
+
+
-}
-
-unittest
-{
-    struct A {}
-    static assert(!isRandomAccessRange!(A));
-    struct B
-    {
-        void popFront();
-        bool empty();
@@ -379 +380 @@
-    static assert(!isRandomAccessRange!(C));
-    struct D
-    {
-        bool empty();
-        @property D save();
-        int front();
-        void popFront();
-        int back();
-        void popBack();
-        ref int opIndex(uint);
+        @property size_t length();
-        //int opSlice(uint, uint);
-    }
-    static assert(isRandomAccessRange!(D));
-    static assert(isRandomAccessRange!(int[]));
-}
-
-/**
-The element type of $(D R). $(D R) does not have to be a range. The
-element type is determined as the type yielded by $(D r.front) for an
-object $(D r) or type $(D R). For example, $(D ElementType!(T[])) is
@@ -931 +933 @@
-    }
-    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) {
-
+ and 3894
-            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);
-            }
@@ -1236 +1238 @@
-        uint[] foo = [1,2,3,4,5];
-        uint[] bar = [1,2,3,4,5];
-        auto c = chain(foo, bar);
-        c[3] = 42;
-        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.
+
+// This test should be uncommented when DMD bug 4379 gets fixed.
+//    foreach(DummyType1; AllDummyRanges) {
+//        DummyType1 dummy1;
+//        foreach(DummyType2; AllDummyRanges) {
+//            DummyType2 dummy2;
+//            auto myChain = chain(dummy1, dummy2);
+//            assert(myChain.front == 1);
+//            foreach(i; 0..dummyLength) {
+//                myChain.popFront();
+//            }
+//            assert(myChain.front == 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:
-----
@@ -1386 +1406 @@
-    }
-    test([], []);
-    test([ 1 ], [ 1 ]);
-    test([ 1, 2 ], [ 1, 2 ]);
-    test([ 1, 2, 3 ], [ 2, 3, 1 ]);
-    test([ 1, 2, 3, 4 ], [ 2, 3, 1, 4 ]);
-    test([ 1, 2, 3, 4, 5 ], [ 3, 4, 2, 5, 1 ]);
-    test([ 1, 2, 3, 4, 5, 6 ], [ 3, 4, 2, 5, 1, 6 ]);
-    int[] a = [ 1, 2, 3, 4, 5 ];
-    assert(equal(radial(a, 1), [ 2, 3, 1, 4, 5 ][]));
+
+    // Test instantiation without lvalue elements.
+
+    // Doesn't instantiate!
+    //DummyRange!(ReturnBy.Value, Length.Yes, RangeType.Random) dummy;
+    //assert(equal(radial(dummy, 4), [5, 6, 4, 7, 3, 8, 2, 9, 1]));
-}
-
-/**
-Lazily takes only up to $(D n) elements of a range. This is
-particulary useful when using with infinite ranges. If the range
-offers random access and $(D length), $(D Take) offers them as well.
-
-Example:
-----
-int[] arr1 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
@@ -1540 +1566 @@
-}
-
-unittest
-{
-    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);
+        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.
-
-Example:
@@ -1716 +1748 @@
-        /// Ditto
-        @property Cycle!(R) save() {
-            return Cycle!(R)(this._original.save, this._index);
-        }
-    }
-    else
-    {
-        R _original, _current;
-        this(R input) { _original = input; _current = input.save; }
-        /// Range primitive implementations.
-auto ref
+ref ElementType!(R)
-        /// Ditto
-        static if (isBidirectionalRange!(R))
-            ref ElementType!(R) back() { return _current.back; }
-        /// Ditto
-        enum bool empty = false;
-        /// Ditto
-        void popFront()
-        {
-            _current.popFront;
-            if (_current.empty) _current = _original;
@@ -1811 +1843 @@
-{
-    assert(equal(take(cycle([1, 2][]), 5), [ 1, 2, 1, 2, 1 ][]));
-    static assert(isForwardRange!(Cycle!(uint[])));
-
-    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)));
+
+    foreach(DummyType; AllDummyRanges) {
+        // Bug 4387
+        static if(isForwardRange!(DummyType) && DummyType.r == ReturnBy.Reference) {
+            DummyType dummy;
+            auto cy = cycle(dummy);
+            static assert(isForwardRange!(typeof(cy)));
+            auto t = take(cy, 20);
+            assert(equal(t, [1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10]));
+        }
+    }
-}
-
-unittest // For infinite ranges
-{
-    struct InfRange
-    {
-        void popFront() { }
-        int front() { return 0; }
-        enum empty = false;
-    }
@@ -2839 +2882 @@
-    auto tr = transposed(x);
-    int[][] witness = [ [ 1, 3 ], [ 2, 4 ] ];
-    uint i;
-
-    foreach (e; tr)
-    {
-        assert(array(e) == witness[i++]);
-    }
-}
-
+// Tests to see whether a struct has a postblit.  Hacky, probably needs to
+// be fixed if a new frontend is ever written.
+private template hasPostblit(R) {
+    static if(!is(R == struct)) {
+        enum bool hasPostblit = false;
+    } else {
+        enum hasPostblit = is(typeof({
+            R r;
+            return &r.__postblit;
+        }));
+    }
+}
+
+unittest {
+    struct S {
+        this(this) {}
+    }
+
+    struct S2 {}
+
+    static assert(hasPostblit!S);
+    static assert(!hasPostblit!S2);
+}
+
-/**
-Moves the front of $(D r) out and returns it. Leaves $(D r.front) in a
-destroyable state that does not allocate any resources (usually equal
-to its $(D .init) value).
- */
-ElementType!R moveFront(R)(R r)
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-}
-
-unittest
-{
-    struct R
-    {
-        ref int front() { static int x = 42; return x; }
+        this(this){}
-    }
-    R r;
-    assert(moveFront(r) == 42);
-}
-
-/// Ditto
-ElementType!R moveFront(R)(R r)
-if (is(typeof(&R.moveFront)))
-{
-    return r.moveFront();
-}
-
-/**
-Moves the front of $(D r) out and returns it. Leaves $(D r.front) in a
-destroyable state that does not allocate any resources (usually equal
-to its $(D .init) value).
- */
-ElementType!R moveBack(R)(R r)
-if (isInputRange!R && is(typeof(&r.front) == ElementType!R*))
-{