Esempio n. 1
0
 public static void SendMessage(TestMessageLevel level, string msg)
 {
     if( _logger != null )
     {
         _logger.SendMessage(level, msg);
     }
 }
Esempio n. 2
0
 public void SendMessage(TestMessageLevel logLevel, string message)
 {
     if (CanLog)
     {
         messageLogger.SendMessage(logLevel, message);
     }
 }
 public override void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     try
     {
         _logger.SendMessage(testMessageLevel, FormatMessage(testMessageLevel, message));
     }
     catch { }
 }
        private void LogSafe(TestMessageLevel level, string message)
        {
            if (string.IsNullOrWhiteSpace(message))
            {
                // Visual Studio 2013 is very picky about empty lines...
                // But it accepts an 'INVISIBLE SEPARATOR' (U+2063)  :-)
                message = "\u2063";
            }

            lock (Lock)
            {
                Logger.SendMessage(level, message);
            }
        }
        public static Severity GetSeverity(this TestMessageLevel level)
        {
            switch (level)
            {
            case TestMessageLevel.Informational: return(Severity.Info);

            case TestMessageLevel.Warning: return(Severity.Warning);

            case TestMessageLevel.Error: return(Severity.Error);

            default:
                throw new InvalidOperationException(String.Format(Resources.UnknownEnum, level));
            }
        }
        void IMessageLogger.SendMessage(TestMessageLevel testMessageLevel, string message)
        {
            TextMessage textMessage = new TextMessage()
            {
                Level = testMessageLevel,
                Text = message
            };

            Events.Add(new Event()
            {
                EventType = EventType.SendMessage,
                Message = textMessage
            });
        }
Esempio n. 7
0
        void IMessageLogger.SendMessage(TestMessageLevel testMessageLevel, string message)
        {
            var textMessage = new TextMessage
            {
                Level = testMessageLevel,
                Text  = message
            };

            Events.Add(new Event
            {
                EventType = EventType.SendMessage,
                Message   = textMessage
            });
        }
        public static Severity GetSeverity(this TestMessageLevel level)
        {
            switch (level)
            {
            case TestMessageLevel.Informational: return(Severity.Info);

            case TestMessageLevel.Warning: return(Severity.Warning);

            case TestMessageLevel.Error: return(Severity.Error);

            default:
                throw new InvalidOperationException($"Unknown enum literal: {level}");
            }
        }
Esempio n. 9
0
        void LogNormal(TestMessageLevel level, string msg)
        {
            if (_logger == null)
            {
                return;
            }

            if (_settings == null ||
                _settings.LoggingLevel == Catch2Interface.LoggingLevels.Normal ||
                _settings.LoggingLevel == Catch2Interface.LoggingLevels.Verbose)
            {
                _logger.SendMessage(level, msg);
            }
        }
Esempio n. 10
0
        private void LogVerbose(TestMessageLevel level, string msg)
        {
            if (_frameworkHandle == null)
            {
                return;
            }

            if (_settings == null ||
                _settings.LoggingLevel == Catch2Interface.LoggingLevels.Verbose ||
                _settings.LoggingLevel == Catch2Interface.LoggingLevels.Debug)
            {
                _frameworkHandle.SendMessage(level, msg);
            }
        }
Esempio n. 11
0
        /// <summary>
        /// Initializes with the level and the message for the event.
        /// </summary>
        /// <param name="level">Level of the message.</param>
        /// <param name="message">The message.</param>
        public TestRunMessageEventArgs(TestMessageLevel level, string message)
        {
            if (string.IsNullOrWhiteSpace(message))
            {
                throw new ArgumentException(CommonResources.CannotBeNullOrEmpty, nameof(message));
            }

            if (level < TestMessageLevel.Informational || level > TestMessageLevel.Error)
            {
                throw new ArgumentOutOfRangeException(nameof(level));
            }

            Level   = level;
            Message = message;
        }
Esempio n. 12
0
        public void HandleLogMessage(TestMessageLevel level, string message)
        {
            if (_discoveryCompletionSource.Task.IsCompleted)
            {
                // PENDING: vstest error, log this
                return;
            }

            if (message == null)
            {
                // PENDING: vstest error, log this
                return;
            }

            RaiseMessageReceived(level, message);
        }
Esempio n. 13
0
        public void SendMessage(TestMessageLevel testMessageLevel, string message, Exception ex)
        {
            switch (Verbosity)
            {
            case 0:
                var type = ex.GetType();
                SendMessage(testMessageLevel, string.Format(EXCEPTION_FORMAT, type, message));
                SendMessage(testMessageLevel, ex.Message);
                break;

            default:
                SendMessage(testMessageLevel, message);
                SendMessage(testMessageLevel, ex.ToString());
                break;
            }
        }
        /// <summary>
        /// Sends the message.
        /// </summary>
        /// <param name="testMessageLevel">The test message level.</param>
        /// <param name="message">The message.</param>
        public void SendMessage(TestMessageLevel testMessageLevel, string message)
        {
            switch (testMessageLevel)
            {
            case TestMessageLevel.Informational:
                Console.Out.WriteLine(message);
                break;

            case TestMessageLevel.Warning:
            case TestMessageLevel.Error:
                Console.Error.WriteLine(message);
                break;

            default:
                throw new NotSupportedException($"TestMessageLevel: {testMessageLevel}");
            }
        }
Esempio n. 15
0
        public static string GetShortName(this TestMessageLevel testMessageLevel)
        {
            switch (testMessageLevel)
            {
            case TestMessageLevel.Informational:
                return("INFO");

            case TestMessageLevel.Warning:
                return("WARN");

            case TestMessageLevel.Error:
                return("FAIL");

            default:
                return("MISC");
            }
        }
Esempio n. 16
0
        protected MessageLevel GetMessageLevel(TestMessageLevel level)
        {
            switch (level)
            {
            case TestMessageLevel.Informational:
                return(MessageLevel.Informational);

            case TestMessageLevel.Warning:
                return(MessageLevel.Warning);

            case TestMessageLevel.Error:
                return(MessageLevel.Error);

            default:
                return(MessageLevel.Error);
            }
        }
        private void LogSafe(TestMessageLevel level, string message)
        {
            if (_settings.TimestampOutput)
                Utils.TimestampMessage(ref message);

            if (string.IsNullOrWhiteSpace(message))
            {
                // Visual Studio 2013 is very picky about empty lines...
                // But it accepts an 'INVISIBLE SEPARATOR' (U+2063)  :-)
                message = "\u2063";
            }

            lock (Lock)
            {
                _logger.SendMessage(level, message);
            }
        }
Esempio n. 18
0
        /// <summary>
        /// Invoked when log messages are received
        /// </summary>
        public void HandleLogMessage(TestMessageLevel level, string message)
        {
            EqtTrace.Verbose("TestRunRequest:SendTestRunMessage: Starting.");

            lock (this.syncObject)
            {
                // If this object is disposed, dont do anything
                if (this.disposed)
                {
                    EqtTrace.Warning("TestRunRequest.SendTestRunMessage: Ignoring as the object is disposed.");
                    return;
                }

                this.TestRunMessage.SafeInvoke(this, new TestRunMessageEventArgs(level, message), "TestRun.LogMessages");
            }

            EqtTrace.Info("TestRunRequest:SendTestRunMessage: Completed.");
        }
Esempio n. 19
0
        /// <summary>
        /// Sends a message to all listeners.
        /// </summary>
        /// <param name="testMessageLevel">Level of the message.</param>
        /// <param name="message">The message to be sent.</param>
        public void SendMessage(TestMessageLevel testMessageLevel, string message)
        {
            if (string.IsNullOrWhiteSpace(message))
            {
                throw new ArgumentException(ObjectModelCommonResources.CannotBeNullOrEmpty, nameof(message));
            }

            if (this.TreatTestAdapterErrorsAsWarnings &&
                testMessageLevel == TestMessageLevel.Error)
            {
                // Downgrade the message severity to Warning...
                testMessageLevel = TestMessageLevel.Warning;
            }

            if (this.TestRunMessage != null)
            {
                var args = new TestRunMessageEventArgs(testMessageLevel, message);
                this.TestRunMessage.SafeInvoke(this, args, "TestRunMessageLoggerProxy.SendMessage");
            }
        }
        private void LogSafe(TestMessageLevel level, string message)
        {
            if (_settings.TimestampOutput)
            {
                string timestamp = DateTime.Now.ToString("HH:mm:ss.fff", CultureInfo.InvariantCulture);
                message = $"{timestamp} - {message ?? ""}";
            }

            if (string.IsNullOrWhiteSpace(message))
            {
                // Visual Studio 2013 is very picky about empty lines...
                // But it accepts an 'INVISIBLE SEPARATOR' (U+2063)  :-)
                message = "\u2063";
            }

            lock (Lock)
            {
                _logger.SendMessage(level, message);
            }
        }
Esempio n. 21
0
        public void HandleLogMessage(TestMessageLevel level, string message)
        {
            switch ((TestMessageLevel)level)
            {
            case TestMessageLevel.Informational:
                EqtTrace.Info(message);
                break;

            case TestMessageLevel.Warning:
                EqtTrace.Warning(message);
                break;

            case TestMessageLevel.Error:
                EqtTrace.Error(message);
                break;

            default:
                EqtTrace.Info(message);
                break;
            }
        }
