1 files changed, 252 insertions, 0 deletions
diff --git a/src/test/burn/WixTestTools/LogVerifier.cs b/src/test/burn/WixTestTools/LogVerifier.cs
new file mode 100644
index 00000000..0252a9f9
--- /dev/null
+++ b/src/test/burn/WixTestTools/LogVerifier.cs
@@ -0,0 +1,252 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+namespace WixTestTools
+{
+    using System;
+    using System.IO;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using Xunit;
+    /// <summary>
+    /// The LogVerifier can verify a log file for given regular expressions.
+    /// </summary>
+    public class LogVerifier
+    {
+        // Member Variables
+        private string logFile;
+        /// <summary>
+        /// Prevent creation of LogVerifier without log file
+        /// </summary>
+        private LogVerifier()
+        { }
+        /// <summary>
+        /// Constructor for log files where the exact file name is known.
+        /// </summary>
+        /// <param name="fileName">The full path to the log file</param>
+        public LogVerifier(string fileName)
+        {
+            if (null == fileName)
+                throw new ArgumentNullException("fileName");
+            if (!File.Exists(fileName))
+                throw new ArgumentException(String.Format(@"File doesn't exist:{0}", fileName), "fileName");
+            logFile = fileName;
+        }
+        /// <summary>
+        /// Constructor for log files where the exact file name is known.
+        /// </summary>
+        /// <param name="directory">The directory in which the log file is located.</param>
+        /// <param name="fileName">The name of the log file.</param>
+        public LogVerifier(string directory, string fileName)
+            : this(Path.Combine(directory, fileName))
+        { }
+        /// <summary>
+        /// Scans a log file line by line until the regex pattern is matched or eof is reached.
+        /// This method would be used in the case where the log file is very large, the regex doesn't
+        /// span multiple lines, and only one match is required.
+        /// </summary>
+        /// <param name="regex">A regular expression</param>
+        /// <returns>True if a match is found, False otherwise.</returns>
+        public bool LineByLine(Regex regex)
+        {
+            string line = string.Empty;
+            StreamReader sr = new StreamReader(logFile);
+            // Read from a file stream line by line.
+            while ((line = sr.ReadLine()) != null)
+            {
+                if (regex.Match(line).Success)
+                {
+                    sr.Close();
+                    sr.Dispose();
+                    return true;
+                }
+            }
+            return false;
+        }
+        /// <summary>
+        /// Scans a log file line by line until the regex pattern is matched or eof is reached.
+        /// This method would be used in the case where the log file is very large, the regex doesn't
+        /// span multiple lines, and only one match is required.
+        /// No RegexOptions are used and matches are case sensitive.
+        /// </summary>
+        /// <param name="regex">A regular expression string.</param>
+        /// <returns>True if a match is found, False otherwise.</returns>
+        public bool LineByLine(string regex)
+        {
+            return LineByLine(new Regex(regex));
+        }
+        /// <summary>
+        /// Scans a log file for matches to the regex.
+        /// </summary>
+        /// <param name="regex">A regular expression</param>
+        /// <returns>The number of matches</returns>
+        public int EntireFileAtOnce(Regex regex)
+        {
+            string logFileText = this.ReadLogFile();
+            return regex.Matches(logFileText).Count;
+        }
+        /// <summary>
+        /// Scans a log file for matches to the regex.
+        /// </summary>
+        /// <param name="regex">A regular expression</param>
+        /// <returns>The number of matches</returns>
+        public bool EntireFileAtOncestr(string regex)
+        {
+            string logFileText = this.ReadLogFile();
+            return logFileText.Contains(regex);
+        }
+        /// <summary>
+        /// Scans a log file for matches to the regex string.
+        /// Only the Multiline RegexOption is used and matches are case sensitive.
+        /// </summary>
+        /// <param name="regex">A regular expression</param>
+        /// <returns>The number of matches</returns>
+        public int EntireFileAtOnce(string regex)
+        {
+            return EntireFileAtOnce(new Regex(regex, RegexOptions.Multiline));
+        }
+        /// <summary>
+        /// Scans a log file for matches to the regex string.
+        /// </summary>
+        /// <param name="regex">A regular expression</param>
+        /// <param name="ignoreCase">Specify whether to perform case sensitive matches</param>
+        /// <returns>The number of matches</returns>
+        public int EntireFileAtOnce(string regex, bool ignoreCase)
+        {
+            if (!ignoreCase)
+                return EntireFileAtOnce(new Regex(regex, RegexOptions.Multiline));
+            else
+                return EntireFileAtOnce(new Regex(regex, RegexOptions.Multiline | RegexOptions.IgnoreCase));
+        }
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is not found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextInLog(string regex, bool ignoreCase)
+        {
+            Assert.True(EntireFileAtOncestr(regex),
+                String.Format("The log does not contain a match to the regular expression \"{0}\" ", regex));
+        }
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is not found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextInLog(Regex regex, bool ignoreCase)
+        {
+            Assert.True(EntireFileAtOnce(regex) >= 1,
+                String.Format("The log does not contain a match to the regular expression \"{0}\" ", regex.ToString()));
+        }
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is not found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextInLog(string regex)
+        {
+            AssertTextInLog(regex, true);
+        }
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is not found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextInLog(Regex regex)
+        {
+            AssertTextInLog(regex, true);
+        }
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is  found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextNotInLog(Regex regex, bool ignoreCase)
+        {
+            Assert.True(EntireFileAtOnce(regex) < 1,
+                String.Format("The log contain a match to the regular expression \"{0}\" ", regex.ToString()));
+        }
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is not found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextNotInLog(string regex, bool ignoreCase)
+        {
+            Assert.False(EntireFileAtOncestr(regex),
+                String.Format("The log does not contain a match to the regular expression \"{0}\" ", regex));
+        }
+        /// <summary>
+        /// Checks if a meesage is in a file
+        /// </summary>
+        /// <param name="logFileName">The full path to the log file</param>
+        /// <param name="message">Search expression</param>
+        /// <returns>True if the message was found, false otherwise</returns>
+        public static bool MessageInLogFile(string logFileName, string message)
+        {
+            LogVerifier logVerifier = new LogVerifier(logFileName);
+            return logVerifier.EntireFileAtOncestr(message);
+        }
+        /// <summary>
+        /// Checks if a meesage is in a file
+        /// </summary>
+        /// <param name="logFileName">The full path to the log file</param>
+        /// <param name="message">Search expression (regex)</param>
+        /// <returns>True if the message was found, false otherwise</returns>
+        public static bool MessageInLogFileRegex(string logFileName, string regexMessage)
+        {
+            LogVerifier logVerifier = new LogVerifier(logFileName);
+            return logVerifier.EntireFileAtOnce(regexMessage) > 0;
+        }
+        /// <summary>
+        /// Read in the entire log file at once.
+        /// </summary>
+        /// <returns>Contents of log file.</returns>
+        private string ReadLogFile()
+        {
+            // Retry a few times.
+            for (int retry = 0; ; ++retry)
+            {
+                try
+                {
+                    using (StreamReader sr = new StreamReader(this.logFile))
+                    {
+                        return sr.ReadToEnd();
+                    }
+                }
+                catch // we'll catch everything a few times until we give up.
+                {
+                    if (retry > 4)
+                    {
+                        throw;
+                    }
+                    System.Threading.Thread.Sleep(1000);
+                }
+            }
+        }
+    }
+}

