JUnit浮点数断言：动态delta值的正确设置与实践

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

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

// 假设这是一个自定义的浮点数类，用于模拟浮点数运算
// 实际实现会更复杂，这里仅为示例提供骨架
class OwnFloat {
    private double value;

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

    // 模拟加法运算，可能存在精度损失
    public OwnFloat add(OwnFloat other) {
        // 实际的OwnFloat实现会在这里进行复杂的自定义浮点数加法逻辑
        // 这里简化为直接的双精度浮点数加法
        return new OwnFloat(this.value + other.value);
    }

    // 模拟减法运算，可能存在精度损失
    public OwnFloat sub(OwnFloat other) {
        // 实际的OwnFloat实现会在这里进行复杂的自定义浮点数减法逻辑
        // 这里简化为直接的双精度浮点数减法
        return new OwnFloat(this.value - other.value);
    }

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

public class FloatingPointAssertionTutorial {

    @Test
    public void testRandomMathWithDynamicDelta() {
        // 生成100个随机双精度浮点数
        DoubleStream doubleStream = ThreadLocalRandom.current().doubles(100);

        // 对生成的双精度数进行处理，使其具有正负、不同量级
        double[] testDoubles = 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[testDoubles.length];
        for (int i = 0; i < testDoubles.length; i++) {
            ownFloats[i] = new OwnFloat(testDoubles[i]);
        }

        // 对所有可能的组合进行加法和减法测试
        for (int i = 0; i < testDoubles.length; i++) {
            for (int j = 0; j < testDoubles.length; j++) {

                // --- 测试加法 ---
                double expectedAdd = testDoubles[i] + testDoubles[j];
                double actualAdd = ownFloats[i].add(ownFloats[j]).toDouble();

                // 动态计算delta值：基于预期值和实际值的最大绝对值，并除以一个精度常数（例如100）
                // 这样delta会根据数值的量级自适应调整
                double deltaAdd = Math.max(Math.abs(expectedAdd), Math.abs(actualAdd)) / 100.0;
                // 特殊处理：如果预期值和实际值都非常接近0，导致deltaAdd也为0，
                // 则设置一个非常小的正数作为delta的下限，以避免断言失败（delta为0意味着必须精确相等）
                if (deltaAdd == 0.0) {
                    deltaAdd = 1e-9; // 设置一个最小的绝对误差，例如10的-9次方
                }

                assertEquals(expectedAdd, actualAdd, deltaAdd,
                        "Addition Failed for: " + testDoubles[i] + " + " + testDoubles[j]);

                // --- 测试减法 ---
                double expectedSub = testDoubles[i] - testDoubles[j];
                double actualSub = ownFloats[i].sub(ownFloats[j]).toDouble();

                // 动态计算delta值（同加法逻辑）
                double deltaSub = Math.max(Math.abs(expectedSub), Math.abs(actualSub)) / 100.0;
                if (deltaSub == 0.0) {
                    deltaSub = 1e-9; // 设置一个最小的绝对误差
                }

                assertEquals(expectedSub, actualSub, deltaSub,
                        "Subtraction Failed for: " + testDoubles[i] + " - " + testDoubles[j]);
            }
        }
    }
}