コード例 #1
0
        public void PathCatcherTests()
        {
            var logger = DefaultActivityLogger.Create();

            // Binds the TestHelper.Logger logger to this one.
            logger.Output.RegisterMuxClient(TestHelper.Logger.Output.ExternalInput);

            ActivityLoggerPathCatcher p = new ActivityLoggerPathCatcher();

            logger.Output.RegisterMuxClient(p);

            logger.Trace("Trace n°1");
            Assert.That(p.DynamicPath.Select(e => e.Level.ToString() + '|' + e.Text).Single(), Is.EqualTo("Trace|Trace n°1"));
            Assert.That(p.LastErrorPath, Is.Null);
            Assert.That(p.LastWarnOrErrorPath, Is.Null);

            logger.Trace("Trace n°2");
            Assert.That(p.DynamicPath.Select(e => e.Level.ToString() + '|' + e.Text).Single(), Is.EqualTo("Trace|Trace n°2"));
            Assert.That(p.LastErrorPath, Is.Null);
            Assert.That(p.LastWarnOrErrorPath, Is.Null);

            logger.Warn("W1");
            Assert.That(p.DynamicPath.Select(e => e.Level.ToString() + '|' + e.Text).Single(), Is.EqualTo("Warn|W1"));
            Assert.That(p.LastErrorPath, Is.Null);
            Assert.That(p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text).Single(), Is.EqualTo("Warn|W1"));

            logger.Error("E2");
            logger.Warn("W1bis");
            Assert.That(p.DynamicPath.Select(e => e.Level.ToString() + '|' + e.Text).Single(), Is.EqualTo("Warn|W1bis"));
            Assert.That(p.LastErrorPath.Select(e => e.Level.ToString() + '|' + e.Text).Single(), Is.EqualTo("Error|E2"));
            Assert.That(p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text).Single(), Is.EqualTo("Warn|W1bis"));

            p.ClearLastWarnPath();
            Assert.That(p.LastErrorPath, Is.Not.Null);
            Assert.That(p.LastWarnOrErrorPath, Is.Null);

            p.ClearLastErrorPath();
            Assert.That(p.LastErrorPath, Is.Null);

            using (logger.OpenGroup(LogLevel.Trace, "G1"))
            {
                using (logger.OpenGroup(LogLevel.Info, "G2"))
                {
                    Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("G1>G2"));
                    Assert.That(p.LastErrorPath, Is.Null);
                    using (logger.OpenGroup(LogLevel.Trace, "G3"))
                    {
                        using (logger.OpenGroup(LogLevel.Info, "G4"))
                        {
                            logger.Warn("W1");

                            Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("G1>G2>G3>G4>W1"));

                            logger.Info(
                                new Exception("An exception logged as an Info.",
                                              new Exception("With an inner exception. Since these exceptions have not been thrown, there is no stack trace.")),
                                "Test With an exception: a Group is created. Since the text of the log is given, the Exception.Message must be displayed explicitely.");

                            Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("G1>G2>G3>G4>Test With an exception: a Group is created. Since the text of the log is given, the Exception.Message must be displayed explicitely."));

                            try
                            {
                                try
                                {
                                    try
                                    {
                                        try
                                        {
                                            throw new Exception("Deepest excpetion.");
                                        }
                                        catch (Exception ex)
                                        {
                                            throw new Exception("Yet another inner with inner Exception.", ex);
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        throw new Exception("Exception with inner Exception.", ex);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    throw new Exception("Log without log text: the text of the entry is the Exception.Message.", ex);
                                }
                            }
                            catch (Exception ex)
                            {
                                logger.Trace(ex);
                            }

                            Assert.That(p.LastErrorPath, Is.Null);
                            Assert.That(String.Join(">", p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Info|G2>Trace|G3>Info|G4>Warn|W1"));
                        }
                        Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("G1>G2>G3>G4"));
                        Assert.That(p.LastErrorPath, Is.Null);
                        Assert.That(String.Join(">", p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Info|G2>Trace|G3>Info|G4>Warn|W1"));

                        logger.Error("E1");
                        Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("G1>G2>G3>E1"));
                        Assert.That(String.Join(">", p.LastErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Info|G2>Trace|G3>Error|E1"));
                        Assert.That(String.Join(">", p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Info|G2>Trace|G3>Error|E1"));
                    }
                    Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("G1>G2>G3"));
                    Assert.That(String.Join(">", p.LastErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Info|G2>Trace|G3>Error|E1"));
                    Assert.That(String.Join(">", p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Info|G2>Trace|G3>Error|E1"));
                }
                Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("G1>G2"));
                using (logger.OpenGroup(LogLevel.Trace, "G2Bis"))
                {
                    Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("G1>G2Bis"));
                    Assert.That(String.Join(">", p.LastErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Info|G2>Trace|G3>Error|E1"));
                    Assert.That(String.Join(">", p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Info|G2>Trace|G3>Error|E1"));

                    logger.Warn("W2");
                    Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("G1>G2Bis>W2"));
                    Assert.That(String.Join(">", p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Trace|G2Bis>Warn|W2"));
                    Assert.That(String.Join(">", p.LastErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Info|G2>Trace|G3>Error|E1"));
                }
                logger.Fatal("F1");
                Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("G1>F1"));
                Assert.That(String.Join(">", p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Fatal|F1"));
                Assert.That(String.Join(">", p.LastErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Fatal|F1"));
            }

            // Extraneous closing are ignored.
            logger.CloseGroup(null);

            logger.Warn("W3");
            Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("W3"));
            Assert.That(String.Join(">", p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Warn|W3"));
            Assert.That(String.Join(">", p.LastErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Fatal|F1"));

            // Extraneous closing are ignored.
            logger.CloseGroup(null);

            logger.Warn("W4");
            Assert.That(String.Join(">", p.DynamicPath.Select(e => e.Text)), Is.EqualTo("W4"));
            Assert.That(String.Join(">", p.LastWarnOrErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Warn|W4"));
            Assert.That(String.Join(">", p.LastErrorPath.Select(e => e.Level.ToString() + '|' + e.Text)), Is.EqualTo("Trace|G1>Fatal|F1"));

            p.ClearLastWarnPath(true);
            Assert.That(p.LastErrorPath, Is.Null);
            Assert.That(p.LastWarnOrErrorPath, Is.Null);
        }