diff --git a/src/test/burn/WixTestTools/LogVerifier.cs b/src/test/burn/WixTestTools/LogVerifier.cs new file mode 100644 index 00000000..0252a9f9 --- /dev/null +++ b/src/test/burn/WixTestTools/LogVerifier.cs
@@ -0,0 +1,252 @@
	1	// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
	2
	3	namespace WixTestTools
	4	{
	5	using System;
	6	using System.IO;
	7	using System.Text;
	8	using System.Text.RegularExpressions;
	9	using Xunit;
	10
	11	/// <summary>
	12	/// The LogVerifier can verify a log file for given regular expressions.
	13	/// </summary>
	14	public class LogVerifier
	15	{
	16	// Member Variables
	17	private string logFile;
	18
	19	/// <summary>
	20	/// Prevent creation of LogVerifier without log file
	21	/// </summary>
	22	private LogVerifier()
	23	{ }
	24
	25	/// <summary>
	26	/// Constructor for log files where the exact file name is known.
	27	/// </summary>
	28	/// <param name="fileName">The full path to the log file</param>
	29	public LogVerifier(string fileName)
	30	{
	31	if (null == fileName)
	32	throw new ArgumentNullException("fileName");
	33
	34	if (!File.Exists(fileName))
	35	throw new ArgumentException(String.Format(@"File doesn't exist:{0}", fileName), "fileName");
	36
	37	logFile = fileName;
	38	}
	39
	40	/// <summary>
	41	/// Constructor for log files where the exact file name is known.
	42	/// </summary>
	43	/// <param name="directory">The directory in which the log file is located.</param>
	44	/// <param name="fileName">The name of the log file.</param>
	45	public LogVerifier(string directory, string fileName)
	46	: this(Path.Combine(directory, fileName))
	47	{ }
	48
	49	/// <summary>
	50	/// Scans a log file line by line until the regex pattern is matched or eof is reached.
	51	/// This method would be used in the case where the log file is very large, the regex doesn't
	52	/// span multiple lines, and only one match is required.
	53	/// </summary>
	54	/// <param name="regex">A regular expression</param>
	55	/// <returns>True if a match is found, False otherwise.</returns>
	56	public bool LineByLine(Regex regex)
	57	{
	58	string line = string.Empty;
	59	StreamReader sr = new StreamReader(logFile);
	60
	61	// Read from a file stream line by line.
	62	while ((line = sr.ReadLine()) != null)
	63	{
	64	if (regex.Match(line).Success)
	65	{
	66	sr.Close();
	67	sr.Dispose();
	68	return true;
	69	}
	70	}
	71	return false;
	72	}
	73
	74
	75	/// <summary>
	76	/// Scans a log file line by line until the regex pattern is matched or eof is reached.
	77	/// This method would be used in the case where the log file is very large, the regex doesn't
	78	/// span multiple lines, and only one match is required.
	79	/// No RegexOptions are used and matches are case sensitive.
	80	/// </summary>
	81	/// <param name="regex">A regular expression string.</param>
	82	/// <returns>True if a match is found, False otherwise.</returns>
	83	public bool LineByLine(string regex)
	84	{
	85	return LineByLine(new Regex(regex));
	86	}
	87
	88
	89	/// <summary>
	90	/// Scans a log file for matches to the regex.
	91	/// </summary>
	92	/// <param name="regex">A regular expression</param>
	93	/// <returns>The number of matches</returns>
	94	public int EntireFileAtOnce(Regex regex)
	95	{
	96	string logFileText = this.ReadLogFile();
	97	return regex.Matches(logFileText).Count;
	98	}
	99
	100	/// <summary>
	101	/// Scans a log file for matches to the regex.
	102	/// </summary>
	103	/// <param name="regex">A regular expression</param>
	104	/// <returns>The number of matches</returns>
	105	public bool EntireFileAtOncestr(string regex)
	106	{
	107	string logFileText = this.ReadLogFile();
	108	return logFileText.Contains(regex);
	109	}
	110	/// <summary>
	111	/// Scans a log file for matches to the regex string.
	112	/// Only the Multiline RegexOption is used and matches are case sensitive.
	113	/// </summary>
	114	/// <param name="regex">A regular expression</param>
	115	/// <returns>The number of matches</returns>
	116	public int EntireFileAtOnce(string regex)
	117	{
	118	return EntireFileAtOnce(new Regex(regex, RegexOptions.Multiline));
	119	}
	120
	121	/// <summary>
	122	/// Scans a log file for matches to the regex string.
	123	/// </summary>
	124	/// <param name="regex">A regular expression</param>
	125	/// <param name="ignoreCase">Specify whether to perform case sensitive matches</param>
	126	/// <returns>The number of matches</returns>
	127	public int EntireFileAtOnce(string regex, bool ignoreCase)
	128	{
	129	if (!ignoreCase)
	130	return EntireFileAtOnce(new Regex(regex, RegexOptions.Multiline));
	131	else
	132	return EntireFileAtOnce(new Regex(regex, RegexOptions.Multiline \| RegexOptions.IgnoreCase));
	133	}
	134
	135	/// <summary>
	136	/// Search through the log and Assert.Fail() if a specified string is not found.
	137	/// </summary>
	138	/// <param name="regex">Search expression</param>
	139	/// <param name="ignoreCase">Perform case insensitive match</param>
	140	public void AssertTextInLog(string regex, bool ignoreCase)
	141	{
	142	Assert.True(EntireFileAtOncestr(regex),
	143	String.Format("The log does not contain a match to the regular expression \"{0}\" ", regex));
	144	}
	145
	146	/// <summary>
	147	/// Search through the log and Assert.Fail() if a specified string is not found.
	148	/// </summary>
	149	/// <param name="regex">Search expression</param>
	150	/// <param name="ignoreCase">Perform case insensitive match</param>
	151	public void AssertTextInLog(Regex regex, bool ignoreCase)
	152	{
	153	Assert.True(EntireFileAtOnce(regex) >= 1,
	154	String.Format("The log does not contain a match to the regular expression \"{0}\" ", regex.ToString()));
	155	}
	156
	157	/// <summary>
	158	/// Search through the log and Assert.Fail() if a specified string is not found.
	159	/// </summary>
	160	/// <param name="regex">Search expression</param>
	161	/// <param name="ignoreCase">Perform case insensitive match</param>
	162	public void AssertTextInLog(string regex)
	163	{
	164	AssertTextInLog(regex, true);
	165	}
	166
	167	/// <summary>
	168	/// Search through the log and Assert.Fail() if a specified string is not found.
	169	/// </summary>
	170	/// <param name="regex">Search expression</param>
	171	/// <param name="ignoreCase">Perform case insensitive match</param>
	172	public void AssertTextInLog(Regex regex)
	173	{
	174	AssertTextInLog(regex, true);
	175	}
	176
	177
	178	/// <summary>
	179	/// Search through the log and Assert.Fail() if a specified string is found.
	180	/// </summary>
	181	/// <param name="regex">Search expression</param>
	182	/// <param name="ignoreCase">Perform case insensitive match</param>
	183	public void AssertTextNotInLog(Regex regex, bool ignoreCase)
	184	{
	185	Assert.True(EntireFileAtOnce(regex) < 1,
	186	String.Format("The log contain a match to the regular expression \"{0}\" ", regex.ToString()));
	187	}
	188
	189	/// <summary>
	190	/// Search through the log and Assert.Fail() if a specified string is not found.
	191	/// </summary>
	192	/// <param name="regex">Search expression</param>
	193	/// <param name="ignoreCase">Perform case insensitive match</param>
	194	public void AssertTextNotInLog(string regex, bool ignoreCase)
	195	{
	196	Assert.False(EntireFileAtOncestr(regex),
	197	String.Format("The log does not contain a match to the regular expression \"{0}\" ", regex));
	198	}
	199
	200	/// <summary>
	201	/// Checks if a meesage is in a file
	202	/// </summary>
	203	/// <param name="logFileName">The full path to the log file</param>
	204	/// <param name="message">Search expression</param>
	205	/// <returns>True if the message was found, false otherwise</returns>
	206	public static bool MessageInLogFile(string logFileName, string message)
	207	{
	208	LogVerifier logVerifier = new LogVerifier(logFileName);
	209	return logVerifier.EntireFileAtOncestr(message);
	210	}
	211
	212	/// <summary>
	213	/// Checks if a meesage is in a file
	214	/// </summary>
	215	/// <param name="logFileName">The full path to the log file</param>
	216	/// <param name="message">Search expression (regex)</param>
	217	/// <returns>True if the message was found, false otherwise</returns>
	218	public static bool MessageInLogFileRegex(string logFileName, string regexMessage)
	219	{
	220	LogVerifier logVerifier = new LogVerifier(logFileName);
	221	return logVerifier.EntireFileAtOnce(regexMessage) > 0;
	222	}
	223
	224	/// <summary>
	225	/// Read in the entire log file at once.
	226	/// </summary>
	227	/// <returns>Contents of log file.</returns>
	228	private string ReadLogFile()
	229	{
	230	// Retry a few times.
	231	for (int retry = 0; ; ++retry)
	232	{
	233	try
	234	{
	235	using (StreamReader sr = new StreamReader(this.logFile))
	236	{
	237	return sr.ReadToEnd();
	238	}
	239	}
	240	catch // we'll catch everything a few times until we give up.
	241	{
	242	if (retry > 4)
	243	{
	244	throw;
	245	}
	246
	247	System.Threading.Thread.Sleep(1000);
	248	}
	249	}
	250	}
	251	}
	252	}