深入理解JUnit浮点数断言：动态Delta值的正确设置与实践

assertEquals("Failed " + doubles[i] + " + " + doubles[j],
             doubles[i] + doubles[j],
             ownFloats[i].add(ownFloats[j]).toDouble(),
             Math.min(doubles[i], doubles[j]));

java.lang.AssertionError: Failed -0.01393084463838419 + -0.01393084463838419 
Expected :-0.02786168927676838
Actual   :-0.027861595153808594

// 计算预期结果
double expectedAdd = doubles[i] + doubles[j];
// 获取实际结果
double actualAdd = ownFloats[i].add(ownFloats[j]).toDouble();
// 计算动态delta
double deltaAdd = Math.max(Math.abs(doubles[i]), Math.abs(doubles[j])) / 100.0;

assertEquals("Failed " + doubles[i] + " + " + doubles[j],
             expectedAdd, actualAdd, deltaAdd);

// 减法同理
double expectedSub = doubles[i] - doubles[j];
double actualSub = ownFloats[i].sub(ownFloats[j]).toDouble();
double deltaSub = Math.max(Math.abs(doubles[i]), Math.abs(doubles[j])) / 100.0; // 或者根据预期结果的magnitude来调整

assertEquals("Failed " + doubles[i] + " - " + doubles[j],
             expectedSub, actualSub, deltaSub);

import org.junit.jupiter.api.Test; // 假设使用JUnit 5
import static org.junit.jupiter.api.Assertions.assertEquals;

import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.DoubleStream;

// 假设有一个OwnFloat类，实现了add和sub方法
class OwnFloat {
    private double value;

    public OwnFloat(double value) {
        this.value = value;
    }

    public OwnFloat add(OwnFloat other) {
        // 实际的自定义浮点数加法逻辑，可能引入精度误差
        return new OwnFloat(this.value + other.value); 
    }

    public OwnFloat sub(OwnFloat other) {
        // 实际的自定义浮点数减法逻辑，可能引入精度误差
        return new OwnFloat(this.value - other.value);
    }

    public double toDouble() {
        return this.value;
    }
}

public class OwnFloatTest {

    @Test
    public void testRandomMath() {
        DoubleStream doubleStream = ThreadLocalRandom.current().doubles(100);

        // 限制double的范围，使其在OwnFloat类可处理的范围内
        double[] doubles = doubleStream.map(d -> {
            if (ThreadLocalRandom.current().nextBoolean()) {
                return d * -1d;
            } else {
                return d;
            }
        }).map(d -> d * Math.pow(2, ThreadLocalRandom.current().nextInt(-8, 9))).toArray();

        OwnFloat[] ownFloats = new OwnFloat[doubles.length];

        for (int i = 0; i < doubles.length; i++) {
            ownFloats[i] = new OwnFloat(doubles[i]);
        }

        for (int i = 0; i < doubles.length; i++) {
            for (int j = 0; j < doubles.length; j++) {
                // 加法测试
                double expectedAdd = doubles[i] + doubles[j];
                double actualAdd = ownFloats[i].add(ownFloats[j]).toDouble();
                // 使用动态delta，基于操作数中绝对值较大的一个
                // 100.0可以根据实际精度要求调整，例如1000.0或更高
                double deltaAdd = Math.max(Math.abs(doubles[i]), Math.abs(doubles[j])) / 100.0;
                // 如果deltaAdd过小（例如接近0），可以设置一个最小delta值，防止除以零或delta过小
                if (deltaAdd < Double.MIN_NORMAL) { // Double.MIN_NORMAL是最小正double值
                    deltaAdd = Double.MIN_NORMAL; 
                }

                assertEquals("Failed " + doubles[i] + " + " + doubles[j],
                             expectedAdd, actualAdd, deltaAdd);

                // 减法测试
                double expectedSub = doubles[i] - doubles[j];
                double actualSub = ownFloats[i].sub(ownFloats[j]).toDouble();
                double deltaSub = Math.max(Math.abs(doubles[i]), Math.abs(doubles[j])) / 100.0;
                if (deltaSub < Double.MIN_NORMAL) {
                    deltaSub = Double.MIN_NORMAL;
                }

                assertEquals("Failed " + doubles[i] + " - " + doubles[j],
                             expectedSub, actualSub, deltaSub);
            }
        }
    }
}