static int Main(string[] args) { // get verbose level to determine how much to print in console VerboseLevel verboseLevel = ArgumentsHelper.GetVerboseLevel(args); if (verboseLevel == VerboseLevel.All) { Console.WriteLine("verbose level set to \"{0}\".", verboseLevel); } if (args.Length < 2) { Console.WriteLine(usageText); return(1); } //foreach (string s in args) //{ // Console.WriteLine(s); //} string inputFile = ArgumentsHelper.GetInputFile(args); if (verboseLevel == VerboseLevel.All) { Console.WriteLine("reading log file \"{0}\".", inputFile); } return(0); }
public void Print(string text, VerboseLevel verbosity = VerboseLevel.REGULAR) { if ((int)Verbosity >= (int)verbosity) { System.Console.Write(text); } }
/// <summary> /// Creates a LogFileWriter that initially queues message /// </summary> public LogSubscriptionConsole() { m_verbose = VerboseLevel.None; m_subscriber = Logger.CreateSubscriber(m_verbose); m_subscriber.SubscribeToAll(m_verbose); m_subscriber.NewLogMessage += SubscriberNewLogMessage; }
/// <summary> /// Creates a <see cref="LogSubscriber"/> /// </summary> /// <returns></returns> public static LogSubscriber CreateSubscriber(VerboseLevel level = VerboseLevel.None) { var subscriber = new LogSubscriber(s_logger.CreateSubscriber()); subscriber.SubscribeToAll(level); return(subscriber); }
public void ShouldWrite_TrueIfLevelMatches(VerboseLevel levelToSet) { // *** Setup _logger.LogLevel = levelToSet; foreach (VerboseLevel level in AllLevels) { int intLevel = (int)level; int intLevelToSet = (int)levelToSet; // The level being requested should be contained in the level that was set. bool shouldWrite = ((intLevel & intLevelToSet) == intLevel); // If either level is set to NONE, then nothing should be written. if ((level == VerboseLevel.NONE) || (levelToSet == VerboseLevel.NONE)) { shouldWrite = false; } // *** Execute bool returnedValue = _logger.ShouldWrite(level); // *** Assert Assert.AreEqual(returnedValue, shouldWrite, "ShouldWrite({0}) returned false with the log level set to {1}!", level.ToString(), levelToSet.ToString()); } }
internal static void LogMessage(string message, VerboseLevel level) { if (VerboseLevel >= level && LoggingMethod != null) { LoggingMethod(message, level); } }
/// <summary> /// Returns whether or not a message should be logged based on the current logging level. /// </summary> protected bool ShouldWrite(VerboseLevel mode) { int intLevel = (int)LogLevel; int intMode = (int)mode; int andResult = (intLevel & intMode); return((andResult > 0) && (andResult == intMode)); }
public static MessageAttributeFilter Create(VerboseLevel level) { if (level == VerboseLevel.None) { return(null); } return(new MessageAttributeFilter(level)); }
/// <summary> /// Subscribes to the publisher of the specified assembly with the specified verbose level. /// </summary> public void SubscribeToAssembly(Assembly assembly, VerboseLevel level) { if (assembly == null) { throw new ArgumentNullException(nameof(assembly)); } m_subscriber.Subscribe(PublisherFilter.CreateAssembly(assembly), MessageAttributeFilter.Create(level), false); }
/// <summary> /// Ignore all messages of this verbose level. /// </summary> public void IgnoreType(Type type, VerboseLevel level) { if (type == null) { throw new ArgumentNullException(nameof(type)); } m_subscriber.Subscribe(PublisherFilter.CreateType(type), MessageAttributeFilter.Create(level), true); }
/// <summary> /// Ignore all messages of this verbose level. /// </summary> public void IgnoreAssembly(string assemblyExpression, VerboseLevel level) { if (assemblyExpression == null) { throw new ArgumentNullException(nameof(assemblyExpression)); } m_subscriber.Subscribe(PublisherFilter.CreateAssembly(assemblyExpression), MessageAttributeFilter.Create(level), true); }
/// <summary> /// Subscribes to the publisher of the specified type expression with the specified verbose level. /// </summary> /// <param name="typeExpression">An expression of the name of a type. Must include a * or ? to be considered an expression.</param> /// <param name="level">The level</param> public void SubscribeToType(string typeExpression, VerboseLevel level) { if (typeExpression == null) { throw new ArgumentNullException(nameof(typeExpression)); } m_subscriber.Subscribe(PublisherFilter.CreateType(typeExpression), MessageAttributeFilter.Create(level), false); }
public void WriteTraceWithArgs_PrintsToStdOutOnlyIfLogLevelIsTrace(VerboseLevel levelToSet) { const bool writeToStdErr = false; var levelsToPrint = new List <VerboseLevel> { VerboseLevel.TRACE }; WriteFuncWithArgs_PrintsOnlyIfLogLevelIsInList(levelToSet, writeToStdErr, levelsToPrint, "WriteTrace", _logger.WriteTrace); }
public void WriteWarningWithArgs_PrintsToStdOutUnlessLogLevelIsErrorOrNone(VerboseLevel levelToSet) { const bool writeToStdErr = true; var levelsToPrint = new List <VerboseLevel> { VerboseLevel.WARNING, VerboseLevel.INFO, VerboseLevel.DEBUG, VerboseLevel.TRACE }; WriteFuncWithArgs_PrintsOnlyIfLogLevelIsInList(levelToSet, writeToStdErr, levelsToPrint, "WriteWarning", _logger.WriteWarning); }
public void WriteDebug_PrintsToStdOutOnlyIfLogLevelIsDebugOrTrace(VerboseLevel levelToSet) { const bool writeToStdErr = false; var levelsToPrint = new List <VerboseLevel> { VerboseLevel.DEBUG, VerboseLevel.TRACE }; WriteFunc_PrintsOnlyIfLogLevelIsInList(levelToSet, writeToStdErr, levelsToPrint, "WriteDebug", _logger.WriteDebug); }
public void WriteError_PrintsToStdOutUnlessLogLevelIsNone(VerboseLevel levelToSet) { const bool writeToStdErr = true; var levelsToPrint = new List <VerboseLevel> { VerboseLevel.ERROR, VerboseLevel.WARNING, VerboseLevel.INFO, VerboseLevel.DEBUG, VerboseLevel.TRACE }; WriteFunc_PrintsOnlyIfLogLevelIsInList(levelToSet, writeToStdErr, levelsToPrint, "WriteError", _logger.WriteError); }
public FileLogger(string filename, int age, VerboseLevel level) { _logfile = filename; _age = age; VerboseLevel = level; InitLogFile(); ExpireLogs(); }
/// <summary> /// Sets log file writer path and optionally its verbosity level. /// </summary> public void SetPath(string logDirectory, VerboseLevel level) { FilePath.ValidatePathName(logDirectory); lock (m_syncRoot) { Verbose = level; m_path = logDirectory; m_flushTask.Start(1000); } }
public static void LogError(object message, VerboseLevel verboseLevel = VerboseLevel.IMPORTANT) { if (instance != null) { if (instance.verboseLevel >= verboseLevel) { Debug.LogError(FormatMessage(message.ToString())); } } }
public TestRun(string base_dir, VerboseLevel verbose_level, List <Test> tests, List <IReport> reports, LoggingServer logging_server, TestRunner runner) { start_time = DateTime.Now; this.base_dir = base_dir; this.verbose_level = verbose_level; this.tests = tests; this.reports = reports; this.logging_server = logging_server; this.runner = runner; }
public TestRun (string base_dir, VerboseLevel verbose_level, List<Test> tests, List<IReport> reports, LoggingServer logging_server, TestRunner runner) { start_time = DateTime.Now; this.base_dir = base_dir; this.verbose_level = verbose_level; this.tests = tests; this.reports = reports; this.logging_server = logging_server; this.runner = runner; }
/// <summary> /// Instantiate a new message handler. /// </summary> /// <param name="shortAppName">Short application name; usually 4 uppercase characters.</param> /// <param name="longAppName">Long application name; usually the executable name.</param> public MessageHandler(string shortAppName, string longAppName) { this.shortAppName = shortAppName; this.longAppName = longAppName; this.lastErrorNumber = SuccessErrorNumber; this.sourceTrace = false; this.verbosityLevel = VerboseLevel.Off; this.warningLevel = WarningLevel.Minor; this.warningAsError = false; this.suppressedWarnings = new Hashtable(); }
/// <summary> /// Helper function that runs the multiple parameter Write function tests. /// </summary> /// <param name="levelToSet">The VerboseLevel to set before running the Write function.</param> /// <param name="writeToStdErr">Pass true if the Write function should print to stderr, otherwise pass false.</param> /// <param name="levelsToPrint">A list of VerboseLevels that (when set) should produce output given the Write function being tested.</param> /// <param name="funcName">The name of the Write function being tested.</param> /// <param name="function">The Write function to call.</param> private void WriteFuncWithArgs_PrintsOnlyIfLogLevelIsInList( VerboseLevel levelToSet, bool writeToStdErr, IList <VerboseLevel> levelsToPrint, string funcName, Action <string, Object[]> function) { const string FORMAT_STRING = "Level is {0}, which equals number {1}."; // *** Setup _logger.LogLevel = levelToSet; _errorStringBuilder.Clear(); _outputStringBuilder.Clear(); StringBuilder targetStr = _outputStringBuilder; StringBuilder emptyStr = _errorStringBuilder; string targetStrName = "stdout"; string emptyStrName = "stderr"; Object[] args = { levelToSet, (int)levelToSet }; string stringToMatch = StringUtils.FormatInvariant(FORMAT_STRING, args); if (writeToStdErr) { targetStr = _errorStringBuilder; emptyStr = _outputStringBuilder; targetStrName = "stderr"; emptyStrName = "stdout"; } // *** Execute function(FORMAT_STRING, args); // *** Assert if (levelsToPrint.Contains(levelToSet)) { Assert.That(targetStr.ToString().Contains(stringToMatch), "{0} didn't print to {1} with LogLevel set to {2}!", funcName, targetStrName, levelToSet.ToString()); } else { Assert.IsEmpty(targetStr.ToString(), "{0} wrote a string to {1} with LogLevel set to {2}!", funcName, targetStrName, levelToSet.ToString()); } // Error & Warning should never print to stdout. // The others should never print to stderr. Assert.IsEmpty(emptyStr.ToString(), "{0} wrote a string to {1}!", funcName, emptyStrName); }
/// <summary> /// Creates a LogFileWriter that initially queues message /// </summary> /// <param name="messageLimit">the number of messages to maintain</param> public LogSubscriptionFileWriter(int messageLimit) { m_processName = Process.GetCurrentProcess().ProcessName; m_fileSequenceNumber = 1; m_syncRoot = new object(); m_maxQueue = messageLimit; m_messageQueue = new ConcurrentQueue <LogMessage>(); m_flushTask = new ScheduledTask(); m_flushTask.Running += m_flushTask_Running; m_verbose = VerboseLevel.High; m_subscriber = Logger.CreateSubscriber(m_verbose); m_subscriber.SubscribeToAll(m_verbose); m_subscriber.NewLogMessage += SubscriberNewLogMessage; }
/// does the logging. /// @param str the string to log /// @param category the category of the log /// @param source the source of the log /// @param logLevel what level to show and how to show it public virtual void Log(string str, Categories category, Sources source, VerboseLevel logLevel) { if (logLevel < m_minLevelToShow) { return; // too low a level } /* if (m_categoriesToShow[(int)category] && m_sourcesToShow[(int)source]) * { * if (logLevel == VerboseLevel.Verbose) * Debug.Log(str); * else if (logLevel == VerboseLevel.Warning) * Debug.LogWarning(str); * else Debug.LogError(str); * }*/ }
/// <summary> /// Creates a LogFileWriter that initially queues message /// </summary> /// <param name="messageLimit">the number of messages to maintain</param> public LogSubscriptionFileWriter(int messageLimit) { m_processName = Process.GetCurrentProcess().ProcessName; m_fileSequenceNumber = 1; m_syncRoot = new object(); m_maxQueue = messageLimit; m_messageQueue = new ConcurrentQueue<LogMessage>(); m_flushTask = new ScheduledTask(); m_flushTask.Running += m_flushTask_Running; m_verbose = VerboseLevel.High; m_subscriber = Logger.CreateSubscriber(m_verbose); m_subscriber.SubscribeToAll(m_verbose); m_subscriber.NewLogMessage += SubscriberNewLogMessage; }
/// <summary> /// Helper function that runs the single parameter Write function tests. /// </summary> /// <param name="levelToSet">The VerboseLevel to set before running the Write function.</param> /// <param name="writeToStdErr">Pass true if the Write function should print to stderr, otherwise pass false.</param> /// <param name="levelsToPrint">A list of VerboseLevels that (when set) should produce output given the Write function being tested.</param> /// <param name="funcName">The name of the Write function being tested.</param> /// <param name="function">The Write function to call.</param> private void WriteFunc_PrintsOnlyIfLogLevelIsInList( VerboseLevel levelToSet, bool writeToStdErr, IList <VerboseLevel> levelsToPrint, string funcName, Action <string> function) { // *** Setup _logger.LogLevel = levelToSet; _errorStringBuilder.Clear(); _outputStringBuilder.Clear(); StringBuilder targetStr = _outputStringBuilder; StringBuilder emptyStr = _errorStringBuilder; string targetStrName = "stdout"; string emptyStrName = "stderr"; if (writeToStdErr) { targetStr = _errorStringBuilder; emptyStr = _outputStringBuilder; targetStrName = "stderr"; emptyStrName = "stdout"; } // *** Execute function(STRING_TO_PRINT); // *** Assert if (levelsToPrint.Contains(levelToSet)) { Assert.That(targetStr.ToString().Contains(STRING_TO_PRINT), "{0} didn't print to {1} with LogLevel set to {2}!", funcName, targetStrName, levelToSet.ToString()); } else { Assert.IsEmpty(targetStr.ToString(), "{0} wrote a string to {1} with LogLevel set to {2}!", funcName, targetStrName, levelToSet.ToString()); } // Error & Warning should never print to stdout. // The others should never print to stderr. Assert.IsEmpty(emptyStr.ToString(), "{0} wrote a string to {1}!", funcName, emptyStrName); }
public virtual AnsibleCommand Verbose(VerboseLevel level = VerboseLevel.Low) { switch (level) { case VerboseLevel.Low: return(AddParameter("-v")); case VerboseLevel.Medium: return(AddParameter("-vv")); case VerboseLevel.High: return(AddParameter("-vvv")); case VerboseLevel.Highest: return(AddParameter("-vvvv")); } return(this); }
public void CandidateExclusionSolve(VerboseLevel verboseLevel) { if (verboseLevel == VerboseLevel.StepByStep) { Console.Write(Print("At start of CandidateExclusionSolve")); } IEnumerable <PicrossActiveLine> solvableLines; while ( (solvableLines = ActiveLines.Where(line => !line.IsSet && line.CandidateCount == 1)).Any() && IsValid) { var selectedLine = solvableLines.First(); selectedLine.ApplyLine(selectedLine.CandidateSolutions.First()); if (verboseLevel == VerboseLevel.StepByStep) { Console.Write(Print("After a CandidateExclusionStep")); } } }
/// <summary> /// Prints the specified message to the output stream if the current log level is >= level. /// This method is thread-safe. All output is prepended with the date & time, and log level. /// </summary> /// <example>2016-05-21 19:10:01Z INFO: This is the message.</example> /// <param name="level">The logging level of this message.</param> /// <param name="writer">The stream to where the output is sent.</param> /// <param name="format">The format string to be printed.</param> /// <param name="args">(optional) The arguments for the format string.</param> protected void Write(VerboseLevel level, TextWriter writer, string format, params Object[] args) { ThrowIf.ArgumentNull(writer, nameof(writer)); if (ShouldWrite(level)) { string datetime = DateTime.Now.ToString("u", CultureInfo.InvariantCulture); format = StringUtils.FormatInvariant("{0} {1}: {2}", datetime, level.ToString(), format); lock (_lock) { if (args == null) { writer.WriteLine(format); } else { writer.WriteLine(format, args); } } } }
/// <summary> /// Ignore all messages of this verbose level. /// </summary> public void IgnoreAll(VerboseLevel level) { m_subscriber.Subscribe(PublisherFilter.CreateUniversal(), MessageAttributeFilter.Create(level), true); }
/// <summary> /// Ignore all messages of this verbose level. /// </summary> public void IgnoreType(Type type, VerboseLevel level) { if (type == null) throw new ArgumentNullException(nameof(type)); m_subscriber.Subscribe(PublisherFilter.CreateType(type), MessageAttributeFilter.Create(level), true); }
/// <summary> /// Ignore all messages of this verbose level. /// </summary> public void IgnoreAssembly(string assemblyExpression, VerboseLevel level) { if (assemblyExpression == null) throw new ArgumentNullException(nameof(assemblyExpression)); m_subscriber.Subscribe(PublisherFilter.CreateAssembly(assemblyExpression), MessageAttributeFilter.Create(level), true); }
/// <summary> /// Subscribes to all publishers with the specified verbose level. /// </summary> public void SubscribeToAll(VerboseLevel level) { m_subscriber.Subscribe(PublisherFilter.CreateUniversal(), MessageAttributeFilter.Create(level), false); }
/// <summary> /// Subscribes to the publisher of the specified type expression with the specified verbose level. /// </summary> /// <param name="typeExpression">An expression of the name of a type. Must include a * or ? to be considered an expression.</param> /// <param name="level">The level</param> public void SubscribeToType(string typeExpression, VerboseLevel level) { if (typeExpression == null) throw new ArgumentNullException(nameof(typeExpression)); m_subscriber.Subscribe(PublisherFilter.CreateType(typeExpression), MessageAttributeFilter.Create(level), false); }
/// does the logging. /// @param str the string to log /// @param category the category of the log /// @param source the source of the log /// @param logLevel what level to show and how to show it public virtual void Log(string str, Categories category, Sources source, VerboseLevel logLevel) { if (logLevel < m_minLevelToShow) return; // too low a level if (m_categoriesToShow[(int)category] && m_sourcesToShow[(int)source]) { if (logLevel == VerboseLevel.Verbose) Debug.Log(str); else if (logLevel == VerboseLevel.Warning) Debug.LogWarning(str); else Debug.LogError(str); } }
/// <summary> /// Sends a verbose message. /// </summary> /// <param name="sourceLineNumbers">Source line numbers.</param> /// <param name="verboseLevel">Level of the verbose message.</param> /// <param name="verboseMessage">Verbose message string.</param> public void OnVerbose(SourceLineNumberCollection sourceLineNumbers, VerboseLevel verboseLevel, string verboseMessage) { this.messageHandler.OnExtensionVerbose(sourceLineNumbers, verboseLevel, verboseMessage); }
/// <summary> /// Subscribes to the publisher of the specified assembly with the specified verbose level. /// </summary> public void SubscribeToAssembly(Assembly assembly, VerboseLevel level) { if (assembly == null) throw new ArgumentNullException(nameof(assembly)); m_subscriber.Subscribe(PublisherFilter.CreateAssembly(assembly), MessageAttributeFilter.Create(level), false); }
/// <summary> /// VerboseEventArgs Constructor. /// </summary> /// <param name="level">Level of the verbose message.</param> /// <param name="message">Verbose message content.</param> public VerboseEventArgs(VerboseLevel level, string message) { this.level = level; this.message = message; }
/// <summary> /// Sends an error to the message delegate if there is one. /// </summary> /// <param name="sourceLineNumbers">Source line numbers.</param> /// <param name="verboseLevel">Level of the verbose message.</param> /// <param name="verboseMessage">Verbose message string.</param> public void OnExtensionVerbose(SourceLineNumberCollection sourceLineNumbers, VerboseLevel verboseLevel, string verboseMessage) { this.OnMessage(WixVerboses.LinkerExtensionVerbose(sourceLineNumbers, verboseLevel, verboseMessage)); }
/// <summary> /// Creates a <see cref="LogSubscriber"/> /// </summary> /// <returns></returns> public static LogSubscriber CreateSubscriber(VerboseLevel level = VerboseLevel.None) { var subscriber = new LogSubscriber(s_logger.CreateSubscriber()); subscriber.SubscribeToAll(level); return subscriber; }
public MatchVerbose(LogMessageSerializable typeName) { m_typeName = typeName.Level; }
/// <summary> /// Sends a verbose message. /// </summary> /// <param name="verboseLevel">Level of the verbose message.</param> /// <param name="verboseMessage">Verbose message string.</param> public void OnExtensionVerbose(VerboseLevel verboseLevel, string verboseMessage) { this.OnMessage(WixVerboses.DecompilerExtensionVerbose(verboseLevel, verboseMessage)); }