经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 软件/图像 » Git » 查看文章
使用Github Copilot生成单元测试并执行
来源：cnblogs　　作者：Eric zhou　　时间：2023/11/6 9:23:42　　对本文有异议

上一篇文章我们介绍了

使用Github Copilot完成代码编写

本文我们继续使用Github Copilot在已有代码的基础上生成代码测试并执行。

一、先说一下代码的背景

需要上需要提供一个度量衡的工具类，实现各种转换，例如

将长度值转换为英寸
将长度值转换为英里
将长度值转换为厘米
将长度值转换为千米
将重量值转换为克
将重量值转换为千克
将功率值转换为瓦特
将电流值转换为安培
将电压值转换为伏特
......
需要比较简单明确，可以引用一个三方库（https://digidemic.github.io/UnitOf/），但是太重了，所以用Github Copilot直接生成代码实现了。
二、使用Github Copilot生成代码
首先需要组织好Prompt，这个至关重要，好的Prompt会事半功倍，不过需要多次尝试，才能把Prompt设计好
这里Share一下Prompt的设计思路：
1. 先提供几个枚举类
Prompt：请用C#生成一个枚举类LengthUnit，包含各种常见的长度单位

 Prompt：请用C#生成一个枚举类WeightUnit，包含各种常见的重量单位，并包含中文注释，标准的注释格式

 这个Prompt跟进一步了

Prompt： 请用C#生成一个枚举类PowerUnit，包含各种常见的功率单位，并包含中文注释，标准的注释格式

Prompt： 请用C#生成一个枚举类CurrentUnit，包含各种常见的电流单位，并包含中文注释，标准的注释格式

Prompt 请用C#生成一个枚举类CurrentUnit，包含各种常见的电压单位，并包含中文注释，标准的注释格式

 2. 用C#生成一个提供度量衡服务的实现类MeasurementService

这个Prompt设计了很久：

Prompt：请用C#生成一个提供度量衡服务的实现类MeasurementService，它提供了以下方法将长度值转换为英寸、长度值转换为英尺、 将长度值转换为英里、 将长度值转换为厘米、 将长度值转换为千米、 将重量值转换为克、 将重量值转换为千克、 将功率值转换为瓦特、 将电流值转换为安培、 将电压值转换为伏特。例如将长度值转换为英寸的实现方法是public double ConvertToInch(double value, LengthUnit lengthUnit)，这个方法中将变量LengthUnit，做长度转换。方法请添加标准注释，使用中文注释。

 生成的代码

  1. public class MeasurementService
  2. {
  3.     /// <summary>
  4.     /// 将长度值转换为英寸
  5.     /// </summary>
  6.     public double ConvertToInch(double value, LengthUnit lengthUnit)
  7.     {
  8.         switch (lengthUnit)
  9.         {
  10.             case LengthUnit.Meter:
  11.                 return value * 39.3701;
  12.             case LengthUnit.Centimeter:
  13.                 return value * 0.393701;
  14.             case LengthUnit.Kilometer:
  15.                 return value * 39370.1;
  16.             case LengthUnit.Mile:
  17.                 return value * 63360;
  18.             case LengthUnit.Foot:
  19.                 return value * 12;
  20.             case LengthUnit.Yard:
  21.                 return value * 36;
  22.             default:
  23.                 throw new NotSupportedException("The provided LengthUnit is not supported.");
  24.         }
  25.     }
  27.     /// <summary>
  28.     /// 将长度值转换为英尺
  29.     /// </summary>
  30.     public double ConvertToFoot(double value, LengthUnit unit)
  31.     {
  32.         // Conversion logic here
  33.     }
  35.     /// <summary>
  36.     /// 将长度值转换为英里
  37.     /// </summary>
  38.     public double ConvertToMile(double value, LengthUnit unit)
  39.     {
  40.         // Conversion logic here
  41.     }
  43.     /// <summary>
  44.     /// 将长度值转换为厘米
  45.     /// </summary>
  46.     public double ConvertToCentimeter(double value, LengthUnit unit)
  47.     {
  48.         // Conversion logic here
  49.     }
  51.     /// <summary>
  52.     /// 将长度值转换为千米
  53.     /// </summary>
  54.     public double ConvertToKilometer(double value, LengthUnit unit)
  55.     {
  56.         // Conversion logic here
  57.     }
  59.     /// <summary>
  60.     /// 将重量值转换为克
  61.     /// </summary>
  62.     public double ConvertToGram(double value, WeightUnit unit)
  63.     {
  64.         // Conversion logic here
  65.     }
  67.     /// <summary>
  68.     /// 将重量值转换为千克
  69.     /// </summary>
  70.     public double ConvertToKilogram(double value, WeightUnit unit)
  71.     {
  72.         // Conversion logic here
  73.     }
  75.     /// <summary>
  76.     /// 将功率值转换为瓦特
  77.     /// </summary>
  78.     public double ConvertToWatt(double value, PowerUnit unit)
  79.     {
  80.         // Conversion logic here
  81.     }
  83.     /// <summary>
  84.     /// 将电流值转换为安培
  85.     /// </summary>
  86.     public double ConvertToAmpere(double value, CurrentUnit unit)
  87.     {
  88.         // Conversion logic here
  89.     }
  91.     /// <summary>
  92.     /// 将电压值转换为伏特
  93.     /// </summary>
  94.     public double ConvertToVolt(double value, VoltageUnit unit)
  95.     {
  96.         // Conversion logic here
  97.     }
  98. }

