Test DataStream

676⟨* 13⟩+≡   ⊲669  685 ⊳
-------------------------------------------------------------------
----
---- Combinat
---- Copyright (C) Ralf Hemmecke <ralf@hemmecke.de>
---- svn co svn://svn.risc.uni-linz.ac.at/hemmecke/combinat/
----
-------------------------------------------------------------------

#assert DontNeedLibraryTestCases
#include "testcases"

TestDataStream: TestCaseType with {
#include "stream.signatures.as"
} == add {
        macro Stream == DataStream;
        import from TestCaseTools;
        import from Stream I, I;
        ⟨test Stream 677a⟩
}

Defines:
TestDataStream, never used.

Uses DataStream 386 and I 47.

677a⟨test Stream 677a⟩≡   (676)  677b ⊳
testStream1(): () == {
        s: Stream I := stream 0;
        assertEquals(I, 1, #s);
        l: List I := [elements s];
        assertEquals(List I, [0], l);
        l := [i for i in s for k in 0..3];
        assertEquals(List I, [0,0,0,0], l);
        assertEquals(I, 1, #s);
}

Uses I 47.

677b⟨test Stream 677a⟩+≡   (676)  ⊲677a  678a ⊳
testStream2(): () == {
        l: List I := [4,3,5,8,4,1,9,7];
        s: Stream I := stream generator l;
        a := s.3;
        assertEquals(I, 8, a);
        assertEquals(I, 4, #s);
        a := s.3;
        assertEquals(I, 8, a);
        assertEquals(I, 4, #s);
        a := s.1;
        assertEquals(I, 3, a);
        assertEquals(I, 4, #s);
        a := s.4;
        assertEquals(I, 4, a);
        assertEquals(I, 5, #s);
        u: List I := [i for i in elements s];
        assertEquals(List I, [i for i in l], u);
        assertEquals(I, 8, #s);
}

Uses I 47.

678a⟨test Stream 677a⟩+≡   (676)  ⊲677b  678b ⊳
testStream3(): () == {
        l: List I := [4,3,5,2,6,1];
        s: Stream I := stream generator l;
        a := s.3;
        assertEquals(I, 2, a);
        assertEquals(I, 4, #s);
        g := generator l;
        set!(s, g);
        b := s.5;
        assertEquals(I, 3, b);
        assertEquals(I, 6, #s);
        assertEquals(List I, append!([4,3,5,2],l), [elements s]);
        assertEquals(I, 10, #s);
}

Uses I 47.

678b⟨test Stream 677a⟩+≡   (676)  ⊲678a  679a ⊳
testStreamElements1(): () == {
        s: Stream I := stream 4;
        g: Generator I := generator s;
        n: Generator I := elements s;
        l1: List I := [i for i in g for k in 0..9];
        l2: List I := [i for i in n for k in 0..9];
        l: List I := [4 for k in 0..9];
        assertEquals(List I, l, l1);
        assertEquals(List I, [4], l2);
}

Uses Generator 617 and I 47.

679a⟨test Stream 677a⟩+≡   (676)  ⊲678b  679b ⊳
testStreamElements2(): () == {
        t: Stream I := stream generator [2,3,5,7,11];
        g3: Generator I := elements(t, 2);
        l3: List I := [i for i in g3 for k in 0..9];
        assertEquals(List I, l3, [5,7,11]);
        g4: Generator I := elements(t, 10);
        l4: List I := [i for i in g4 for k in 0..9];
        assertEquals(List I, l4, [11]);
}

Uses Generator 617 and I 47.

679b⟨test Stream 677a⟩+≡   (676)  ⊲679a  680a ⊳
testStream5(): () == {
        l: List String := ["Hello", " ", "World", "!"];
        s: Stream String := stream generator l;
        assertEquals(I, 0, #s);
        assertEquals(String, "World", s.2);
        assertEquals(I, 3, #s);
        d: PrimitiveArray String := data s;
        u: String := "";
        for i in 0..prev #s repeat u := u + d.i;
        assertEquals(String, "Hello World", u);
        v: String := "";
        for i in 0..9 for x in s repeat v := v + x;
        assertEquals(String, "Hello World!!!!!!!", v);
        assertEquals(I, 4, #s);
}

Uses I 47 and String 65.

680a⟨test Stream 677a⟩+≡   (676)  ⊲679b  680b ⊳
testStream6(): () == {
        import from Integer;
        l: List Integer := [2,3,5,7,11,0];
        s: Stream Integer := stream generator l;
        a := constant? s;
        x := s.3;
        assertFalse(constant? s);
        y := s.5;
        assertFalse(constant? s);
        z := s.6;
        assertTrue(constant? s);
}

Uses Integer 66.

680b⟨test Stream 677a⟩+≡   (676)  ⊲680a  681a ⊳
testStream7(): () == {
        import from String;
        s: Stream String := stream "I am constant";
        assertTrue(constant? s);
}

Uses I 47 and String 65.

681a⟨test Stream 677a⟩+≡   (676)  ⊲680b  681b ⊳
testStream8(): () == {
      import from Integer, List Integer;
      s: Stream Integer := stream generator [1,2,3,4,5,6];
      a: List Integer := empty;
      b: List Integer := empty;
      for i: I in 0.. for x in elements s repeat {
              a := cons(x, a);
              b := cons(s.(i+i), b);
      }
      assertEquals(List Integer, [6,5,4,3,2,1], a);
      assertEquals(List Integer, [6,6,6,5,3,1], b);
}

Uses I 47 and Integer 66.

681b⟨test Stream 677a⟩+≡   (676)  ⊲681a  682a ⊳
testStream9(): () == {
      import from Integer;
      fib: Stream Integer := new();
      g: Generator Integer := generate {
              yield 1;
              yield 1;
              for n: I in 0.. repeat yield fib.n + fib.(next n);
      }
      set!(fib, g);
      f: List Integer := [x for x in fib while x < 100];
      assertEquals(List Integer, [1,1,2,3,5,8,13,21,34,55,89], f);
}

Uses Generator 617, I 47, and Integer 66.

682a⟨test Stream 677a⟩+≡   (676)  ⊲681b  682b ⊳
testStream9b(): () == {
      import from Integer;
      h(n: I, s: Stream Integer): Integer == {
              n < 2 => 1;
              s(n-1) + s(n-2);
      }
      fib: Stream Integer := stream h;
      f: List Integer := [x for x in fib while x < 100];
      assertEquals(List Integer, [1,1,2,3,5,8,13,21,34,55,89], f);
}

Uses I 47 and Integer 66.

682b⟨test Stream 677a⟩+≡   (676)  ⊲682a  683a ⊳
testStream10(): () == {
        T ==> Integer;
        S ==> Stream T;
        import from T, S;
        (x: S) + (y: S): S == stream(a+b for a in x for b in y);
        (x: S) * (y: S): S == {
                local times(n: I): T == {
                        t: T := 0;
                        for k in 0..n | not zero?(xk := x.k) repeat {
                                t := t + xk * y.(n-k);
                        }
                        t;
                }
                stream(times n for n: I in 0..);
        }
        s: Stream T := new();
        1: S := stream(generator [1, 0]);
        x: S := stream(generator [0, 1, 0]);
        set!(s, generator(1 + x * s * s));
        l1: List Integer := [1,1,2,5,14,42];
        l2: List Integer := [t for i in l1 for t in s];
        assertEquals(List Integer, l1, l2);
}

Uses I 47 and Integer 66.

683a⟨test Stream 677a⟩+≡   (676)  ⊲682b  683b ⊳
testStreamMap1(): () == {
        T ==> Integer;
        S ==> Stream T;
        import from T, S;
        f(n: I, x: S): T == {zero? n => 0; x(n-1) + 1}
        one: S := stream f;
        l1: List T := [0,1,2,3,4,5,6,7,8,9];
        lone: List T := [t for i in l1 for t in one];
        assertEquals(List T, l1, lone);

        double(t: T): T == 2*t;
        two: S := map(double)(one);
        l2: List T := map(double)(l1);
        ltwo: List T := [t for i in l2 for t in two];
        assertEquals(List T, l2, ltwo);
}

Uses I 47 and Integer 66.

683b⟨test Stream 677a⟩+≡   (676)  ⊲683a  684 ⊳
testStreamMap2(): () == {
        T ==> Integer;
        S ==> Stream T;
        import from T, S;
        l1: List T := [0,1,2,3];
        one: S := stream generator l1;
        lone: List T := [t for i: I in 0..5 for t in one];
        assertEquals(List T, [0,1,2,3,3,3], lone);

        double(t: T): T == 2*t;
        two: S := map(double)(one);
        ltwo: List T := [t for i: I in 0..5 for t in two];
        assertEquals(List T, [0,2,4,6,6,6], ltwo);
}

Uses I 47 and Integer 66.

684⟨test Stream 677a⟩+≡   (676)  ⊲683b
testStreamSet!1(): () == {
        T ==> Integer;
        S ==> Stream T;
        import from T, S;
        r: List T := [4,3,5,2,6,1,1,1,1,1];
        l: List T := [4,3,5,2,6,1];
        s: S := stream generator l;
        s.3 := -1; u: List T := [z for t in r for z in s];
        assertEquals(List T, [4,3,5,-1,6,1,1,1,1,1], u);
        s.5 := -2; u: List T := [z for t in r for z in s];
        assertEquals(List T, [4,3,5,-1,6,-2,1,1,1,1], u);
        s.6 := -3; u: List T := [z for t in r for z in s];
        assertEquals(List T, [4,3,5,-1,6,-2,-3,1,1,1], u);
        s.8 := -4; u: List T := [z for t in r for z in s];
        assertEquals(List T, [4,3,5,-1,6,-2,-3,1,-4,1], u);

        a: S := stream 0;
        a.2 := 3;
        v: List T := [z for t:I in 0..3 for z in a];
        assertEquals(List T,  [0,0,3,0], v);
}

Uses I 47 and Integer 66.

27 Test DataStream