public void AssignmentTest ()
		{
			BuildWarningEventArgs bwea;
			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 = "senderName";
			
			bwea = new BuildWarningEventArgs (subcategory, code, file, lineNumber, columnNumber, endLineNumber,
				endColumnNumber, message, helpKeyword, senderName);
			
			Assert.AreEqual (subcategory, bwea.Subcategory, "Subcategory");
			Assert.AreEqual (code, bwea.Code, "Code");
			Assert.AreEqual (file, bwea.File, "File");
			Assert.AreEqual (lineNumber, bwea.LineNumber, "LineNumber");
			Assert.AreEqual (columnNumber, bwea.ColumnNumber, "ColumnNumber");
			Assert.AreEqual (endLineNumber, bwea.EndLineNumber, "EndLineNumber");
			Assert.AreEqual (endColumnNumber, bwea.EndColumnNumber, "EndColumnNumber");
			Assert.AreEqual (message, bwea.Message, "Message");
			Assert.AreEqual (helpKeyword, bwea.HelpKeyword, "HelpKeyword");
			Assert.AreEqual (senderName, bwea.SenderName, "SenderName");
		}

		void EventSourceWarningRaised (object sender, BuildWarningEventArgs e)
		{
			string file = e.File;
			if (file != null)
				file = Path.GetFullPath (Path.Combine (basePath, file));
			results.Add (new MSBuildResult (true, file, e.LineNumber, e.ColumnNumber, e.Code, e.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 override string FormatWarningEvent(BuildWarningEventArgs args)
 {
     return (string.Format(Resources.WARNING_MESSAGE.Replace(@"\t", "\t"),
                           trimPath(args.ProjectFile),
                           trimPath(args.File),
                           args.LineNumber, args.ColumnNumber, args.Message));
 }

 public override bool Execute()
 {
     var message = "CustomTask version is " + GetType().Assembly.GetName().Version;
     var args = new BuildWarningEventArgs("", "", "", 0, 0, 0, 0, message, "", "CustomTask");
     BuildEngine.LogWarningEvent(args);
     return true;
 }

        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);
        }

 private void HandleWarningRaised(object sender, BuildWarningEventArgs e)
 {
     var fullPath = m_projectDirectory != null ? Path.Combine(m_projectDirectory, e.File) : e.File;
     if (e.Code != null)
     {
         Console.WriteLine("{0}:{1}:{2}: Warning: {3}", fullPath, e.LineNumber, e.ColumnNumber, e.Message);
         m_warningCount++;
     }
 }

        /// <summary>
        /// Format the warning message and all the other event data into a
        /// single string.
        /// </summary>
        /// <owner>t-jeffv, sumedhk</owner>
        /// <param name="e">Warning to format</param>
        /// <returns>The formatted message string.</returns>
        internal static string FormatEventMessage(BuildWarningEventArgs e, bool removeCarriageReturn)
        {
            ErrorUtilities.VerifyThrowArgumentNull(e, "e");

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

		void EventSourceWarningRaised (object sender, BuildWarningEventArgs 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, true, e.Subcategory, e.Code, e.File,
				e.LineNumber, e.ColumnNumber, e.ColumnNumber, e.EndLineNumber,
				e.Message, e.HelpKeyword)
			);
		}

 public void EventArgsCtors()
 {
     BuildWarningEventArgs buildWarningEvent = new BuildWarningEventArgs2();
     buildWarningEvent = new BuildWarningEventArgs("Subcategory", "Code", "File", 1, 2, 3, 4, "Message", "HelpKeyword", "sender");
     buildWarningEvent = new BuildWarningEventArgs("Subcategory", "Code", "File", 1, 2, 3, 4, "Message", "HelpKeyword", "sender", DateTime.Now);
     buildWarningEvent = new BuildWarningEventArgs("Subcategory", "Code", "File", 1, 2, 3, 4, "{0}", "HelpKeyword", "sender", DateTime.Now, "Message");
     buildWarningEvent = new BuildWarningEventArgs(null, null, null, 1, 2, 3, 4, null, null, null);
     buildWarningEvent = new BuildWarningEventArgs(null, null, null, 1, 2, 3, 4, null, null, null, DateTime.Now);
     buildWarningEvent = new BuildWarningEventArgs(null, null, null, 1, 2, 3, 4, null, null, null, DateTime.Now, null);
 }

 void WarningRaised(object sender, BuildWarningEventArgs e)
 {
     string fullPath = ProjectDirectory != null ? Path.Combine(ProjectDirectory, e.File) : e.File;
     Console.ForegroundColor = ConsoleColor.DarkYellow;
     if (e.Code != null)
     {
         Console.WriteLine("{0}({1},{2})  warning:{3}  {4}", fullPath, e.LineNumber, e.ColumnNumber, e.Code, e.Message);
         WarningCount++;
     }
     Console.ForegroundColor = ConsoleColor.White;
 }

		public virtual string FormatWarningEvent (BuildWarningEventArgs 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 (" warning ");
			sb.Append (args.Code);
			sb.Append (": ");
			sb.Append (args.Message);

			return sb.ToString ();
		}

 public SharpBuildWarningEvent(BuildWarningEventArgs arg)
     : base(SharpBuildEventType.WarningLog)
 {
     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 LogWarningEvent(BuildWarningEventArgs eventArgs)
        {
            if (eventArgs.File != null && eventArgs.File.Length > 0)
            {
                Console.Write("{0}({1},{2}): ", eventArgs.File, eventArgs.LineNumber, eventArgs.ColumnNumber);
            }

            Console.Write("WARNING " + eventArgs.Code + ": ");
            _log += "WARNING " + eventArgs.Code + ": ";
            ++_warnings;

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

 public BuildMessage(BuildWarningEventArgs args)
 {
     EventType = args.GetType().Name.Replace("EventArgs", "");
     Code = args.Code;
     ColumnNumber = args.ColumnNumber;
     EndColumnNumber = args.EndColumnNumber;
     EndLineNumber = args.EndLineNumber;
     File = args.File;
     LineNumber = args.LineNumber;
     Message = args.Message;
     ProjectFile = args.ProjectFile;
     Subcategory = args.Subcategory;
     HelpKeyword = args.HelpKeyword;
     SenderName = args.SenderName;
     Timestamp = args.Timestamp;
     ThreadId = args.ThreadId;
 }

        private void LogWarning(string value)
        {
            BuildWarningEventArgs warning = new BuildWarningEventArgs(
                subcategory: null,
                code: null,
                file: this.buildEngine.ProjectFileOfTaskNode,
                lineNumber: this.buildEngine.LineNumberOfTaskNode,
                columnNumber: this.buildEngine.ColumnNumberOfTaskNode,
                endLineNumber: 0,
                endColumnNumber: 0,
                message: value,
                helpKeyword: null,
                senderName: this.taskName,
                eventTimestamp: DateTime.UtcNow);

            this.buildEngine.LogWarningEvent(warning);
        }

        public void LogWarningEvent(BuildWarningEventArgs 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("{0}({1},{2}): ", eventArgs.File, eventArgs.LineNumber, eventArgs.ColumnNumber);
            }

            if (logToConsole)
                Console.Write("WARNING " + eventArgs.Code + ": ");
            log += "WARNING " + eventArgs.Code + ": ";
            ++warnings;

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

 internal override void OutputWarning(object sender, BuildWarningEventArgs e)
 {
     if (GetHeaderOnlyFirstTyme() != null) { logStream.WriteLine(GetHeaderOnlyFirstTyme()); }
     logStream.WriteLine(FormatWarningEvent(e));
 }

        /// <summary>
        /// Generates the error event corresponding to a particular resource string and set of args
        /// </summary>
        private void LogWarningFromResource(string messageResource, params object[] messageArgs)
        {
            ErrorUtilities.VerifyThrow(_currentConfiguration != null, "We should never have a null configuration when we're trying to log warnings!");

            // Using the CLR 2 build event because this class is shared between MSBuildTaskHost.exe (CLR2) and MSBuild.exe (CLR4+)
            BuildWarningEventArgs warning = new BuildWarningEventArgs
                                                (
                                                    null,
                                                    null,
                                                    ProjectFileOfTaskNode,
                                                    LineNumberOfTaskNode,
                                                    ColumnNumberOfTaskNode,
                                                    0,
                                                    0,
                                                    ResourceUtilities.FormatString(AssemblyResources.GetString(messageResource), messageArgs),
                                                    null,
                                                    _currentConfiguration.TaskName
                                                );

            LogWarningEvent(warning);
        }

 void OnWarningRaised(object sender, BuildWarningEventArgs e)
 {
     TraceSource.TraceEvent(TraceEventType.Warning, 0, e.Message);
 }