这里你会发现，其他方法未实现，需要继续告诉Github Copilot继续生成代码

Prompt：MeasurementService类中，请参考ConvertToInch这个方法的实现方式和注释要求，继续生成ConvertToMile，ConvertToFoot，ConvertToCentimeter，ConvertToKilometer，ConvertToGram，ConvertToKilogram，ConvertToWatt，ConvertToAmpere，ConvertToVolt等方法的具体转换逻辑，每个方法都要实现代码输出

Github Copilot生成的代码不一定全面准确，需要做代码确认，这个很关键，以下是人工确认后的代码（改了不少地方）

  1. /// <summary>
  2.     /// 提供度量衡服务的实现类
  3.     /// </summary>
  4.     public class MeasurementService : IMeasurementService
  5.     {
  6.         /// <summary>
  7.         /// 将长度值转换为英寸
  8.         /// </summary>
  9.         public double ConvertToInch(double value, LengthUnit lengthUnit)
  10.         {
  11.             switch (lengthUnit)
  12.             {
  13.                 case LengthUnit.Inch:
  14.                     return value;
  15.                 case LengthUnit.Meter:
  16.                     return value * 39.3701;
  17.                 case LengthUnit.Centimeter:
  18.                     return value * 0.393701;
  19.                 case LengthUnit.Kilometer:
  20.                     return value * 39370.1;
  21.                 case LengthUnit.Mile:
  22.                     return value * 63360;
  23.                 case LengthUnit.Foot:
  24.                     return value * 12;
  25.                 case LengthUnit.Yard:
  26.                     return value * 36;
  27.                 default:
  28.                     throw new NotSupportedException("The provided LengthUnit is not supported.");
  29.             }
  30.         }
  32.         /// <summary>
  33.         /// 将长度值转换为英里
  34.         /// </summary>
  35.         public double ConvertToMile(double value, LengthUnit lengthUnit)
  36.         {
  38.             // 根据长度单位进行转换
  39.             switch (lengthUnit)
  40.             {
  41.                 case LengthUnit.Mile:
  42.                     return value;
  43.                 case LengthUnit.Centimeter:
  44.                     return value / 160934.4;
  45.                 case LengthUnit.Inch:
  46.                     return value / 63360;
  47.                 case LengthUnit.Kilometer:
  48.                     return value / 1.609344;
  49.                 case LengthUnit.Yard:
  50.                     return value / 1760;
  51.                 case LengthUnit.Meter:
  52.                     return value / 1609.344;
  53.                 case LengthUnit.Foot:
  54.                     return value / 5280;
  55.                 default:
  56.                     throw new NotSupportedException($"Unsupported length unit: {lengthUnit}");
  57.             }
  58.         }
  60.         /// <summary>
  61.         /// 将长度值转换为英尺
  62.         /// </summary>
  63.         public double ConvertToFoot(double value, LengthUnit lengthUnit)
  64.         {
  65.             // 根据长度单位进行转换
  66.             switch (lengthUnit)
  67.             {
  68.                 case LengthUnit.Foot:
  69.                     return value;
  70.                 case LengthUnit.Meter:
  71.                     return value / 0.3048;
  72.                 case LengthUnit.Centimeter:
  73.                     return value / 30.48;
  74.                 case LengthUnit.Mile:
  75.                     return value * 5280;
  76.                 case LengthUnit.Kilometer:
  77.                     return value * 3280.84;
  78.                 case LengthUnit.Yard:
  79.                     return value * 3;
  80.                 case LengthUnit.Inch:
  81.                     return value * 12;
  82.                 default:
  83.                     throw new NotSupportedException($"Unsupported length unit: {lengthUnit}");
  84.             }
  85.         }
  87.         /// <summary>
  88.         /// 将长度值转换为厘米
  89.         /// </summary>
  90.         public double ConvertToCentimeter(double value, LengthUnit lengthUnit)
  91.         {
  92.             // 根据长度单位进行转换
  93.             switch (lengthUnit)
  94.             {
  95.                 case LengthUnit.Centimeter:
  96.                     return value;
  97.                 case LengthUnit.Meter:
  98.                     return value * 100;
  99.                 case LengthUnit.Inch:
  100.                     return value * 2.54;
  101.                 case LengthUnit.Mile:
  102.                     return value * 160934.4;
  103.                 case LengthUnit.Kilometer:
  104.                     return value * 100000;
  105.                 case LengthUnit.Yard:
  106.                     return value * 91.44;
  107.                 case LengthUnit.Foot:
  108.                     return value * 30.48;
  109.                 default:
  110.                     throw new NotSupportedException($"Unsupported length unit: {lengthUnit}");
  111.             }
  112.         }
  114.         /// <summary>
  115.         /// 将长度值转换为千米
  116.         /// </summary>
  117.         public double ConvertToKilometer(double value, LengthUnit lengthUnit)
  118.         {
  119.             // 根据长度单位进行转换
  120.             switch (lengthUnit)
  121.             {
  122.                 case LengthUnit.Meter:
  123.                     return value / 1000;
  124.                 case LengthUnit.Inch:
  125.                     return value / 39370.1;
  126.                 case LengthUnit.Mile:
  127.                     return value / 1.609344;
  128.                 case LengthUnit.Yard:
  129.                     return value / 1093.6133;
  130.                 case LengthUnit.Foot:
  131.                     return value / 3280.8399;
  132.                 case LengthUnit.Kilometer:
  133.                     return value;
  134.                 case LengthUnit.Centimeter:
  135.                     return value / 100000;
  136.                 default:
  137.                     throw new NotSupportedException($"Unsupported length unit: {lengthUnit}");
  138.             }
  139.         }
  141.         /// <summary>
  142.         /// 将重量值转换为克
  143.         /// </summary>
  144.         public double ConvertToGram(double value, WeightUnit weightUnit)
  145.         {
  146.             // 根据重量单位进行转换
  147.             switch (weightUnit)
  148.             {
  149.                 case WeightUnit.Gram:
  150.                     return value;
  151.                 case WeightUnit.Kilogram:
  152.                     return value * 1000;
  153.                 case WeightUnit.Pound:
  154.                     return value * 453.59237;
  155.                 case WeightUnit.Tonne:
  156.                     return value * 1000000;
  157.                 case WeightUnit.Ounce:
  158.                     return value * 28.349523125;
  159.                 case WeightUnit.Milligram:
  160.                     return value / 1000;
  161.                 default:
  162.                     throw new NotSupportedException($"Unsupported weight unit: {weightUnit}");
  163.             }
  164.         }
  166.         /// <summary>
  167.         /// 将重量值转换为千克
  168.         /// </summary>
  169.         public double ConvertToKilogram(double value, WeightUnit weightUnit)
  170.         {
  171.             // 根据重量单位进行转换
  172.             switch (weightUnit)
  173.             {
  174.                 case WeightUnit.Kilogram:
  175.                     return value;
  176.                 case WeightUnit.Gram:
  177.                     return value / 1000;
  178.                 case WeightUnit.Pound:
  179.                     return value * 0.45359237;
  180.                 case WeightUnit.Tonne:
  181.                     return value * 1000;
  182.                 case WeightUnit.Ounce:
  183.                     return value * 0.028349523125;
  184.                 case WeightUnit.Milligram:
  185.                     return value / 1000000;
  186.                 default:
  187.                     throw new NotSupportedException($"Unsupported weight unit: {weightUnit}");
  188.             }
  189.         }
  191.         /// <summary>
  192.         /// 将功率值转换为瓦特
  193.         /// </summary>
  194.         public double ConvertToWatt(double value, PowerUnit powerUnit)
  195.         {
  196.             // 根据功率单位进行转换
  197.             switch (powerUnit)
  198.             {
  199.                 case PowerUnit.Watt:
  200.                     return value;
  201.                 case PowerUnit.Kilowatt:
  202.                     return value * 1000;
  203.                 case PowerUnit.Horsepower:
  204.                     return value * 745.699872;
  205.                 case PowerUnit.Megawatt:
  206.                     return value * 1000000;
  207.                 default:
  208.                     throw new NotSupportedException($"Unsupported power unit: {powerUnit}");
  209.             }
  210.         }
  212.         /// <summary>
  213.         /// 将电流值转换为安培
  214.         /// </summary>
  215.         public double ConvertToAmpere(double value, CurrentUnit currentUnit)
  216.         {
  217.             // 根据电流单位进行转换
  218.             switch (currentUnit)
  219.             {
  220.                 case CurrentUnit.Ampere:
  221.                     return value;
  222.                 case CurrentUnit.Milliampere:
  223.                     return value / 1000;
  224.                 case CurrentUnit.Microampere:
  225.                     return value / 1000000;
  226.                 case CurrentUnit.Kiloampere:
  227.                     return value * 1000;
  228.                 default:
  229.                     throw new NotSupportedException($"Unsupported current unit: {currentUnit}");
  230.             }
  231.         }
  233.         /// <summary>
  234.         /// 将电压值转换为伏特
  235.         /// </summary>
  236.         public double ConvertToVolt(double value, VoltageUnit voltageUnit)
  237.         {
  238.             // 根据电压单位进行转换
  239.             switch (voltageUnit)
  240.             {
  241.                 case VoltageUnit.Volt:
  242.                     return value;
  243.                 case VoltageUnit.Millivolt:
  244.                     return value / 1000;
  245.                 case VoltageUnit.Microvolt:
  246.                     return value / 1000000;
  247.                 case VoltageUnit.Kilovolt:
  248.                     return value * 1000;
  249.                 default:
  250.                     throw new NotSupportedException($"Unsupported voltage unit: {voltageUnit}");
  251.             }
  252.         }
  253.     }

