Initial checkin

IDEHelper/Tests/src/LocalFunctions.bf

@@ -0,0 +1,346 @@
+#pragma warning disable 168
+
+using System;
+
+namespace Tests
+{
+	class LocalFunctions
+	{
+		[Test]
+		static void TestA()
+		{
+			int a = 1;
+
+			void FuncA()
+			{
+				void FuncB()
+				{
+					a += 100;
+				}
+
+				FuncB();
+			}
+
+			FuncA();
+			Test.Assert(a == 101);
+		}
+
+		[Test]
+		static void TestB()
+		{
+			int a = 1;
+			Action act = scope [&] () =>
+			{
+				a += 100;
+			};
+			act();
+			Test.Assert(a == 101);
+		}
+
+		[Test]
+		static void TestC()
+		{
+			int a = 1;
+			const int c = 10;
+
+			Action OuterLocal()
+			{
+				return new [&] () =>
+				{
+					void FuncA()
+					{
+						FuncB();
+					}
+
+					void FuncB()
+					{
+						a += c;
+					}
+
+					FuncA();
+				};
+			}
+
+			var act = OuterLocal();
+			act();
+			delete act;
+			Test.Assert(a == 11);
+		}
+
+		[Test]
+		static void TestD()
+		{
+			int a = 1;
+			int b = 2;
+
+			void FuncA()
+			{
+				a += 100;
+			}
+
+			mixin MixA(var refVal)
+			{
+				refVal += 10;
+				FuncA();
+				MixB!();
+			}
+
+			mixin MixB()
+			{
+				b += 20;
+			}
+
+			MixA!(b);
+			Test.Assert(a == 101);
+			Test.Assert(b == 32);
+		}
+
+		[Test]
+		static void TestE()
+		{
+			int a = 1;
+			int b = 2;
+			int c = 3;
+
+			void FuncA()
+			{
+				a += 100;
+				FuncB();
+				b += 200;
+			}
+
+			void FuncB()
+			{
+				c += 300;
+			}
+
+			FuncA();
+			Test.Assert(a == 101);
+			Test.Assert(b == 202);
+			Test.Assert(c == 303);
+		}
+
+		[Test]
+		static void TestF()
+		{
+			int a = 1;
+			const int c = 100;
+
+			Action act = scope [&] () =>
+			{
+				void FuncA()
+				{
+					FuncB();
+
+					const int d = 1000;
+
+					void FuncB()
+					{
+						a += c;
+						a += d;
+					}
+				}
+
+				FuncA();
+			};
+			act();
+			Test.Assert(a == 1101);
+		}
+
+		[Test]
+		static void TestG()
+		{
+			int a = 1;
+
+			void FuncA()
+			{
+				a += 100;
+
+				int a = 2;
+
+				void FuncB()
+				{
+					a += 1000;
+				}
+
+				FuncB();
+			}
+
+			FuncA();
+			Test.Assert(a == 101);
+		}
+
+		[Test]
+		public static void TestH()
+		{
+			int a = 1;
+
+			void FuncA(int b)
+			{
+				a += 100;
+				if (b == 0)
+					FuncB();
+			}
+
+			void FuncB()
+			{
+				Action act = scope [&] () =>
+				{
+					FuncA(1);
+				};
+
+				act();
+			}
+		}
+
+		[Test]
+		public static void TestI()
+		{
+			int a = 1;
+
+			void FuncA()
+			{
+				a += 100;
+			}
+
+			void FuncB()
+			{
+				int a = 2;
+				FuncA();
+			}
+
+			FuncB();
+			Test.Assert(a == 101);
+		}
+
+		class ClassA
+		{
+			public int mA;
+
+			public mixin MixA()
+			{
+				mA += 10;
+
+				void LocalA()
+				{
+					mA += 20;
+				}
+			}
+
+			public void FuncA()
+			{
+				MixA!();
+			}
+
+			public (int, int) MethodT<T>()
+			{
+				int a = 8;
+				int b = 90;
+
+				int FuncT<T2>()
+				{
+					int GetIt()
+					{
+						return b;
+					}
+
+					int GetIt<T3>(T3 val)
+					{
+						return sizeof(T3);
+					}
+					
+					return mA + sizeof(T)*10000 + sizeof(T2)*1000 + GetIt<float>(2.0f)*100 + GetIt() + a;
+				}
+
+
+				int val = FuncT<int8>();
+				return (FuncT<int8>(), FuncT<int16>());
+			}
+		}
+
+		[Test]
+		public static void TestJ()
+		{
+			int a = 8;
+			int b = 90;
+
+			int FuncT<T>()
+			{
+				int GetIt()
+				{
+					return b;
+				}
+
+				int GetIt<T2>(T2 val)
+				{
+					return sizeof(T2);
+				}
+											 
+  				return sizeof(T)*1000 + GetIt(2.0f)*100 + GetIt() + a;
+			}
+
+			Test.Assert(FuncT<int8>() == 1498);
+			Test.Assert(FuncT<int16>() == 2498);
+
+			///
+			ClassA ca = scope ClassA();
+			ca.mA = 300000;
+			let res2 = ca.MethodT<int32>();
+			Test.Assert(res2.0 == 341498);
+			Test.Assert(res2.1 == 342498);
+		}
+
+		[Test]
+		public static void TestK()
+		{
+			int a = 8;
+			int b = 90;
+
+			int GetIt(Object val)
+			{
+				return 0;
+			}
+
+			int GetIt(int8 val)
+			{
+				return a + val;
+			}
+
+			int GetIt(int16 val)
+			{
+				return b + val;
+			}
+
+			// We want to ensure that each specialization of Get<T> has its own capture list
+			int Get<T>(T val)
+			{
+				return GetIt(val);
+			}
+
+			Test.Assert(GetIt((int8)100) == 108);
+			Test.Assert(GetIt((int16)100) == 190);
+		}
+
+		[Test]
+		public static void TestL()
+		{
+			int a = 8;
+
+			int LocalA()
+			{
+				return 9;
+			}
+
+			int LocalB()
+			{
+				return a;
+			}
+
+			function int() func = => LocalA;
+			Test.Assert(func() == 9);
+
+			delegate int() dlg = scope => LocalB;
+			Test.Assert(dlg() == 8);
+		}
+	}
+}