public void ErrorRaised(object sender, BuildErrorEventArgs e)
 {
     // BuildErrorEventArgs adds LineNumber, ColumnNumber, File, amongst other parameters
     string line = string.Format("{3}: Error {0}({1},{2}): ", e.File, e.LineNumber, e.ColumnNumber, e.Message);
     this.handler(this, new ValEventArgs(line, this.indent));
     this.errors++;
 }

		void EventSourceErrorRaised (object sender, BuildErrorEventArgs e)
		{
			string file = e.File;
			if (file != null)
				file = Path.GetFullPath (Path.Combine (basePath, file));
			results.Add (new MSBuildResult (false, file, e.LineNumber, e.ColumnNumber, e.Code, e.Message));
		}

 public override string FormatErrorEvent(BuildErrorEventArgs args)
 {
     return (string.Format(Resources.ERROR_MESSAGE.Replace(@"\t", "\t"),
                           trimPath(args.ProjectFile),
                           trimPath(args.File),
                           args.LineNumber, args.ColumnNumber, args.Message));
 }

        public void LogBuildEvents()
        {
            // This event should only be logged when OnlyLogCriticalEvents is off
            BuildMessageEventArgs messageEvent = new BuildMessageEventArgs("MyMessage", "HelpKeyword", "Sender", MessageImportance.High);

            // These three should be logged when OnlyLogCritical Events is on or off
            BuildWarningEventArgs warning = new BuildWarningEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender");
            BuildErrorEventArgs error = new BuildErrorEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender");
            ExternalProjectStartedEventArgs externalStartedEvent = new ExternalProjectStartedEventArgs("message", "help", "senderName", "projectFile", "targetNames");

            ProcessBuildEventHelper loggingService = (ProcessBuildEventHelper)ProcessBuildEventHelper.CreateLoggingService(LoggerMode.Synchronous, 1);

            // Verify when OnlyLogCriticalEvents is false
            LogandVerifyBuildEvent(messageEvent, loggingService);
            LogandVerifyBuildEvent(warning, loggingService);
            LogandVerifyBuildEvent(error, loggingService);
            LogandVerifyBuildEvent(externalStartedEvent, loggingService);

            // Verify when OnlyLogCriticalEvents is true
            loggingService.OnlyLogCriticalEvents = true;
            loggingService.LogBuildEvent(messageEvent);
            Assert.IsNull(loggingService.ProcessedBuildEvent, "Expected ProcessedBuildEvent to be null");
            LogandVerifyBuildEvent(warning, loggingService);
            LogandVerifyBuildEvent(error, loggingService);
            LogandVerifyBuildEvent(externalStartedEvent, loggingService);
        }

        public void VerifyEventType()
        {
            BuildFinishedEventArgs buildFinished = new BuildFinishedEventArgs("Message", "Keyword", true);
            BuildStartedEventArgs buildStarted = new BuildStartedEventArgs("Message", "Help");
            BuildMessageEventArgs lowMessage = new BuildMessageEventArgs("Message", "help", "sender", MessageImportance.Low);
            TaskStartedEventArgs taskStarted = new TaskStartedEventArgs("message", "help", "projectFile", "taskFile", "taskName");
            TaskFinishedEventArgs taskFinished = new TaskFinishedEventArgs("message", "help", "projectFile", "taskFile", "taskName", true);
            TaskCommandLineEventArgs commandLine = new TaskCommandLineEventArgs("commandLine", "taskName", MessageImportance.Low);
            BuildWarningEventArgs warning = new BuildWarningEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender");
            BuildErrorEventArgs error = new BuildErrorEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender");
            TargetStartedEventArgs targetStarted = new TargetStartedEventArgs("message", "help", "targetName", "ProjectFile", "targetFile");
            TargetFinishedEventArgs targetFinished = new TargetFinishedEventArgs("message", "help", "targetName", "ProjectFile", "targetFile", true);
            ProjectStartedEventArgs projectStarted = new ProjectStartedEventArgs(-1, "message", "help", "ProjectFile", "targetNames", null, null, null);
            ProjectFinishedEventArgs projectFinished = new ProjectFinishedEventArgs("message", "help", "ProjectFile", true);
            ExternalProjectStartedEventArgs externalStartedEvent = new ExternalProjectStartedEventArgs("message", "help", "senderName", "projectFile", "targetNames");

            VerifyLoggingPacket(buildFinished, LoggingEventType.BuildFinishedEvent);
            VerifyLoggingPacket(buildStarted, LoggingEventType.BuildStartedEvent);
            VerifyLoggingPacket(lowMessage, LoggingEventType.BuildMessageEvent);
            VerifyLoggingPacket(taskStarted, LoggingEventType.TaskStartedEvent);
            VerifyLoggingPacket(taskFinished, LoggingEventType.TaskFinishedEvent);
            VerifyLoggingPacket(commandLine, LoggingEventType.TaskCommandLineEvent);
            VerifyLoggingPacket(warning, LoggingEventType.BuildWarningEvent);
            VerifyLoggingPacket(error, LoggingEventType.BuildErrorEvent);
            VerifyLoggingPacket(targetStarted, LoggingEventType.TargetStartedEvent);
            VerifyLoggingPacket(targetFinished, LoggingEventType.TargetFinishedEvent);
            VerifyLoggingPacket(projectStarted, LoggingEventType.ProjectStartedEvent);
            VerifyLoggingPacket(projectFinished, LoggingEventType.ProjectFinishedEvent);
            VerifyLoggingPacket(externalStartedEvent, LoggingEventType.CustomEvent);
        }

 /// <summary>
 /// Handles error notification events by storing the error message String.
 /// </summary>
 void ErrorRaised(object sender, BuildErrorEventArgs e)
 {
     _errors.Add(e.Message);
     #if DEBUG
     Debug.WriteLine("CONTENT: " + e.Message);
     #endif
 }

		public void AssignmentTest ()
		{
			BuildErrorEventArgs beea;
			string subcategory = "subcategory";
			string code = "CS0000";
			string file = "file";
			int lineNumber = 1;
			int columnNumber = 2;
			int endLineNumber = 3;
			int endColumnNumber = 4;
			string message = "message";
			string helpKeyword = "helpKeyword";
			string senderName = "MSBuild";
			
			beea = new BuildErrorEventArgs (subcategory, code, file, lineNumber, columnNumber, endLineNumber,
				endColumnNumber, message, helpKeyword, senderName);
			
			Assert.AreEqual (subcategory, beea.Subcategory, "Subcategory");
			Assert.AreEqual (code, beea.Code, "Code");
			Assert.AreEqual (file, beea.File, "File");
			Assert.AreEqual (lineNumber, beea.LineNumber, "LineNumber");
			Assert.AreEqual (columnNumber, beea.ColumnNumber, "ColumnNumber");
			Assert.AreEqual (endLineNumber, beea.EndLineNumber, "EndLineNumber");
			Assert.AreEqual (endColumnNumber, beea.EndColumnNumber, "EndColumnNumber");
			Assert.AreEqual (message, beea.Message, "Message");
			Assert.AreEqual (helpKeyword, beea.HelpKeyword, "HelpKeyword");
			Assert.AreEqual (senderName, beea.SenderName, "SenderName");
		}

        void eventSource_ErrorRaised(object sender, BuildErrorEventArgs e)
        {
            //TODO: task list?
            var s = String.Format("{0}({1},{2}): error {3}: {4}\n",
                e.File, e.LineNumber, e.ColumnNumber, e.Code, e.Message);

            Log(s);
        }

 void ErrorRaised(object sender, BuildErrorEventArgs e)
 {
     string fullPath = ProjectDirectory != null ? Path.Combine(ProjectDirectory, e.File) : e.File;
     Console.ForegroundColor = ConsoleColor.DarkRed;
     Console.WriteLine("{0}({1},{2})  error:{3}  {4}", fullPath, e.LineNumber, e.ColumnNumber, e.Code, e.Message);
     ErrorCount++;
     Console.ForegroundColor = ConsoleColor.White;
 }

        /// <summary>
        /// Format the error event message and all the other event data into
        /// a single string.
        /// </summary>
        /// <param name="e">Error to format</param>
        /// <returns>The formatted message string.</returns>
        internal static string FormatEventMessage(BuildErrorEventArgs e, bool removeCarriageReturn, bool showProjectFile)
        {
            ErrorUtilities.VerifyThrowArgumentNull(e, "e");

            // "error" should not be localized
            return FormatEventMessage("error", e.Subcategory, removeCarriageReturn ? EscapeCarriageReturn(e.Message) : e.Message,
                e.Code, e.File, showProjectFile ? e.ProjectFile : null, e.LineNumber, e.EndLineNumber,
                            e.ColumnNumber, e.EndColumnNumber, e.ThreadId);
        }

		void EventSourceErrorRaised (object sender, BuildErrorEventArgs e)
		{
			//NOTE: as of Mono 3.2.7, e.ProjectFile does not exist, so we use our projectFile variable instead
			results.Add (new MSBuildTargetResult (
				projectFile, false, e.Subcategory, e.Code, e.File,
				e.LineNumber, e.ColumnNumber, e.ColumnNumber, e.EndLineNumber,
				e.Message, e.HelpKeyword)
			);;
		}

        public void LogErrorEvent(BuildErrorEventArgs eventArgs)
        {
            Console.WriteLine(EventArgsFormatting.FormatEventMessage(eventArgs));
            _log += EventArgsFormatting.FormatEventMessage(eventArgs);
            ++_errors;

            _log += "\n";
            _upperLog = null;
        }

 public void EventArgsCtors()
 {
     BuildErrorEventArgs beea = new BuildErrorEventArgs2();
     beea = new BuildErrorEventArgs("Subcategory", "Code", "File", 1, 2, 3, 4, "Message", "HelpKeyword", "sender");
     beea = new BuildErrorEventArgs("Subcategory", "Code", "File", 1, 2, 3, 4, "Message", "HelpKeyword", "sender", DateTime.Now);
     beea = new BuildErrorEventArgs("Subcategory", "Code", "File", 1, 2, 3, 4, "{0}", "HelpKeyword", "sender", DateTime.Now, "Messsage");
     beea = new BuildErrorEventArgs(null, null, null, 1, 2, 3, 4, null, null, null);
     beea = new BuildErrorEventArgs(null, null, null, 1, 2, 3, 4, null, null, null, DateTime.Now);
     beea = new BuildErrorEventArgs(null, null, null, 1, 2, 3, 4, null, null, null, DateTime.Now, null);
 }

        void eventSource_ErrorRaised(object sender, BuildErrorEventArgs e)
        {
            // BUILDERROREVENTARGS ADDS LINENUMBER, COLUMNNUMBER, FILE, AMONGST OTHER PARAMETERS
            string line = String.Format(": ERROR {0}({1},{2}): ", e.File, e.LineNumber, e.ColumnNumber);

            using (StreamWriter sw = new StreamWriter("logfil.txt"))
            {
                sw.WriteLine(line);
            }
        }

		public static void LogErrorWithFilename (this Engine engine, string filename, string message,
				     params object[] messageArgs)
		{
			if (message == null)
				throw new ArgumentNullException ("message");
				
			BuildErrorEventArgs beea = new BuildErrorEventArgs (
				null, null, filename, 0, 0, 0, 0, FormatString (message, messageArgs),
				null, null);
			engine.EventSource.FireErrorRaised (engine, beea);
		}

        public virtual string FormatErrorEvent(BuildErrorEventArgs args)
        {
            StringBuilder sb = new StringBuilder ();

            sb.Append (args.File);
            AppendLineNumbers (sb, args.LineNumber, args.ColumnNumber, args.EndLineNumber, args.EndColumnNumber);
            sb.Append (": ");
            sb.Append (args.Subcategory);
            sb.Append (" error ");
            sb.Append (args.Code);
            sb.Append (": ");
            sb.Append (args.Message);

            return sb.ToString ();
        }

 public SharpBuildErrorEvent(BuildErrorEventArgs arg)
     : base(SharpBuildEventType.ErrorLog)
 {
     if (arg != null)
     {
         Code = arg.Code;
         ColumnNumber = arg.ColumnNumber;
         EndColumnNumber = arg.EndColumnNumber;
         EndLineNumber = arg.EndLineNumber;
         File = arg.File;
         LineNumber = arg.LineNumber;
         ProjectFile = arg.ProjectFile;
         Message = arg.Message;
     }
 }

        public void LogErrorEvent(BuildErrorEventArgs eventArgs)
        {
            if (eventArgs.File != null && eventArgs.File.Length > 0)
            {
                Console.Write("{0}({1},{2}): ", eventArgs.File, eventArgs.LineNumber, eventArgs.ColumnNumber);
            }

            Console.Write("ERROR: ");
            _log += "ERROR: ";
            Console.Write("ERROR " + eventArgs.Code + ": ");
            _log += "ERROR " + eventArgs.Code + ": ";
            ++_errors;

            Console.WriteLine(eventArgs.Message);
            _log += eventArgs.Message;
            _log += "\n";
        }

        public static void LogError(this Engine engine, string subcategory, string errorCode,
				      string helpKeyword, string file,
				      int lineNumber, int columnNumber,
				      int endLineNumber, int endColumnNumber,
				      string message,
				      params object[] messageArgs)
        {
            if (message == null)
                throw new ArgumentNullException ("message");

            BuildErrorEventArgs beea = new BuildErrorEventArgs (
                subcategory, errorCode, file, lineNumber,
                columnNumber, endLineNumber, endColumnNumber,
                FormatString (message, messageArgs), helpKeyword /*it's helpKeyword*/,
                null /*it's senderName*/);

            engine.EventSource.FireErrorRaised (engine, beea);
        }

        public void LogErrorEvent(BuildErrorEventArgs eventArgs)
        {
            if (eventArgs.File != null && eventArgs.File.Length > 0)
            {
                if (logToConsole)
                    Console.Write("{0}({1},{2}): ", eventArgs.File, eventArgs.LineNumber, eventArgs.ColumnNumber);
                log += String.Format(CultureInfo.InvariantCulture, "{0}({1},{2}): ", eventArgs.File, eventArgs.LineNumber, eventArgs.ColumnNumber);
            }

            if (logToConsole)
                Console.Write("ERROR " + eventArgs.Code + ": ");
            log += "ERROR " + eventArgs.Code + ": ";
            ++errors;

            if (logToConsole)
                Console.WriteLine(eventArgs.Message);
            log += eventArgs.Message;
            log += "\n";
        }