1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
// 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 WixInternal.MSTestSupport
{
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
public class WixAssert
{
public static void CompareLineByLine(string[] expectedLines, string[] actualLines)
{
var lineNumber = 0;
for (; lineNumber < expectedLines.Length && lineNumber < actualLines.Length; ++lineNumber)
{
StringEqual($"{lineNumber}: {expectedLines[lineNumber]}", $"{lineNumber}: {actualLines[lineNumber]}");
}
var additionalExpectedLines = expectedLines.Length > lineNumber ? String.Join(Environment.NewLine, expectedLines.Skip(lineNumber).Select((s, i) => $"{lineNumber + i}: {s}")) : $"Missing {actualLines.Length - lineNumber} lines";
var additionalActualLines = actualLines.Length > lineNumber ? String.Join(Environment.NewLine, actualLines.Skip(lineNumber).Select((s, i) => $"{lineNumber + i}: {s}")) : $"Missing {expectedLines.Length - lineNumber} lines";
Assert.AreEqual<object>(additionalExpectedLines, additionalActualLines, StringObjectEqualityComparer.InvariantCulture);
}
public static void CompareXml(XContainer xExpected, XContainer xActual)
{
var expecteds = ComparableElements(xExpected);
var actuals = ComparableElements(xActual);
CompareLineByLine(expecteds.OrderBy(s => s).ToArray(), actuals.OrderBy(s => s).ToArray());
}
public static void CompareXml(string expectedPath, string actualPath)
{
var expectedDoc = XDocument.Load(expectedPath, LoadOptions.PreserveWhitespace | LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);
var actualDoc = XDocument.Load(actualPath, LoadOptions.PreserveWhitespace | LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);
CompareXml(expectedDoc, actualDoc);
}
private static IEnumerable<string> ComparableElements(XContainer container)
{
return container.Descendants().Select(x => $"{x.Name.LocalName}:{String.Join(",", x.Attributes().OrderBy(a => a.Name.LocalName).Select(a => $"{a.Name.LocalName}={ComparableAttribute(a)}"))}");
}
private static string ComparableAttribute(XAttribute attribute)
{
switch (attribute.Name.LocalName)
{
case "SourceFile":
return "<SourceFile>";
default:
return attribute.Value;
}
}
public static void StringCollectionEmpty(IList<string> collection)
{
if (collection.Count > 0)
{
Assert.Fail($"The collection was expected to be empty, but instead was [{Environment.NewLine}\"{String.Join($"\", {Environment.NewLine}\"", collection)}\"{Environment.NewLine}]");
}
}
public static void StringEqual(string expected, string actual, bool ignoreCase = false)
{
WixStringEqualException.ThrowIfNotEqual(expected, actual, ignoreCase);
}
public static void NotStringEqual(string expected, string actual, bool ignoreCase = false)
{
var comparer = ignoreCase ? StringObjectEqualityComparer.InvariantCultureIgnoreCase : StringObjectEqualityComparer.InvariantCulture;
Assert.AreNotEqual(expected, actual, comparer);
}
public static T Single<T>(IEnumerable<T> collection)
{
return collection.Single();
}
public static T Single<T>(IEnumerable<T> collection, Func<T, bool> predicate)
{
return collection.Where(predicate).Single();
}
public static void All<T>(IEnumerable<T> collection, Func<T, bool> predicate)
{
Assert.IsTrue(collection.All(predicate));
}
public static void Any<T>(IEnumerable<T> collection, Func<T, bool> predicate)
{
Assert.IsTrue(collection.Any(predicate));
}
public static void NotEmpty<T>(IEnumerable<T> collection)
{
Assert.IsTrue(collection.Count() > 0);
}
public static void Empty<T>(IEnumerable<T> collection)
{
Assert.AreEqual(0, collection.Count());
}
public static void Empty<T>(IEnumerable<T> collection, Func<T, bool> predicate)
{
var results = collection.Where(predicate);
Assert.AreEqual(0, results.Count());
}
}
internal class StringObjectEqualityComparer : IEqualityComparer<object>
{
public static readonly StringObjectEqualityComparer InvariantCultureIgnoreCase = new StringObjectEqualityComparer(true);
public static readonly StringObjectEqualityComparer InvariantCulture = new StringObjectEqualityComparer(false);
private readonly StringComparer stringComparer;
public StringObjectEqualityComparer(bool ignoreCase)
{
this.stringComparer = ignoreCase ? StringComparer.InvariantCultureIgnoreCase : StringComparer.InvariantCulture;
}
public new bool Equals(object x, object y)
{
return this.stringComparer.Equals((string)x, (string)y);
}
public int GetHashCode(object obj)
{
return this.stringComparer.GetHashCode((string)obj);
}
}
public class WixStringEqualException : AssertFailedException
{
public WixStringEqualException(string userMessage) : base(userMessage) { }
public static void ThrowIfNotEqual(string expected, string actual, bool ignoreCase)
{
var comparer = ignoreCase ? StringObjectEqualityComparer.InvariantCultureIgnoreCase : StringObjectEqualityComparer.InvariantCulture;
if (comparer.Equals(expected, actual))
{
return;
}
var sbMessage = new StringBuilder();
try
{
Assert.AreEqual(expected, actual, ignoreCase);
}
catch (AssertFailedException xe)
{
// If either string is not completely in the message, then make sure it gets in there.
if (!xe.Message.Contains(expected) || !xe.Message.Contains(actual))
{
sbMessage.AppendLine(xe.Message);
sbMessage.AppendLine();
sbMessage.AppendFormat("Expected: {0}", expected);
sbMessage.AppendLine();
sbMessage.AppendFormat("Actual: {0}", actual);
}
else
{
throw;
}
}
throw new WixStringEqualException(sbMessage.ToString());
}
}
}
|
