public static void FlushTests()
 {
     var factory = new LogFactory();
     factory.Flush();
     factory.Flush(100);
     factory.Flush(TimeSpan.FromSeconds(1));
 }

 public static void EnableDisableLogging()
 {
     var factory = new LogFactory();
     factory.DisableLogging();
     factory.EnableLogging();
     factory.IsLoggingEnabled();
 }

 public SessionFactory(Application app, MessageStoreFactory storeFactory, LogFactory logFactory, IMessageFactory messageFactory)
 {
     application_ = app;
     messageStoreFactory_ = storeFactory;
     logFactory_ = logFactory;
     messageFactory_ = messageFactory ?? new DefaultMessageFactory();
 }

 public SocketInitiator(Application application, MessageStoreFactory storeFactory, SessionSettings settings, LogFactory logFactory)
     : base(application, storeFactory, settings, logFactory)
 {
     app_ = application;
     storeFactory_ = storeFactory;
     settings_ = settings;
     logFactory_ = logFactory;
 }

        public void Configuration_PrivateBinPathIsNull_DoesNotThrowWhen()
        {
            AppDomainHelper.PrivateBinPath = () => null;
            var fakeFileSystem = A.Fake<IFileSystem>();
            var factory = new LogFactory(fakeFileSystem);

            var loggingConfiguration = factory.Configuration;
        }

        public void GenericGetCurrentClassLoggerTest()
        {
            LogFactory<MyLogger> lf = new LogFactory<MyLogger>();

            MyLogger l1 = lf.GetCurrentClassLogger();
            MyLogger l2 = lf.GetCurrentClassLogger();

            Assert.Same(l1, l2);
            Assert.Equal("NLog.UnitTests.GetLoggerTests", l1.Name);
        }

        public void Configuration_PrivateBinPathIsNull_DoesNotThrow()
        {
            var fakeAppDomain = A.Fake<IAppDomain>();
            A.CallTo(() => fakeAppDomain.PrivateBinPath).Returns(null);
            LogFactory.CurrentAppDomain = fakeAppDomain;

            var fakeFileSystem = A.Fake<IFileSystem>();
            var factory = new LogFactory(fakeFileSystem);

            var dummy = factory.Configuration;
        }

        public void Configuration_WithPrivateBinPath_CheckIfConfigFileExistsInPrivateBinPath()
        {
            const string AnyDirectory = "C:\\any\\";
            AppDomainHelper.PrivateBinPath = () => AnyDirectory;
            var fakeFileSystem = A.Fake<IFileSystem>();
            var factory = new LogFactory(fakeFileSystem);

            var loggingConfiguration = factory.Configuration;

            A.CallTo(() => fakeFileSystem.File.Exists(Path.Combine(AnyDirectory, "NLog.config"))).MustHaveHappened();
        }

 public void EnableAndDisableLogging()
 {
     LogFactory factory = new LogFactory();
     #pragma warning disable 618
     // In order Suspend => Resume
     Assert.True(factory.IsLoggingEnabled());
     factory.DisableLogging();
     Assert.False(factory.IsLoggingEnabled());
     factory.EnableLogging();
     Assert.True(factory.IsLoggingEnabled());
     #pragma warning restore 618
 }

        public Session(
            Application app, MessageStoreFactory storeFactory, SessionID sessID, DataDictionaryProvider dataDictProvider,
            SessionSchedule sessionSchedule, int heartBtInt, LogFactory logFactory, IMessageFactory msgFactory, string senderDefaultApplVerID)
        {
            this.Application = app;
            this.SessionID = sessID;
            this.DataDictionaryProvider = new DataDictionaryProvider(dataDictProvider);
            this.schedule_ = sessionSchedule;
            this.msgFactory_ = msgFactory;

            this.SenderDefaultApplVerID = senderDefaultApplVerID;

            this.SessionDataDictionary = this.DataDictionaryProvider.GetSessionDataDictionary(this.SessionID.BeginString);
            if (this.SessionID.IsFIXT)
                this.ApplicationDataDictionary = this.DataDictionaryProvider.GetApplicationDataDictionary(this.SenderDefaultApplVerID);
            else
                this.ApplicationDataDictionary = this.SessionDataDictionary;

            Log log;
            if (null != logFactory)
                log = logFactory.Create(sessID);
            else
                log = new NullLog();

            state_ = new SessionState(log, heartBtInt)
            {
                MessageStore = storeFactory.Create(sessID)
            };

            this.PersistMessages = true;
            this.ResetOnDisconnect = false;
            this.SendRedundantResendRequests = false;
            this.ValidateLengthAndChecksum = true;
            this.CheckCompID = true;
            this.MillisecondsInTimeStamp = true;
            this.EnableLastMsgSeqNumProcessed = false;
            this.MaxMessagesInResendRequest = 0;
            this.SendLogoutBeforeTimeoutDisconnect = false;
            this.IgnorePossDupResendRequests = false;

            if (!IsSessionTime)
                Reset("Out of SessionTime at construction");
            else if (IsNewSession)
                Reset("New session");

            lock (sessions_)
            {
                sessions_[this.SessionID] = this;
            }

            this.Application.OnCreate(this.SessionID);
            this.Log.OnEvent("Created session");
        }

        public void Configuration_WithPrivateBinPath_CheckIfConfigFileExistsInPrivateBinPath()
        {
            const string AnyDirectory = "C:\\any\\";
            var fakeAppDomain = A.Fake<IAppDomain>();
            A.CallTo(() => fakeAppDomain.PrivateBinPath).Returns(new[] { AnyDirectory });
            LogFactory.CurrentAppDomain = fakeAppDomain;

            var fakeFileSystem = A.Fake<IFileSystem>();
            var factory = new LogFactory(fakeFileSystem);

            var dummy = factory.Configuration;

            A.CallTo(() => fakeFileSystem.File.Exists(Path.Combine(AnyDirectory, "NLog.config"))).MustHaveHappened();
        }

        public void GenericGetLoggerTest()
        {
            LogFactory<MyLogger> lf = new LogFactory<MyLogger>();

            MyLogger l1 = lf.GetLogger("AAA");
            MyLogger l2 = lf.GetLogger("AAA");
            MyLogger l3 = lf.GetLogger("BBB");

            Assert.Same(l1, l2);
            Assert.NotSame(l1, l3);

            Assert.Equal("AAA", l1.Name);
            Assert.Equal("BBB", l3.Name);
        }

        internal static void Write(Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
        {
            if (targets == null)
            {
                return;
            }

#if !NET_CF
            StackTraceUsage stu = targets.GetStackTraceUsage();

            if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
            {
                StackTrace stackTrace;
#if !SILVERLIGHT
                stackTrace = new StackTrace(StackTraceSkipMethods, stu == StackTraceUsage.WithSource);
#else
                stackTrace = new StackTrace();
#endif

                int firstUserFrame = FindCallingMethodOnStackTrace(stackTrace, loggerType);

                logEvent.SetStackTrace(stackTrace, firstUserFrame);
            }
#endif

            int originalThreadId = Thread.CurrentThread.ManagedThreadId;
            AsyncContinuation exceptionHandler = ex =>
                {
                    if (ex != null)
                    {
                        if (factory.ThrowExceptions && Thread.CurrentThread.ManagedThreadId == originalThreadId)
                        {
                            throw new NLogRuntimeException("Exception occurred in NLog", ex);
                        }
                    }
                };

            for (var t = targets; t != null; t = t.NextInChain)
            {
                if (!WriteToTargetWithFilterChain(t, logEvent, exceptionHandler))
                {
                    break;
                }
            }
        }

        /// FIXME
        public Session(
            Application app, MessageStoreFactory storeFactory, SessionID sessID, DataDictionaryProvider dataDictProvider,
            SessionSchedule sessionSchedule, int heartBtInt, LogFactory logFactory, IMessageFactory msgFactory)
        {
            this.Application = app;
            this.SessionID = sessID;
            this.DataDictionaryProvider = new DataDictionaryProvider(dataDictProvider);
            this.schedule_ = sessionSchedule;
            this.msgFactory_ = msgFactory;

            this.SessionDataDictionary = this.DataDictionaryProvider.GetSessionDataDictionary(this.SessionID.BeginString);
            if (this.SessionID.IsFIXT)
                this.ApplicationDataDictionary = this.DataDictionaryProvider.GetApplicationDataDictionary(this.SenderDefaultApplVerID);
            else
                this.ApplicationDataDictionary = this.SessionDataDictionary;

            Log log;
            if (null != logFactory)
                log = logFactory.Create(sessID);
            else
                log = new NullLog();

            state_ = new SessionState(log, heartBtInt);
            state_.MessageStore = storeFactory.Create(sessID);

            this.PersistMessages = true;
            this.ResetOnDisconnect = false;
            this.SendRedundantResendRequests = false;
            this.ValidateLengthAndChecksum = true;
            this.CheckCompID = true;

            if (!CheckSessionTime())
                Reset();

            lock (sessions_)
            {
                sessions_[this.SessionID] = this;
            }

            this.Application.OnCreate(this.SessionID);
            this.Log.OnEvent("Created session");
        }

        public void TypedGetLoggerTest()
        {
            LogFactory lf = new LogFactory();

            MyLogger l1 = (MyLogger)lf.GetLogger("AAA", typeof(MyLogger));
            MyLogger l2 = (MyLogger)lf.GetLogger("AAA", typeof(MyLogger));
            Logger l3 = lf.GetLogger("AAA", typeof(Logger));
            Logger l4 = lf.GetLogger("AAA", typeof(Logger));
            Logger l5 = lf.GetLogger("AAA");
            Logger l6 = lf.GetLogger("AAA");

            Assert.AreSame(l1, l2);
            Assert.AreSame(l3, l4);
            Assert.AreSame(l5, l6);
            Assert.AreSame(l3, l5);

            Assert.AreNotSame(l1, l3);

            Assert.AreEqual("AAA", l1.Name);
            Assert.AreEqual("AAA", l3.Name);
        }

        public void TypedGetCurrentClassLoggerTest()
        {
            LogFactory lf = new LogFactory();

            MyLogger l1 = (MyLogger)lf.GetCurrentClassLogger(typeof(MyLogger));
            MyLogger l2 = (MyLogger)lf.GetCurrentClassLogger(typeof(MyLogger));
            Logger l3 = lf.GetCurrentClassLogger(typeof(Logger));
            Logger l4 = lf.GetCurrentClassLogger(typeof(Logger));
            Logger l5 = lf.GetCurrentClassLogger();
            Logger l6 = lf.GetCurrentClassLogger();

            Assert.AreSame(l1, l2);
            Assert.AreSame(l3, l4);
            Assert.AreSame(l5, l6);
            Assert.AreSame(l3, l5);

            Assert.AreNotSame(l1, l3);

            Assert.AreEqual("NLog.UnitTests.GetLoggerTests", l1.Name);
            Assert.AreEqual("NLog.UnitTests.GetLoggerTests", l3.Name);
        }

        public AbstractInitiator(Application app, MessageStoreFactory storeFactory, SessionSettings settings, LogFactory logFactory, IMessageFactory messageFactory)
        {
            settings_ = settings;

            HashSet<SessionID> definedSessions = settings.GetSessions();
            if (0 == definedSessions.Count)
                throw new ConfigError("No sessions defined");

            SessionFactory factory = new SessionFactory(app, storeFactory, logFactory, messageFactory);
            foreach (SessionID sessionID in definedSessions)
            {
                Dictionary dict = settings.Get(sessionID);
                if ("initiator".Equals(dict.GetString(SessionSettings.CONNECTION_TYPE)))
                {
                    sessionIDs_.Add(sessionID);
                    sessions_[sessionID] = factory.Create(sessionID, dict);
                    SetDisconnected(sessionID);
                }
            }

            if (0 == sessions_.Count)
                throw new ConfigError("No sessions defined for initiator");
        }

        public void ReloadConfigOnTimer_DoesNotThrowConfigException_IfConfigReloadReturnsNull()
        {
            var loggingConfiguration = new ReloadNullConfiguration();
            LogManager.Configuration = loggingConfiguration;
            var logFactory = new LogFactory(loggingConfiguration);

            Assert.DoesNotThrow(() => logFactory.ReloadConfigOnTimer(loggingConfiguration));
        }

        public void ReloadConfigOnTimer_DoesNotThrowConfigException_IfConfigChangedInBetween()
        {
            var loggingConfiguration = new LoggingConfiguration();
            LogManager.Configuration = loggingConfiguration;
            var logFactory = new LogFactory(loggingConfiguration);
            var differentConfiguration = new LoggingConfiguration();

            Assert.DoesNotThrow(() => logFactory.ReloadConfigOnTimer(differentConfiguration));
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="LogReceiverForwardingService"/> class.
 /// </summary>
 /// <param name="logFactory">The log factory.</param>
 public LogReceiverForwardingService(LogFactory logFactory)
 {
     this.logFactory = logFactory;
 }