Exemplo n.º 1
0
 public static double Norm <T1, T2, T3, T4, T5, T6, T7>(this Tuple <T1, T2, T3, T4, T5, T6, T7> value,
                                                        Func <object, double> func)
 {
     Contract.Requires <ArgumentNullException>(value != null);
     Contract.Requires <ArgumentNullException>(func != null);
     return(value.AsEnumerable().Norm(func));
 }
Exemplo n.º 2
0
 public void ShortAverageOnTwoTuple()
 {
     var sut = new Tuple<short, short>(1, 2);
       double expected = sut.AsEnumerable().Cast<short>().Average();
       double actual = sut.Average(x => (short) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 3
0
 public void IntegerSumOnThreeTuple()
 {
     var sut = new Tuple<int, int, int>(1, 2, 3);
       int expected = sut.AsEnumerable().Cast<int>().Sum();
       int actual = sut.Sum(x => (int) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 4
0
 public void LongSumOnThreeTuple()
 {
     var sut = new Tuple<long, long, long>(1, 2, 3);
       long expected = sut.AsEnumerable().Cast<long>().Sum();
       long actual = sut.Sum(x => (long) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 5
0
 public void IntegerMinOnSixTuple()
 {
     var sut = new Tuple<int, int, int, int, int, int>(1, 2, 3, 4, 5, 6);
       int expected = sut.AsEnumerable().Cast<int>().Min();
       int actual = sut.Min(x => (int) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 6
0
 public void DecimalMinOnThreeTuple()
 {
     var sut = new Tuple<decimal, decimal, decimal>(1, 2, 3);
       decimal expected = sut.AsEnumerable().Cast<decimal>().Min();
       decimal actual = sut.Min(x => (decimal) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 7
0
 public void DecimalAverageOnTwoTuple()
 {
     var sut = new Tuple<decimal, decimal>(1, 2);
       decimal expected = sut.AsEnumerable().Cast<decimal>().Average();
       decimal actual = sut.Average(x => (decimal) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 8
0
 public void LongAverageOnTwoTuple()
 {
     var sut = new Tuple<long, long>(1, 2);
       double expected = sut.AsEnumerable().Cast<long>().Average();
       double actual = sut.Average(x => (long) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 9
0
 public void ShortCountOnTwoTuple()
 {
     var sut = new Tuple<short, short>(1, 2);
       int expected = sut.AsEnumerable().Cast<short>().Count();
       int actual = sut.Count();
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 10
0
 public void DoubleMinOnSevenTuple()
 {
     var sut = new Tuple<double, double, double, double, double, double, double>(1, 2, 3, 4, 5, 6, 7);
       double expected = sut.AsEnumerable().Cast<double>().Min();
       double actual = sut.Min(x => (double) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 11
0
 public void LongMinOnSixTuple()
 {
     var sut = new Tuple<long, long, long, long, long, long>(1, 2, 3, 4, 5, 6);
       long expected = sut.AsEnumerable().Cast<long>().Min();
       long actual = sut.Min(x => (long) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 12
0
 public void IntegerCountOnTwoTuple()
 {
     var sut = new Tuple<int, int>(1, 2);
       int expected = sut.AsEnumerable().Cast<int>().Count();
       int actual = sut.Count();
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 13
0
 public void ShortMaxOnSixTuple()
 {
     var sut = new Tuple<short, short, short, short, short, short>(1, 2, 3, 4, 5, 6);
       short expected = sut.AsEnumerable().Cast<short>().Max();
       short actual = sut.Max(x => (short) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 14
0
 public void DoubleMaxOnTwoTuple()
 {
     var sut = new Tuple<double, double>(1, 2);
       double expected = sut.AsEnumerable().Cast<double>().Max();
       double actual = sut.Max(x => (double) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 15
0
 public void DoubleAverageOnThreeTuple()
 {
     var sut = new Tuple<double, double, double>(1, 2, 3);
       double expected = sut.AsEnumerable().Cast<double>().Average();
       double actual = sut.Average(x => (double) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 16
0
 public void ShortSumOnOneTuple()
 {
   var sut = new Tuple<short>(1);
   short expected = sut.AsEnumerable().Cast<short>().Sum();
   short actual = sut.Sum(x => (short) x);
   Assert.AreEqual(expected, actual);
 }
Exemplo n.º 17
0
 public void DecimalCountOnThreeTuple()
 {
     var sut = new Tuple<decimal, decimal, decimal>(1, 2, 3);
       int expected = sut.AsEnumerable().Cast<decimal>().Count();
       int actual = sut.Count();
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 18
0
 public void IntegerAverageOnTwoTuple()
 {
     var sut = new Tuple<int, int>(1, 2);
       double expected = sut.AsEnumerable().Cast<int>().Average();
       double actual = sut.Average(x => (int) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 19
0
 public void DoubleCountOnTwoTuple()
 {
     var sut = new Tuple<double, double>(1, 2);
       int expected = sut.AsEnumerable().Cast<double>().Count();
       int actual = sut.Count();
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 20
0
 public void LongMaxOnTwoTuple()
 {
     var sut = new Tuple<long, long>(1, 2);
       long expected = sut.AsEnumerable().Cast<long>().Max();
       long actual = sut.Max(x => (long) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 21
0
 public void DoubleSumOnSixTuple()
 {
     var sut = new Tuple<double, double, double, double, double, double>(1, 2, 3, 4, 5, 6);
       double expected = sut.AsEnumerable().Cast<double>().Sum();
       double actual = sut.Sum(x => (double) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 22
0
 public void IntegerMaxOnTwoTuple()
 {
     var sut = new Tuple<int, int>(1, 2);
       int expected = sut.AsEnumerable().Cast<int>().Max();
       int actual = sut.Max(x => (int) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 23
0
 public void DecimalSumOnSixTuple()
 {
     var sut = new Tuple<decimal, decimal, decimal, decimal, decimal, decimal>(1, 2, 3, 4, 5, 6);
       decimal expected = sut.AsEnumerable().Cast<decimal>().Sum();
       decimal actual = sut.Sum(x => (decimal) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 24
0
 public void LongCountOnTwoTuple()
 {
     var sut = new Tuple<long, long>(1, 2);
       int expected = sut.AsEnumerable().Cast<long>().Count();
       int actual = sut.Count();
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 25
0
 public void ShortMinOnTwoTuple()
 {
     var sut = new Tuple<short, short>(1, 2);
       short expected = sut.AsEnumerable().Cast<short>().Min();
       short actual = sut.Min(x => (short) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 26
0
 public void ShortSumOnThreeTuple()
 {
     var sut = new Tuple<short, short, short>(1, 2, 3);
       short expected = sut.AsEnumerable().Cast<short>().Sum();
       short actual = sut.Sum(x => (short) x);
       Assert.AreEqual(expected, actual);
 }
Exemplo n.º 27
0
 public void ShortSumOnSevenTuple()
 {
   var sut = new Tuple<short, short, short, short, short, short, short>(1, 2, 3, 4, 5, 6, 7);
   short expected = sut.AsEnumerable().Cast<short>().Sum();
   short actual = sut.Sum(x => (short) x);
   Assert.AreEqual(expected, actual);
 }
Exemplo n.º 28
0
        public void IntegerSumOnSevenTuple()
        {
            var sut      = new Tuple <int, int, int, int, int, int, int>(1, 2, 3, 4, 5, 6, 7);
            int expected = sut.AsEnumerable().Cast <int>().Sum();
            int actual   = sut.Sum(x => (int)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 29
0
        public void DoubleSumOnOneTuple()
        {
            var    sut      = new Tuple <double>(1);
            double expected = sut.AsEnumerable().Cast <double>().Sum();
            double actual   = sut.Sum(x => (double)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 30
0
        public void DoubleSumOnSevenTuple()
        {
            var    sut      = new Tuple <double, double, double, double, double, double, double>(1, 2, 3, 4, 5, 6, 7);
            double expected = sut.AsEnumerable().Cast <double>().Sum();
            double actual   = sut.Sum(x => (double)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 31
0
        public void ShortMaxOnFiveTuple()
        {
            var   sut      = new Tuple <short, short, short, short, short>(1, 2, 3, 4, 5);
            short expected = sut.AsEnumerable().Cast <short>().Max();
            short actual   = sut.Max(x => (short)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 32
0
        public void IntegerMaxOnSixTuple()
        {
            var sut      = new Tuple <int, int, int, int, int, int>(1, 2, 3, 4, 5, 6);
            int expected = sut.AsEnumerable().Cast <int>().Max();
            int actual   = sut.Max(x => (int)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 33
0
        public void LongCountOnSixTuple()
        {
            var sut      = new Tuple <long, long, long, long, long, long>(1, 2, 3, 4, 5, 6);
            int expected = sut.AsEnumerable().Cast <long>().Count();
            int actual   = sut.Count();

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 34
0
        public void LongMinOnOneTuple()
        {
            var  sut      = new Tuple <long>(1);
            long expected = sut.AsEnumerable().Cast <long>().Min();
            long actual   = sut.Min(x => (long)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 35
0
        public void IntegerAverageOnOneTuple()
        {
            var    sut      = new Tuple <int>(1);
            double expected = sut.AsEnumerable().Cast <int>().Average();
            double actual   = sut.Average(x => (int)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 36
0
        public void DecimalAverageOnOneTuple()
        {
            var     sut      = new Tuple <decimal>(1);
            decimal expected = sut.AsEnumerable().Cast <decimal>().Average();
            decimal actual   = sut.Average(x => (decimal)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 37
0
        public void ShortAverageOnOneTuple()
        {
            var    sut      = new Tuple <short>(1);
            double expected = sut.AsEnumerable().Cast <short>().Average();
            double actual   = sut.Average(x => (short)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 38
0
        public void IntegerMinOnOneTuple()
        {
            var sut      = new Tuple <int>(1);
            int expected = sut.AsEnumerable().Cast <int>().Min();
            int actual   = sut.Min(x => (int)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 39
0
        public void DecimalMinOnSevenTuple()
        {
            var     sut      = new Tuple <decimal, decimal, decimal, decimal, decimal, decimal, decimal>(1, 2, 3, 4, 5, 6, 7);
            decimal expected = sut.AsEnumerable().Cast <decimal>().Min();
            decimal actual   = sut.Min(x => (decimal)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 40
0
        public void ShortCountOnSevenTuple()
        {
            var sut      = new Tuple <short, short, short, short, short, short, short>(1, 2, 3, 4, 5, 6, 7);
            int expected = sut.AsEnumerable().Cast <short>().Count();
            int actual   = sut.Count();

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 41
0
        public void LongSumOnSixTuple()
        {
            var  sut      = new Tuple <long, long, long, long, long, long>(1, 2, 3, 4, 5, 6);
            long expected = sut.AsEnumerable().Cast <long>().Sum();
            long actual   = sut.Sum(x => (long)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 42
0
        public void DoubleMinOnSixTuple()
        {
            var    sut      = new Tuple <double, double, double, double, double, double>(1, 2, 3, 4, 5, 6);
            double expected = sut.AsEnumerable().Cast <double>().Min();
            double actual   = sut.Min(x => (double)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 43
0
        public void DecimalSumOnSixTuple()
        {
            var     sut      = new Tuple <decimal, decimal, decimal, decimal, decimal, decimal>(1, 2, 3, 4, 5, 6);
            decimal expected = sut.AsEnumerable().Cast <decimal>().Sum();
            decimal actual   = sut.Sum(x => (decimal)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 44
0
        public void LongMaxOnSevenTuple()
        {
            var  sut      = new Tuple <long, long, long, long, long, long, long>(1, 2, 3, 4, 5, 6, 7);
            long expected = sut.AsEnumerable().Cast <long>().Max();
            long actual   = sut.Max(x => (long)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 45
0
        public void DoubleAverageOnFourTuple()
        {
            var    sut      = new Tuple <double, double, double, double>(1, 2, 3, 4);
            double expected = sut.AsEnumerable().Cast <double>().Average();
            double actual   = sut.Average(x => (double)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 46
0
        public void DecimalCountOnSixTuple()
        {
            var sut      = new Tuple <decimal, decimal, decimal, decimal, decimal, decimal>(1, 2, 3, 4, 5, 6);
            int expected = sut.AsEnumerable().Cast <decimal>().Count();
            int actual   = sut.Count();

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 47
0
        public void DoubleMaxOnFiveTuple()
        {
            var    sut      = new Tuple <double, double, double, double, double>(1, 2, 3, 4, 5);
            double expected = sut.AsEnumerable().Cast <double>().Max();
            double actual   = sut.Max(x => (double)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 48
0
        public void LongAverageOnOneTuple()
        {
            var    sut      = new Tuple <long>(1);
            double expected = sut.AsEnumerable().Cast <long>().Average();
            double actual   = sut.Average(x => (long)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 49
0
        public void ShortMinOnSixTuple()
        {
            var   sut      = new Tuple <short, short, short, short, short, short>(1, 2, 3, 4, 5, 6);
            short expected = sut.AsEnumerable().Cast <short>().Min();
            short actual   = sut.Min(x => (short)x);

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 50
0
        public void IntegerCountOnFiveTuple()
        {
            var sut      = new Tuple <int, int, int, int, int>(1, 2, 3, 4, 5);
            int expected = sut.AsEnumerable().Cast <int>().Count();
            int actual   = sut.Count();

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 51
0
        public void DoubleCountOnOneTuple()
        {
            var sut      = new Tuple <double>(1);
            int expected = sut.AsEnumerable().Cast <double>().Count();
            int actual   = sut.Count();

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 52
0
        public void DoubleCountOnSevenTuple()
        {
            var sut      = new Tuple <double, double, double, double, double, double, double>(1, 2, 3, 4, 5, 6, 7);
            int expected = sut.AsEnumerable().Cast <double>().Count();
            int actual   = sut.Count();

            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 53
0
        public void Test1TupleIteration()
        {
            var       t        = new Tuple <int>(-1);
            const int expected = -1;
            int       actual   = 0;

            foreach (int v in t.AsEnumerable())
            {
                actual += v;
            }
            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 54
0
        public void Test7TupleIteration()
        {
            var       t        = new Tuple <int, int, int, int, int, int, int>(-1, -2, -3, -4, -5, -6, -7);
            const int expected = -28;
            int       actual   = 0;

            foreach (int v in t.AsEnumerable())
            {
                actual += v;
            }
            Assert.AreEqual(expected, actual);
        }
Exemplo n.º 55
0
 public void Test2TupleIteration()
 {
     var t = new Tuple<int, int>(-1, -2);
       const int expected = -3;
       int actual = 0;
      foreach (int v in t.AsEnumerable()) actual += v;
      Assert.AreEqual(expected, actual);
 }