Exemplo n.º 1
0
        private void _job1Button_Click(object sender, EventArgs e)
        {
            var textWriter = new TextBoxWriter(textBox1);
            var logger     = new MulticastLogger(
                new TextWriterLogger(textWriter),
                new ConsoleLogger()
                );

            var job1 =
                JobBuilder.For(() => logger.Info("Executed Job 1"))
                .Called("Job1")
                .RunOnce(DateTime.Now)
                .RunAsyncronously()
                .Repeat
                .OnInterval(TimeSpan.FromSeconds(1))
                .Build();

            var job2 =
                JobBuilder.For(() => logger.Info("Executed Job 2"))
                .Called("Job2")
                .RunOnce(DateTime.Now)
                .RunAsyncronously()
                .Repeat
                .OnInterval(TimeSpan.FromSeconds(2))
                .Build();

            Sphere10.Framework.Scheduler.Scheduler.Global.JobStatusChanged +=
                (job, fromStatus, toStatus) => textWriter.WriteLine("{0}: {1} -> {2}", job.Name, fromStatus, toStatus);
            Sphere10.Framework.Scheduler.Scheduler.Global.AddJob(job1);
            Sphere10.Framework.Scheduler.Scheduler.Global.AddJob(job2);
        }
Exemplo n.º 2
0
        public void ShouldFormatWithException()
        {
            DateTime                dateTime;
            MulticastLogger         logger;
            MockedMulticastReceiver receiver;

            receiver = new MockedMulticastReceiver(IPAddress.Parse("224.0.0.1"), 2023);

            logger = new MulticastLogger(IPAddress.Parse("224.0.0.1"), 2023);

            dateTime = DateTime.Now;
            logger.Log(1, "Component", "Method", new Exception("Message1"));
            receiver.ReceivedEvent.WaitOne();
            Assert.AreEqual(1, receiver.Logs.Count);
            Assert.AreEqual("Message1", receiver.Logs[0].Message);

            dateTime = DateTime.Now;
            logger.Log(1, "Component", "Method", new Exception("Message2"));
            receiver.ReceivedEvent.WaitOne();
            Assert.AreEqual(2, receiver.Logs.Count);
            Assert.AreEqual("Message2", receiver.Logs[1].Message);


            logger.Dispose();
            receiver.Dispose();
        }
Exemplo n.º 3
0
        public void ShouldFormatWithNullInput()
        {
            DateTime                dateTime;
            MulticastLogger         logger;
            MockedMulticastReceiver receiver;

            receiver = new MockedMulticastReceiver(IPAddress.Parse("224.0.0.1"), 2022);

            logger = new MulticastLogger(IPAddress.Parse("224.0.0.1"), 2022);

            dateTime = DateTime.Now;
            logger.Log(1, null, null, LogLevels.Debug, null);
            receiver.ReceivedEvent.WaitOne();
            Assert.AreEqual(1, receiver.Logs.Count);
            Assert.AreEqual(null, receiver.Logs[0].Message);

            dateTime = DateTime.Now;
            logger.Log(1, null, null, LogLevels.Debug, null);
            receiver.ReceivedEvent.WaitOne();
            Assert.AreEqual(2, receiver.Logs.Count);
            Assert.AreEqual(null, receiver.Logs[1].Message);

            logger.Dispose();
            receiver.Dispose();
        }
Exemplo n.º 4
0
        public void ShouldFormatWithValidInput()
        {
            DateTime                dateTime;
            MulticastLogger         logger;
            MockedMulticastReceiver receiver;

            receiver = new MockedMulticastReceiver(IPAddress.Parse("224.0.0.1"), 2021);

            logger = new MulticastLogger(IPAddress.Parse("224.0.0.1"), 2021);

            dateTime = DateTime.Now;
            logger.Log(1, "Component", "Method", LogLevels.Debug, "Message0");
            receiver.ReceivedEvent.WaitOne();
            Assert.AreEqual(1, receiver.Logs.Count);
            Assert.AreEqual("Message0", receiver.Logs[0].Message);

            dateTime = DateTime.Now;
            logger.Log(1, "Component", "Method", LogLevels.Debug, "Message1");
            receiver.ReceivedEvent.WaitOne();
            Assert.AreEqual(2, receiver.Logs.Count);
            Assert.AreEqual("Message1", receiver.Logs[1].Message);

            dateTime = DateTime.Now;
            logger.Log(new Log(dateTime, 1, "Component", "Method", LogLevels.Debug, "Message2"));
            receiver.ReceivedEvent.WaitOne();
            Assert.AreEqual(3, receiver.Logs.Count);
            Assert.AreEqual("Message2", receiver.Logs[2].Message);

            logger.Dispose();
            receiver.Dispose();
        }
