public VerifySettings(VerifySettings?settings)
{
if (settings == null)
{
return;
}
instanceScrubbers = new List <Action <StringBuilder> >(settings.instanceScrubbers);
extension = settings.extension;
clipboardEnabled = settings.clipboardEnabled;
diffEnabled = settings.diffEnabled;
autoVerify = settings.autoVerify;
serialization = settings.serialization;
newLineEscapingDisabled = settings.newLineEscapingDisabled;
handleOnFirstVerify = settings.handleOnFirstVerify;
handleOnVerifyMismatch = settings.handleOnVerifyMismatch;
Namer = new Namer(settings.Namer);
foreach (var pair in settings.Data)
{
if (pair.Value is ICloneable cloneable)
{
Data.Add(pair.Key, cloneable.Clone());
}
else
{
Data.Add(pair.Key, pair.Value);
}
}
}
public async Task Verify <T>(IAsyncEnumerable <T> enumerable, VerifySettings?settings = null)
{
Guard.AgainstNull(enumerable, nameof(enumerable));
settings = settings.OrDefault();
var list = new List <T>();
await foreach (var item in enumerable)
{
list.Add(item);
}
try
{
await Verify(list, settings);
}
finally
{
foreach (var item in list)
{
if (item is IAsyncDisposable asyncDisposable)
{
await asyncDisposable.DisposeAsync();
}
else if (item is IDisposable disposable)
{
disposable.Dispose();
}
}
}
}
public SettingsTask ThrowsAsync(
Func <ValueTask> target,
VerifySettings?settings = null)
{
settings ??= this.settings;
return(Verifier.ThrowsAsync(target, settings, sourceFile));
}
public SettingsTask Verify <T>(
T target,
VerifySettings?settings = null)
{
settings ??= this.settings;
return(Verifier.Verify(target, settings, sourceFile));
}
public SettingsTask Verify(
Expression <Func <ITuple> > target,
VerifySettings?settings = null)
{
settings ??= this.settings;
return(Verifier.Verify(target, settings, sourceFile));
}
Task VerifyString(string target, VerifySettings?settings = null)
{
var builder = new StringBuilder(target);
builder.FixNewlines();
return(Verify(builder, settings));
}
public SettingsTask Throws(
Func <object?> target,
VerifySettings?settings = null,
[CallerFilePath] string sourceFile = "")
{
return(Verify(settings, sourceFile, _ => _.Throws(target)));
}
public Task Verify(byte[] target, VerifySettings?settings = null)
{
Guard.AgainstNull(target, nameof(target));
var stream = new MemoryStream(target);
return(Verify(stream, settings));
}
public SettingsTask VerifyFile(
FileInfo path,
VerifySettings?settings = null)
{
settings ??= this.settings;
return(Verifier.VerifyFile(path, settings, sourceFile));
}
public VerifySettings(VerifySettings?settingsToClone)
{
if (settingsToClone == null)
{
return;
}
instanceScrubbers = new List <Func <string, string> >(settingsToClone.instanceScrubbers);
extension = settingsToClone.extension;
ignoreTrailingWhitespace = settingsToClone.ignoreTrailingWhitespace;
clipboardEnabled = settingsToClone.clipboardEnabled;
diffEnabled = settingsToClone.diffEnabled;
autoVerify = settingsToClone.autoVerify;
serialization = settingsToClone.serialization;
newLineEscapingDisabled = settingsToClone.newLineEscapingDisabled;
handleOnFirstVerify = settingsToClone.handleOnFirstVerify;
handleOnVerifyMismatch = settingsToClone.handleOnVerifyMismatch;
Namer = new Namer(settingsToClone.Namer);
foreach (var pair in settingsToClone.Data)
{
if (pair.Value is ICloneable cloneable)
{
Data.Add(pair.Key, cloneable.Clone());
}
else
{
Data.Add(pair.Key, pair.Value);
}
}
}
public async Task Verify(string target, VerifySettings?settings = null)
{
var verifier = GetVerifier();
await verifier.Verify(target, settings);
Flush();
}
public VerifySettings(VerifySettings?settings)
{
if (settings == null)
{
return;
}
instanceScrubbers = new(settings.instanceScrubbers);
extension = settings.extension;
clipboardEnabled = settings.clipboardEnabled;
diffEnabled = settings.diffEnabled;
autoVerify = settings.autoVerify;
serialization = settings.serialization;
handleOnFirstVerify = settings.handleOnFirstVerify;
handleOnVerifyMismatch = settings.handleOnVerifyMismatch;
comparer = settings.comparer;
Namer = new(settings.Namer);
foreach (var pair in settings.Context)
{
if (pair.Value is ICloneable cloneable)
{
Context.Add(pair.Key, cloneable.Clone());
}
else
{
Context.Add(pair.Key, pair.Value);
}
}
}
public Task Verify <T>(T input, VerifySettings?settings = null)
{
Guard.AgainstNull(input, nameof(input));
settings = settings.OrDefault();
if (SharedVerifySettings.TryGetConverter <T>(
settings.extension,
out var typeConverter))
{
var converterSettings = GetConverterSettings <T>(settings, typeConverter);
var result = typeConverter.Func(input !, converterSettings);
return(VerifyBinary(result.Streams, converterSettings, result.Info));
}
if (input is Stream stream)
{
return(VerifyStream(settings, stream));
}
if (typeof(T).ImplementsStreamEnumerable())
{
var enumerable = (IEnumerable)input !;
return(VerifyBinary(enumerable.Cast <Stream>(), settings, null));
}
var formatJson = JsonFormatter.AsJson(input, settings.serialization.currentSettings);
return(Verify(formatJson, settings));
}
public SettingsTask ThrowsValueTask <T>(
Func <Task <T> > target,
VerifySettings?settings = null)
{
settings ??= this.settings;
return(Verifier.ThrowsTask(target, settings, sourceFile));
}
public static SettingsTask VerifyFile(
FileInfo path,
VerifySettings?settings = null,
[CallerFilePath] string sourceFile = "")
{
return(Verify(settings, sourceFile, _ => _.VerifyFile(path)));
}
public static SettingsTask Throws(
Action target,
VerifySettings?settings = null,
[CallerFilePath] string sourceFile = "")
{
return(Verify(settings, sourceFile, _ => _.Throws(target)));
}
public static SettingsTask Verify <T>(
IAsyncEnumerable <T> target,
VerifySettings?settings = null,
[CallerFilePath] string sourceFile = "")
{
return(Verify(settings, sourceFile, _ => _.Verify(target)));
}
public VerifySettings(VerifySettings?settings)
{
if (settings == null)
{
return;
}
instanceScrubbers = new(settings.instanceScrubbers);
extensionMappedInstanceScrubbers = new(settings.extensionMappedInstanceScrubbers);
extension = settings.extension;
diffEnabled = settings.diffEnabled;
methodName = settings.methodName;
typeName = settings.typeName;
directory = settings.directory;
autoVerify = settings.autoVerify;
serialization = settings.serialization;
stringComparer = settings.stringComparer;
streamComparer = settings.streamComparer;
parameters = settings.parameters;
parametersText = settings.parametersText;
fileName = settings.fileName;
Namer = new(settings.Namer);
foreach (var pair in settings.Context)
{
if (pair.Value is ICloneable cloneable)
{
Context.Add(pair.Key, cloneable.Clone());
}
else
{
Context.Add(pair.Key, pair.Value);
}
}
}
public static SettingsTask VerifyJson(
Stream target,
VerifySettings?settings = null,
[CallerFilePath] string sourceFile = "")
{
return(Verify(settings, sourceFile, _ => _.VerifyJson(target)));
}
public SettingsTask Verify(
Expression <Func <ITuple> > target,
VerifySettings?settings = null,
[CallerFilePath] string sourceFile = "")
{
return(Verify(settings, sourceFile, _ => _.Verify(target)));
}
public async Task Verify(
Task <byte[]> target,
VerifySettings?settings = null)
{
var verifier = GetVerifier();
await verifier.Verify(await target, settings);
}
public Task VerifyFile(
FileInfo target,
VerifySettings?settings = null)
{
Guard.AgainstNull(target, nameof(target));
return(VerifyFile(target.FullName, settings));
}
public async Task Verify <T>(Task <T> task, VerifySettings?settings = null)
{
Guard.AgainstNull(task, nameof(task));
settings = settings.OrDefault();
var target = await task;
if (target == null)
{
throw new Exception("Task returned null.");
}
try
{
await Verify(target, settings);
}
finally
{
#if NETSTANDARD2_1
if (target is IAsyncDisposable asyncDisposable)
{
await asyncDisposable.DisposeAsync();
}
else if (target is IDisposable disposable)
{
disposable.Dispose();
}
#else
if (target is IDisposable disposable)
{
disposable.Dispose();
}
#endif
}
}
public SettingsTask Throws(
Action target,
VerifySettings?settings = null)
{
settings ??= this.settings;
return(Verifier.Throws(target, settings, sourceFile));
}
public SettingsTask Verify <T>(
Task <T> target,
VerifySettings?settings = null,
[CallerFilePath] string sourceFile = "")
{
return(Verify(settings, sourceFile, _ => _.Verify(target)));
}
public SettingsTask VerifyJson(
Stream target,
VerifySettings?settings = null)
{
settings ??= this.settings;
return(Verifier.VerifyJson(target, settings, sourceFile));
}
public static SettingsTask ThrowsValueTask <T>(
Func <ValueTask <T> > target,
VerifySettings?settings = null,
[CallerFilePath] string sourceFile = "")
{
return(Verify(settings, sourceFile, _ => _.ThrowsValueTask(target)));
}
public Task VerifyFile(
FileInfo file,
VerifySettings?settings = null)
{
Guard.AgainstNull(file, nameof(file));
return(VerifyFile(file.FullName, settings));
}
public VerifySettings(VerifySettings?settingsToClone)
{
if (settingsToClone == null)
{
return;
}
instanceScrubbers = new List <Func <string, string> >(settingsToClone.instanceScrubbers);
extension = settingsToClone.extension;
clipboardEnabled = settingsToClone.clipboardEnabled;
diffEnabled = settingsToClone.diffEnabled;
autoVerify = settingsToClone.autoVerify;
Namer = new Namer(settingsToClone.Namer);
foreach (var pair in settingsToClone.Data)
{
if (pair.Value is ICloneable cloneable)
{
Data.Add(pair.Key, cloneable.Clone());
}
else
{
Data.Add(pair.Key, pair.Value);
}
}
}
public static async Task Verify(
string target,
VerifySettings?settings = null,
[CallerFilePath] string sourceFile = "")
{
using var verifier = BuildVerifier(sourceFile);
await verifier.Verify(target, settings);
}
