path: root/mcs/tests/test-154.cs

using System;
using System.Collections;

public class X
{
	public static int Main ()
	{
		// This is a compilation-only test.
		return 0;
	}

	// All code paths throw an exception, no need to set out parameters.
	public static void test1 (out float f)
	{
		throw new NotSupportedException ();
	}

	// The while loop breaks but does not return, so this is ok.
	public static void test2 (int a, out float f)
	{
		while (a > 0) {
			if (a == 5)
				continue;

			Console.WriteLine (a);
		}

		f = 8.53F;
	}

	// a has been assigned in all code paths which do not return.
	public static void test3 (long[] b, int c)
	{
		ICollection a;
		if (b == null)
			throw new ArgumentException ();
		else
			a = (ICollection) b;

		Console.WriteLine (a);
	}

	// Forward goto, it's ok to set f after the target label.
	public static int test4 (int b, out float f)
	{
		long a;

		Console.WriteLine ("Hello World");

		a = 5;

		goto World;

	World:
		Console.WriteLine (a);

		f = 8.53F;

		return 0;
	}

	// try { ... } catch { ... } finally { ... } block
	static public int test5 (out float f, long d)
	{
                int a;
		long b = 8;

		try {
			f = 8.53F;

			if (d == 500)
				return 9;

			a = 5;
		} catch (NotSupportedException e) {
			a = 9;
		} catch (Exception e) {
			return 9;
		} finally {
			f = 9.234F;
		}

		return a;
        }

	// Passing out parameter to method invocation
	static public int test6 (out float f)
	{
		return test5 (out f, 50);
	}

	// Loop-variable of foreach() and for() loop.
	static public long test7 (int[] a, int stop)
	{
		long b = 0;
		foreach (int i in a)
			b += i;

		for (int i = 1; i < stop; i++)
			b *= i;

		return b;
	}

	// Initializing locals in initialize or test of for block
	static public long test8 (int stop)
	{
		int i;
		long b;
		for (i = 1; (b = stop) > 3; i++) {
			stop--;
			b += i;
		}
		return b;
	}

	// Initializing locals in test of while block
	static public long test9 (int stop)
	{
		long b;
		while ((b = stop) > 3) {
			stop--;
			b += stop;
		}
		return b;
	}

	// Return in subblock
	public static void test10 (int a, out float f)
	{
		if (a == 5) {
			f = 8.53F;
			return;
		}

		f = 9.0F;
	}

	// Switch block
	public static long test11 (int a)
	{
		long b;

		switch (a) {
		case 5:
			b = 1;
			break;

		case 9:
			b = 3;
			break;

		default:
			return 9;
		}

		return b;
	}

	// Try block which rethrows exception.
	public static void test12 (out float f)
	{
		try {
			f = 9.0F;
		} catch {
			throw new NotSupportedException ();
		}
	}

	// Return in subblock.
	public static void test13 (int a, out float f)
	{
		do {
			if (a == 8) {
				f = 8.5F;
				return;
			}
		} while (false);

		f = 1.3F;
		return;
	}

	// Switch block with goto case / goto default.
	public static long test14 (int a, out float f)
	{
		long b;

		switch (a) {
		case 1:
			goto case 2;

		case 2:
			f = 9.53F;
			return 9;

		case 3:
			goto default;

		default:
			b = 10;
			break;
		}

		f = 10.0F;

		return b;
	}

	// Forward goto, it's ok to set f before the jump.
	public static int test15 (int b, out float f)
	{
		long a;

		Console.WriteLine ("Hello World");

		a = 5;
		f = 8.53F;

		goto World;

	World:
		Console.WriteLine (a);

		return 0;
	}

	// `continue' breaks unless we're a loop block.
	public static void test16 ()
	{
                int value;

                for (int i = 0; i < 5; ++i) {
                        if (i == 0) {
                                continue;
                        } else if (i == 1) {
                                value = 2;
                        } else {
                                value = 0;
                        }
                        if (value > 0)
                                return;
                }
	}

	// `continue' in a nested if.
	public static void test17 ()
	{
		 int value;
		 long charCount = 9;
		 long testit = 5;

		 while (charCount > 0) {
			 --charCount;

			 if (testit == 8) {
				 if (testit == 9)
					 throw new Exception ();

				 continue;
			 } else {
				 value = 0;
			 }

			 Console.WriteLine (value);
		 }
	}

	// `out' parameter assigned after conditional exception.
	static void test18 (int a, out int f)
	{
		try {
			if (a == 5)
				throw new Exception ();

			f = 9;
		} catch (IndexOutOfRangeException) {
			throw new FormatException ();
		}
	}