Exemplo n.º 5
0
        public void ShouldFormatWithValidInputWhenNoReceiverIsRunning()
        {
            DateTime        dateTime;
            MulticastLogger logger;

            logger = new MulticastLogger(IPAddress.Parse("224.0.0.1"), 2020);

            dateTime = DateTime.Now;
            logger.Log(1, "Component", "Method", LogLevels.Debug, "Message");

            logger.Dispose();
        }
        public void passes_test_run_dir_to_other_loggers_with_parameters()
        {
            var logger = new MulticastLogger();
            const string runDir = "c:\\TestRunDir";

            logger.Initialize(Substitute.For<TestLoggerEvents>(), new Dictionary<string, string>
            {
                {"logger1", "Test"},
                {MulticastLogger.Testrundirectory, runDir}
            });

            Assert.True(TestLogger.Parameters.ContainsKey(MulticastLogger.Testrundirectory));
            Assert.Equal(runDir, TestLogger.Parameters[MulticastLogger.Testrundirectory]);
        }
        public void passes_test_run_dir_to_other_loggers_with_parameters()
        {
            var          logger = new MulticastLogger();
            const string runDir = "c:\\TestRunDir";

            logger.Initialize(Substitute.For <TestLoggerEvents>(), new Dictionary <string, string>
            {
                { "logger1", "Test" },
                { MulticastLogger.Testrundirectory, runDir }
            });

            Assert.True(TestLogger.Parameters.ContainsKey(MulticastLogger.Testrundirectory));
            Assert.Equal(runDir, TestLogger.Parameters[MulticastLogger.Testrundirectory]);
        }
        public void parses_alternate_syntax_parameters_correctly()
        {
            var logger = new MulticastLogger();

            const string someParameter = "some parameter";
            const string differentLoggerParameter = "different logger parameter";
            logger.Initialize(Substitute.For<TestLoggerEvents>(), new Dictionary<string, string>
            {
                {"loggers", "Test,Test2"},
                {"Test.parameter", someParameter},
                {"Test2.parameter", differentLoggerParameter},
                {MulticastLogger.Testrundirectory, "c:\\TestRunDir"}
            });

            Assert.Equal(someParameter, TestLogger.Parameters["parameter"]);
            Assert.Equal(differentLoggerParameter, Test2Logger.Parameters["parameter"]);
        }
        public void parses_alternate_syntax_parameters_correctly()
        {
            var logger = new MulticastLogger();

            const string someParameter            = "some parameter";
            const string differentLoggerParameter = "different logger parameter";

            logger.Initialize(Substitute.For <TestLoggerEvents>(), new Dictionary <string, string>
            {
                { "loggers", "Test,Test2" },
                { "Test.parameter", someParameter },
                { "Test2.parameter", differentLoggerParameter },
                { MulticastLogger.Testrundirectory, "c:\\TestRunDir" }
            });

            Assert.Equal(someParameter, TestLogger.Parameters["parameter"]);
            Assert.Equal(differentLoggerParameter, Test2Logger.Parameters["parameter"]);
        }
Exemplo n.º 10
0
        /// <summary>
        ///     Returns a logger in accordance with the specified settings.</summary>
        /// <param name="console">
        ///     If <c>true</c>, the resulting logger will log to the console.</param>
        /// <param name="file">
        ///     If non-<c>null</c>, the resulting logger will log to the specified file.</param>
        /// <param name="logVerbosity">
        ///     Configures the verbosity of the resulting logger.</param>
        /// <remarks>
        ///     <para>
        ///         Uses <see cref="ConsoleLogger"/> amd <see cref="FileAppendLogger"/> as appropriate.</para>
        ///     <para>
        ///         If both logging mechanisms are specified, uses a <see cref="MulticastLogger"/> to combine the two.</para></remarks>
        public static LoggerBase GetLogger(bool console, string file, string logVerbosity)
        {
            if (!console && file == null)
            {
                return(new NullLogger());
            }

            ConsoleLogger consoleLogger = null;

            if (console)
            {
                consoleLogger = new ConsoleLogger();
                consoleLogger.ConfigureVerbosity(logVerbosity);
                if (file == null)
                {
                    return(consoleLogger);
                }
            }

            FileAppendLogger fileLogger = null;

            if (file != null)
            {
                fileLogger = new FileAppendLogger(file)
                {
                    SharingVioWait = TimeSpan.FromSeconds(2)
                };
                fileLogger.ConfigureVerbosity(logVerbosity);
                if (!console)
                {
                    return(fileLogger);
                }
            }

            var logger = new MulticastLogger();

            logger.Loggers["file"]    = fileLogger;
            logger.Loggers["console"] = consoleLogger;
            logger.ConfigureVerbosity(logVerbosity);
            return(logger);
        }
Exemplo n.º 11
0
 public ITestLogger BeginTest(IConeTest test)
 {
     var log = new MulticastLogger();
     children.ForEach(x => log.Add(x.BeginTest(test)));
     return log;
 }
Exemplo n.º 12
0
        /// <summary>
        /// Example how to multicast logs to several destinations (File, Console, Debug log,...)
        /// </summary>
        public static void MulticastLogExample()
        {
            var cLogger = new MulticastLogger(new ConsoleLogger(), new DebugLogger());

            cLogger.Log("Something went wrong!", LogSeverity.Warning);
        }