source: default/TinyLogViewer/trunk/TinyLogViewerTest/Sources/Parser/LogEntryParserTest.cs @ 1474

// ----------------------------------------------------------------------------
// <copyright company="F.C. Soft., Inc.">
//   Copyright(c) F.C. Soft., Inc.  All rights reserved.
// </copyright>
// <license>
//   Licensed to F.C. Soft., Inc. (FCSoft) under one or more contributor
//   license agreements.  See the NOTICE file distributed with this work for
//   additional information regarding copyright ownership.  FCSoft licenses
//   this file to You under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.  You
//   may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
// </license>
// ----------------------------------------------------------------------------
namespace FCSoft.TinyLogViewer.Parser
{
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.IO;
    using System.Text;
    using System.Text.RegularExpressions;
    using NUnit.Framework;


    /// <summary>
    /// <see cref="LogEntryParser"/> をテストするクラスです。
    /// </summary>
    [TestFixture]
    public class LogEntryParserTest
    {
        /// <summary>
        /// デフォルトで使用するログファイルのパス。
        /// </summary>
        private const string DefulatLogFilePath = "path.txt";


        /// <summary>
        /// インスタンスを作成します。
        /// </summary>
        public LogEntryParserTest()
        {
            // AVOID
        }


        /// <summary>
        /// ログエントリーの開始を検出ルテストです。
        /// </summary>
        [Test]
        public void TestStartDetection()
        {
            List<LogEntryInfo> logEntryInfos = new List<LogEntryInfo>();
            LogEntryParser parser
                = new LogEntryParser(
                    new Regex("^[^ ]+ [^:]+: [0-9]+ : ", RegexOptions.ExplicitCapture),
                    null,
                    delegate(LogEntry logEntry)
                    {
                        logEntryInfos.Add(new LogEntryInfo(logEntry));
                    });

            Execute(
                parser,
                @"FCosft.TinyLogViewer.Test Information: 101 : Message1.
    ProcessId=1001
    ThreadId=2
    DateTime=2020-01-23T10:20:30.1234567+09:00
FCosft.TinyLogViewer.Test Information: 102 : Message2.
FCosft.TinyLogViewer.Test Information: 103 : Message3.
XX yyy.
    ProcessId=1001
    ThreadId=2
    DateTime=2020-01-23T10:20:32.1234567+09:00
");

            Assert.That(
                logEntryInfos,
                Is.EqualTo(new[]
                {
                    new LogEntryInfo(
                        DefulatLogFilePath,
                        1,
                        4,
                        @"FCosft.TinyLogViewer.Test Information: 101 : Message1.
    ProcessId=1001
    ThreadId=2
    DateTime=2020-01-23T10:20:30.1234567+09:00
"),
                    new LogEntryInfo(
                        DefulatLogFilePath,
                        5,
                        1,
                        @"FCosft.TinyLogViewer.Test Information: 102 : Message2.
"),
                    new LogEntryInfo(
                        DefulatLogFilePath,
                        6,
                        5,
                        @"FCosft.TinyLogViewer.Test Information: 103 : Message3.
XX yyy.
    ProcessId=1001
    ThreadId=2
    DateTime=2020-01-23T10:20:32.1234567+09:00
"),
                }));
        }


        /// <summary>
        /// 文字列をパーサに供給します。
        /// </summary>
        /// <param name="parser">パーサ。</param>
        /// <param name="text">文字列。</param>
        private static void Execute(LogEntryParser parser, string text)
        {
            LogFile logFile = new LogFile(DefulatLogFilePath, 0x1000, Encoding.Unicode, Encoding.Unicode, 0x1000);

            using (StringReader reader = new StringReader(text))
            {
                long position = 0;
                int lineNumber = 1;
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    string value = line + "\r\n";
                    int byteCount = Encoding.Unicode.GetByteCount(value);

                    parser.FeedLine(
                        logFile,
                        position,
                        byteCount,
                        lineNumber,
                        LineEndType.CarriageReturnAndLineFeed,
                        value.ToCharArray(),
                        0,
                        value.Length);

                    position += byteCount;
                    lineNumber++;
                }
            }

            parser.Flush();
        }


        /// <summary>
        /// ログエントリーの情報を表すクラスです。
        /// </summary>
        [DebuggerDisplay(@"\{LineNumber = {lineNumber} LineCount = {lineCount}\}")]
        private sealed class LogEntryInfo :
            IEquatable<LogEntryInfo>
        {
            /// <summary>
            /// ファイルパス。
            /// </summary>
            private readonly string path;

            /// <summary>
            /// 行番号。
            /// </summary>
            private readonly long lineNumber;

            /// <summary>
            /// 行数。
            /// </summary>
            private readonly long lineCount;

            /// <summary>
            /// 値。
            /// </summary>
            private readonly string value;


            /// <summary>
            /// インスタンスを作成します。
            /// </summary>
            /// <param name="path">ファイルパス。</param>
            /// <param name="lineNumber">行番号。</param>
            /// <param name="lineCount">行数。</param>
            /// <param name="value">値。</param>
            internal LogEntryInfo(string path, long lineNumber, long lineCount, string value)
            {
                this.path = path;
                this.lineNumber = lineNumber;
                this.lineCount = lineCount;
                this.value = value;
            }

            /// <summary>
            /// インスタンスを作成します。
            /// </summary>
            /// <param name="logEntry">ログエントリー。</param>
            internal LogEntryInfo(LogEntry logEntry)
            {
                path = logEntry.FirstLogFile.Path;
                lineNumber = logEntry.FirstLineNumber;
                lineCount = logEntry.LineCount;
                value = logEntry.Value;
            }


            /// <summary>
            /// 等号演算子を実装します。
            /// </summary>
            /// <param name="o1">比較するオブジェクト 1。</param>
            /// <param name="o2">比較するオブジェクト 2。</param>
            /// <returns>
            /// <paramref name="o1"/> と <paramref name="o2"/>
            /// が等しい場合は <see langword="true"/>、それ以外の場合は <see langword="false"/>。
            /// </returns>
            public static bool operator ==(
                LogEntryInfo o1,
                LogEntryInfo o2)
            {
                return ReferenceEquals(o1, null) ? ReferenceEquals(o2, null) : o1.Equals(o2);
            }

            /// <summary>
            /// 不等号演算子を実装します。
            /// </summary>
            /// <param name="o1">比較するオブジェクト 1。</param>
            /// <param name="o2">比較するオブジェクト 2。</param>
            /// <returns>
            /// <paramref name="o1"/> と <paramref name="o2"/>
            /// が等しい場合は <see langword="true"/>、それ以外の場合は <see langword="false"/>。
            /// </returns>
            public static bool operator !=(
                LogEntryInfo o1,
                LogEntryInfo o2)
            {
                return !(o1 == o2);
            }


            /// <summary>
            /// 現在の <see cref="LogEntryInfo"/> を表す <see cref="string"/> を返します。
            /// </summary>
            /// <returns>
            /// 現在の <see cref="LogEntryInfo"/> を表す <see cref="string"/>。
            /// </returns>
            public override string ToString()
            {
                return @"LogEntryInfo{
  Path=" + path + @"
  LineNumber=" + lineNumber + @"
  LineCount=" + lineCount + @"
  Value=" + value + @"
}";
            }

            /// <summary>
            /// 特定の型のハッシュ関数として機能します。
            /// </summary>
            /// <returns>
            /// 現在の <see cref="LogEntryInfo"/> のハッシュ コード。
            /// </returns>
            public override int GetHashCode()
            {
                return (path != null ? path.GetHashCode() : -0x63928471)
                    ^ ~lineNumber.GetHashCode()
                    ^ lineCount.GetHashCode()
                    ^ (value != null ? value.GetHashCode() : 0x199F8DE3);
            }

            /// <summary>
            /// 指定した <see cref="LogEntryInfo"/> が、現在の <see cref="LogEntryInfo"/> と等しいかどうかを判断します。
            /// </summary>
            /// <param name="obj">現在の <see cref="LogEntryInfo"/> と比較する <see cref="LogEntryInfo"/>。</param>
            /// <returns>
            /// 指定した <see cref="LogEntryInfo"/> が現在の <see cref="LogEntryInfo"/> と等しい場合は <see langword="true"/>。
            /// それ以外の場合は <see langword="false"/>。
            /// </returns>
            public override bool Equals(object obj)
            {
                return Equals(obj as LogEntryInfo);
            }

            /// <summary>
            /// 現在のオブジェクトが、同じ型の別のオブジェクトと等しいかどうかを示します。
            /// </summary>
            /// <param name="other">このオブジェクトと比較するオブジェクト。</param>
            /// <returns>
            /// 現在のオブジェクトが <paramref name="other"/> パラメータと等しい場合は <see langword="true"/>。
            /// それ以外の場合は <see langword="false"/>。
            /// </returns>
            public bool Equals(LogEntryInfo other)
            {
                return !ReferenceEquals(other, null)
                    && Equals(path, other.path)
                    && lineNumber == other.lineNumber
                    && lineCount == other.lineCount
                    && Equals(value, other.value);
            }
        }
    }
}