3. 生成单元测试代码

首先选择整个类，然后输入以下Prompt

@workspace /tests  请对选中的代码，使用MSTest单元测试框架，生成单元测试代码，请为每个方法都实现单元测试

 

 每次仅生成了一个方法的单元测试，可以继续使用以下Prompt

Repeat similar tests for other methods：ConvertToMile, ConvertToFoot, ConvertToCentimeter, ConvertToKilometer, ConvertToGram, ConvertToKilogram, ConvertToWatt, ConvertToAmpere, ConvertToVolt

最终生成的UnitTest代码

  1. using Microsoft.VisualStudio.TestTools.UnitTesting;
  2. using T.Core.i10n.Service;
  3. using T.Core.i10n.SPI;
  5. namespace T.Core.i10n.Service.Tests
  6. {
  7.     [TestClass]
  8.     public class MeasurementServiceTests
  9.     {
  10.         private MeasurementService? _measurementService;
  12.         [TestInitialize]
  13.         public void Setup()
  14.         {
  15.             _measurementService = new MeasurementService();
  16.         }
  18.         [TestMethod]
  19.         public void ConvertToInch_ShouldConvertCorrectly()
  20.         {
  21.             var result = _measurementService!.ConvertToInch(1, LengthUnit.Meter);
  22.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(39.3701, result, 0.0001);
  23.         }
  25.         [TestMethod]
  26.         [ExpectedException(typeof(NotSupportedException))]
  27.         public void ConvertToInch_ShouldThrowExceptionForUnsupportedUnit()
  28.         {
  29.             _measurementService!.ConvertToInch(1, (LengthUnit)999);
  30.         }
  32.         [TestMethod]
  33.         public void ConvertToMile_ShouldConvertCorrectly()
  34.         {
  35.             var result = _measurementService!.ConvertToMile(1, LengthUnit.Kilometer);
  36.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.621371, result, 0.0001);
  37.         }
  39.         [TestMethod]
  40.         [ExpectedException(typeof(NotSupportedException))]
  41.         public void ConvertToMile_ShouldThrowExceptionForUnsupportedUnit()
  42.         {
  43.             _measurementService!.ConvertToMile(1, (LengthUnit)999);
  44.         }
  46.         [TestMethod]
  47.         public void ConvertToFoot_ShouldConvertCorrectly()
  48.         {
  49.             var result = _measurementService!.ConvertToFoot(1, LengthUnit.Meter);
  50.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(3.28084, result, 0.0001);
  51.         }
  53.         [TestMethod]
  54.         [ExpectedException(typeof(NotSupportedException))]
  55.         public void ConvertToFoot_ShouldThrowExceptionForUnsupportedUnit()
  56.         {
  57.             _measurementService!.ConvertToFoot(1, (LengthUnit)999);
  58.         }
  60.         [TestMethod]
  61.         public void ConvertToCentimeter_ShouldConvertCorrectly()
  62.         {
  63.             var result = _measurementService!.ConvertToCentimeter(1, LengthUnit.Meter);
  64.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(100, result, 0.0001);
  65.         }
  67.         [TestMethod]
  68.         [ExpectedException(typeof(NotSupportedException))]
  69.         public void ConvertToCentimeter_ShouldThrowExceptionForUnsupportedUnit()
  70.         {
  71.             _measurementService!.ConvertToCentimeter(1, (LengthUnit)999);
  72.         }
  74.         [TestMethod]
  75.         public void ConvertToKilometer_ShouldConvertCorrectly()
  76.         {
  77.             var result = _measurementService!.ConvertToKilometer(1, LengthUnit.Meter);
  78.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.001, result, 0.0001);
  79.         }
  81.         [TestMethod]
  82.         [ExpectedException(typeof(NotSupportedException))]
  83.         public void ConvertToKilometer_ShouldThrowExceptionForUnsupportedUnit()
  84.         {
  85.             _measurementService!.ConvertToKilometer(1, (LengthUnit)999);
  86.         }
  88.         [TestMethod]
  89.         public void ConvertToGram_ShouldConvertCorrectly()
  90.         {
  91.             var result = _measurementService!.ConvertToGram(1, WeightUnit.Kilogram);
  92.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1000, result, 0.0001);
  93.         }
  95.         [TestMethod]
  96.         [ExpectedException(typeof(NotSupportedException))]
  97.         public void ConvertToGram_ShouldThrowExceptionForUnsupportedUnit()
  98.         {
  99.             _measurementService!.ConvertToGram(1, (WeightUnit)999);
  100.         }
  102.         [TestMethod]
  103.         public void ConvertToKilogram_ShouldConvertCorrectly()
  104.         {
  105.             var result = _measurementService!.ConvertToKilogram(1, WeightUnit.Gram);
  106.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.001, result, 0.0001);
  107.         }
  109.         [TestMethod]
  110.         [ExpectedException(typeof(NotSupportedException))]
  111.         public void ConvertToKilogram_ShouldThrowExceptionForUnsupportedUnit()
  112.         {
  113.             _measurementService!.ConvertToKilogram(1, (WeightUnit)999);
  114.         }
  116.         [TestMethod]
  117.         public void ConvertToWatt_ShouldConvertCorrectly()
  118.         {
  119.             var result = _measurementService!.ConvertToWatt(1, PowerUnit.Kilowatt);
  120.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1000, result, 0.0001);
  121.         }
  123.         [TestMethod]
  124.         [ExpectedException(typeof(NotSupportedException))]
  125.         public void ConvertToWatt_ShouldThrowExceptionForUnsupportedUnit()
  126.         {
  127.             _measurementService!.ConvertToWatt(1, (PowerUnit)999);
  128.         }
  130.         [TestMethod]
  131.         public void ConvertToAmpere_ShouldConvertCorrectly()
  132.         {
  133.             var result = _measurementService!.ConvertToAmpere(1, CurrentUnit.Milliampere);
  134.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.001, result, 0.0001);
  135.         }
  137.         [TestMethod]
  138.         [ExpectedException(typeof(NotSupportedException))]
  139.         public void ConvertToAmpere_ShouldThrowExceptionForUnsupportedUnit()
  140.         {
  141.             _measurementService!.ConvertToAmpere(1, (CurrentUnit)999);
  142.         }
  144.         [TestMethod]
  145.         public void ConvertToVolt_ShouldConvertCorrectly()
  146.         {
  147.             var result = _measurementService!.ConvertToVolt(1, VoltageUnit.Millivolt);
  148.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.001, result, 0.0001);
  149.         }
  151.         [TestMethod]
  152.         [ExpectedException(typeof(NotSupportedException))]
  153.         public void ConvertToVolt_ShouldThrowExceptionForUnsupportedUnit()
  154.         {
  155.             _measurementService!.ConvertToVolt(1, (VoltageUnit)999);
  156.         }
  157.         [TestMethod]
  158.         public void ConvertToInch_ShouldConvertCorrectly_ForEachLengthUnit()
  159.         {
  160.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1, _measurementService!.ConvertToInch(1, LengthUnit.Inch), 0.0001);
  161.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(39.3701, _measurementService!.ConvertToInch(1, LengthUnit.Meter), 0.0001);
  162.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.393701, _measurementService!.ConvertToInch(1, LengthUnit.Centimeter), 0.0001);
  163.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(39370.1, _measurementService!.ConvertToInch(1, LengthUnit.Kilometer), 0.0001);
  164.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(63360, _measurementService!.ConvertToInch(1, LengthUnit.Mile), 0.0001);
  165.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(12, _measurementService!.ConvertToInch(1, LengthUnit.Foot), 0.0001);
  166.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(36, _measurementService!.ConvertToInch(1, LengthUnit.Yard), 0.0001);
  167.         }
  169.         [TestMethod]
  170.         public void ConvertToMile_ShouldConvertCorrectly_ForEachLengthUnit()
  171.         {
  172.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1, _measurementService!.ConvertToMile(1, LengthUnit.Mile), 0.0001);
  173.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0000062137, _measurementService!.ConvertToMile(1, LengthUnit.Centimeter), 0.0000000001);
  174.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0000157828, _measurementService!.ConvertToMile(1, LengthUnit.Inch), 0.0000000001);
  175.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.621371, _measurementService!.ConvertToMile(1, LengthUnit.Kilometer), 0.0001);
  176.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0005681818, _measurementService!.ConvertToMile(1, LengthUnit.Yard), 0.0000000001);
  177.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0006213712, _measurementService!.ConvertToMile(1, LengthUnit.Meter), 0.0000000001);
  178.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0001893939, _measurementService!.ConvertToMile(1, LengthUnit.Foot), 0.0000000001);
  179.         }
  181.         [TestMethod]
  182.         public void ConvertToFoot_ShouldConvertCorrectly_ForEachLengthUnit()
  183.         {
  184.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1, _measurementService!.ConvertToFoot(1, LengthUnit.Foot), 0.0001);
  185.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(3.28084, _measurementService!.ConvertToFoot(1, LengthUnit.Meter), 0.0001);
  186.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0328084, _measurementService!.ConvertToFoot(1, LengthUnit.Centimeter), 0.0001);
  187.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(3280.84, _measurementService!.ConvertToFoot(1, LengthUnit.Kilometer), 0.0001);
  188.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(5280, _measurementService!.ConvertToFoot(1, LengthUnit.Mile), 0.0001);
  189.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(3, _measurementService!.ConvertToFoot(1, LengthUnit.Yard), 0.0001);
  190.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0833333, _measurementService!.ConvertToFoot(1, LengthUnit.Inch), 0.0001);
  191.         }
  193.         [TestMethod]
  194.         public void ConvertToCentimeter_ShouldConvertCorrectly_ForEachLengthUnit()
  195.         {
  196.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1, _measurementService!.ConvertToCentimeter(1, LengthUnit.Centimeter), 0.0001);
  197.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(100, _measurementService!.ConvertToCentimeter(1, LengthUnit.Meter), 0.0001);
  198.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(2.54, _measurementService!.ConvertToCentimeter(1, LengthUnit.Inch), 0.0001);
  199.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(100000, _measurementService!.ConvertToCentimeter(1, LengthUnit.Kilometer), 0.0001);
  200.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(160934.4, _measurementService!.ConvertToCentimeter(1, LengthUnit.Mile), 0.0001);
  201.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(91.44, _measurementService!.ConvertToCentimeter(1, LengthUnit.Yard), 0.0001);
  202.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(30.48, _measurementService!.ConvertToCentimeter(1, LengthUnit.Foot), 0.0001);
  203.         }
  205.         // Continue with similar tests for the other methods...
  206.         [TestMethod]
  207.         public void ConvertToKilometer_ShouldConvertCorrectly_ForEachLengthUnit()
  208.         {
  209.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1, _measurementService!.ConvertToKilometer(1, LengthUnit.Kilometer), 0.0001);
  210.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.001, _measurementService!.ConvertToKilometer(1, LengthUnit.Meter), 0.0001);
  211.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0000254, _measurementService!.ConvertToKilometer(1, LengthUnit.Inch), 0.0001);
  212.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1.609344, _measurementService!.ConvertToKilometer(1, LengthUnit.Mile), 0.0001);
  213.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0009144, _measurementService!.ConvertToKilometer(1, LengthUnit.Yard), 0.0001);
  214.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0003048, _measurementService!.ConvertToKilometer(1, LengthUnit.Foot), 0.0001);
  215.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.00001, _measurementService!.ConvertToKilometer(1, LengthUnit.Centimeter), 0.0001);
  216.         }
  218.         [TestMethod]
  219.         public void ConvertToGram_ShouldConvertCorrectly_ForEachWeightUnit()
  220.         {
  221.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1, _measurementService!.ConvertToGram(1, WeightUnit.Gram), 0.0001);
  222.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1000, _measurementService!.ConvertToGram(1, WeightUnit.Kilogram), 0.0001);
  223.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(453.59237, _measurementService!.ConvertToGram(1, WeightUnit.Pound), 0.0001);
  224.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1000000, _measurementService!.ConvertToGram(1, WeightUnit.Tonne), 0.0001);
  225.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(28.349523125, _measurementService!.ConvertToGram(1, WeightUnit.Ounce), 0.0001);
  226.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.001, _measurementService!.ConvertToGram(1, WeightUnit.Milligram), 0.0001);
  227.         }        
  229.         [TestMethod]
  230.         public void ConvertToKilogram_ShouldConvertCorrectly_ForEachWeightUnit()
  231.         {
  232.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1, _measurementService!.ConvertToKilogram(1, WeightUnit.Kilogram), 0.0001);
  233.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.001, _measurementService!.ConvertToKilogram(1, WeightUnit.Gram), 0.0001);
  234.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.453592, _measurementService!.ConvertToKilogram(1, WeightUnit.Pound), 0.0001);
  235.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1000, _measurementService!.ConvertToKilogram(1, WeightUnit.Tonne), 0.0001);
  236.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.0283495, _measurementService!.ConvertToKilogram(1, WeightUnit.Ounce), 0.0001);
  237.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.000001, _measurementService!.ConvertToKilogram(1, WeightUnit.Milligram), 0.0001);
  238.         }
  240.         [TestMethod]
  241.         public void ConvertToWatt_ShouldConvertCorrectly_ForEachPowerUnit()
  242.         {
  243.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1, _measurementService!.ConvertToWatt(1, PowerUnit.Watt), 0.0001);
  244.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1000, _measurementService!.ConvertToWatt(1, PowerUnit.Kilowatt), 0.0001);
  245.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(745.7, _measurementService!.ConvertToWatt(1, PowerUnit.Horsepower), 0.0001);
  246.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1000000, _measurementService!.ConvertToWatt(1, PowerUnit.Megawatt), 0.0001);
  247.         }
  249.         [TestMethod]
  250.         public void ConvertToAmpere_ShouldConvertCorrectly_ForEachCurrentUnit()
  251.         {
  252.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1, _measurementService!.ConvertToAmpere(1, CurrentUnit.Ampere), 0.0001);
  253.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.001, _measurementService!.ConvertToAmpere(1, CurrentUnit.Milliampere), 0.0001);
  254.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.000001, _measurementService!.ConvertToAmpere(1, CurrentUnit.Microampere), 0.0001);
  255.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1000, _measurementService!.ConvertToAmpere(1, CurrentUnit.Kiloampere), 0.0001);
  256.         }
  258.         [TestMethod]
  259.         public void ConvertToVolt_ShouldConvertCorrectly_ForEachVoltageUnit()
  260.         {
  261.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1, _measurementService!.ConvertToVolt(1, VoltageUnit.Volt), 0.0001);
  262.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.001, _measurementService!.ConvertToVolt(1, VoltageUnit.Millivolt), 0.0001);
  263.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(0.000001, _measurementService!.ConvertToVolt(1, VoltageUnit.Microvolt), 0.0001);
  264.             Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(1000, _measurementService!.ConvertToVolt(1, VoltageUnit.Kilovolt), 0.0001);
  265.         }
  267.         // Continue with similar tests for the other methods...
  268.     }
  269. }

