public void Constructor1 ()
		{
			CodeEventReferenceExpression eventref = new CodeEventReferenceExpression ();
			CodeExpression listener = new CodeExpression ();

			CodeAttachEventStatement caes = new CodeAttachEventStatement (eventref, listener);
			Assert.AreSame (eventref, caes.Event, "#1");
			Assert.AreEqual (string.Empty, caes.Event.EventName, "#2");
			Assert.IsNull (caes.Event.TargetObject, "#3");
			Assert.AreSame (listener, caes.Listener, "#4");

			caes.Event = null;
			Assert.IsNotNull (caes.Event, "#5");
			Assert.AreEqual (string.Empty, caes.Event.EventName, "#6");
			Assert.IsNull (caes.Event.TargetObject, "#7");
			Assert.AreSame (listener, caes.Listener, "#8");

			caes.Listener = null;
			Assert.IsNull (caes.Listener, "#9");

			caes.Event = eventref;
			Assert.AreSame (eventref, caes.Event, "#10");

			caes.Listener = listener;
			Assert.AreSame (listener, caes.Listener, "#11");

			caes = new CodeAttachEventStatement ((CodeEventReferenceExpression) null, (CodeExpression) null);
			Assert.IsNotNull (caes.Event, "#12");
			Assert.IsNull (caes.Listener, "#13");
			Assert.AreEqual (string.Empty, caes.Event.EventName, "#14");
			Assert.IsNull (caes.Event.TargetObject, "#15");
		}

		public void Constructor0 ()
		{
			CodeAttachEventStatement caes = new CodeAttachEventStatement ();
			Assert.IsNotNull (caes.Event, "#1");
			Assert.IsNull (caes.Listener, "#2");
			Assert.AreEqual (string.Empty, caes.Event.EventName, "#3");
			Assert.IsNull (caes.Event.TargetObject, "#4");
		}

		public void Constructor0_Deny_Unrestricted ()
		{
			CodeAttachEventStatement caes = new CodeAttachEventStatement ();
			Assert.AreEqual (String.Empty, caes.Event.EventName, "Event.EventName");
			Assert.IsNull (caes.Event.TargetObject, "Event.TargetObject");
			caes.Event = new CodeEventReferenceExpression ();
			Assert.IsNull (caes.Listener, "Listener");
			caes.Listener = new CodeExpression ();
		}

 public TypescriptAttachEventStatement(
     IExpressionFactory expressionFactory,
     CodeAttachEventStatement statement,
     CodeGeneratorOptions options)
 {
     _expressionFactory = expressionFactory;
     _statement = statement;
     _options = options;
 }

		public void Constructor1_Deny_Unrestricted ()
		{
			CodeEventReferenceExpression eventref = new CodeEventReferenceExpression ();
			CodeExpression listener = new CodeExpression ();
			CodeAttachEventStatement caes = new CodeAttachEventStatement (eventref, listener);
			Assert.AreSame (eventref, caes.Event, "Event");
			caes.Event = new CodeEventReferenceExpression ();
			Assert.AreSame (listener, caes.Listener, "Listener");
			caes.Listener = new CodeExpression ();
		}

 public static CodeAttachEventStatement Clone(this CodeAttachEventStatement statement)
 {
     if (statement == null) return null;
     CodeAttachEventStatement s = new CodeAttachEventStatement();
     s.EndDirectives.AddRange(statement.EndDirectives);
     s.Event = statement.Event.Clone();
     s.LinePragma = statement.LinePragma;
     s.Listener = statement.Listener.Clone();
     s.StartDirectives.AddRange(statement.StartDirectives);
     s.UserData.AddRange(statement.UserData);
     return s;
 }

		public void Constructor2_Deny_Unrestricted ()
		{
			CodeExpression target = new CodeExpression ();
			string eventName = "Mono";
			CodeExpression listener = new CodeExpression ();
			CodeAttachEventStatement caes = new CodeAttachEventStatement (target, eventName, listener);
			Assert.AreEqual (eventName, caes.Event.EventName, "Event.EventName");
			Assert.AreSame (target, caes.Event.TargetObject, "Event.TargetObject");
			caes.Event = new CodeEventReferenceExpression ();
			Assert.AreSame (listener, caes.Listener, "Listener");
			caes.Listener = new CodeExpression ();
		}

 public override void Serialize(IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements)
 {
     EventDescriptor e = descriptor as EventDescriptor;
     if (manager == null)
     {
         throw new ArgumentNullException("manager");
     }
     if (value == null)
     {
         throw new ArgumentNullException("value");
     }
     if (e == null)
     {
         throw new ArgumentNullException("descriptor");
     }
     if (statements == null)
     {
         throw new ArgumentNullException("statements");
     }
     try
     {
         IEventBindingService service = (IEventBindingService) manager.GetService(typeof(IEventBindingService));
         if (service != null)
         {
             string methodName = (string) service.GetEventProperty(e).GetValue(value);
             if (methodName != null)
             {
                 CodeExpression targetObject = base.SerializeToExpression(manager, value);
                 if (targetObject != null)
                 {
                     CodeTypeReference delegateType = new CodeTypeReference(e.EventType);
                     CodeDelegateCreateExpression listener = new CodeDelegateCreateExpression(delegateType, _thisRef, methodName);
                     CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression(targetObject, e.Name);
                     CodeAttachEventStatement statement = new CodeAttachEventStatement(eventRef, listener);
                     statement.UserData[typeof(Delegate)] = e.EventType;
                     statements.Add(statement);
                 }
             }
         }
     }
     catch (Exception innerException)
     {
         if (innerException is TargetInvocationException)
         {
             innerException = innerException.InnerException;
         }
         manager.ReportError(System.Design.SR.GetString("SerializerPropertyGenFailed", new object[] { e.Name, innerException.Message }));
     }
 }

		protected override void GenerateAttachEventStatement (CodeAttachEventStatement statement)
		{
			TextWriter output = Output;

			Output.Write ("AddHandler ");
			if (statement.Event.TargetObject != null) {
				GenerateEventReferenceExpression (statement.Event);
			} else {
				Output.Write (CreateEscapedIdentifier (statement.Event.EventName));
			}
			Output.Write ( ", ");
			GenerateExpression (statement.Listener);
			output.WriteLine ();
		}

			public void Visit (CodeAttachEventStatement o)
			{
				g.GenerateAttachEventStatement (o);
			}

		protected abstract void GenerateAttachEventStatement (CodeAttachEventStatement s);

        /// <summary>
        /// Generates code for the specified attach event statement.
        /// </summary>
        /// <remarks><c>EVENT->Add(LISTENER);</c></remarks>
        protected override void GenerateAttachEventStatement(CodeAttachEventStatement e)
        {
            GenerateEventReferenceExpression(e.Event);
            Output.Write(Tokens.Arrow);
            Output.Write(SpecialWords.Add);
            Output.Write(Tokens.ParenthesisLeft);

            GenerateExpression(e.Listener);

            Output.Write(Tokens.ParenthesisRight);
            Output.WriteLine(Tokens.Semicolon);
        }

 protected override void GenerateAttachEventStatement(CodeAttachEventStatement e) {
   GenerateExpression(e.Event.TargetObject);
   Output.Write(".add_");
   Output.Write(e.Event.EventName);
   Output.Write("(");
   GenerateExpression(e.Listener);
   Output.WriteLine(");");
 }

        private CodeStatement AddCLREvent(Type eventTarget, CodeContext cc, CodeExpression ce, MarkupEventInfo mei)
        {

            bool subClassed = _ccRoot.SubClass.Length > 0;
            CodeStatement csEvent = null;
            // param2: <FooEventHandler>
            CodeExpression cDelExp = GetEventDelegate(cc, mei.mi, mei.eventName, mei.eventHandler);

            if (mei.mi.DeclaringType.IsAssignableFrom(eventTarget))
            {
                // _element.FooEvent += new FooEventHandlerDelegate(OnFoo);
                csEvent = new CodeAttachEventStatement(ce, mei.eventName, cDelExp);
            }
            else if (eventTarget == null || // for known attached events on unknown local tags
                     KnownTypes.Types[(int)KnownElements.UIElement].IsAssignableFrom(eventTarget) ||
                     KnownTypes.Types[(int)KnownElements.ContentElement].IsAssignableFrom(eventTarget))
            {
                // _element.AddHandler(FooEvent, new FooEventHandlerDelegate(OnFoo));
                CodeFieldReferenceExpression cfreEvent = GetEvent(mei.mi, mei.eventName, mei.eventHandler);
                CodeMethodInvokeExpression cmieAddHandler = new CodeMethodInvokeExpression(ce, ADDHANDLER, cfreEvent, cDelExp);
                csEvent = new CodeExpressionStatement(cmieAddHandler);
            }
            else
            {
                string eventTargetName = eventTarget != null ? eventTarget.FullName : cc.LocalElementFullName;
                ThrowCompilerException(SRID.UnknownEventAttribute, mei.eventName, mei.eventHandler, eventTargetName);
            }

            // When x:SubClass is used, event handlers can be specified in a code-behind file, under this sub class.
            // But these handler methods need to be accessible from the intermediary generated sub class. So an empty
            // internal virtual method with the same signature as the handler method is generated in this intermediary
            // sub class (in the generated file):
            //
            //      internal virtual void OnFooEvent(object sender, FooEventArgs ea)
            //      {
            //      }
            //
            // Since a delegate cannot take the address of a virtual function, a non-virtual helper function
            // with the same signature as the above function & which calls the above function is also generated:
            //
            //      private void OnFooEventHelper(object sender, FooEventArgs ea)
            //      {
            //          OnFooEvent(sender, ea);
            //      }
            //
            // All this is done only if x:Subclass is specified, since this means that this sub class would need to be
            // defined in a code-behind file. This also means that inline events (in <x:Code>) will not be supported.

            if (subClassed)
            {
                GenerateProtectedEventHandlerMethod(mei);
            }

            AddLinePragma(csEvent, mei.lineNumber);
            return csEvent;
        }

        public override bool AddEventHandler(EventDescription eventDescription, string objectName, string methodName)
        {
            const string Init = "__init__";
            //This is not the most optimal solution for WPF since we will call FindLogicalNode for each event handler,
            //but it simplifies the code generation for now.

            CodeDomDocDataAdapter adapter = GetDocDataAdapterForPyFile();

            //Find the __init__ method
            CodeMemberMethod method = null;
            foreach(CodeTypeMember ctMember in adapter.TypeDeclaration.Members)
            {
                if (ctMember is CodeConstructor)
                {
                    if (ctMember.Name == Init)
                    {
                        method = ctMember as CodeMemberMethod;
                        break;
                    }
                }
            }
            if (method == null)
            {
                method = new CodeConstructor();
                method.Name = Init;
            }

            //Create a code statement which looks like: LogicalTreeHelper.FindLogicalNode(self.Root, "button1").Click += self.button1_Click
            CodeTypeReferenceExpression logicalTreeHelper = new CodeTypeReferenceExpression("LogicalTreeHelper");
            CodeMethodReferenceExpression findLogicalNodeMethod = new CodeMethodReferenceExpression(logicalTreeHelper, "FindLogicalNode");
            CodeFieldReferenceExpression selfWindow = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Root");
            CodeMethodInvokeExpression findLogicalNodeInvoke = new CodeMethodInvokeExpression( findLogicalNodeMethod, selfWindow, new CodeSnippetExpression("\'" + objectName + "\'"));
            CodeDelegateCreateExpression createDelegateExpression = new CodeDelegateCreateExpression(new CodeTypeReference("System.EventHandler"), new CodeThisReferenceExpression(), methodName);
            CodeAttachEventStatement attachEvent = new CodeAttachEventStatement(findLogicalNodeInvoke, eventDescription.Name, createDelegateExpression);
            method.Statements.Add(attachEvent);
            adapter.Generate();
            return true;
        }

			// top of stack is reference to an event
			public override void CreateEventDelegate(string functionName, Type eventDelegateType)
			{
				debug();
				CodeExpression expr = buildDelegate(eventDelegateType, functionName);
				CodeAttachEventStatement attach = new CodeAttachEventStatement(
						(CodeEventReferenceExpression)peek(),
						expr);
				constructor.Statements.Add(attach);

			}

 /// <include file='doc\CSharpCodeProvider.uex' path='docs/doc[@for="CSharpCodeGenerator.GenerateAttachEventStatement"]/*' />
 /// <devdoc>
 ///    <para>
 ///       Generates code for the specified CodeDom based attach event statement
 ///       representation.
 ///    </para>
 /// </devdoc>
 protected override void GenerateAttachEventStatement(CodeAttachEventStatement e) {
     GenerateEventReferenceExpression(e.Event);
     Output.Write(" += ");
     GenerateExpression(e.Listener);
     Output.WriteLine(";");
 }

		/// <summary>
		/// Using an anonymous code block to call the event handler method:
		/// 
		/// @button1.Click { |sender, e| self.Button1Click(sender, e) }
		/// </summary>
		void AppendAttachEventStatement(CodeAttachEventStatement statement)
		{
			codeBuilder.AppendIndented(String.Empty);
			AppendExpression(statement.Event.TargetObject);
			codeBuilder.Append(".");
			codeBuilder.Append(statement.Event.EventName);
			
			codeBuilder.Append(" { |sender, e| ");
			AppendExpression(statement.Listener);
			codeBuilder.Append("(sender, e) }");
			
			codeBuilder.AppendLine();
		}

 private void ValidateAttachEventStatement(CodeAttachEventStatement e) {
     ValidateEventReferenceExpression(e.Event);
     ValidateExpression(e.Listener);
 }

		protected override void GenerateAttachEventStatement (CodeAttachEventStatement statement)
		{
			TextWriter output = Output;

			GenerateEventReferenceExpression (statement.Event);
			output.Write (" += ");
			GenerateExpression (statement.Listener);
			output.WriteLine (';');
		}