public void Save_WriteBananaToFile_Test()
        {
            LogData logData = new LogData();
            logData.Category = "Fruta";
            logData.LogType = "Erro";
            logData.ObjectToLog = "Banana";
            logData.MethodName = "Save_WriteBanana_To_File";

            ConfigurationUtilityMock mock = new ConfigurationUtilityMock();
            mock.LogPath = "c:/BananaDePijama";
            mock.LogType = "File";

            IocFactory.Register(
                    Component.For<IConfigurationUtility>()
                    .Instance(mock),

                    Component.For<ILog>()
                    .ImplementedBy<FileLogProcessor>()
                    .Interceptor<LogInterceptor>()
                );

            ILog log = IocFactory.Resolve<ILog>();

            log.Save(logData);
        }

        /// <summary>
        /// Called when any message is written to the log.
        /// </summary>
        /// <param name="log">The log.</param>
        /// <param name="message">The message.</param>
        /// <param name="logEvent">The log event.</param>
        /// <param name="extraData">The additional data.</param>
        /// <param name="logData">The log data.</param>
        /// <param name="time">The time.</param>
        protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, System.DateTime time)
        {
            base.Write(log, message, logEvent, extraData, time);

            switch (logEvent)
            {
                case LogEvent.Debug:
                    _eventSource.Debug(message);
                    break;

                case LogEvent.Info:
                    _eventSource.Info(message);
                    break;

                case LogEvent.Warning:
                    _eventSource.Warning(message);
                    break;

                case LogEvent.Error:
                    _eventSource.Error(message);
                    break;

                default:
                    throw new ArgumentOutOfRangeException("logEvent");
            }
        }

            protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
            {
                if (log.TargetType != typeof(TestLogListener))
                {
                    return;
                }

                switch (logEvent)
                {
                    case LogEvent.Debug:
                        DebugCount++;
                        break;

                    case LogEvent.Info:
                        InfoCount++;
                        break;

                    case LogEvent.Warning:
                        WarningCount++;
                        break;

                    case LogEvent.Error:
                        ErrorCount++;
                        break;

                    case LogEvent.Status:
                        StatusCount++;
                        break;
                }
            }

 public void Post(LogData data)
 {
     data.User = GetCurrentSession().User;
     var log = GetLog(data);
     var @event = CreateEvent(data, log);
     SaveMeasurements(data.User, log, @event, data.Measurements);
     SaveTags(log, data.User, @event, data.Tags);
 }

        /// <summary>
        /// Writes the specified LogData to NLog.
        /// </summary>
        /// <param name="logData">The log data.</param>
        public static void WriteLog(LogData logData)
        {
            var logEvent = logData.ToLogEvent();
            var name = logData.Logger ?? typeof(NLogWriter).FullName;

            var logger = global::NLog.LogManager.GetLogger(name);
            logger.Log(logEvent);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="LogMessageEventArgs" /> class.
 /// </summary>
 /// <param name="log">The log.</param>
 /// <param name="message">The message.</param>
 /// <param name="extraData">The extra data.</param>
 /// <param name="logData">The log data.</param>
 /// <param name="logEvent">The log event.</param>
 /// <param name="time">The time.</param>
 public LogMessageEventArgs(ILog log, string message, object extraData, LogData logData, LogEvent logEvent, DateTime time)
 {
     Log = log;
     Time = time;
     Message = message;
     ExtraData = extraData;
     LogEvent = logEvent;
     LogData = logData;
 }

 protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
 {
     _textBox.Dispatcher.Invoke(() =>
     {
         _textBox.AppendText(string.Format("{0} {1}", time.ToString("HH:mm:ss.fff"), message));
         _textBox.AppendText(Environment.NewLine);
         _textBox.ScrollToEnd();
     });
 }

        protected override bool ShouldIgnoreLogMessage(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
        {
            if (message.StartsWith("Uninitialized"))
            {
                return true;
            }

            return false;
        }

 private Log GetLog(LogData data)
 {
     var log = LogRepository.Name(data.Name);
     if (log == null)
     {
         log = new Log { Id = Guid.NewGuid(), Name = data.Name, UserId = data.User.Id };
         LogRepository.Create(log);
     }
     return log;
 }

 public Reverse(Stage stage, Game1 game, ContentManager content)
 {
     this.game = game;
     this.stage = stage;
     this.content = content;
     nowlogdata = new LogData();
     reverseLog = new List<LogData>();
     score_prev = 0;
     tasSound = content.Load<SoundEffect>("Audio\\SE\\TAS");
 }

        public void Save(LogData logData)
        {
            EventLog log = new EventLog();

            log.Source = "Troco$erto";

            string logMessage = Serializer.JsonSerialize(logData.ObjectToLog);

            log.WriteEntry(logMessage, EventLogEntryType.Information);
        }

		/// <summary>
		/// メッセージを記録する
		/// </summary>
		/// <param name="message"></param>
		public void LogMessage(string message)
		{
			if (_saveLog) {
				LogData data = new LogData(LogData.LogType.Message, message);
				Loglist.Add(data);

				DebugWrite(message);

			}

		}

    public static void Log( LogData playClipData )
    {
        playClipData.time = Time.time;

        if ( logData.Count >= 1024 )
        {
            logData.RemoveLast();
        }

        logData.AddFirst( playClipData );

        _OnLogUpdated();

    }

        private static void WriteLog(LogData logData, Action<object> logAction, Action<object, Exception> errorAction)
        {
            bool isFormatted = logData.Parameters != null && logData.Parameters.Length > 0;

            string message = isFormatted
                ? string.Format(logData.FormatProvider, logData.Message, logData.Parameters)
                : logData.Message;


            if (logData.Exception == null)
                logAction(message);
            else
                errorAction(message, logData.Exception);
        }

        /// <summary>
        /// Called when any message is written to the log.
        /// </summary>
        /// <param name="log">The log.</param>
        /// <param name="message">The message.</param>
        /// <param name="logEvent">The log event.</param>
        /// <param name="extraData">The additional data.</param>
        /// <param name="logData">The log data.</param>
        /// <param name="time">The time.</param>
        protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
        {
            lock (_lock)
            {
                _logBatch.Add(new LogBatchEntry(log, message, logEvent, extraData, logData, time));

                if (_logBatch.Count >= MaximumBatchCount)
                {
                    // TODO: remove pragma in 5.0.0
#pragma warning disable 4014
                    Flush();
#pragma warning restore 4014
                }
            }
        }

        protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
        {
            _textBox.Dispatcher.Invoke(() =>
            {
                var finalMessage = string.Format("{0} {1}", time.ToString("hh:mm:ss.fff"), message);

                var paragraph = new Paragraph(new Run(finalMessage));

                FixParagraphSpacing(paragraph);

                paragraph.Foreground = ColorSets[logEvent];
                _textBox.Document.Blocks.Add(paragraph);
                _textBox.ScrollToEnd();
            });
        }

		public LogDump(LogData data)
		{
			if (data != null)
			{
				this.StationName = data.SolutionName;
				this.NumberOfBuildsFailed = data.NumberOfBuildsFailed;
				this.NumberOfBuildsSucceeded = data.NumberOfBuildsSucceeded;
				this.NumberOfProjectsBuilt = data.NumberOfProjectsBuilt;
				this.NumberOfTestsFailed = data.NumberOfTestsFailed;
				this.NumberOfTestsIgnored = data.NumberOfTestsIgnored;
				this.NumberOfTestsPassed = data.NumberOfTestsPassed;
				this.NumberOfTestsRan = data.NumberOfTestsRan;
				this.StationName = data.StationName;
				this.TimeStamp = data.TimeStamp;
				this.UserName = data.UserName;
			}
		}

        /// <summary>
        /// Called when any message is written to the log.
        /// </summary>
        /// <param name="log">The log.</param>
        /// <param name="message">The message.</param>
        /// <param name="logEvent">The log event.</param>
        /// <param name="extraData">The extra data.</param>
        /// <param name="logData">The log data.</param>
        /// <param name="time">The time.</param>
        protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
        {
            base.Write(log, message, logEvent, extraData, time);

            var logEntry = new LogEntry(log, message, logEvent, extraData, null, time);

            AddLogEvent(_lastLogEntries, logEntry, MaximumNumberOfLogEntries);

            switch (logEvent)
            {
                case LogEvent.Warning:
                    AddLogEvent(_lastWarningLogEntries, logEntry, MaximumNumberOfWarningLogEntries);
                    break;

                case LogEvent.Error:
                    AddLogEvent(_lastErrorLogEntries, logEntry, MaximumNumberOfErrorLogEntries);
                    break;
            }
        }

 protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
 {
     if (string.Equals(log.Tag, "Orc.CommandLine.CommandLineParser"))
     {
         return;
     }
     if (logEvent == LogEvent.Error)
     {
         Console.ForegroundColor = ConsoleColor.Red;
     }
     else if (logEvent == LogEvent.Warning)
     {
         Console.ForegroundColor = ConsoleColor.Yellow;
     }
     else
     {
         Console.ForegroundColor = ConsoleColor.White;
     }
     Console.WriteLine("{0}", message);
 }

        /// <summary>
        /// Called when any message is written to the log.
        /// </summary>
        /// <param name="log">The log.</param>
        /// <param name="message">The message.</param>
        /// <param name="logEvent">The log event.</param>
        /// <param name="extraData">The additional data.</param>
        /// <param name="logData">The log data.</param>
        /// <param name="time">The time.</param>
        protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
        {
            string consoleMessage = FormatLogEvent(log, message, logEvent, extraData, time);

#if NET
            var oldConsoleBackgroundColor = Console.BackgroundColor;
            var oldConsoleForegroundColor = Console.ForegroundColor;

            UpdateConsoleColors(logEvent);
#endif

#if NETFX_CORE || PCL
            System.Diagnostics.Debug.WriteLine(consoleMessage);
#else
            Console.WriteLine(consoleMessage);
#endif

#if NET
            Console.BackgroundColor = oldConsoleBackgroundColor;
            Console.ForegroundColor = oldConsoleForegroundColor;
#endif
        }