以上单元测试代码，直接在VS Code 右键Run Test即可。

 

 

周国庆

2023/11/5

 

原文链接：https://www.cnblogs.com/tianqing/p/17810231.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Git热门文章

  • 浅谈如何使用 github.com/kardianos/service
  • Git报错 bad numeric config value &#39;100000&#39; for &#39;pack.windowmemory&#39;: out of range
  • 当你登录Github要求你邮箱验证身份，但是你的邮箱登录不了了怎么办？
  • 解决docker搭建gitlab时容器不停重启的问题
  • Jenkinsfile 同时检出多个 Git 仓库
  • Gitlab 定时备份
  • github上fork2.4k,star8.7k的这款状态机，原来长这样！
  • Python Gitlab Api 使用方法
  • 使用Java统计gitlab代码行数
  • GitHub?AI编程工具copilot在Pycharm的应用

    • Git推荐文章

  • 《HelloGitHub》第 100 期
  • 英伟达又向开源迈了一步「GitHub 热点速览」
  • GitHub Star 数量前 12 的开源无代码工具
  • 《HelloGitHub》第 99 期
  • 《HelloGitHub》第 98 期
  • Git——分支管理（2）
  • Git 版本控制：构建高效协作和开发流程的最佳实践
  • 《HelloGitHub》第 97 期
  • Llama 3 开源了「GitHub 热点速览」
  • 为 AI 而生的编程语言「GitHub 热点速览」

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号