mcs/class/Microsoft.Build.Tasks/Test/Microsoft.Build.Tasks/TestMessageLogger.cs

   1 using Microsoft.Build.Framework;
   2 using System.Collections;
   3 using System;
   4 using System.Collections.Generic;
   5 using NUnit.Framework;
   6
   7 namespace MonoTests.Microsoft.Build.Tasks
   8 {
   9         internal class TestMessageLogger : ILogger
  10         {
  11                 List<BuildMessageEventArgs> messages;
  12                 List<BuildEventArgs> all_messages;
  13                 int target_started, target_finished;
  14                 int task_started, task_finished;
  15                 int project_started, project_finished;
  16                 int build_started, build_finished;
  17
  18                 public int BuildStarted
  19                 {
  20                         get { return build_started; }
  21                         set { build_started = value; }
  22                 }
  23
  24                 public int BuildFinished
  25                 {
  26                         get { return build_finished; }
  27                         set { build_finished = value; }
  28                 }
  29
  30                 public TestMessageLogger ()
  31                 {
  32                         messages = new List<BuildMessageEventArgs> ();
  33                         all_messages = new List<BuildEventArgs> ();
  34                 }
  35
  36                 public int ProjectStarted
  37                 {
  38                         get { return project_started; }
  39                         set { project_started = value; }
  40                 }
  41
  42                 public int ProjectFinished
  43                 {
  44                         get { return project_finished; }
  45                         set { project_finished = value; }
  46                 }
  47
  48                 public int TargetFinished
  49                 {
  50                         get { return target_finished; }
  51                         set { target_finished = value; }
  52                 }
  53
  54                 public int TargetStarted
  55                 {
  56                         get { return target_started; }
  57                         set { target_started = value; }
  58                 }
  59
  60                 public int TaskStarted
  61                 {
  62                         get { return task_started; }
  63                         set { task_started = value; }
  64                 }
  65
  66                 public int TaskFinished
  67                 {
  68                         get { return task_finished; }
  69                         set { task_finished = value; }
  70                 }
  71
  72                 public int Count
  73                 {
  74                         get { return messages.Count; }
  75                 }
  76
  77                 public LoggerVerbosity Verbosity { get { return LoggerVerbosity.Normal; } set { } }
  78
  79                 public string Parameters { get { return null; } set { } }
  80
  81                 public void Initialize (IEventSource eventSource)
  82                 {
  83                         eventSource.MessageRaised += new BuildMessageEventHandler (MessageHandler);
  84                         eventSource.ErrorRaised += new BuildErrorEventHandler (AllMessagesHandler);
  85                         eventSource.WarningRaised += new BuildWarningEventHandler(AllMessagesHandler);
  86                         eventSource.TargetStarted += delegate { target_started++; };
  87                         eventSource.TargetFinished += delegate { target_finished++; };
  88                         eventSource.TaskStarted += delegate { task_started++; };
  89                         eventSource.TaskFinished += delegate { task_finished++; };
  90                         eventSource.ProjectStarted += delegate(object sender, ProjectStartedEventArgs args) { project_started++; Console.WriteLine ("Project started: {0}", args.ProjectFile); };
  91                         eventSource.ProjectFinished += delegate (object sender, ProjectFinishedEventArgs args) { project_finished++; Console.WriteLine ("Project finished: {0}", args.ProjectFile); };
  92                         eventSource.BuildStarted += delegate { build_started ++; };
  93                         eventSource.BuildFinished += delegate { build_finished++; };
  94                 }
  95
  96                 public void Shutdown ()
  97                 {
  98                 }
  99
 100                 private void MessageHandler (object sender, BuildMessageEventArgs args)
 101                 {
 102                         if (args.Message.StartsWith ("Using") == false)
 103                                 messages.Add (args);
 104                         all_messages.Add (args);
 105                 }
 106
 107                 private void AllMessagesHandler (object sender, BuildEventArgs args)
 108                 {
 109                         all_messages.Add (args);
 110                 }
 111
 112                 public int NormalMessageCount {
 113                         get
 114                         {
 115                                 int count = 0, i = 0;
 116                                 while (i ++ < messages.Count)
 117                                         if (messages [i - 1].Importance == MessageImportance.Normal)
 118                                                 count++;
 119                                 return count;
 120                         }
 121                 }
 122
 123                 public int CheckHead (string text, MessageImportance importance)
 124                 {
 125                         string actual_msg;
 126                         return CheckHead (text, importance, out actual_msg);
 127                 }
 128
 129                 public int CheckHead (string text, MessageImportance importance, out string actual_msg)
 130                 {
 131                         BuildMessageEventArgs actual = null;
 132                         actual_msg = String.Empty;
 133
 134                         if (messages.Count > 0) {
 135                                 //find first @importance level message
 136                                 int i = -1;
 137                                 while (++i < messages.Count && messages [i].Importance != importance)
 138                                         ;
 139
 140                                 if (i < messages.Count) {
 141                                         actual = messages [i];
 142                                         messages.RemoveAt (i);
 143                                 }
 144                         } else
 145                                 return 1;
 146
 147                         if (actual != null)
 148                                 actual_msg = actual.Message;
 149                         if (actual != null && text == actual_msg && importance == actual.Importance)
 150                                 return 0;
 151                         else
 152                                 return 2;
 153                 }
 154
 155                 //return: 0 - found
 156                 //              1 - msg not found,
 157                 public int CheckAny (string text, MessageImportance importance)
 158                 {
 159                         if (messages.Count <= 0)
 160                                 return 1;
 161
 162                         int foundAt = -1;
 163                         for (int i = 0; i < messages.Count; i ++) {
 164                                 BuildMessageEventArgs arg = messages [i];
 165                                 if (text == arg.Message && importance == arg.Importance) {
 166                                         foundAt = i;
 167                                         break;
 168                                 }
 169                         }
 170
 171                         if (foundAt < 0)
 172                                 return 1;
 173
 174                         //found
 175                         messages.RemoveAt (foundAt);
 176                         return 0;
 177                 }
 178
 179                 public void DumpMessages ()
 180                 {
 181                         foreach (BuildEventArgs arg in all_messages)
 182                                 Console.WriteLine ("Msg: {0}", arg.Message);
 183                 }
 184
 185                 public void CheckLoggedMessageHead (string expected, string id)
 186                 {
 187                         string actual;
 188                         int result = CheckHead (expected, MessageImportance.Normal, out actual);
 189                         if (result == 1)
 190                                 Assert.Fail ("{0}: Expected message '{1}' was not emitted.", id, expected);
 191                         if (result == 2)
 192                                 Assert.AreEqual (expected, actual, id);
 193                 }
 194
 195                 public void CheckLoggedAny (string expected, MessageImportance importance, string id)
 196                 {
 197                         int res = CheckAny (expected, importance);
 198                         if (res != 0)
 199                                 Assert.Fail ("{0}: Expected message '{1}' was not emitted.", id, expected);
 200                 }
 201
 202
 203         }
 204
 205 }