devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

任务06——封装与单元测试(Markdown版)

作者：Cpp五条 | 2024-02-24 23:29:17

赞

踩

markdown单元测试

模块代码地址

两个地址是一样的，为了方便，所以把测试的代码很模块代码放在一起git了。

封装阶段

  1. public class Core {
  2.     public static StringBuffer Suffix(StringBuffer infix){
  3.         Stack<Character> stack=new Stack <Character>();
  4.         StringBuffer suffix=new StringBuffer();
  5.         int i=0;
  6.         char tempchar=infix.charAt(i++);
  7.         char tempchar2=' ';
  8.         try {
  9.             while (tempchar!='='){
  10.                 switch (tempchar){
  11.                     case '(':
  12.                         stack.push(tempchar);
  13.                         tempchar=infix.charAt(i++);
  14.                         break;
  15.                     case ')':
  16.                         while (stack.peek()!='('){
  17.                             tempchar2=stack.pop();
  18.                             suffix.append(tempchar2);
  19.                             suffix.append(' ');
  20.                             if (stack.empty()) {
  21.                                 break;
  22.                             }
  23.                         }
  24.                         if (!stack.empty()) {
  25.                             stack.pop();
  26.                         }
  27.                         tempchar=infix.charAt(i++);
  28.                         break;
  29.                     case '+':
  30.                     case '-':
  31.                         while (!stack.empty()&&stack.peek()!='('){
  32.                             tempchar2=stack.pop();
  33.                             suffix.append(tempchar2);
  34.                             suffix.append(' ');
  35.                         }
  36.                         stack.push(tempchar);
  37.                         tempchar=infix.charAt(i++);
  38.                         break;
  39.                     case '×':
  40.                     case '*':
  41.                     case '/':
  42.                     case '÷':
  43.                         Character ch=new Character(' ');
  44.                         if (!stack.empty()) {
  45.                             while((ch=stack.peek()).equals('×')||(ch=stack.peek()).equals('÷'))
  46.                             {
  47.                                 tempchar2=stack.pop();
  48.                                 suffix.append(tempchar2);
  49.                                 suffix.append(' ');
  50.                                 if (stack.empty()) {
  51.                                     break;
  52.                                 }
  53.                             }
  54.                         }
  55.                         stack.push(tempchar);
  56.                         tempchar=infix.charAt(i++);
  57.                         break;
  58.                     case ' ':
  59.                         tempchar=infix.charAt(i++);
  60.                         break;
  61.                     default:
  62.                         while(tempchar<='9'&&tempchar>='0')
  63.                         {
  64.                             suffix.append(tempchar);
  65.                             tempchar=infix.charAt(i++);
  66.                         }
  67.                         suffix.append(' ');
  68.                         break;
  69.                 }
  70.  
  71.  
  72.             }
  73.             while(!stack.empty())
  74.             {
  75.                 tempchar2=stack.pop();
  76.                 suffix.append(tempchar2);
  77.                 suffix.append(' ');
  78.             }
  79.  
  80.             suffix.append('\0');
  81.         } catch (Exception e) {
  82.             e.printStackTrace();
  83.         }
  84.         return suffix;
  85.     }
  86.  
  87.     //根据后缀表达式计算结果（小数格式的String类型）
  88.     public static String Calculate(StringBuffer suffix){
  89.         int i=0;
  90.         char tempchar=suffix.charAt(i++);
  91.         double []answer=new double[20];
  92.         int top=0,d;
  93.         String Answer= null;
  94.         try {
  95.             while (tempchar!='\0'){
  96.                 switch (tempchar){
  97.                     case '+':
  98.                         answer[top-1]=answer[top-1]+answer[top];
  99.                         top--;
  100.                         tempchar=suffix.charAt(i++);
  101.                         break;
  102.                     case '-':
  103.                         answer[top-1]=answer[top-1]-answer[top];
  104.                         top--;
  105.                         tempchar=suffix.charAt(i++);
  106.                         break;
  107.                     case '*':
  108.                     case '×':
  109.                         answer[top-1]=answer[top-1]*answer[top];
  110.                         top--;
  111.                         tempchar=suffix.charAt(i++);
  112.                         break;
  113.                     case '/':
  114.                     case '÷':
  115.                         try {
  116.                             if(answer[top]!=0)
  117.                                 answer[top-1]=answer[top-1]/answer[top];
  118.                             else
  119.                             {
  120.                                 System.out.println("\n\t除零错误!\n");
  121.                                 throw new InvalidExpression("无效的表达式");
  122.                             }
  123.                         } catch (InvalidExpression invalidExpression) {
  124.                             invalidExpression.printStackTrace();
  125.                             System.exit(0);
  126.                         }
  127.                         top--;
  128.                         tempchar=suffix.charAt(i++);
  129.                         break;
  130.                     case ' ':
  131.                         tempchar=suffix.charAt(i++);
  132.                         break;
  133.                     default:
  134.                         d=0;
  135.                         while(tempchar>='0'&&tempchar<='9')
  136.                         {
  137.                             d=10*d+tempchar-'0';//将数字字符转化为对应的数值
  138.                             tempchar=suffix.charAt(i++);
  139.                         }
  140.                         top++;
  141.                         answer[top]=d;
  142.                         break;
  143.                 }
  144.             }
  145.             Answer = null;
  146.             if (top!=1){
  147.                 throw new InvalidExpression("无效的表达式");
  148.             }
  149.             Double an=new Double(answer[top]);
  150.             Answer = new String(an.toString());
  151.  
  152.         }catch (InvalidExpression invalidExpression) {
  153.             invalidExpression.printStackTrace();
  154.         }catch (Exception e) {
  155.             e.printStackTrace();
  156.         }
  157.         return Answer;
  158.     }
  159. }

在封装的过程中遇到的困难，以及是如何解决的:

1100697-20170427124741131-1096628975.png

对于封装首先想到几天前学习的软件工程的知识，关于模块的分解、抽象，恰好与本次的任务吻合，可以理论用于实践。上图是我画的UML图，在尝试在学习中，算不上很规范，但能基本看懂大概的结构。
因为之前的代码基于结构化编程，运用函数思想，所以在本次封装过程中很好的将功能抽象出来，这次完成的虽然不是很完美，但后期可以通过老师的指导不断改进。

单元测试阶段

单元测试代码 此处粘贴单元测试代码（用一对 把代码括起来） public class CoreTest {

  1. @Before
  2. public void before() throws Exception { 
  3. } 
  4.  
  5. @After
  6. public void after() throws Exception { 
  7. } 
  8.  
  9. /** 
  10. * 
  11. * Method: Suffix(StringBuffer infix) 
  12. * 
  13. */ 
  14. @Test
  15. public void testSuffix() throws Exception {
  16.     Core s=new Core();
  17.     s.Suffix(new StringBuffer("1+2+3="));
  18.     s.Suffix(new StringBuffer("1+2×3="));
  19.     s.Suffix(new StringBuffer("1+2÷3="));
  20.     s.Suffix(new StringBuffer("1÷2×3="));
  21.     s.Suffix(new StringBuffer("1÷+2×3="));
  22.     s.Suffix(new StringBuffer("1÷2*3="));
  23.     s.Suffix(new StringBuffer("1÷0×3="));
  24.     s.Suffix(new StringBuffer("1÷2×0="));
  25.  
  26. } 
  27.  
  28. /** 
  29. * 
  30. * Method: Calculate(StringBuffer suffix) 
  31. * 
  32. */ 
  33. @Test
  34. public void testCalculate() throws Exception { 
  35.     Core s=new Core();
  36.     s.Calculate(new StringBuffer("1 2 + 3 +"));
  37.     s.Calculate(new StringBuffer("1 + 2 + 3 +"));
  38.     s.Calculate(new StringBuffer("1 2 +"));
  39.     s.Calculate(new StringBuffer("1 2 × 3 +"));
  40.     s.Calculate(new StringBuffer("1+ + 2 × 3 +"));
  41. } 
  42.  
  43.  
  44. }

```

单元测试运行结果（截图，含测试是否全部通过，代码覆盖率等）

1100697-20170427124820147-372622570.png
1100697-20170427124823053-789133932.png
1100697-20170427124826834-1015767284.png

在编写单元测试代码过程中遇到的困难，以及是如何解决的

按照老师提供的教程，一开始看不懂，需要自己慢慢琢磨，Junit包，不知道是哪个，IDEA上找到有好多个，后来自己在网上找一个发现可以用。
下面提供它的下载网址。
链接：http://pan.baidu.com/s/1o84pWQQ 密码：1mda

别的大问题没有，关于对Core的测试，计算表达式都是自己按照规则生成的，不会出现不规则的情况，
所以对于测试情况的全面性没有更深一步进行。

感受（小结）

Junit很方便，测试的时候，不能以编程时的思维方式去看待问题，否则有些问题永远测试不出来。
需要打破常规的思路，不能认为自己的代码运行结果都是对的。

转载于:https://www.cnblogs.com/jinxiaohang/p/6773642.html

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/136774
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号