How to implement a Precision Tolerance feature about fitsharp HOT 7 CLOSED

    public override void Execute()
    {
        if(Processor is null)
            Processor = new Service();

        Processor.AddOperatorFirst("MyNamespace.ToleranceCellOperator");
    ...

    public class ToleranceCellOperator : CellOperator, CompareOperator<Cell>
    {
        private static readonly HashSet<Type> supportedTypes = new HashSet<Type>(new[]
        {
            typeof(string),
            typeof(float),
            typeof(double),
            typeof(decimal),
        });

        public static decimal Tolerance { get; set; } = 0.01m;

        public bool CanCompare(TypedValue actual, Tree<Cell> expected)
        {
            return supportedTypes.Contains(actual.Type);
        }

        public bool Compare(TypedValue actual, Tree<Cell> expected)
        {
            decimal val = StrToDecimal(actual.ValueString);
            decimal exp = StrToDecimal(expected.Value.Content);

            return (Math.Abs(exp - val) < Tolerance);
        }
        
        private static decimal StrToDecimal(string strVal)
        {
            strVal = strVal.Replace(',', '.');            // convert to invariant culture
            while (strVal.Sum(a => a == '.' ? 1 : 0) > 1) // strip thousands separators
            {
                int idx = strVal.IndexOf('.');
                strVal = strVal.Substring(0, idx) + strVal.Substring(idx + 1);
            }

            return decimal.Parse(strVal, CultureInfo.InvariantCulture);
        }
    }

Sample.cs:
namespace SampleSUT {
    public class Sample {
        public int Add(int a, int b) {
            return a + b;
        }
    }
}

MyCompare.cs:
using fitSharp.Fit.Operators;
using fitSharp.Machine.Engine;
using fitSharp.Machine.Model;

namespace SampleSUT {
    public class MyCompare: CellOperator, CompareOperator<Cell> {
        public bool CanCompare(TypedValue actual, Tree<Cell> expected) {
            return actual.Type == typeof(int);
        }

        public bool Compare(TypedValue actual, Tree<Cell> expected) {
            if (actual.GetValue<int>() == 42) return false;
            return actual.GetValue<int>() == int.Parse(expected.Value.Text);
        }
    }
}

sample.config.xml:
<suiteConfig>
    <ApplicationUnderTest>
        <AddAssembly>./bin/Debug/net5.0/SampleSUT.dll</AddAssembly>
        <AddNamespace>SampleSUT</AddNamespace>
    </ApplicationUnderTest>
    <Fit.Operators>
       <Add>SampleSUT.MyCompare</Add>
   </Fit.Operators>
   <Settings>
        <InputFolder>./tests/in</InputFolder>
        <OutputFolder>./tests/out</OutputFolder>
        <Runner>fit.Runner.FolderRunner</Runner>
   </Settings>
</suiteConfig>

sampleTest.txt in tests/in:
test@

sample
check add 1 " " 2 3
check add 1 " " 41 42

using fit;

namespace SampleSUT
{
    public class Sample: ColumnFixture
    {
        public Sample()
        { }

        public int A { get; set; }

        public int B { get; set; }

        public int Result { get; set; }

        public override void Execute()
        {
            Result = A + B;
        }
    }
}

!*< hide stuff 
!define TEST_SYSTEM {slim}
!path ".\SampleSUT.dll"
!define TEST_RUNNER {".\Runner.exe"}
!define COMMAND_PATTERN {%m -c ".\sample.config.xml" -r fitSharp.Slim.Service.Runner %p}
*! 

|Sample      |
|A|B |Result?|
|1|2 |3      |
|1|41|42     |
|1|3 |9      |

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using fitSharp.Fit.Operators;
using fitSharp.Machine.Engine;
using fitSharp.Machine.Model;

namespace DiscountTest.Helpers
{
    /// <summary>
    /// Compares values allowing a specific margin of difference between expected and actual values.
    /// This will allow for rounding differences between different generations of implementations of the same functionality.
    /// </summary>
    public class CompareWithTolerance : CellOperator, CompareOperator<Cell>
    {
        private static readonly HashSet<Type> supportedTypes = new HashSet<Type>(new[]
        {
            typeof(string),
            typeof(float),
            typeof(double),
            typeof(decimal),
        });

        public static decimal Tolerance { get; set; } = 0.02m;

        public bool CanCompare(TypedValue actual, Tree<Cell> expected)
        {
            return supportedTypes.Contains(actual.Type);
        }

        public bool Compare(TypedValue actual, Tree<Cell> expected)
        {
            if (actual.ValueString.ToLowerInvariant().StartsWith("error"))
                return false;

            if (string.IsNullOrWhiteSpace(expected.Value.Content))
                return true;

            if (expected.Value.Content.Any(char.IsLetter))
                return string.Compare(actual.ValueString, 0, expected.Value.Content, 0, int.MaxValue, true, CultureInfo.InvariantCulture) == 0;

            string filteredActual   = actual.ValueString.Replace("%", string.Empty);
            string filteredExpected = expected.Value.Content.Replace("%", string.Empty);

            decimal val = StrToDecimal(filteredActual);
            decimal exp = StrToDecimal(filteredExpected);

            bool ret = (Math.Abs(exp - val) < Tolerance);
            return ret;
        }
        
        private static decimal StrToDecimal(string strVal)
        {
            try
            {
                strVal = strVal.Replace(',', '.');            // convert to invariant culture
                while (strVal.Sum(a => a == '.' ? 1 : 0) > 1) // strip thousands separators
                {
                    int idx = strVal.IndexOf('.');
                    strVal = strVal.Substring(0, idx) + strVal.Substring(idx + 1);
                }

                return decimal.Parse(strVal, CultureInfo.InvariantCulture);
            }
            catch (Exception ex)
            {
                throw new Exception(string.Concat("Parse string was \"", strVal, "\"."), ex);
            }
        }
    }
}