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));
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
public void DoubleCountOnOneTuple()
{
var sut = new Tuple <double>(1);
int expected = sut.AsEnumerable().Cast <double>().Count();
int actual = sut.Count();
Assert.AreEqual(expected, actual);
}
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);
}
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);
}
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);
}
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);
}
