async Task VerifyBinary(IEnumerable <ConversionStream> streams, string infoExtension, VerifySettings settings, object?info, Func <Task>?cleanup)
{
var engine = new VerifyEngine(
infoExtension,
settings,
directory,
testName,
assembly);
var list = streams.ToList();
await VerifyInfo(engine, settings, info);
for (var index = 0; index < list.Count; index++)
{
var conversionStream = list[index];
var file = GetFileForIndex(settings, list, index, conversionStream.Extension);
var result = await GetResult(settings, file, conversionStream);
engine.HandleCompareResult(result, file);
}
if (cleanup != null)
{
await cleanup.Invoke();
}
await engine.ThrowIfRequired();
}
async Task VerifyBinary(IEnumerable <Stream> streams, VerifySettings settings, object?info)
{
var extension = settings.ExtensionOrBin();
var innerVerifier = new VerifyEngine(
extension,
settings,
testType,
directory,
testName);
var list = streams.ToList();
await VerifyInfo(innerVerifier, settings, info);
for (var index = 0; index < list.Count; index++)
{
var suffix = GetSuffix(list, index);
var stream = list[index];
var file = GetFileNames(extension, settings.Namer, suffix);
var result = await Comparer.Streams(stream, file);
innerVerifier.HandleCompareResult(result, file);
}
await innerVerifier.ThrowIfRequired();
}
async Task HandleResults(List <ResultBuilder> results, VerifyEngine engine)
{
async Task HandleBuilder(ResultBuilder item, FilePair file)
{
var result = await item.GetResult(file);
engine.HandleCompareResult(result, file);
}
if (results.Count == 1)
{
var item = results[0];
var file = GetFileNames(item.Extension, settings.Namer);
await HandleBuilder(item, file);
return;
}
for (var index = 0; index < results.Count; index++)
{
var item = results[index];
var file = GetFileNames(item.Extension, settings.Namer, $"{index:D2}");
await HandleBuilder(item, file);
}
}
async Task VerifyBinary(IEnumerable <Stream> streams, VerifySettings settings, object?info)
{
var extension = settings.ExtensionOrBin();
var engine = new VerifyEngine(
extension,
settings,
testType,
directory,
testName);
var list = streams.ToList();
await VerifyInfo(engine, settings, info);
for (var index = 0; index < list.Count; index++)
{
var file = GetFileForIndex(settings, list, index, extension);
var stream = list[index];
stream.MoveToStart();
var result = await GetResult(settings, file, stream);
engine.HandleCompareResult(result, file);
}
await engine.ThrowIfRequired();
}
async Task VerifyInfo(VerifyEngine engine, VerifySettings settings, object?info)
{
if (info == null)
{
return;
}
var file = GetFileNames("txt", settings.Namer, "info");
var formatJson = JsonFormatter.AsJson(info, settings.serialization.currentSettings);
var scrubbedInput = ScrubInput(formatJson, settings);
var result = await Comparer.Text(file, scrubbedInput);
engine.HandleCompareResult(result, file);
}
public async Task Verify(string input, VerifySettings?settings = null)
{
Guard.AgainstNull(input, nameof(input));
settings = settings.OrDefault();
var extension = settings.ExtensionOrTxt();
var innerVerifier = new VerifyEngine(
extension,
settings,
testType,
directory,
testName);
var file = GetFileNames(extension, settings.Namer);
var scrubbedInput = ScrubInput(input, settings);
FileHelpers.DeleteIfEmpty(file.Verified);
if (!File.Exists(file.Verified))
{
await FileHelpers.WriteText(file.Received, input);
innerVerifier.AddMissing(file);
await innerVerifier.ThrowIfRequired();
return;
}
var verifiedText = await FileHelpers.ReadText(file.Verified);
verifiedText = verifiedText.Replace("\r\n", "\n");
try
{
assert(verifiedText, scrubbedInput);
}
catch (Exception exception)
when(!BuildServerDetector.Detected)
{
await FileHelpers.WriteText(file.Received, scrubbedInput);
innerVerifier.AddNotEquals(file);
await innerVerifier.ThrowIfRequired(exception.Message);
}
}
static void Verify(VerifyEngine.VerificationType verificationType)
{
using (Archive archive = new Archive(GetStore())) {
VerifyEngine engine = new VerifyEngine(archive);
if (verificationType != VerifyEngine.VerificationType.ArchiveHashWithArchiveData)
{
engine.Origins.Add(new FileSystemOrigin(@"C:\Data\Portable Program Files"));
}
bool same = engine.Run(verificationType);
if (same)
{
Console.WriteLine("Verification succeeded");
}
else
{
Console.WriteLine("Verification failed");
}
}
}
async Task VerifyInfo(VerifyEngine engine, VerifySettings settings, object?info)
{
if (info == null)
{
return;
}
var file = GetFileNames("txt", settings.Namer, "info");
var builder = JsonFormatter.AsJson(
info,
settings.serialization.currentSettings,
settings.IsNewLineEscapingDisabled);
ApplyScrubbers.Apply(builder, settings.instanceScrubbers);
var result = await Comparer.Text(file, builder, settings);
engine.HandleCompareResult(result, file);
}
async Task Verify(StringBuilder target, VerifySettings?settings)
{
Guard.AgainstNull(target, nameof(target));
settings = settings.OrDefault();
var extension = settings.ExtensionOrTxt();
var engine = new VerifyEngine(
extension,
settings,
directory,
testName,
assembly);
var file = GetFileNames(extension, settings.Namer);
ApplyScrubbers.Apply(target, settings.instanceScrubbers);
var result = await Comparer.Text(file, target, settings);
engine.HandleCompareResult(result, file);
await engine.ThrowIfRequired();
}
public async Task Verify(string input, VerifySettings?settings = null)
{
Guard.AgainstNull(input, nameof(input));
settings = settings.OrDefault();
var extension = settings.ExtensionOrTxt();
var engine = new VerifyEngine(
extension,
settings,
testType,
directory,
testName);
var file = GetFileNames(extension, settings.Namer);
var scrubbedInput = ApplyScrubbers.Apply(input, settings.instanceScrubbers);
var result = await Comparer.Text(file, scrubbedInput, settings);
engine.HandleCompareResult(result, file);
await engine.ThrowIfRequired();
}
async Task VerifyInfo(VerifyEngine engine, object?info)
{
var appends = VerifierSettings.GetJsonAppenders(settings);
if (info == null && !appends.Any())
{
return;
}
var file = GetFileNames("txt", settings.Namer, "info");
var builder = JsonFormatter.AsJson(
info,
settings.serialization.currentSettings,
appends,
settings);
ApplyScrubbers.Apply(builder, settings.instanceScrubbers);
var result = await Comparer.Text(file, builder, settings);
engine.HandleCompareResult(result, file);
}
async Task VerifyBinary(IEnumerable <Stream> streams, VerifySettings settings)
{
var extension = settings.ExtensionOrBin();
var innerVerifier = new VerifyEngine(
extension,
settings,
testType,
directory,
testName);
var list = streams.ToList();
for (var index = 0; index < list.Count; index++)
{
var suffix = GetSuffix(list, index);
var stream = list[index];
var file = GetFileNames(extension, settings.Namer, suffix);
var verifyResult = await StreamVerifier.VerifyStreams(stream, file);
switch (verifyResult)
{
case VerifyResult.MissingVerified:
innerVerifier.AddMissing(file);
break;
case VerifyResult.NotEqual:
innerVerifier.AddNotEquals(file);
break;
case VerifyResult.Equal:
innerVerifier.AddEquals(file);
break;
}
}
await innerVerifier.ThrowIfRequired();
}