Esempio n. 22
0
        private void AppendOutputPrefix(StringBuilder builder, TestMessageLevel level)
        {
            if (_prefixOutput())
            {
                builder.Append("GTA");
            }

            var timestampMode = _timeStampMode();

            if (timestampMode == TimestampMode.PrintTimestamp ||
                timestampMode == TimestampMode.Automatic && !VsVersionUtils.VsVersion.PrintsTimeStampAndSeverity())
            {
                if (builder.Length > 0)
                {
                    builder.Append(' ');
                }

                builder.Append(Utils.GetTimestamp());
            }

            var severityMode = _severityMode();

            if (level > TestMessageLevel.Informational &&
                (severityMode == SeverityMode.PrintSeverity ||
                 severityMode == SeverityMode.Automatic && !VsVersionUtils.VsVersion.PrintsTimeStampAndSeverity()))
            {
                if (builder.Length > 0)
                {
                    builder.Append(' ');
                }

                builder.Append(GetSeverity(level));
            }

            if (builder.Length > 0)
            {
                builder.Insert(0, '[');
                builder.Append("] ");
            }
        }
        private void LogSafe(TestMessageLevel level, string message)
        {
            if (_timeStampOutput())
            {
                Utils.TimestampMessage(ref message);
            }

            if (string.IsNullOrWhiteSpace(message))
            {
                // Visual Studio 2013 is very picky about empty lines...
                // But it accepts an 'INVISIBLE SEPARATOR' (U+2063)  :-)
                message = "\u2063";
            }

            _logger.SendMessage(level, message);
            ReportFinalLogEntry(
                new LogEntry
            {
                Severity = level.GetSeverity(),
                Message  = message
            });
        }
Esempio n. 24
0
        /// <summary>
        /// Method that accepts a message along with the severity level so as to be printed onto the tests output tab
        /// </summary>
        /// <param name="testMessageLevel">level parameter used to indicate the severity of the message</param>
        /// <param name="message">text message that needs to be printed</param>
        /// <remarks>In case the Logger is not properly initialized then any messages are simply discared without raising any exceptions</remarks>
        public static void SendMessage(TestMessageLevel testMessageLevel, string message)
        {
            if (_loggerInstance != null)
            {
                _loggerInstance.SendMessage(testMessageLevel, message);
            }

            switch (testMessageLevel)
            {
                case TestMessageLevel.Informational:
                    log4netLogger.Info(message);
                    break;

                case TestMessageLevel.Warning:
                    log4netLogger.Warn(message);
                    break;

                case TestMessageLevel.Error:
                    log4netLogger.Error(message);
                    break;
            }
        }
        /// <summary>
        /// Method that accepts a message along with the severity level so as to be printed onto the tests output tab
        /// </summary>
        /// <param name="testMessageLevel">level parameter used to indicate the severity of the message</param>
        /// <param name="message">text message that needs to be printed</param>
        /// <remarks>In case the Logger is not properly initialized then any messages are simply discarded without raising any exceptions</remarks>
        public static void SendMessage(TestMessageLevel testMessageLevel, string message)
        {
            if (_loggerInstance != null)
            {
                _loggerInstance.SendMessage(testMessageLevel, message);
            }

            switch (testMessageLevel)
            {
            case TestMessageLevel.Informational:
                log4netLogger.Info(message);
                break;

            case TestMessageLevel.Warning:
                log4netLogger.Warn(message);
                break;

            case TestMessageLevel.Error:
                log4netLogger.Error(message);
                break;
            }
        }
Esempio n. 26
0
        public void SendMessage(TestMessageLevel testMessageLevel, string message, Exception ex)
        {
            switch (Verbosity)
            {
            case 0:
                var type = ex.GetType();
                SendMessage(testMessageLevel, string.Format(EXCEPTION_FORMAT, type, message));
                SendMessage(testMessageLevel, ex.Message);
                SendMessage(testMessageLevel, ex.StackTrace);
                if (ex.InnerException != null)
                {
                    SendMessage(testMessageLevel, $"Innerexception: {ex.InnerException.ToString()}");
                }
                break;

            default:
                SendMessage(testMessageLevel, message);
                SendMessage(testMessageLevel, ex.ToString());
                SendMessage(testMessageLevel, ex.StackTrace);
                break;
            }
        }
Esempio n. 27
0
        public void HandleLogMessage(TestMessageLevel level, string message)
        {
            LogLevel levelFinal;

            switch (level)
            {
            case TestMessageLevel.Informational:
                levelFinal = LogLevel.Debug;
                break;

            case TestMessageLevel.Warning:
                levelFinal = LogLevel.Warning;
                break;

            case TestMessageLevel.Error:
                levelFinal = LogLevel.Error;
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(level), level, null);
            }
            _logger.LogTrace($"{_runnerId}: [{levelFinal}] {message}");
        }
Esempio n. 28
0
 void IMessageLogger.SendMessage(TestMessageLevel testMessageLevel, string message)
 {
 }
