# mention all targets
all-local $(STD_TARGETS:=-local):
--VALID_PROFILE := $(filter net_1_1 net_2_0 net_2_1, $(PROFILE))
++VALID_PROFILE := $(filter net_1_1 net_2_0 net_2_1 net_4_0, $(PROFILE))
ifdef VALID_PROFILE
# casts
bootstrap-cast.exe: gen-cast-test.cs
eval.exe: eval-tests.cs
++ifeq (net_4_0, $(PROFILE))
++COMPILER_NAME = dmcs
++TEST_PATTERN = 'v4'
++LOCAL_RUNTIME_FLAGS = --verify-all
++#TOPTIONS += '-il:ver-il-dmcs.xml'
++endif
ifeq (net_2_1, $(PROFILE))
COMPILER_NAME = smcs
--TEST_PATTERN = '*test-*.cs'
++TEST_PATTERN = 'v2'
LOCAL_RUNTIME_FLAGS = --security=temporary-smcs-hack
endif
ifeq (net_2_0, $(PROFILE))
COMPILER_NAME = gmcs
--TEST_PATTERN = '*test-*.cs'
++TEST_PATTERN = 'v2'
LOCAL_RUNTIME_FLAGS = --verify-all
TOPTIONS += '-il:ver-il-gmcs.xml'
endif
ifeq (net_1_1, $(PROFILE))
COMPILER_NAME = mcs
--TEST_PATTERN = 'test-*.cs'
++TEST_PATTERN = 'v1'
LOCAL_RUNTIME_FLAGS = --verify-all
endif
--- /dev/null
--- /dev/null
++
++//
++// Lambda expression test, basics.
++//
++using System;
++
++delegate int IntFunc (int x);
++delegate void VoidFunc (int x);
++
++class X {
++
++ static IntFunc func, increment;
++ static VoidFunc nothing;
++
++ static int Main ()
++ {
++ int y = 0;
++ int r;
++
++ //
++ // The following tests body-style lambda
++ //
++ increment = (int x) => { return x + 1; };
++ r = increment (4);
++ Console.WriteLine ("Should be 5={0}", r);
++ if (r != 5)
++ return 1;
++
++ //
++ // This tests the body of a lambda being an expression
++ //
++ func = (int x) => x + 1;
++ r = func (10);
++ Console.WriteLine ("Should be 11={0}", r);
++ if (r != 11)
++ return 2;
++
++ //
++ // The following tests that the body is a statement
++ //
++ nothing = (int x) => { y = x; };
++ nothing (10);
++ Console.WriteLine ("Should be 10={0}", y);
++ if (y != 10)
++ return 3;
++
++ nothing = (int x) => { new X (x); };
++ nothing (314);
++ if (instantiated_value != 314)
++ return 4;
++
++ Console.WriteLine ("All tests pass");
++ return 0;
++ }
++
++ static int instantiated_value;
++
++ X (int v)
++ {
++ instantiated_value = v;
++ }
++}
--- /dev/null
--- /dev/null
++
++//
++// Lambda expression test overload resolution with parameterless arguments
++//
++
++using System;
++delegate string funcs (string s);
++delegate int funci (int i);
++
++class X {
++ static void Foo (funci fi)
++ {
++ int res = fi (10);
++ Console.WriteLine (res);
++ }
++
++ static void Foo (funcs fs)
++ {
++ string res = fs ("hello");
++ Console.WriteLine (res);
++ }
++
++ static void Main ()
++ {
++ Foo (x => x + "dingus");
++ }
++}
--- /dev/null
--- /dev/null
++
++
++using System;
++
++public delegate TResult Func<TArg0, TResult> (TArg0 arg0);
++
++class Demo
++{
++ static Y F<X, Y> (int a, X value, Func<X, Y> f1)
++ {
++ return f1 (value);
++ }
++ static int Main ()
++ {
++ object o = F (1, "1:15:30", s => TimeSpan.Parse (s));
++ Console.WriteLine (o);
++ return 0;
++ }
++}
--- /dev/null
--- /dev/null
++
++//
++// This test is used to test the type information flow between arguments
++// in a generic method invocation, where:
++//
++// 1. We first infer the type of X from the first argument to F
++//
++// 2. We use this information to infer from the type of f1 and Func
++// that X is a TimeSpan.
++//
++// 3. Use the X=String and Y=TimeSpan to infer the value for Z
++// which is double
++//
++
++using System;
++public delegate TResult Func<TArg0, TResult> (TArg0 arg0);
++
++class Demo {
++ static Z F<X,Y,Z>(X value, Func<X,Y> f1, Func<Y,Z> f2)
++ {
++ return f2 (f1(value));
++ }
++ static int Main ()
++ {
++ double d = F("1:15:30", s => TimeSpan.Parse(s), t => t.TotalSeconds);
++ if (d < 4529 || d > 4531)
++ return 1;
++ return 0;
++ }
++}
--- /dev/null
--- /dev/null
++
++
++using System;
++
++public class C
++{
++
++ delegate int di (int x);
++ delegate string ds (string s);
++ delegate bool db (bool x);
++
++ static bool M (db d) { return d (false); }
++ static string M (ds d) { return "b"; }
++ static int M (di d) { return d (0); }
++
++ public static int Main ()
++ {
++ string[] s = new string[] { "1" };
++ int[] i = new int[] { 1 };
++
++ string s_res = M (x=> M (y=> x.ToLower ()));
++ int i_res = M (x=> M (y=> (x * 0) + 5));
++
++ if (s_res != "b")
++ return 1;
++
++ if (i_res != 5)
++ return 2;
++
++ return 0;
++ }
++}
--- /dev/null
--- /dev/null
++// Inspired by
++// http://blogs.msdn.com/ericlippert/archive/2007/03/28/lambda-expressions-vs-anonymous-methods-part-five.aspx
++
++using System;
++
++class TestClass
++{
++ delegate void DT (T t);
++ delegate void DF (F f);
++
++ struct T { }
++ struct F { }
++
++ static void P (DT dt)
++ {
++ Console.WriteLine ("True");
++ dt (new T ());
++ }
++
++ static void P (DF df)
++ {
++ System.Console.WriteLine ("False");
++ df (new F ());
++ }
++
++ static T And (T a1, T a2) { return new T (); }
++ static F And (T a1, F a2) { return new F (); }
++ static F And (F a1, T a2) { return new F (); }
++ static F And (F a1, F a2) { return new F (); }
++
++ static T Or (T a1, T a2) { return new T (); }
++ static T Or (T a1, F a2) { return new T (); }
++ static T Or (F a1, T a2) { return new T (); }
++ static F Or (F a1, F a2) { return new F (); }
++
++ static F Not (T a) { return new F (); }
++ static T Not (F a) { return new T (); }
++
++ static void StopTrue (T t) { }
++
++ static int Main ()
++ {
++ // Test that we encode (!v3) & ((!v1) & ((v1 | v2) & (v2 | v3)))
++ P (v1 => P (v2 => P (v3 => StopTrue (
++ And (Not (v3),
++ And (Not (v1),
++ And (Or (v1, v2), Or (v2, v3))
++ )
++ )
++ ))));
++
++ return 0;
++ }
++}
--- /dev/null
--- /dev/null
++
++
++// Lambda parser tests
++
++delegate void D ();
++delegate void E (bool b);
++
++public class C
++{
++ static void Test (D d)
++ {
++ }
++
++ static void Test (object o, D d)
++ {
++ }
++
++ static void Test (D d1, D d2)
++ {
++ }
++
++ static void Test2 (object o, E e)
++ {
++ }
++
++ public static void Main ()
++ {
++ D e = () => { };
++ e = (D)null;
++ e = default (D);
++
++ Test (() => { });
++ Test (1, () => { });
++ Test (() => { }, () => { });
++ Test2 (null, (foo) => { });
++ }
++}
--- /dev/null
--- /dev/null
++
++
++using System;
++using System.Linq;
++using System.Collections.Generic;
++
++public class C
++{
++ static void Test<T, R> (Func<T, R> d)
++ {
++ }
++
++ public static int Main ()
++ {
++ Test ((int x) => { return x + 1; });
++
++ int[] source = new int[] { 2, 1, 0 };
++ IEnumerable<int> e = source.Where((i) => i == 0).Select((i) => i + 1);
++
++ if (e.ToList ()[0] != 1)
++ return 1;
++
++ e = source.Where((int i) => i == 0).Select((int i) => i + 1);
++
++ if (e.ToList ()[0] != 1)
++ return 2;
++
++ e = source.Where(delegate (int i) { return i == 0; }).Select(delegate (int i) { return i + 1; });
++
++ if (e.ToList ()[0] != 1)
++ return 3;
++
++ return 0;
++ }
++}
--- /dev/null
--- /dev/null
++
++using System.Collections.Generic;
++
++delegate TD Func<TD>();
++delegate TR Func<TA,TR>(TA arg);
++
++public class C
++{
++ static IEnumerable<T> Test<T> (T t)
++ {
++ return null;
++ }
++
++ static IEnumerable<T> Test<T> (Func<T> f)
++ {
++ return null;
++ }
++
++ static IEnumerable<T> Test2<T> (Func<T, T> f)
++ {
++ return null;
++ }
++
++ public static void Main ()
++ {
++ IEnumerable<int> ie = Test (1);
++ IEnumerable<string> se;
++ se = Test (() => "a");
++ se = Test (delegate () { return "a"; });
++ se = Test2 ((string s) => "s");
++ }
++}
--- /dev/null
--- /dev/null
++
++
++using System;
++using System.Collections.Generic;
++
++class C
++{
++ public static void Foo<TSource> (IEnumerable<TSource> a)
++ {
++ }
++
++ public static void Foo<TCollection, TSource> (IEnumerable<TSource> a,
++ Func<TSource, IEnumerable <TCollection>> b)
++ {
++ }
++
++ public static void Foo<TCollection, TSource> (IEnumerable<TSource> a,
++ Func<TSource, TCollection[], IEnumerable <TCollection>> b)
++ {
++ }
++
++ public static void Foo<TCollection, TSource> (Func<TCollection[], IEnumerable <TSource>> b)
++ {
++ }
++
++ public static void Main ()
++ {
++ int[] a = new int [] { 1 };
++ Foo (a);
++ Foo (a, (int i) => { return a; });
++ Foo (a, (int i, int[] b) => { return a; });
++ Foo ((int[] b) => { return a; });
++ }
++}
++
--- /dev/null
--- /dev/null
++
++
++using System;
++
++public class Pair<T1, T2>
++{
++}
++
++public delegate Pair<T1, T2> Group<T1, T2>(T1 input);
++
++
++public static class C
++{
++ public static void Foo<TInput, TValue, TIntermediate> (Group<TInput, TValue> Pair,
++ Func<TValue, Group<TInput, TIntermediate>> selector)
++ {
++ }
++}
++
++public class E<TI>
++{
++ public void Rep1<TV>(Group<TI, TV> parser)
++ {
++ C.Foo (parser, (x) => parser);
++ }
++}
++
++public class M
++{
++ public static void Main ()
++ {
++ }
++}
++
--- /dev/null
--- /dev/null
++
++
++using System;
++
++public delegate void Func<TA> (TA arg0);
++
++class Demo
++{
++ static void F<T> (T[] values, T value, Func<T> f)
++ {
++ Console.WriteLine (values [0]);
++ f (value);
++ Console.WriteLine (values [0]);
++ }
++
++ static int Main ()
++ {
++ int[] a = new int [] { 10 };
++ F (a, 5, i => a [0] = i);
++
++ if (a [0] != 5)
++ return 1;
++
++ return 0;
++ }
++}
--- /dev/null
--- /dev/null
++using System;
++
++class TestUnary
++{
++ static void Foo (Action<int> a)
++ {
++ }
++
++ static void Bar ()
++ {
++ Foo (str => ++str);
++ }
++}
++
++class Program
++{
++
++ static void Foo (Action<string> a)
++ {
++ a ("action");
++ }
++
++ static T Foo<T> (Func<string, T> f)
++ {
++ return f ("function");
++ }
++
++ static string Bar ()
++ {
++ return Foo (str => str.ToLower ());
++ }
++
++ static void Main ()
++ {
++ var str = Foo (s => s);
++ Console.WriteLine (str);
++ Foo (s => Console.WriteLine (s));
++ }
++}
--- /dev/null
--- /dev/null
++// identity functions
++using System;
++
++class Test {
++ public static void Main ()
++ {
++ }
++
++ static void Foo<T> ()
++ {
++ Func<T,T> f = n => n;
++ }
++}
--- /dev/null
--- /dev/null
++using System;
++using System.Collections.Generic;
++
++static class Enumerable
++{
++
++ public static int Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
++ {
++ return Sum<TSource, int> (source, (a, b) => a + selector (b));
++ }
++
++ static TR Sum<TA, TR> (this IEnumerable<TA> source, Func<TR, TA, TR> selector)
++ {
++ if (source == null)
++ throw new ArgumentNullException ("source");
++ if (selector == null)
++ throw new ArgumentNullException ("selector");
++
++ TR total = default (TR);
++ int counter = 0;
++ foreach (var element in source) {
++ total = selector (total, element);
++ ++counter;
++ }
++
++ if (counter == 0)
++ throw new InvalidOperationException ();
++
++ return total;
++ }
++
++}
++
++class Repro
++{
++
++ static int Main ()
++ {
++ var sum = new [] { "1", "2", "3", "4", "5", "6", "7" }.Sum ((s) => int.Parse (s));
++ if (sum != 28)
++ return 4;
++
++ Console.WriteLine (sum);
++ return 0;
++ }
++}
--- /dev/null
--- /dev/null
++using System;
++using System.Collections.Generic;
++
++class Repro
++{
++ class Runner<T>
++ {
++ public Runner (Action<T> action, T t) { }
++ }
++
++ static void AssertFoo<T> (IList<T> list)
++ {
++ new Runner<int> (delegate {
++ foreach (T item in list) { }
++ }, 42);
++ }
++
++ static void Main ()
++ {
++ }
++}
--- /dev/null
--- /dev/null
++using System;
++
++class TestCase
++{
++ string a;
++ string b;
++ string c;
++
++ public void Testing ()
++ {
++ string z = a + b + "blah1" + c + "blah2";
++ Action test = () => {
++ string x = a;
++ };
++ test ();
++ }
++
++ public static void Main ()
++ {
++ new TestCase ().Testing ();
++ }
++}
--- /dev/null
--- /dev/null
++using System;
++
++static class Test
++{
++ public static void Foo<T1, T2, TResult> (
++ T1 arg1, T2 arg2, Func<T1, T2, TResult> func)
++ {
++ Bar (arg1, arg2, (a, b, _) => func (a, b));
++ }
++
++ public static void Bar<T1, T2, TResult> (
++ T1 arg1, T2 arg2, Func<T1, T2, int, TResult> func)
++ {
++ }
++
++ public static void Main ()
++ {
++ }
++}
--- /dev/null
--- /dev/null
++using System;
++
++public class Crasher
++{
++ public static void Crash ()
++ {
++ double [] array = new double [1];
++ Do (() => {
++ int col = 1;
++ array [col] += array [col];
++ });
++ }
++
++ static void Do (Action action)
++ {
++ }
++
++ public static void Main ()
++ {
++ }
++}
--- /dev/null
--- /dev/null
++public class Z
++{
++ public Z ()
++ {
++ TestMethod tm = () => Test.Foo ();
++ }
++}
++
++public class Test
++{
++ public static bool Foo ()
++ {
++ return true;
++ }
++
++ public static void Main ()
++ {
++ }
++}
++
++public delegate void TestMethod ();
--- /dev/null
--- /dev/null
++using System;
++
++class Program
++{
++ static void Foo (Action<string> a)
++ {
++ a ("action");
++ }
++
++ static T Foo<T> (Func<string, T> f)
++ {
++ return f ("function");
++ }
++
++ static string Bar ()
++ {
++ return Foo (str => str.ToLower ());
++ }
++
++ static int Main ()
++ {
++ var str = Foo (s => s);
++ Console.WriteLine (str);
++ if (str != "function")
++ return 1;
++ Foo (s => Console.WriteLine (s));
++ return 0;
++ }
++}
--- /dev/null
--- /dev/null
++using System.Linq;
++
++//
++// This is a lambda test for situation when parent is infering return types and child not
++//
++
++public class Product
++{
++ public int CategoryID;
++ public decimal UnitPrice;
++}
++
++class MainClass
++{
++ public static void Main ()
++ {
++ Product[] products = new[] {
++ new Product { CategoryID = 1, UnitPrice = 1m }
++ };
++
++ var categories = from p in products
++ group p by p.CategoryID into g
++ select new {
++ g,
++ ExpensiveProducts = from p2 in g
++ where (p2.UnitPrice > g.Average (p3 => p3.UnitPrice))
++ select p2
++ };
++ }
++}
--- /dev/null
--- /dev/null
++# This file contains test files which cause any type of error.
++
++# This file supports extended syntax
++# csXXXX.cs : test case causes error
++# csXXXX.cs IGNORE : adds test to ignore list
++
++test-xml-027.cs
++test-539.cs IGNORE # In 2.0 profile, RuntimeCompatilityAttribute is added by default with WrapNonExceptionThrows set to true and conditional compilation symbols are not provided yet.
++
++gtest-230.cs
++gtest-437.cs
++
++# Missing runtime support for variance should cause Execution Error only
++gtest-variance-1.cs
++gtest-variance-2.cs
++gtest-variance-3.cs
++gtest-variance-4.cs
++gtest-variance-5.cs IGNORE
++gtest-variance-8.cs
++gtest-variance-10.cs
++gtest-variance-12.cs
++
++test-416.cs bug #504085
++test-418.cs bug #504085
++test-704.cs IGNORE #472845
+++ /dev/null
--
--//
--// Lambda expression test, basics.
--//
--using System;
--
--delegate int IntFunc (int x);
--delegate void VoidFunc (int x);
--
--class X {
--
-- static IntFunc func, increment;
-- static VoidFunc nothing;
--
-- static int Main ()
-- {
-- int y = 0;
-- int r;
--
-- //
-- // The following tests body-style lambda
-- //
-- increment = (int x) => { return x + 1; };
-- r = increment (4);
-- Console.WriteLine ("Should be 5={0}", r);
-- if (r != 5)
-- return 1;
--
-- //
-- // This tests the body of a lambda being an expression
-- //
-- func = (int x) => x + 1;
-- r = func (10);
-- Console.WriteLine ("Should be 11={0}", r);
-- if (r != 11)
-- return 2;
--
-- //
-- // The following tests that the body is a statement
-- //
-- nothing = (int x) => { y = x; };
-- nothing (10);
-- Console.WriteLine ("Should be 10={0}", y);
-- if (y != 10)
-- return 3;
--
-- nothing = (int x) => { new X (x); };
-- nothing (314);
-- if (instantiated_value != 314)
-- return 4;
--
-- Console.WriteLine ("All tests pass");
-- return 0;
-- }
--
-- static int instantiated_value;
--
-- X (int v)
-- {
-- instantiated_value = v;
-- }
--}
+++ /dev/null
--
--//
--// Lambda expression test overload resolution with parameterless arguments
--//
--
--using System;
--delegate string funcs (string s);
--delegate int funci (int i);
--
--class X {
-- static void Foo (funci fi)
-- {
-- int res = fi (10);
-- Console.WriteLine (res);
-- }
--
-- static void Foo (funcs fs)
-- {
-- string res = fs ("hello");
-- Console.WriteLine (res);
-- }
--
-- static void Main ()
-- {
-- Foo (x => x + "dingus");
-- }
--}
+++ /dev/null
--
--
--using System;
--
--public delegate TResult Func<TArg0, TResult> (TArg0 arg0);
--
--class Demo
--{
-- static Y F<X, Y> (int a, X value, Func<X, Y> f1)
-- {
-- return f1 (value);
-- }
-- static int Main ()
-- {
-- object o = F (1, "1:15:30", s => TimeSpan.Parse (s));
-- Console.WriteLine (o);
-- return 0;
-- }
--}
+++ /dev/null
--
--//
--// This test is used to test the type information flow between arguments
--// in a generic method invocation, where:
--//
--// 1. We first infer the type of X from the first argument to F
--//
--// 2. We use this information to infer from the type of f1 and Func
--// that X is a TimeSpan.
--//
--// 3. Use the X=String and Y=TimeSpan to infer the value for Z
--// which is double
--//
--
--using System;
--public delegate TResult Func<TArg0, TResult> (TArg0 arg0);
--
--class Demo {
-- static Z F<X,Y,Z>(X value, Func<X,Y> f1, Func<Y,Z> f2)
-- {
-- return f2 (f1(value));
-- }
-- static int Main ()
-- {
-- double d = F("1:15:30", s => TimeSpan.Parse(s), t => t.TotalSeconds);
-- if (d < 4529 || d > 4531)
-- return 1;
-- return 0;
-- }
--}
+++ /dev/null
--
--
--using System;
--
--public class C
--{
--
-- delegate int di (int x);
-- delegate string ds (string s);
-- delegate bool db (bool x);
--
-- static bool M (db d) { return d (false); }
-- static string M (ds d) { return "b"; }
-- static int M (di d) { return d (0); }
--
-- public static int Main ()
-- {
-- string[] s = new string[] { "1" };
-- int[] i = new int[] { 1 };
--
-- string s_res = M (x=> M (y=> x.ToLower ()));
-- int i_res = M (x=> M (y=> (x * 0) + 5));
--
-- if (s_res != "b")
-- return 1;
--
-- if (i_res != 5)
-- return 2;
--
-- return 0;
-- }
--}
+++ /dev/null
--// Inspired by
--// http://blogs.msdn.com/ericlippert/archive/2007/03/28/lambda-expressions-vs-anonymous-methods-part-five.aspx
--
--using System;
--
--class TestClass
--{
-- delegate void DT (T t);
-- delegate void DF (F f);
--
-- struct T { }
-- struct F { }
--
-- static void P (DT dt)
-- {
-- Console.WriteLine ("True");
-- dt (new T ());
-- }
--
-- static void P (DF df)
-- {
-- System.Console.WriteLine ("False");
-- df (new F ());
-- }
--
-- static T And (T a1, T a2) { return new T (); }
-- static F And (T a1, F a2) { return new F (); }
-- static F And (F a1, T a2) { return new F (); }
-- static F And (F a1, F a2) { return new F (); }
--
-- static T Or (T a1, T a2) { return new T (); }
-- static T Or (T a1, F a2) { return new T (); }
-- static T Or (F a1, T a2) { return new T (); }
-- static F Or (F a1, F a2) { return new F (); }
--
-- static F Not (T a) { return new F (); }
-- static T Not (F a) { return new T (); }
--
-- static void StopTrue (T t) { }
--
-- static int Main ()
-- {
-- // Test that we encode (!v3) & ((!v1) & ((v1 | v2) & (v2 | v3)))
-- P (v1 => P (v2 => P (v3 => StopTrue (
-- And (Not (v3),
-- And (Not (v1),
-- And (Or (v1, v2), Or (v2, v3))
-- )
-- )
-- ))));
--
-- return 0;
-- }
--}
+++ /dev/null
--
--
--// Lambda parser tests
--
--delegate void D ();
--delegate void E (bool b);
--
--public class C
--{
-- static void Test (D d)
-- {
-- }
--
-- static void Test (object o, D d)
-- {
-- }
--
-- static void Test (D d1, D d2)
-- {
-- }
--
-- static void Test2 (object o, E e)
-- {
-- }
--
-- public static void Main ()
-- {
-- D e = () => { };
-- e = (D)null;
-- e = default (D);
--
-- Test (() => { });
-- Test (1, () => { });
-- Test (() => { }, () => { });
-- Test2 (null, (foo) => { });
-- }
--}
+++ /dev/null
--
--
--using System;
--using System.Linq;
--using System.Collections.Generic;
--
--public class C
--{
-- static void Test<T, R> (Func<T, R> d)
-- {
-- }
--
-- public static int Main ()
-- {
-- Test ((int x) => { return x + 1; });
--
-- int[] source = new int[] { 2, 1, 0 };
-- IEnumerable<int> e = source.Where((i) => i == 0).Select((i) => i + 1);
--
-- if (e.ToList ()[0] != 1)
-- return 1;
--
-- e = source.Where((int i) => i == 0).Select((int i) => i + 1);
--
-- if (e.ToList ()[0] != 1)
-- return 2;
--
-- e = source.Where(delegate (int i) { return i == 0; }).Select(delegate (int i) { return i + 1; });
--
-- if (e.ToList ()[0] != 1)
-- return 3;
--
-- return 0;
-- }
--}
+++ /dev/null
--
--using System.Collections.Generic;
--
--delegate TD Func<TD>();
--delegate TR Func<TA,TR>(TA arg);
--
--public class C
--{
-- static IEnumerable<T> Test<T> (T t)
-- {
-- return null;
-- }
--
-- static IEnumerable<T> Test<T> (Func<T> f)
-- {
-- return null;
-- }
--
-- static IEnumerable<T> Test2<T> (Func<T, T> f)
-- {
-- return null;
-- }
--
-- public static void Main ()
-- {
-- IEnumerable<int> ie = Test (1);
-- IEnumerable<string> se;
-- se = Test (() => "a");
-- se = Test (delegate () { return "a"; });
-- se = Test2 ((string s) => "s");
-- }
--}
+++ /dev/null
--
--
--using System;
--using System.Collections.Generic;
--
--class C
--{
-- public static void Foo<TSource> (IEnumerable<TSource> a)
-- {
-- }
--
-- public static void Foo<TCollection, TSource> (IEnumerable<TSource> a,
-- Func<TSource, IEnumerable <TCollection>> b)
-- {
-- }
--
-- public static void Foo<TCollection, TSource> (IEnumerable<TSource> a,
-- Func<TSource, TCollection[], IEnumerable <TCollection>> b)
-- {
-- }
--
-- public static void Foo<TCollection, TSource> (Func<TCollection[], IEnumerable <TSource>> b)
-- {
-- }
--
-- public static void Main ()
-- {
-- int[] a = new int [] { 1 };
-- Foo (a);
-- Foo (a, (int i) => { return a; });
-- Foo (a, (int i, int[] b) => { return a; });
-- Foo ((int[] b) => { return a; });
-- }
--}
--
+++ /dev/null
--
--
--using System;
--
--public class Pair<T1, T2>
--{
--}
--
--public delegate Pair<T1, T2> Group<T1, T2>(T1 input);
--
--
--public static class C
--{
-- public static void Foo<TInput, TValue, TIntermediate> (Group<TInput, TValue> Pair,
-- Func<TValue, Group<TInput, TIntermediate>> selector)
-- {
-- }
--}
--
--public class E<TI>
--{
-- public void Rep1<TV>(Group<TI, TV> parser)
-- {
-- C.Foo (parser, (x) => parser);
-- }
--}
--
--public class M
--{
-- public static void Main ()
-- {
-- }
--}
--
+++ /dev/null
--
--
--using System;
--
--public delegate void Func<TA> (TA arg0);
--
--class Demo
--{
-- static void F<T> (T[] values, T value, Func<T> f)
-- {
-- Console.WriteLine (values [0]);
-- f (value);
-- Console.WriteLine (values [0]);
-- }
--
-- static int Main ()
-- {
-- int[] a = new int [] { 10 };
-- F (a, 5, i => a [0] = i);
--
-- if (a [0] != 5)
-- return 1;
--
-- return 0;
-- }
--}
+++ /dev/null
--using System;
--
--class TestUnary
--{
-- static void Foo (Action<int> a)
-- {
-- }
--
-- static void Bar ()
-- {
-- Foo (str => ++str);
-- }
--}
--
--class Program
--{
--
-- static void Foo (Action<string> a)
-- {
-- a ("action");
-- }
--
-- static T Foo<T> (Func<string, T> f)
-- {
-- return f ("function");
-- }
--
-- static string Bar ()
-- {
-- return Foo (str => str.ToLower ());
-- }
--
-- static void Main ()
-- {
-- var str = Foo (s => s);
-- Console.WriteLine (str);
-- Foo (s => Console.WriteLine (s));
-- }
--}
+++ /dev/null
--// identity functions
--using System;
--
--class Test {
-- public static void Main ()
-- {
-- }
--
-- static void Foo<T> ()
-- {
-- Func<T,T> f = n => n;
-- }
--}
+++ /dev/null
--using System;
--using System.Collections.Generic;
--
--static class Enumerable
--{
--
-- public static int Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
-- {
-- return Sum<TSource, int> (source, (a, b) => a + selector (b));
-- }
--
-- static TR Sum<TA, TR> (this IEnumerable<TA> source, Func<TR, TA, TR> selector)
-- {
-- if (source == null)
-- throw new ArgumentNullException ("source");
-- if (selector == null)
-- throw new ArgumentNullException ("selector");
--
-- TR total = default (TR);
-- int counter = 0;
-- foreach (var element in source) {
-- total = selector (total, element);
-- ++counter;
-- }
--
-- if (counter == 0)
-- throw new InvalidOperationException ();
--
-- return total;
-- }
--
--}
--
--class Repro
--{
--
-- static int Main ()
-- {
-- var sum = new [] { "1", "2", "3", "4", "5", "6", "7" }.Sum ((s) => int.Parse (s));
-- if (sum != 28)
-- return 4;
--
-- Console.WriteLine (sum);
-- return 0;
-- }
--}
+++ /dev/null
--using System;
--using System.Collections.Generic;
--
--class Repro
--{
-- class Runner<T>
-- {
-- public Runner (Action<T> action, T t) { }
-- }
--
-- static void AssertFoo<T> (IList<T> list)
-- {
-- new Runner<int> (delegate {
-- foreach (T item in list) { }
-- }, 42);
-- }
--
-- static void Main ()
-- {
-- }
--}
+++ /dev/null
--using System;
--
--class TestCase
--{
-- string a;
-- string b;
-- string c;
--
-- public void Testing ()
-- {
-- string z = a + b + "blah1" + c + "blah2";
-- Action test = () => {
-- string x = a;
-- };
-- test ();
-- }
--
-- public static void Main ()
-- {
-- new TestCase ().Testing ();
-- }
--}
+++ /dev/null
--using System;
--
--static class Test
--{
-- public static void Foo<T1, T2, TResult> (
-- T1 arg1, T2 arg2, Func<T1, T2, TResult> func)
-- {
-- Bar (arg1, arg2, (a, b, _) => func (a, b));
-- }
--
-- public static void Bar<T1, T2, TResult> (
-- T1 arg1, T2 arg2, Func<T1, T2, int, TResult> func)
-- {
-- }
--
-- public static void Main ()
-- {
-- }
--}
+++ /dev/null
--using System;
--
--public class Crasher
--{
-- public static void Crash ()
-- {
-- double [] array = new double [1];
-- Do (() => {
-- int col = 1;
-- array [col] += array [col];
-- });
-- }
--
-- static void Do (Action action)
-- {
-- }
--
-- public static void Main ()
-- {
-- }
--}
+++ /dev/null
--public class Z
--{
-- public Z ()
-- {
-- TestMethod tm = () => Test.Foo ();
-- }
--}
--
--public class Test
--{
-- public static bool Foo ()
-- {
-- return true;
-- }
--
-- public static void Main ()
-- {
-- }
--}
--
--public delegate void TestMethod ();
+++ /dev/null
--using System;
--
--class Program
--{
-- static void Foo (Action<string> a)
-- {
-- a ("action");
-- }
--
-- static T Foo<T> (Func<string, T> f)
-- {
-- return f ("function");
-- }
--
-- static string Bar ()
-- {
-- return Foo (str => str.ToLower ());
-- }
--
-- static int Main ()
-- {
-- var str = Foo (s => s);
-- Console.WriteLine (str);
-- if (str != "function")
-- return 1;
-- Foo (s => Console.WriteLine (s));
-- return 0;
-- }
--}
+++ /dev/null
--using System.Linq;
--
--//
--// This is a lambda test for situation when parent is infering return types and child not
--//
--
--public class Product
--{
-- public int CategoryID;
-- public decimal UnitPrice;
--}
--
--class MainClass
--{
-- public static void Main ()
-- {
-- Product[] products = new[] {
-- new Product { CategoryID = 1, UnitPrice = 1m }
-- };
--
-- var categories = from p in products
-- group p by p.CategoryID into g
-- select new {
-- g,
-- ExpensiveProducts = from p2 in g
-- where (p2.UnitPrice > g.Average (p3 => p3.UnitPrice))
-- select p2
-- };
-- }
--}
</method>
</type>
</test>
++ <test name="gtest-lambda-01.cs">
++ <type name="X">
++ <method name="Int32 Main()">
++ <size>300</size>
++ </method>
++ <method name="Int32 <Main>m__0(Int32)">
++ <size>4</size>
++ </method>
++ <method name="Int32 <Main>m__1(Int32)">
++ <size>4</size>
++ </method>
++ <method name="Void <Main>m__3(Int32)">
++ <size>8</size>
++ </method>
++ <method name="Void .ctor(Int32)">
++ <size>13</size>
++ </method>
++ </type>
++ <type name="IntFunc">
++ <method name="Int32 Invoke(Int32)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(Int32, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Int32 EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="VoidFunc">
++ <method name="Void Invoke(Int32)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(Int32, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Void EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="X+<Main>c__AnonStorey0">
++ <method name="Void <>m__2(Int32)">
++ <size>8</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-02.cs">
++ <type name="X">
++ <method name="Void Foo(funci)">
++ <size>16</size>
++ </method>
++ <method name="Void Foo(funcs)">
++ <size>19</size>
++ </method>
++ <method name="Void Main()">
++ <size>35</size>
++ </method>
++ <method name="System.String <Main>m__0(System.String)">
++ <size>12</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="funcs">
++ <method name="System.String Invoke(System.String)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(System.String, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="System.String EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="funci">
++ <method name="Int32 Invoke(Int32)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(Int32, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Int32 EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-03.cs">
++ <type name="Demo">
++ <method name="Y F[X,Y](Int32, X, Func`2[X,Y])">
++ <size>8</size>
++ </method>
++ <method name="Int32 Main()">
++ <size>54</size>
++ </method>
++ <method name="TimeSpan <Main>m__0(System.String)">
++ <size>7</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="Func`2[TArg0,TResult]">
++ <method name="TResult Invoke(TArg0)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(TArg0, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="TResult EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-04.cs">
++ <type name="Demo">
++ <method name="Z F[X,Y,Z](X, Func`2[X,Y], Func`2[Y,Z])">
++ <size>14</size>
++ </method>
++ <method name="Int32 Main()">
++ <size>103</size>
++ </method>
++ <method name="TimeSpan <Main>m__0(System.String)">
++ <size>7</size>
++ </method>
++ <method name="Double <Main>m__1(TimeSpan)">
++ <size>8</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="Func`2[TArg0,TResult]">
++ <method name="TResult Invoke(TArg0)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(TArg0, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="TResult EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-05.cs">
++ <type name="C">
++ <method name="Boolean M(C+db)">
++ <size>8</size>
++ </method>
++ <method name="System.String M(C+ds)">
++ <size>6</size>
++ </method>
++ <method name="Int32 M(C+di)">
++ <size>8</size>
++ </method>
++ <method name="Int32 Main()">
++ <size>125</size>
++ </method>
++ <method name="System.String <Main>m__0(System.String)">
++ <size>31</size>
++ </method>
++ <method name="Int32 <Main>m__1(Int32)">
++ <size>31</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="C+di">
++ <method name="Int32 Invoke(Int32)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(Int32, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Int32 EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="C+ds">
++ <method name="System.String Invoke(System.String)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(System.String, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="System.String EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="C+db">
++ <method name="Boolean Invoke(Boolean)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(Boolean, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Boolean EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="C+<Main>c__AnonStorey0">
++ <method name="System.String <>m__2(System.String)">
++ <size>12</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="C+<Main>c__AnonStorey1">
++ <method name="Int32 <>m__3(Int32)">
++ <size>11</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-06.cs">
++ <type name="TestClass">
++ <method name="Void P(TestClass+DT)">
++ <size>26</size>
++ </method>
++ <method name="Void P(TestClass+DF)">
++ <size>26</size>
++ </method>
++ <method name="T And(T, T)">
++ <size>10</size>
++ </method>
++ <method name="F And(T, F)">
++ <size>10</size>
++ </method>
++ <method name="F And(F, T)">
++ <size>10</size>
++ </method>
++ <method name="F And(F, F)">
++ <size>10</size>
++ </method>
++ <method name="T Or(T, T)">
++ <size>10</size>
++ </method>
++ <method name="T Or(T, F)">
++ <size>10</size>
++ </method>
++ <method name="T Or(F, T)">
++ <size>10</size>
++ </method>
++ <method name="F Or(F, F)">
++ <size>10</size>
++ </method>
++ <method name="F Not(T)">
++ <size>10</size>
++ </method>
++ <method name="T Not(F)">
++ <size>10</size>
++ </method>
++ <method name="Void StopTrue(T)">
++ <size>1</size>
++ </method>
++ <method name="Int32 Main()">
++ <size>36</size>
++ </method>
++ <method name="Void <Main>m__0(F)">
++ <size>31</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="TestClass+DT">
++ <method name="Void Invoke(T)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(T, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Void EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="TestClass+DF">
++ <method name="Void Invoke(F)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(F, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Void EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="TestClass+<Main>c__AnonStorey0">
++ <method name="Void <>m__1(T)">
++ <size>38</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="TestClass+<Main>c__AnonStorey0+<Main>c__AnonStorey1">
++ <method name="Void <>m__2(F)">
++ <size>77</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-07.cs">
++ <type name="C">
++ <method name="Void Test(D)">
++ <size>1</size>
++ </method>
++ <method name="Void Test(System.Object, D)">
++ <size>1</size>
++ </method>
++ <method name="Void Test(D, D)">
++ <size>1</size>
++ </method>
++ <method name="Void Test2(System.Object, E)">
++ <size>1</size>
++ </method>
++ <method name="Void Main()">
++ <size>207</size>
++ </method>
++ <method name="Void <Main>m__0()">
++ <size>1</size>
++ </method>
++ <method name="Void <Main>m__1()">
++ <size>1</size>
++ </method>
++ <method name="Void <Main>m__2()">
++ <size>1</size>
++ </method>
++ <method name="Void <Main>m__3()">
++ <size>1</size>
++ </method>
++ <method name="Void <Main>m__4()">
++ <size>1</size>
++ </method>
++ <method name="Void <Main>m__5(Boolean)">
++ <size>1</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="D">
++ <method name="Void Invoke()">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Void EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="E">
++ <method name="Void Invoke(Boolean)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(Boolean, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Void EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-08.cs">
++ <type name="C">
++ <method name="Void Test[T,R](System.Func`2[T,R])">
++ <size>1</size>
++ </method>
++ <method name="Int32 Main()">
++ <size>321</size>
++ </method>
++ <method name="Int32 <Main>m__0(Int32)">
++ <size>4</size>
++ </method>
++ <method name="Boolean <Main>m__1(Int32)">
++ <size>5</size>
++ </method>
++ <method name="Int32 <Main>m__2(Int32)">
++ <size>4</size>
++ </method>
++ <method name="Boolean <Main>m__3(Int32)">
++ <size>5</size>
++ </method>
++ <method name="Int32 <Main>m__4(Int32)">
++ <size>4</size>
++ </method>
++ <method name="Boolean <Main>m__5(Int32)">
++ <size>5</size>
++ </method>
++ <method name="Int32 <Main>m__6(Int32)">
++ <size>4</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-09.cs">
++ <type name="C">
++ <method name="IEnumerable`1 Test[T](T)">
++ <size>2</size>
++ </method>
++ <method name="IEnumerable`1 Test[T](Func`1[T])">
++ <size>2</size>
++ </method>
++ <method name="IEnumerable`1 Test2[T](Func`2[T,T])">
++ <size>2</size>
++ </method>
++ <method name="Void Main()">
++ <size>113</size>
++ </method>
++ <method name="System.String <Main>m__0()">
++ <size>6</size>
++ </method>
++ <method name="System.String <Main>m__1()">
++ <size>6</size>
++ </method>
++ <method name="System.String <Main>m__2(System.String)">
++ <size>6</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="Func`1[TD]">
++ <method name="TD Invoke()">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="TD EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="Func`2[TA,TR]">
++ <method name="TR Invoke(TA)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(TA, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="TR EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-10.cs">
++ <type name="C">
++ <method name="Void Foo[TSource](IEnumerable`1)">
++ <size>1</size>
++ </method>
++ <method name="Void Foo[TCollection,TSource](IEnumerable`1, System.Func`2[TSource,System.Collections.Generic.IEnumerable`1[TCollection]])">
++ <size>1</size>
++ </method>
++ <method name="Void Foo[TCollection,TSource](IEnumerable`1, System.Func`3[TSource,TCollection[],System.Collections.Generic.IEnumerable`1[TCollection]])">
++ <size>1</size>
++ </method>
++ <method name="Void Foo[TCollection,TSource](System.Func`2[TCollection[],System.Collections.Generic.IEnumerable`1[TSource]])">
++ <size>1</size>
++ </method>
++ <method name="Void Main()">
++ <size>97</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="C+<Main>c__AnonStorey0">
++ <method name="IEnumerable`1 <>m__0(Int32)">
++ <size>7</size>
++ </method>
++ <method name="IEnumerable`1 <>m__1(Int32, System.Int32[])">
++ <size>7</size>
++ </method>
++ <method name="IEnumerable`1 <>m__2(System.Int32[])">
++ <size>7</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-11.cs">
++ <type name="Pair`2[T1,T2]">
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="C">
++ <method name="Void Foo[TInput,TValue,TIntermediate](Group`2[TInput,TValue], System.Func`2[TValue,Group`2[TInput,TIntermediate]])">
++ <size>1</size>
++ </method>
++ </type>
++ <type name="E`1[TI]">
++ <method name="Void Rep1[TV](Group`2[TI,TV])">
++ <size>37</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="M">
++ <method name="Void Main()">
++ <size>1</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="Group`2[T1,T2]">
++ <method name="Pair`2[T1,T2] Invoke(T1)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(T1, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Pair`2[T1,T2] EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="E`1+<Rep1>c__AnonStorey0`1[TI,TV]">
++ <method name="Group`2[TI,TV] <>m__0(TV)">
++ <size>7</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-12.cs">
++ <type name="Demo">
++ <method name="Void F[T](T[], T, Func`1[T])">
++ <size>42</size>
++ </method>
++ <method name="Int32 Main()">
++ <size>65</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="Func`1[TA]">
++ <method name="Void Invoke(TA)">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(TA, System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Void EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ <type name="Demo+<Main>c__AnonStorey0">
++ <method name="Void <>m__0(Int32)">
++ <size>10</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-13.cs">
++ <type name="TestUnary">
++ <method name="Void Foo(System.Action`1[System.Int32])">
++ <size>1</size>
++ </method>
++ <method name="Void Bar()">
++ <size>35</size>
++ </method>
++ <method name="Void <Bar>m__0(Int32)">
++ <size>6</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="Program">
++ <method name="Void Foo(System.Action`1[System.String])">
++ <size>12</size>
++ </method>
++ <method name="T Foo[T](System.Func`2[System.String,T])">
++ <size>12</size>
++ </method>
++ <method name="System.String Bar()">
++ <size>35</size>
++ </method>
++ <method name="Void Main()">
++ <size>76</size>
++ </method>
++ <method name="System.String <Bar>m__1(System.String)">
++ <size>7</size>
++ </method>
++ <method name="System.String <Main>m__2(System.String)">
++ <size>2</size>
++ </method>
++ <method name="Void <Main>m__3(System.String)">
++ <size>7</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-14.cs">
++ <type name="Test">
++ <method name="Void Main()">
++ <size>1</size>
++ </method>
++ <method name="Void Foo[T]()">
++ <size>14</size>
++ </method>
++ <method name="T <Foo>m__0[T](T)">
++ <size>2</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-15.cs">
++ <type name="Enumerable">
++ <method name="Int32 Sum[TSource](IEnumerable`1, System.Func`2[TSource,System.Int32])">
++ <size>32</size>
++ </method>
++ <method name="TR Sum[TA,TR](IEnumerable`1, System.Func`3[TR,TA,TR])">
++ <size>120</size>
++ </method>
++ </type>
++ <type name="Repro">
++ <method name="Int32 Main()">
++ <size>115</size>
++ </method>
++ <method name="Int32 <Main>m__1(System.String)">
++ <size>7</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="Enumerable+<Sum>c__AnonStorey0`1[TSource]">
++ <method name="Int32 <>m__0(Int32, TSource)">
++ <size>15</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-16.cs">
++ <type name="Repro">
++ <method name="Void AssertFoo[T](IList`1)">
++ <size>34</size>
++ </method>
++ <method name="Void Main()">
++ <size>1</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="Repro+Runner`1[T]">
++ <method name="Void .ctor(Action`1, T)">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="Repro+<AssertFoo>c__AnonStorey0`1[T]">
++ <method name="Void <>m__0(Int32)">
++ <size>52</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-17.cs">
++ <type name="TestCase">
++ <method name="Void Testing()">
++ <size>75</size>
++ </method>
++ <method name="Void Main()">
++ <size>11</size>
++ </method>
++ <method name="Void <Testing>m__0()">
++ <size>8</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-18.cs">
++ <type name="Test">
++ <method name="Void Foo[T1,T2,TResult](T1, T2, System.Func`3[T1,T2,TResult])">
++ <size>33</size>
++ </method>
++ <method name="Void Bar[T1,T2,TResult](T1, T2, System.Func`4[T1,T2,System.Int32,TResult])">
++ <size>1</size>
++ </method>
++ <method name="Void Main()">
++ <size>1</size>
++ </method>
++ </type>
++ <type name="Test+<Foo>c__AnonStorey0`3[T1,T2,TResult]">
++ <method name="TResult <>m__0(T1, T2, Int32)">
++ <size>14</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-19.cs">
++ <type name="Crasher">
++ <method name="Void Crash()">
++ <size>36</size>
++ </method>
++ <method name="Void Do(System.Action)">
++ <size>1</size>
++ </method>
++ <method name="Void Main()">
++ <size>1</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="Crasher+<Crash>c__AnonStorey0">
++ <method name="Void <>m__0()">
++ <size>27</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-20.cs">
++ <type name="Z">
++ <method name="Void <Z>m__0()">
++ <size>7</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>37</size>
++ </method>
++ </type>
++ <type name="Test">
++ <method name="Boolean Foo()">
++ <size>2</size>
++ </method>
++ <method name="Void Main()">
++ <size>1</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="TestMethod">
++ <method name="Void Invoke()">
++ <size>0</size>
++ </method>
++ <method name="IAsyncResult BeginInvoke(System.AsyncCallback, System.Object)">
++ <size>0</size>
++ </method>
++ <method name="Void EndInvoke(IAsyncResult)">
++ <size>0</size>
++ </method>
++ <method name="Void .ctor(Object, IntPtr)">
++ <size>0</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-21.cs">
++ <type name="Program">
++ <method name="Void Foo(System.Action`1[System.String])">
++ <size>12</size>
++ </method>
++ <method name="T Foo[T](System.Func`2[System.String,T])">
++ <size>12</size>
++ </method>
++ <method name="System.String Bar()">
++ <size>35</size>
++ </method>
++ <method name="Int32 Main()">
++ <size>95</size>
++ </method>
++ <method name="System.String <Bar>m__0(System.String)">
++ <size>7</size>
++ </method>
++ <method name="System.String <Main>m__1(System.String)">
++ <size>2</size>
++ </method>
++ <method name="Void <Main>m__2(System.String)">
++ <size>7</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
++ <test name="gtest-lambda-22.cs">
++ <type name="Product">
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="MainClass">
++ <method name="Void Main()">
++ <size>136</size>
++ </method>
++ <method name="Int32 <Main>m__0(Product)">
++ <size>7</size>
++ </method>
++ <method name="Product <Main>m__1(Product)">
++ <size>2</size>
++ </method>
++ <method name="<>__AnonType0`2[System.Linq.IGrouping`2[System.Int32,Product],System.Collections.Generic.IEnumerable`1[Product]] <Main>m__2(IGrouping`2)">
++ <size>48</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ <type name="<>__AnonType0`2[<g>__T,<ExpensiveProducts>__T]">
++ <method name="<g>__T get_g()">
++ <size>7</size>
++ </method>
++ <method name="<ExpensiveProducts>__T get_ExpensiveProducts()">
++ <size>7</size>
++ </method>
++ <method name="Boolean Equals(System.Object)">
++ <size>69</size>
++ </method>
++ <method name="Int32 GetHashCode()">
++ <size>86</size>
++ </method>
++ <method name="System.String ToString()">
++ <size>142</size>
++ </method>
++ <method name="Void .ctor(<g>__T, <ExpensiveProducts>__T)">
++ <size>21</size>
++ </method>
++ </type>
++ <type name="MainClass+<Main>c__AnonStorey0">
++ <method name="Boolean <>m__3(Product)">
++ <size>52</size>
++ </method>
++ <method name="Decimal <>m__4(Product)">
++ <size>7</size>
++ </method>
++ <method name="Void .ctor()">
++ <size>7</size>
++ </method>
++ </type>
++ </test>
<test name="gtest-linq-01.cs">
<type name="from.C">
<method name="Void .ctor()">
projects / mono.git / commitdiff