public static TestName ReadTestName(XElement node)
{
if (!node.Name.LocalName.Equals("TestName"))
{
throw new InternalErrorException();
}
var builder = new TestNameBuilder();
var nameAttr = node.Attribute("Name");
if (nameAttr != null)
{
builder.PushName(nameAttr.Value);
}
foreach (var child in node.Elements("Parameter"))
{
var name = child.Attribute("Name").Value;
var value = child.Attribute("Value").Value;
var isHidden = bool.Parse(child.Attribute("IsHidden").Value);
builder.PushParameter(name, value, isHidden);
}
return(builder.GetName());
}
static InnerVerifier GetVerifier(string sourceFile, string method, VerifySettings?settings)
{
var methodInfo = TypeCache.GetInfo(sourceFile, method);
var parameters = settings.GetParameters(methodInfo);
var className = Path.GetFileNameWithoutExtension(sourceFile);
var name = TestNameBuilder.GetUniqueTestName(className, methodInfo, parameters);
return(new InnerVerifier(name, sourceFile));
}
public async Task Split(
bool hasExistingReceived,
bool autoVerify)
{
TypeToSplit initialTarget = new("info1", "value1", "value2");
TypeToSplit secondTarget = new("info2", "value1.1", "value2.1");
VerifySettings settings = new();
if (autoVerify)
{
settings.AutoVerify();
}
var uniqueTestName = TestNameBuilder.GetUniqueTestName(
"Tests_Split",
Info.OfMethod <Tests>("Split"),
new object[] { hasExistingReceived, autoVerify });
settings.UseParameters(hasExistingReceived, autoVerify);
var prefix = Path.Combine(SourceDirectory, $"{uniqueTestName}.");
var danglingFile = $"{prefix}03.verified.txt";
FilePair info = new("txt", $"{prefix}info");
FilePair file1 = new("txt", $"{prefix}00");
FilePair file2 = new("txt", $"{prefix}01");
DeleteAll(danglingFile, info.Received, info.Verified, file1.Verified, file1.Received, file2.Verified, file2.Received);
File.WriteAllText(danglingFile, "");
if (hasExistingReceived)
{
File.WriteAllText(info.Received, "");
File.WriteAllText(file1.Received, "");
File.WriteAllText(file2.Received, "");
}
await InitialVerifySplit(initialTarget, true, settings, info, file1, file2);
if (!autoVerify)
{
RunClipboardCommand();
}
AssertNotExists(danglingFile);
await ReVerifySplit(initialTarget, settings, info, file1, file2);
await InitialVerifySplit(secondTarget, true, settings, info, file1, file2);
if (!autoVerify)
{
RunClipboardCommand();
}
await ReVerifySplit(secondTarget, settings, info, file1, file2);
}
static DisposableVerifier BuildVerifier(string sourceFile)
{
Guard.AgainstNullOrEmpty(sourceFile, nameof(sourceFile));
var context = TestContext.CurrentContext;
var testAdapter = context.Test;
var test = (Test)field.GetValue(testAdapter);
var testType = test.TypeInfo.Type;
var uniqueTestName = TestNameBuilder.GetUniqueTestName(testType, test.Method.MethodInfo, testAdapter.Arguments);
return(new DisposableVerifier(testType, Path.GetDirectoryName(sourceFile), uniqueTestName));
}
static InnerVerifier BuildVerifier(string sourceFile)
{
Guard.AgainstNullOrEmpty(sourceFile, nameof(sourceFile));
var context = TestContext.CurrentContext;
var adapter = context.Test;
var test = (Test)field.GetValue(adapter) !;
var method = test.Method.MethodInfo;
var name = TestNameBuilder.GetUniqueTestName(Path.GetFileNameWithoutExtension(sourceFile), method, adapter.Arguments);
return(new InnerVerifier(name, sourceFile, test.TypeInfo.Assembly));
}
static InnerVerifier GetVerifier(string sourceFile, VerifySettings?settings)
{
var className = Path.GetFileNameWithoutExtension(sourceFile);
if (!UsesVerifyAttribute.TryGet(out var info))
{
throw new XunitException($"Expected to find a `[UsesVerify]` on `{className}`.");
}
var parameters = settings.GetParameters(info);
var name = TestNameBuilder.GetUniqueTestName(className, info, parameters);
return(new InnerVerifier(name, sourceFile, info.DeclaringType !.Assembly));
}
static InnerVerifier GetVerifier(VerifySettings settings, string sourceFile)
{
if (!UsesVerifyAttribute.TryGet(out var info))
{
var fileName = Path.GetFileName(sourceFile);
throw new Exception($"Expected to find a `[UsesVerify]` on test class. File: {fileName}.");
}
var className = Path.GetFileNameWithoutExtension(sourceFile);
var parameters = settings.GetParameters(info);
var name = TestNameBuilder.GetUniqueTestName(className, info, parameters);
return(new(name, sourceFile, info.DeclaringType !.Assembly, settings));
}
InnerVerifier BuildVerifier(string sourceFile, VerifySettings?settings)
{
Guard.AgainstNullOrEmpty(sourceFile, nameof(sourceFile));
var type = GetType();
var methodInfo = type.GetMethod(TestContext.TestName, BindingFlags.Instance | BindingFlags.Public);
if (methodInfo == null)
{
throw new Exception($"Could not find method `{type.Name}.{TestContext.TestName}`");
}
var parameters = settings.GetParameters(methodInfo);
var uniqueTestName = TestNameBuilder.GetUniqueTestName(type, methodInfo, parameters);
return(new InnerVerifier(uniqueTestName, sourceFile, type.Assembly));
}
public async Task Text(
bool hasExistingReceived,
bool autoVerify)
{
var uniqueTestName = TestNameBuilder.GetUniqueTestName("Tests_Single", Info.OfMethod <Tests>("Text"), new object[] { hasExistingReceived, autoVerify });
var settings = new VerifySettings();
settings.UseParameters(hasExistingReceived, autoVerify);
await RunTest(
"txt",
() => "someText",
() => "someOtherText",
hasMatchingDiffTool : true,
hasExistingReceived,
autoVerify,
settings,
uniqueTestName);
}
InnerVerifier BuildVerifier(VerifySettings settings, string sourceFile)
{
var type = GetType();
var methodInfo = type
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.FirstOrDefault(x => x.Name == TestContext.TestName);
if (methodInfo == null)
{
throw new($"Could not find method `{type.Name}.{TestContext.TestName}`");
}
var parameters = settings.GetParameters(methodInfo);
var uniqueTestName = TestNameBuilder.GetUniqueTestName(type, methodInfo, parameters);
return(new(uniqueTestName, sourceFile, type.Assembly, settings));
}
static TestName GetTestName(TestHost host, TestPath parent, ITestParameter parameter = null)
{
var builder = new TestNameBuilder();
if (parent != null)
{
builder.Merge(parent.name);
}
if (host.Name != null)
{
if (parameter != null && ((host.Flags & TestFlags.PathHidden) == 0))
{
builder.PushParameter(host.Name, parameter.Value, (host.Flags & TestFlags.Hidden) != 0);
}
else if ((host.Flags & TestFlags.Hidden) == 0)
{
builder.PushName(host.Name);
}
}
return(builder.GetName());
}
public async Task Stream(
bool hasMatchingDiffTool,
bool hasExistingReceived,
bool autoVerify)
{
var extension = hasMatchingDiffTool ? "knownBin" : "unknownBin";
var uniqueTestName = TestNameBuilder.GetUniqueTestName("Tests_Single", Info.OfMethod <Tests>("Stream"), new object[] { hasMatchingDiffTool, hasExistingReceived, autoVerify });
var settings = new VerifySettings();
settings.UseParameters(hasMatchingDiffTool, hasExistingReceived, autoVerify);
await RunTest(
extension : extension,
() => new MemoryStream(new byte[] { 1 }),
() => new MemoryStream(new byte[] { 2 }),
hasMatchingDiffTool,
hasExistingReceived,
autoVerify,
settings,
uniqueTestName);
}
