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 WarningsCount { get; set; }
  73                 public int ErrorsCount { get; set; }
  74
  75                 public int Count
  76                 {
  77                         get { return messages.Count; }
  78                 }
  79
  80                 public LoggerVerbosity Verbosity { get { return LoggerVerbosity.Normal; } set { } }
  81
  82                 public string Parameters { get { return null; } set { } }
  83
  84                 public void Initialize (IEventSource eventSource)
  85                 {
  86                         eventSource.MessageRaised += new BuildMessageEventHandler (MessageHandler);
  87
  88                         eventSource.ErrorRaised += new BuildErrorEventHandler (AllMessagesHandler);
  89                         eventSource.ErrorRaised += (e,o) => ErrorsCount ++;
  90
  91                         eventSource.WarningRaised += new BuildWarningEventHandler(AllMessagesHandler);
  92                         eventSource.WarningRaised += (e,o) => WarningsCount ++;
  93
  94                         eventSource.TargetStarted += delegate { target_started++; };
  95                         eventSource.TargetFinished += delegate { target_finished++; };
  96                         eventSource.TaskStarted += delegate { task_started++; };
  97                         eventSource.TaskFinished += delegate { task_finished++; };
  98                         eventSource.ProjectStarted += delegate(object sender, ProjectStartedEventArgs args) { project_started++; };
  99                         eventSource.ProjectFinished += delegate (object sender, ProjectFinishedEventArgs args) { project_finished++; };
 100                         eventSource.BuildStarted += delegate { build_started ++; };
 101                         eventSource.BuildFinished += delegate { build_finished++; };
 102                 }
 103
 104                 public void Shutdown ()
 105                 {
 106                 }
 107
 108                 private void MessageHandler (object sender, BuildMessageEventArgs args)
 109                 {
 110                         if (args.Message.StartsWith ("Using") == false)
 111                                 messages.Add (args);
 112                         all_messages.Add (args);
 113                 }
 114
 115                 private void AllMessagesHandler (object sender, BuildEventArgs args)
 116                 {
 117                         all_messages.Add (args);
 118                 }
 119
 120                 public int NormalMessageCount {
 121                         get
 122                         {
 123                                 int count = 0, i = 0;
 124                                 while (i ++ < messages.Count)
 125                                         if (messages [i - 1].Importance == MessageImportance.Normal)
 126                                                 count++;
 127                                 return count;
 128                         }
 129                 }
 130
 131                 public int CheckHead (string text, MessageImportance importance)
 132                 {
 133                         string actual_msg;
 134                         return CheckHead (text, importance, out actual_msg);
 135                 }
 136
 137                 public int CheckHead (string text, MessageImportance importance, out string actual_msg)
 138                 {
 139                         BuildMessageEventArgs actual = null;
 140                         actual_msg = String.Empty;
 141
 142                         if (messages.Count > 0) {
 143                                 //find first @importance level message
 144                                 int i = -1;
 145                                 while (++i < messages.Count && messages [i].Importance != importance)
 146                                         ;
 147
 148                                 if (i < messages.Count) {
 149                                         actual = messages [i];
 150                                         messages.RemoveAt (i);
 151                                 }
 152                         } else
 153                                 return 1;
 154
 155                         if (actual != null)
 156                                 actual_msg = actual.Message;
 157                         if (actual != null && text == actual_msg && importance == actual.Importance)
 158                                 return 0;
 159                         else
 160                                 return 2;
 161                 }
 162
 163                 //return: 0 - found
 164                 //              1 - msg not found,
 165                 public int CheckAny (string text, MessageImportance importance)
 166                 {
 167                         if (messages.Count <= 0)
 168                                 return 1;
 169
 170                         int foundAt = -1;
 171                         for (int i = 0; i < messages.Count; i ++) {
 172                                 BuildMessageEventArgs arg = messages [i];
 173                                 if (text == arg.Message && importance == arg.Importance) {
 174                                         foundAt = i;
 175                                         break;
 176                                 }
 177                         }
 178
 179                         if (foundAt < 0)
 180                                 return 1;
 181
 182                         //found
 183                         messages.RemoveAt (foundAt);
 184                         return 0;
 185                 }
 186
 187                 public void DumpMessages ()
 188                 {
 189                         foreach (BuildEventArgs arg in all_messages)
 190                                 Console.WriteLine ("Msg: {0}", arg.Message);
 191                 }
 192
 193                 public void CheckLoggedMessageHead (string expected, string id)
 194                 {
 195                         string actual;
 196                         int result = CheckHead (expected, MessageImportance.Normal, out actual);
 197                         if (result == 1)
 198                                 Assert.Fail ("{0}: Expected message '{1}' was not emitted.", id, expected);
 199                         if (result == 2)
 200                                 Assert.AreEqual (expected, actual, id);
 201                 }
 202
 203                 public void CheckLoggedAny (string expected, MessageImportance importance, string id)
 204                 {
 205                         int res = CheckAny (expected, importance);
 206                         if (res != 0)
 207                                 Assert.Fail ("{0}: Expected message '{1}' was not emitted.", id, expected);
 208                 }
 209
 210
 211         }
 212
 213 }