Пример #1
0
        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();
        }
Пример #2
0
    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();
    }
Пример #3
0
    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();
    }
    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);
            }
    }
Пример #5
0
        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();
        }
Пример #6
0
    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 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();
    }