public void Constructor0 ()
		{
			CodeCatchClause ccc = new CodeCatchClause ();

			Assert.IsNotNull (ccc.CatchExceptionType, "#1");
			Assert.AreEqual (typeof(Exception).FullName, ccc.CatchExceptionType.BaseType, "#2");

			Assert.IsNotNull (ccc.LocalName, "#3");
			Assert.AreEqual (string.Empty, ccc.LocalName, "#4");

			Assert.IsNotNull (ccc.Statements, "#5");
			Assert.AreEqual (0, ccc.Statements.Count, "#6");

			ccc.LocalName = null;
			Assert.IsNotNull (ccc.LocalName, "#7");
			Assert.AreEqual (string.Empty, ccc.LocalName, "#8");

			string localName = "mono";
			ccc.LocalName = localName;
			Assert.AreSame (localName, ccc.LocalName, "#9");

			ccc.CatchExceptionType = null;
			Assert.IsNotNull (ccc.CatchExceptionType, "#10");
			Assert.AreEqual (typeof(Exception).FullName, ccc.CatchExceptionType.BaseType, "#11");

			CodeTypeReference cet = new CodeTypeReference("SomeException");
			ccc.CatchExceptionType = cet;
			Assert.AreSame (cet, ccc.CatchExceptionType, "#12");
		}

        // Generate a codedom exception handler statement
        public static CodeStatement Emit(ExceptionHandler ex)
        {
            // Create the codedom exception handler statement
            var codeTry = new CodeTryCatchFinallyStatement();

            // Add the statements in the try block
            foreach (var e in ex.Try.ChildExpressions)
                codeTry.TryStatements.Add(CodeDomEmitter.EmitCodeStatement(e));

            // Add all the catch clauses.
            foreach (var c in ex.CatchClauses)
            {
                // Create the codedom catch statement.
                var catchClause = new CodeCatchClause();
                // To do: replace with non-test code
                catchClause.CatchExceptionType = new CodeTypeReference("System.Exception");
                catchClause.LocalName = "ex";
                codeTry.CatchClauses.Add(catchClause);

                // Add the statemnts in the catch block
                foreach(var e in c.ChildExpressions)
                    catchClause.Statements.Add(CodeDomEmitter.EmitCodeStatement(e));
            }

            // Add the statements in the finally block.
            foreach (var e in ex.Finally.ChildExpressions)
                codeTry.FinallyStatements.Add(CodeDomEmitter.EmitCodeStatement(e));

            return codeTry;
        }

 /// <devdoc>
 /// <para>Copies the elements of an array to the end of the <see cref='System.CodeDom.CodeCatchClauseCollection'/>.</para>
 /// </devdoc>
 public void AddRange(CodeCatchClause[] value) {
     if (value == null) {
         throw new ArgumentNullException("value");
     }
     for (int i = 0; ((i) < (value.Length)); i = ((i) + (1))) {
         this.Add(value[i]);
     }
 }

		public CodeTryCatchFinallyStatement (CodeStatement [] tryStatements,
						     CodeCatchClause [] catchClauses,
						     CodeStatement [] finallyStatements)
		{
			TryStatements.AddRange( tryStatements );
			CatchClauses.AddRange( catchClauses );
			FinallyStatements.AddRange( finallyStatements );
		}

 public CodeTryCatchFinallyStatement(CodeStatement[] tryStatements, CodeCatchClause[] catchClauses)
 {
     this.tryStatments = new CodeStatementCollection();
     this.finallyStatments = new CodeStatementCollection();
     this.catchClauses = new CodeCatchClauseCollection();
     this.TryStatements.AddRange(tryStatements);
     this.CatchClauses.AddRange(catchClauses);
 }

		public void Constructor1_NullItem ()
		{
			CodeCatchClause[] catchClauses = new CodeCatchClause[] { 
				new CodeCatchClause (), null };

			CodeCatchClauseCollection coll = new CodeCatchClauseCollection (
				catchClauses);
		}

		public void Constructor1_Deny_Unrestricted ()
		{
			CodeCatchClause ccc = new CodeCatchClause ("mono");
			Assert.AreEqual ("System.Exception", ccc.CatchExceptionType.BaseType, "CatchExceptionType.BaseType");
			ccc.CatchExceptionType = new CodeTypeReference ("System.Void");
			Assert.AreEqual ("mono", ccc.LocalName, "LocalName");
			ccc.LocalName = String.Empty;
			Assert.AreEqual (0, ccc.Statements.Count, "Statements");
		}

 public static CodeCatchClause Clone(this CodeCatchClause clause)
 {
     if (clause == null) return null;
     CodeCatchClause c = new CodeCatchClause();
     c.CatchExceptionType = clause.CatchExceptionType.Clone();
     c.LocalName = clause.LocalName;
     c.Statements.AddRange(clause.Statements.Clone());
     return c;
 }

		public void Constructor1_Deny_Unrestricted ()
		{
			CodeStatement[] try_statements = new CodeStatement[1] { new CodeStatement () };
			CodeCatchClause[] catch_clauses = new CodeCatchClause[1] { new CodeCatchClause () };
			CodeTryCatchFinallyStatement ctcfs = new CodeTryCatchFinallyStatement (try_statements, catch_clauses);
			Assert.AreEqual (1, ctcfs.CatchClauses.Count, "CatchClauses");
			Assert.AreEqual (0, ctcfs.FinallyStatements.Count, "FinallyStatements");
			Assert.AreEqual (1, ctcfs.TryStatements.Count, "TryStatements");
		}

 private static CodeCatchClause Catch(System.Type type, string name, CodeStatement catchStmnt)
 {
     CodeCatchClause clause = new CodeCatchClause {
         CatchExceptionType = Type(type),
         LocalName = name
     };
     clause.Statements.Add(catchStmnt);
     return clause;
 }

		public void AddRange (CodeCatchClause [] value)
		{
			if (value == null) {
				throw new ArgumentNullException ("value");
			}

			for (int i = 0; i < value.Length; i++) {
				Add (value[i]);
			}
		}

 public CodeDomStatments PushCatch(string localName)
 {
     Pop();
     var SS = _Data.Peek();
     var S = SS[SS.Count - 1] as CodeTryCatchFinallyStatement;
     var c = new CodeCatchClause(localName);
     S.CatchClauses.Add(c);
     _Data.Push(c.Statements);
     return this;
 }

 internal static CodeCatchClause Catch(CodeTypeReference type, string name, CodeStatement catchStmnt)
 {
     CodeCatchClause clause = new CodeCatchClause {
         CatchExceptionType = type,
         LocalName = name
     };
     if (catchStmnt != null)
     {
         clause.Statements.Add(catchStmnt);
     }
     return clause;
 }

		public void Constructor1 ()
		{
			CodeCatchClause cc1 = new CodeCatchClause ();
			CodeCatchClause cc2 = new CodeCatchClause ();

			CodeCatchClause[] catchClauses = new CodeCatchClause[] { cc1, cc2 };
			CodeCatchClauseCollection coll = new CodeCatchClauseCollection (
				catchClauses);

			Assert.AreEqual (2, coll.Count, "#1");
			Assert.AreEqual (0, coll.IndexOf (cc1), "#2");
			Assert.AreEqual (1, coll.IndexOf (cc2), "#3");
		}

		public void Constructor2 ()
		{
			CodeCatchClause cc1 = new CodeCatchClause ();
			CodeCatchClause cc2 = new CodeCatchClause ();

			CodeCatchClauseCollection c = new CodeCatchClauseCollection ();
			c.Add (cc1);
			c.Add (cc2);

			CodeCatchClauseCollection coll = new CodeCatchClauseCollection (c);
			Assert.AreEqual (2, coll.Count, "#1");
			Assert.AreEqual (0, coll.IndexOf (cc1), "#2");
			Assert.AreEqual (1, coll.IndexOf (cc2), "#3");
		}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="member"></param>
        /// <param name="inner"></param>
        /// <param name="attrs"></param>
        /// <returns></returns>
        public CodeTypeMember CreateMember(MemberInfo member, CodeFieldReferenceExpression inner, MemberAttributes attrs)
        {
            Debug.Assert(member is MethodInfo);
            MethodInfo method = member as MethodInfo;
            CodeMemberMethod codeMethod = new CodeMemberMethod();

            codeMethod.Name = method.Name;
            codeMethod.ReturnType = new CodeTypeReference(method.ReturnType);
            codeMethod.Attributes = attrs;

            // try
            CodeTryCatchFinallyStatement tryCode = new CodeTryCatchFinallyStatement();

            // decleare parameters
            List<CodeArgumentReferenceExpression> codeParamiteRefrs = new List<CodeArgumentReferenceExpression>();

            foreach (ParameterInfo codeParameter in method.GetParameters()) {
                CodeParameterDeclarationExpression codeParameterDeclare = new CodeParameterDeclarationExpression(codeParameter.ParameterType, codeParameter.Name);
                codeMethod.Parameters.Add(codeParameterDeclare);
                codeParamiteRefrs.Add(new CodeArgumentReferenceExpression(codeParameter.Name));
            }

            // invoke
            CodeMethodInvokeExpression invokeMethod = new CodeMethodInvokeExpression(
                inner, method.Name, codeParamiteRefrs.ToArray());
            if (method.ReturnType.Name.ToLower() == "void") {
                tryCode.TryStatements.Add(invokeMethod);
            } else {
                CodeVariableDeclarationStatement var = new CodeVariableDeclarationStatement(method.ReturnType, "returnObject", invokeMethod);
                //CodeAssignStatement assign = new CodeAssignStatement(var, invokeMethod);
                tryCode.TryStatements.Add(var);

                CodeCommentStatement todo = new CodeCommentStatement("TODO: your code", false);
                tryCode.TryStatements.Add(todo);

                CodeVariableReferenceExpression varRef = new CodeVariableReferenceExpression("returnObject");
                CodeMethodReturnStatement codeReturn = new CodeMethodReturnStatement(varRef);
                tryCode.TryStatements.Add(codeReturn);
            }

            // catch
            CodeTypeReference codeTypeRef = new CodeTypeReference(typeof(Exception));
            CodeCatchClause catchClause = new CodeCatchClause("ex", codeTypeRef);
            catchClause.Statements.Add(new CodeThrowExceptionStatement());
            tryCode.CatchClauses.Add(catchClause);

            codeMethod.Statements.Add(tryCode);
            return codeMethod;
        }

		public void Constructor1 () {
			string localName = "mono";

			CodeCatchClause ccc = new CodeCatchClause (localName);

			Assert.IsNotNull (ccc.CatchExceptionType, "#1");
			Assert.AreEqual (typeof(Exception).FullName, ccc.CatchExceptionType.BaseType, "#2");

			Assert.IsNotNull (ccc.LocalName, "#3");
			Assert.AreEqual (localName, ccc.LocalName, "#4");
			Assert.AreSame (localName, ccc.LocalName, "#5");

			Assert.IsNotNull (ccc.Statements, "#6");
			Assert.AreEqual (0, ccc.Statements.Count, "#7");

			ccc.LocalName = null;
			Assert.IsNotNull (ccc.LocalName, "#8");
			Assert.AreEqual (string.Empty, ccc.LocalName, "#9");

			ccc = new CodeCatchClause ((string) null);
			Assert.IsNotNull (ccc.LocalName, "#10");
			Assert.AreEqual (string.Empty, ccc.LocalName, "#22");
		}

 /// <devdoc>
 /// <para>Inserts a <see cref='System.CodeDom.CodeCatchClause'/> into the <see cref='System.CodeDom.CodeCatchClauseCollection'/> at the specified index.</para>
 /// </devdoc>
 public void Insert(int index, CodeCatchClause value) {
     List.Insert(index, value);
 }

		public void Remove ()
		{
			CodeCatchClause ccc1 = new CodeCatchClause ();
			CodeCatchClause ccc2 = new CodeCatchClause ();

			CodeCatchClauseCollection coll = new CodeCatchClauseCollection ();
			coll.Add (ccc1);
			coll.Add (ccc2);
			Assert.AreEqual (2, coll.Count, "#1");
			Assert.AreEqual (0, coll.IndexOf (ccc1), "#2");
			Assert.AreEqual (1, coll.IndexOf (ccc2), "#3");
			coll.Remove (ccc1);
			Assert.AreEqual (1, coll.Count, "#4");
			Assert.AreEqual (-1, coll.IndexOf (ccc1), "#5");
			Assert.AreEqual (0, coll.IndexOf (ccc2), "#6");
		}

        /// <summary>
        /// Gets the throw clause.
        /// </summary>
        /// <returns>return catch...throw statment</returns>
        internal static CodeCatchClause[] GetThrowClause()
        {
            var catchStatmanents = new CodeStatementCollection();
            catchStatmanents.Add(new CodeThrowExceptionStatement(new CodeVariableReferenceExpression("ex")));
            var catchClause = new CodeCatchClause(
                                                    "ex",
                                                    new CodeTypeReference(typeof(Exception)),
                                                    catchStatmanents.ToArray());

            var catchClauses = new[] { catchClause };
            return catchClauses;
        }