Esempio n. 29
0
 /// <summary>
 /// Logs the provided message at the requested severity level. Uses a format, args pair to construct the log message.
 /// </summary>
 /// <param name="testMessageLevel">level parameter used to indicate the severity of the message</param>
 /// <param name="format">Format string</param>
 /// <param name="args">Arguments for the format string</param>
 public static void SendMessage(TestMessageLevel testMessageLevel, string format, params object[] args)
 {
     SendMessage(testMessageLevel, string.Format(CultureInfo.InvariantCulture, format, args));
 }
Esempio n. 30
0
 public void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     this.TestMessageLevel = testMessageLevel;
     this.Message          = message;
 }
 protected MessageLevel GetMessageLevel(TestMessageLevel level)
 {
     switch (level)
     {
         case TestMessageLevel.Informational:
             return MessageLevel.Informational;
         case TestMessageLevel.Warning:
             return MessageLevel.Warning;
         case TestMessageLevel.Error:
             return MessageLevel.Error;
         default:
             return MessageLevel.Error;
     }
 }
Esempio n. 32
0
 void SendMessage(TestMessageLevel level, string assemblyName, string message)
 {
     var assemblyText = assemblyName == null ? "" : $"{Path.GetFileNameWithoutExtension(assemblyName)}: ";
     InnerLogger.SendMessage(level, $"[xUnit.net {Stopwatch.Elapsed}] {assemblyText}{message}");
 }
Esempio n. 33
0
 public void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     _monitor.RecordMessage(testMessageLevel.Convert(), message.PadLinesLeft("   "));
 }
 void IMessageLogger.SendMessage(TestMessageLevel testMessageLevel, string message)
 {
 }
 public void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
 }
 public void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     Console.WriteLine("{0}: {1}", testMessageLevel, message);
 }
Esempio n. 37
0
        public void SendMessage(TestMessageLevel testMessageLevel, string message)
        {
            var consoleOutput = String.Format("{0}) {1}", messageLevelToTextMap[testMessageLevel], message);

            Console.WriteLine(consoleOutput);
        }
 public override void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     Log(GetMessageLevel(testMessageLevel), message);
 }
Esempio n. 39
0
 public void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     // Do nothing
 }
Esempio n. 40
0
 public void SendMessage(TestMessageLevel testMessageLevel, string message) {
     Messages.Add(string.Format("{0}:{1}", testMessageLevel, message));
 }
Esempio n. 41
0
 public void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     if (MessageLogger != null)
         MessageLogger.SendMessage(testMessageLevel, message);
 }
Esempio n. 42
0
 void IMessageLogger.SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     Assert.That(message, Does.Not.Contain("failed to load"));
 }
 protected string LevelText(TestMessageLevel level)
 {
     return LevelText(GetMessageLevel(level));
 }
Esempio n. 44
0
 public void SendMessage(TestMessageLevel testMessageLevel, string message)
     => NotImplemented();
 protected string FormatMessage(TestMessageLevel level, string message)
 {
     return FormatMessage(GetMessageLevel(level), message);
 }
Esempio n. 46
0
 void ITestDiscoveryMonitor.RecordMessage(TestMessageLevel testMessageLevel, string message)
 {
     MessageReceived?.Invoke(this, new EventArgs <string>(message));
 }
 void IMessageLogger.SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     Assert.That(message, Does.Not.Contain("failed to load"));
 }
Esempio n. 48
0
 public void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     throw new NotImplementedException();
 }
 public static string FormatMessage(this ITestLogger logger, TestMessageLevel level, string message)
 {
     return logger.FormatMessage(level.GetTestLogLevel(), logger.Context, message);
 }
 public void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     Messages.Add(string.Format("{0}:{1}", testMessageLevel, message));
 }
Esempio n. 51
0
 public override void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
     foreach (var logger in _loggers)
     {
         try
         {
             logger.SendMessage(testMessageLevel, message);
         }
         catch { }
     }
 }
 private static void SendMessage(TestMessageLevel level, string message, IMessageLogger logger)
 {
     if (logger != null)
     {
         logger.SendMessage(level, message);
     }
 }
 void SendMessage(TestMessageLevel level, string assemblyName, string message)
 {
     var assemblyText = assemblyName == null ? "" : string.Format("{0}: ", Path.GetFileNameWithoutExtension(assemblyName));
     InnerLogger.SendMessage(level, string.Format("[xUnit.net {0}] {1}{2}", Stopwatch.Elapsed, assemblyText, message));
 }
Esempio n. 54
0
 public void SendMessage(TestMessageLevel testMessageLevel, string message)
 {
 }
Esempio n. 55
0
 public void SendMessage(TestMessageLevel testMessageLevel, string message) {
     this.Messages.Add(new Tuple<TestMessageLevel, string>(testMessageLevel, message));
 }