ListTest.n

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;

using Nemerle.ComputationExpressions;

using System;
using System.Collections.Generic;
using System.Linq;

namespace Test
{
  /// <summary>
  /// Description of EnumerableTest.
  /// </summary>
  public class ListTest
  {
    private static ManyTimes() : list[int]
    {
      def upTo (n : int)
      {
        comp list
        {
          mutable i = 0;
          while (i < n)
          {
            i ++;
            yield i
          }
        }
      }

      comp list
      {
        yieldcomp upTo(2);   // 1 2
        yield 100;           // 100
        yieldcomp upTo(3);   // 1 2 3
        yield 100;           // 100
        yieldcomp upTo(10);  // 1 2 3 .. 10
      }
    }

    [TestCaseAttribute(<#
1
2
100
1
2
3
100
1
2
3
4
5
6
7
8
9
10
#>)]
    public static ManyTimesTest(stream : IO.TextWriter) : void
    {
      ManyTimes().Iter(stream.WriteLine);
    }

    [TestCaseAttribute(<#
10
40
-=-
20
30
#>)]
    public static TestIf(stream : IO.TextWriter) : void
    {
      def testIf(n)
      {
        comp list
        {
          if (n > 5) (); else yield 10;
          if (n > 5) { yield 20; } else ();

          when (n > 5) ();
          when (n > 5) yield 30;

          unless (n > 5) ();
          unless (n > 5) yield 40;
        }
      }
      testIf(1).Iter(stream.WriteLine);
      stream.WriteLine("-=-");
      testIf(10).Iter(stream.WriteLine);
    }

    [TestCaseAttribute(<#
0
1
2
3
4
5
1000000
2
2000000
100
1
3000000
1
2
3
4000000
2
3
100
1
5000000
3
100
1
2
3
6000000
100
1
2
3
4
5
#>)]
    public static TestWhile(stream : IO.TextWriter) : void
    {
      def testWhile(n)
      {
        comp list
        {
          mutable i1 = 0;
          mutable i2 = 0;

          while (i1 < n)
          {
            yield i1;
            ++i1;
          }

          while (i2 < n)
          { 
            ++i2;
            yield i2 * 1000000;
            yieldcomp ManyTimes().Skip(i2).Take(i2)
          }
        }
      }
      testWhile(6).Iter(stream.WriteLine);
    }

    [TestCaseAttribute(<#
456456
1
-=-
333333
456456
3
-=-
10
123123
#>)]
    public static TestMatching(stream : IO.TextWriter) : void
    {
      def testMatching(n)
      {
        comp list
        {
          match (n)
          {
            | 3 =>
              yield 333333;

            | x when x > 5 =>
              yield x;

            | _ => ()
          }

          match (n)
          {
            | x when x < 5 =>
              yield 456456;
              yield x;

            | _ =>
              yield 123123;
          }
        }
      }
      testMatching(1).Iter(stream.WriteLine);
      stream.WriteLine("-=-");
      testMatching(3).Iter(stream.WriteLine);
      stream.WriteLine("-=-");
      testMatching(10).Iter(stream.WriteLine);
    }

    [TestCaseAttribute(<#
6
7
8
9
10
-=-
10
9
8
7
6
#>)]
    public static TestForeach(stream : IO.TextWriter) : void
    {
      def testForeach(coll : IEnumerable[_])
      {
        comp list
        {
          foreach (x in coll)
            _ = x;
          foreach (x in coll)
            yield x + 5;
        }
      }
      testForeach([1, 2, 3, 4, 5]).Iter(stream.WriteLine);
      stream.WriteLine("-=-");
      testForeach([5, 4, 3, 2, 1]).Iter(stream.WriteLine);
    }

    [TestCaseAttribute(<#
0
2
4
6
8
#>)]
    public static TestFor(stream : IO.TextWriter) : void
    {
      def testFor(n)
      {
        comp list
        {
          for (mutable x = 0; x < n; ++x)
            _ = x;

          for (mutable x = 0; x < n; ++x)
            yield 2 * x;

          mutable x = 0;

          for (; false;)
            _ = x;
          for (; false;)
            yield 2 * x;
        }
      }
      testFor(5).Iter(stream.WriteLine);
    }

    [TestCaseAttribute(<#
5
5
5
5
5
#>)]
    public static TestRepeat(stream : IO.TextWriter) : void
    {
      def testRepeat(n)
      {
        comp list
        {
          repeat(n)
            ();
          repeat(n)
            yield n;
        }
      }
      testRepeat(5).Iter(stream.WriteLine);
    }

    [TestCaseAttribute(<#
do-while
1
2
3
4
5
-=-
do-while
1
2
3
4
5
6
7
8
9
10
#>)]
    public static TestDoWhile(stream : IO.TextWriter) : void
    {
      def testDoWhile(n)
      {
        comp list
        {
          do
          {
            stream.WriteLine ("do-while")
          }
          while (false || false);

          mutable i = 0;
          do
          {
            ++i;
            yield i;
          }
          while (i < n);
        }
      }
      testDoWhile(5).Iter(stream.WriteLine);
      stream.WriteLine("-=-");
      testDoWhile(10).Iter(stream.WriteLine);
    }

    [TestCaseAttribute(<#
1
1
0
-1
1
0
1
-1
1
#>)]
    public static TestForeachMatch(stream : IO.TextWriter) : void
    {
      def testForeachMatch(coll : IEnumerable [_])
      {
        comp list
        {
          foreach (x in coll)
          {
            | x when x > 0 => yield 1
            | x when x < 0 => yield -1
            | _            => yield 0
          }
        }
      }
      testForeachMatch([10, 2, 0, -2, 4, 0, 2, -1, 2]).Iter(stream.WriteLine);
    }

    [TestCaseAttribute(<#
write 1
try-finally
Exception: System.InvalidOperationException
#>)]
    public static TestTryFinally(stream : IO.TextWriter) : void
    {
      def testTryFinally() : IEnumerable[_]
      {
        comp list
        {
          try
          {
            yield 1;
            stream.WriteLine ("write 1");
            throw InvalidOperationException("Test exception");
          }
          finally
          {
            stream.WriteLine("try-finally")
          }
        }
      }
      testTryFinally().Iter(stream.WriteLine);
    }

    [TestCaseAttribute(<#
777 must follow.
The final part.
1
777
#>)]
    public static TestTryCatch(stream : IO.TextWriter) : void
    {
      def testTryCatch() : IEnumerable[_]
      {
        comp list
        {
          try
          {
            yield 1;
            throw Exception ();
          }
          catch
          {
            | _ is InvalidOperationException =>
              stream.WriteLine ("InvalidOperationException")
            | _ is Exception =>
              stream.WriteLine ("777 must follow.");
              yield 777;
          }
          finally
          {
            stream.WriteLine ("The final part.");
          }
        }
      }
      testTryCatch().Iter(stream.WriteLine);
    }

    private class ScopeWriter : IDisposable
    {
      private _stream : IO.TextWriter;
      private _name : string;
      public this(name : string, stream : IO.TextWriter)
      {
        _stream = stream;
        _name = name;
        _stream.WriteLine($"Scope $_name begin.");
      }

      public Dispose() : void
      {
        _stream.WriteLine($"Scope $_name end.");
      }
    }

    [TestCaseAttribute(<#
Scope 1 begin.
Scope 1 end.
Scope 2 begin.
Scope 3 begin.
Scope 3 end.
Scope 2 end.
Scope 4 begin.
Scope 5 begin.
Scope 5 end.
Scope 4 end.
Scope 6 begin.
Scope 7 begin.
Exception
Scope 7 end.
Scope 6 end.
1
2
3
#>)]
    public static TestUsing(stream : IO.TextWriter) : void
    {
      def testUsing()
      {
        comp list
        {
          using (_scope1 = ScopeWriter("1", stream))
          {
            yield 1;
          }

          using (_scope1 = ScopeWriter("2", stream))
          using (_scope2 = ScopeWriter("3", stream))
          {
            yield 2;
          }

          using (_scope1 = ScopeWriter("4", stream), _scope2 = ScopeWriter("5", stream))
          {
            ()
          }

          using (_scope1 = ScopeWriter("6", stream), _scope2 = ScopeWriter("7", stream))
          {
            yield 3;
            throw Exception();
          } 
          catch
          {
            | _e is Exception =>
              stream.WriteLine("Exception");
          }
        }
      }
      testUsing().Iter(stream.WriteLine);
    }
  }
}