Question

我在下面的代码中进行了单元测试。此测试有时会通过，有时会失败。不知道为什么，并且犹豫要从根本上更改事物，因为它是一个公式，有时会通过...我认为这可能与double类型的精度有关？不确定。有想法吗？

[TestMethod]
public void CircleFromCircumference()
{
    var random = new Random();
    var circumference = random.NextDouble();
    var circle = new Circle("My circle", circumference, Circle.CircleDimensions.Circumference);

    var var1 = circumference - circle.Circumference;
    var var2 = circumference - 2 * Math.PI * circle.Radius;
    var var3 = circumference - Math.PI * circle.Diameter;
    var var4 = Math.Pow(circumference / (2 * Math.PI), 2) * Math.PI - circle.Area;

    Assert.IsTrue(
        circumference - circle.Circumference <= 0 //circumference
        && circumference - 2 * Math.PI * circle.Radius <= 0 //radius
        && circumference - Math.PI * circle.Diameter <= 0 //diameter
        && Math.Pow(circumference / (2 * Math.PI), 2) * Math.PI - circle.Area <= 0 //area
        && string.IsNullOrEmpty(circle.ShapeException));
}



using System;
using System.Runtime.Serialization;

namespace Shapes
{
    [DataContract]
    public class Circle : Shape
    {
        [DataMember] public double Radius { get; set; }
        [DataMember] public double Diameter { get; set; }
        [DataMember] public double Circumference { get; set; }

        /// <summary>
        /// The name of the value you are sending. Radius is the default
        /// </summary>
        public enum CircleDimensions
        {
            Circumference = 1,
            Area = 2,
            Diameter = 3
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="circleName">The name of your circle</param>
        /// <param name="dimension">The value of the dimension you are providing</param>
        /// <param name="circleDimensions">The name of the value you are providing. Radius is default</param>
        public Circle(string circleName, double dimension = 0, CircleDimensions circleDimensions = 0)
        {
            this.ShapeName = circleName;
            if (dimension <= 0)
            {
                this.ShapeException = "Parameters must be greater than zero";
                return;
            }

            switch (circleDimensions)
            {
                case CircleDimensions.Circumference:
                    //radius from Circumference
                    this.Circumference = dimension;
                    this.Radius = this.RadiusFromCircumference(dimension);
                    this.Area = this.CalculateArea(this.Radius);
                    this.Diameter = this.CalculateDiameter(this.Radius);
                    break;
                case CircleDimensions.Area:
                    //radius from Area
                    break;
                case CircleDimensions.Diameter:
                    //radius from diameter
                    break;
                default: //calculate from radius
                    this.Radius = dimension;
                    this.Diameter = this.CalculateDiameter(dimension);
                    this.Circumference = this.CalculateCircumference(dimension);
                    this.Area = this.CalculateArea(dimension);
                    break;
            }
        }

        private double RadiusFromCircumference(double dimension) => dimension / (2 * Math.PI);

        private double CalculateCircumference(double dimension) => 2 * Math.PI * dimension;
        private double CalculateDiameter(double dimension) => 2 * dimension;
        private double CalculateArea(double dimension) =>
            Math.PI * (Math.Pow(dimension, 2));
    }
}

Answer 1

不一致本身与精度无关，而与浮点表示的工作方式有关。例如，如果您编写此代码：

for (float f = 0.0f; f != 1.0f; f+=0.1f)
{
   Console.WriteLine(f);
}

它将永远不会退出。因为0.1没有二进制形式的精确表示。（https://www.exploringbinary.com/why-0-point-1-does-not-exist-in-floating-point/）。我还建议您阅读（https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html）

回到当前的问题，在您的代码中，您正在使用以下方法获取半径：

dimension / (2 * Math.PI); //passed in dimension is the Circumference, returns radius

然后在测试中您断言：

circumference - 2 * Math.PI * circle.Radius <= 0

相除然后乘以相同的浮点数并不能保证为您提供原始的浮点数。

因此，断言这通常是一个坏主意。测试“几乎相等”的最常见方法是“在限制内”测试相等。在您的情况下，您所要做的就是定义一个您认为“可以接受”的足够小的ε，大于或等于double.Epsilon。

var epsilon = double.Epsilon;
Assert.IsTrue(
    Math.Abs(circumference - circle.Circumference) <= epsilon //circumference
    && Math.Abs(circumference - 2 * Math.PI * circle.Radius) <= epsilon //radius
    && Math.Abs(circumference - Math.PI * circle.Diameter) <= epsilon //diameter
    && Math.Abs(Math.Pow(circumference / (2 * Math.PI), 2) * Math.PI - circle.Area) <= epsilon //area
    && string.IsNullOrEmpty(circle.ShapeException));

如果必须保证准确性，一种选择是切换到非浮点类型（如小数），但会导致性能下降。

单元测试-有时可行，有时不可行

1 个答案: