public static SimpleStruct Test1(SimpleStruct
ss)
    {
        Console.WriteLine
        ("Test1 called "
        +
        ss.a
        +
        " "
        +
        ss.b);
        SimpleStruct
        res
        =
        new
        SimpleStruct
        ();
        res.a
        =
        !ss.a;
        res.b
        =
        !ss.b;
        return
        res;
    }

 // Use this for initialization
 void Start()
 {
     feeding_rate = power / defence;
     SimpleStruct ss = new SimpleStruct();
     ss.X = 500;
     ss.DisplayX();
 }

		public void testCall1() 
		{
			var x = new SimpleStruct();
			var a = ModifyA(x);
			AssertEquals("x.a", 0, x.a);
			AssertEquals("a", 27, a);
		}

    public static void Main()
    {
        SimpleStruct ss = new SimpleStruct();
        ss.X = 5;
        ss.DisplayX();

        SS si = (SS) ss;
        si.X = 90;
        si.DisplayX();
        
        ss =  (SimpleStruct) si ;
        ss.X = 5;
        ss.DisplayX();
        
        SimpleClass ss1 = new SimpleClass();
        ss1.X = 5;
        ss1.DisplayX();
        
        try {
        ss1 =  (SimpleClass) si ;
        ss1.X = 5;
        ss1.DisplayX();
        } 
        catch(Exception)
        {
        	Console.WriteLine("Failed to cast");
        }
        

    }

 public static SimpleStruct aMethod_Inline(SimpleStruct Struct)
 {
     Struct.i = 10;
     Struct.str = "abc";
     int x = Struct.i;
     string str1 = Struct.str;
     return Struct;
 }

 public static void Main()
 {
     Console.WriteLine("instaniante a ss structure object");
     SimpleStruct ss = new SimpleStruct();
     Console.WriteLine("Set the integer to 5 in the ss structure object");
     ss.X = 5;
     Console.WriteLine("Call the Displayx function in the ss structure object");
     ss.DisplayX();
 }

		public void testLocalVar1() 
		{
			var x = new SimpleStruct();
			x.a = 5;
			var y = x;
			y.a = 6;
			AssertEquals("x.a", 5, x.a);
			AssertEquals("y.a", 6, y.a);
		}

 public static bool InstanceDelegateWithStruct() {
   Delegates delegates = new Delegates();
   SimpleStruct simpleStruct = new SimpleStruct();
   simpleStruct.i = 2;
   simpleStruct.j = 3;
   StructDel sd = new StructDel(delegates.StructAsArgument);
   int result = sd(simpleStruct);
   return result == 5 ? true : false;
 }

		public void testArray1() 
		{
			var x = new SimpleStruct[5];
			var y = new SimpleStruct[5];
			x[0].a = 5;
			y[0] = x[0];
			y[0].a = 6;
			AssertEquals("x[0].a", 5, x[0].a);
			AssertEquals("y[0].a", 6, y[0].a);
		}

	public static int delegate_test_struct_out (int a, out SimpleStruct ss, int b)
	{
		ss.a = true;
		ss.b = true;
		ss.c = true;
		ss.d = "TEST3";
		ss.d2 = "TEST4";

		return 0;
	}

	static int Main () {
		Type t = typeof (Test);

		MethodInfo m2 = t.GetMethod ("Test2");
		if (m2 != null)
			return 1;

		MethodInfo m1 = t.GetMethod ("Test1");
		if (m1 == null)
			return 1;

		object [] args = new object [1];
		SimpleStruct ss = new SimpleStruct ();
		ss.a = true;
		ss.b = false;
		args [0] = ss;
		
		SimpleStruct res = (SimpleStruct)m1.Invoke (null, args);

		if (res.a == true)
			return 1;
		if (res.b == false)
			return 1;

		// Test that the objects for byref valuetype arguments are 
		// automatically created
		MethodInfo m3 = typeof(Test).GetMethod("Foo");
		
		args = new object[2];
		
		m3.Invoke(null, args);

		if ((((int)(args [0])) != 20) || (((int)(args [1])) != 30))
			return 2;

		// Test the return value from  ConstructorInfo.Invoke when a precreated
		// valuetype is used.
		ConstructorInfo ci = typeof (SimpleStruct).GetConstructor (new Type [] { typeof (bool) });
		ci.Invoke (ss, new object [] { false });

		// Test invoking of the array Get/Set methods
		string[,] arr = new string [10, 10];

		arr.GetType ().GetMethod ("Set").Invoke (arr, new object [] { 1, 1, "FOO" });
		string s = (string)arr.GetType ().GetMethod ("Get").Invoke (arr, new object [] { 1, 1 });
		if (s != "FOO")
			return 3;

		// Test the sharing of runtime invoke wrappers for string ctors
		typeof (string).GetConstructor (new Type [] { typeof (char[]) }).Invoke (null, new object [] { new char [] { 'a', 'b', 'c' } });

		typeof (Assembly).GetMethod ("GetType", new Type [] { typeof (string), }).Invoke (typeof (int).Assembly, new object [] { "A" });
	
		return 0;
	}

	public static SimpleStruct delegate_test_struct (SimpleStruct ss)
	{
		SimpleStruct res;

		res.a = !ss.a;
		res.b = !ss.b;
		res.c = !ss.c;
		res.d = ss.d + "-RES";
		res.d2 = ss.d2 + "-RES";

		return res;
	}

	public static int delegate_test_struct_byref (int a, ref SimpleStruct ss, int b)
	{
		if (a == 1 && b == 2 && ss.a && !ss.b && ss.c && ss.d == "TEST2") {
			ss.a = true;
			ss.b = true;
			ss.c = true;
			ss.d = "TEST3";
			return 0;
		}

		return 1;
	}

	public static int test_0_ctor_vtype () {
		// Test the return value from  ConstructorInfo.Invoke when a precreated
		// valuetype is used.

		SimpleStruct ss = new SimpleStruct ();
		ss.a = true;
		ss.b = false;

		ConstructorInfo ci = typeof (SimpleStruct).GetConstructor (new Type [] { typeof (bool) });
		ci.Invoke (ss, new object [] { false });

		return 0;
	}

    static int Main()
    {
        Type t = typeof (Test);

        MethodInfo m2 = t.GetMethod ("Test2");
        if (m2 != null)
            return 1;

        MethodInfo m1 = t.GetMethod ("Test1");
        if (m1 == null)
            return 1;

        object [] args = new object [1];
        SimpleStruct ss = new SimpleStruct ();
        ss.a = true;
        ss.b = false;
        args [0] = ss;

        SimpleStruct res = (SimpleStruct)m1.Invoke (null, args);

        if (res.a == true)
            return 1;
        if (res.b == false)
            return 1;

        // Test that the objects for byref valuetype arguments are
        // automatically created
        MethodInfo m3 = typeof(Test).GetMethod("Foo");

        args = new object[2];

        m3.Invoke(null, args);

        if ((((int)(args [0])) != 20) || (((int)(args [1])) != 30))
            return 2;

        return 0;
    }

	/* Test structures as out arguments of delegates */
	public static int test_0_marshal_out_struct_delegate () {
		SimpleStruct ss = new SimpleStruct ();
		OutStructDelegate d = new OutStructDelegate (delegate_test_struct_out);

		return mono_test_marshal_out_struct (1, out ss, 2, d);
	}

	/* Test structures as byref arguments of delegates */
	public static int test_0_marshal_byref_struct_delegate () {
		SimpleStruct ss = new SimpleStruct ();
		TestDelegate d = new TestDelegate (delegate_test_struct_byref);
		
		ss.b = true;
		ss.d = "TEST1";

		if (mono_test_ref_vtype (1, ref ss, 2, d) != 0)
			return 1;

		if (! (ss.a && ss.b && ss.c && ss.d == "TEST3"))
			return 2;
		
		return 0;
	}

	public static extern int mono_test_marshal_in_struct (int a, ref SimpleStruct ss, int b, InStructDelegate d);

	public static extern int mono_test_marshal_out_struct (int a, out SimpleStruct ss, int b, OutStructDelegate d);

	public static extern int mono_test_ref_vtype (int a, ref SimpleStruct ss, int b, TestDelegate d);