	// code after try/catch block is unreachable. always returns.
        static int test19 () {
                int res;
                int a = Environment.NewLine.Length;
                int fin = 0;

                try {
                        res = 10/a;
                        throw new NotImplementedException ();
                } catch (NotImplementedException e) {
                        fin = 2;
                        throw new NotImplementedException ();
                } finally {
                        fin = 1;
                }
                return fin;
        }

	// from bug #30487.
	static int test20 () {
		try {
			return 0;
		}
		catch (Exception) {
			throw;
		}
	}

	// from bug #31546
	static int test21 () {
		int res;

		try {
			res = 4;
			return 3;
		} catch (DivideByZeroException) {
			res = 33;
		} finally {
			// Do nothing
		}

		return res;
	}

	// the same, but without the finally block.
	static int test22 () {
		int res;

		try {
			res = 4;
			return 3;
		} catch (DivideByZeroException) {
			res = 33;
		}

		return res;
	}

	static int test23 (object obj, int a, out bool test) {
		if (obj == null)
			throw new ArgumentNullException ();

		if (a == 5) {
			test = false;
			return 4;
		} else {
			test = true;
			return 5;
		}
	}

	static long test24 (int a) {
		long b;

		switch (a) {
		case 0:
			return 4;
		}

		if (a > 2) {
			if (a == 5)
				b = 4;
			else if (a == 6)
				b = 5;
			else
				return 7;

			Console.WriteLine (b);
			return b;
		}

		return 4;
	}

	static long test25 (int a) {
		long b, c;

		try {
			b = 5;
		} catch (NotSupportedException) {
			throw new InvalidOperationException ();
		}

		try {
			c = 5;
		} catch {
			throw new InvalidOperationException ();
		}

		return b + c;
	}

	//
	// Tests that the flow analysis is preformed first in the for statement
	// and later on the `increment' part of the for
	//
	static void test26 ()
	{
		int j;
		for( int i=0; i<10; i=j ) 
			j = i+1;
	}

	//
	// Nested infinite loops.  Bug #40670.
	//
	static int test27 ()
	{
		while (true) {
			break;

			while (true)
				Console.WriteLine ("Test");
		}

		return 0;
	}

	//
	// Bug #41657.
	//
	static void test28 (out object value)
	{
		if (true) {
			try {
				value = null;
				return;
			} catch {
			}
		}
		value = null;
	}

	//
	// Bug #47095
	//
	static bool test29 (out int a)
	{
		try {
			a = 0;
			return true;
		} catch (System.Exception) {
			a = -1;
			return false;
		}
	}

	//
	// Bug #46949
	//
	public string test30 (out string outparam)
	{
		try {
			if (true) {
				outparam = "";
				return "";
			}
		} catch {
		}

		outparam = null;
		return null;
	}

	//
	// Bug #49153
	//
	public string test31 (int blah)
	{
		switch(blah) {
		case 1: return("foo"); break;
		case 2: return("bar"); break;
		case 3: return("baz"); break;

		default:
			throw new ArgumentException ("Value 0x"+blah.ToString ("x4")+" is not supported.");
		}
	}

	//
	// Bug #49359
	//
        public void test32 ()
	{
                while (true) {
                        System.Threading.Thread.Sleep (1);
                }

                Console.WriteLine ("Hello");
        }

	//
	// Bug 49602
	//
        public int test33 ()
        {
                int i = 0;
                return 0;
                if (i == 0)
                        return 0;
        }

	//
	// Bug 48962
	//
	public void test34 ()
	{
		int y, x = 3;
		if (x > 3) {
			y = 3;
			goto end;
		}
		return;
        end:
		x = y;
	}

	//
	// Bug 46640
	//
	public static void test35 (int a, bool test)
	{
		switch (a) {
		case 3:
			if (test)
				break;
			return;
		default:
			return;
		}
	}

	//
	// Bug 52625
	//
	public static void test36 ()
	{
		string myVar;
		int counter = 0;

		while (true)
		{
			if (counter < 3)
				counter++;
			else {
				myVar = "assigned";
				break;
			}
		}
		Console.WriteLine (myVar);
	}

	//
	// Bug 58322
	//
	public static void test37 ()
	{
		int x = 0;
		int y = 0;
		switch (x) {
		case 0:
			switch (y) {
			case 0:
				goto k_0;
			default:
				throw new Exception ();
			}
		}

	k_0:
		;
	}

	//
	// Bug 59429
	//
	public static int test38 ()
	{
		return 0;
	foo:
		;
	}

	static int test40 (int stop)
	{
		int service;

		int pos = 0;
		do {
			service = 1;
			break;
		} while (pos < stop);

		return service;
	}
}