精华内容
下载资源
问答
  •  基于测试驱动开发(TDD)思想,代码开发方式有如下三种:一是先根据设计把框架写好,该留接口留。然后再写测试代码,最后写开发代码。二是在编写代码之前,把所有代码测试代码写好。三是先写完代码,后测试...

    原文:http://cmmi9.blogbus.com/logs/2110514.html

     

    1.       基于测试驱动开发(TDD)的思想,代码开发的方式有如下三种:一是先根据设计把框架写好,该留的接口留。然后再写测试代码,最后写开发代码。二是在编写代码之前,把所有的代码测试代码写好。三是先写完代码,后测试。个人推荐第一种方式。

    2.       单元测试的方法为每个类建立对应的测试类,为每个函数(很简单的除外)建立相应的测试函数,建议主张以函作作为测试单元的单位。单元测试不应过分强调面向对象,因为局部的代码依然是结构化的。

    3.       关于单元测试的覆盖度问题:首先选择测试的范围,范围的确定是要保证能找到Bug。然后建立相应的测试覆盖度要达到的最小百分比,以决定什么时候停止覆盖度分析。关于覆盖度,它可以分析哪些语句或是分支没有测试到,从而新增测试用例。目前使用了DJUnit的单元测试覆盖度分析。使用时,用RUN AS.. http://cmmi9.blogbus.com/files/1143002801.gif

    4.       关于单元测试工具JUnit的使用

    (一)JUnit的特征 

    1.       使用断言方法判断期望值和实际值的差异,返回布尔值;

    2.       测试驱动设备使用共同的初始化变量或方实例;

    3.       支持图形交互模式和文本支持格式;

      (二)框架组成

            1.对测试目标进行测试的方法和过程集合,称为测试用例TestCase

            2.测试用例的集合,可容纳多个TestCase,称为测试包TestSuite

            3.测试结果的描述与记录TestResult

            4.测试过程中的事件监听者TestListener

            5.每个测试方法所发生的与预期不一致的状态的描述,称为测试失败元素TestFailure

      (三)抽象类

            1.TestCaseTest的接口的实现,构造函数TestCaseString name),由于每个TestCase在创建时都有一个名称,若某测试失败了,便可识别哪个测试失败了。

            2.SetUp()方法集中初始化测试所需的所有变量和实例,testDown()是每个测试方法结束后取消初始的方法。

            3.开发人员只须继承TestCase类,完成run方法即可,测试结果放在TestResult中。

       () 测试公约

            1.测试用例必须是公有类(public)

            2.测试用例必须继承TestCase

            3. 测试用例中的方法必须是public

            4. 测试方法必须声明为void

            5. 测试方法的前置名称必须为test

            6. 测试方法不许有任何参数传递

            7. 当新加入一个插件时,把插件文件考入到插件目录中,然后用eclipse –clean启动。Eclipse会自动检查所有的插件。

      (五)如何测试异常

            1.原程序会有抛出异常,或者有重新输入等方法(throw)

            2.对于这类异常流的测试方法有

              Try{

                  使用异常数据调用源代码函数

                  Fail(“失败”);            }

              Catch(Exception)  {}

    ()源代码与测试代码如何分在不同目录

       采用相同的包,不同的路径方式。如源代码用的是com.source包。而测试代码采用com.testJUnit会自动识别。

    (七)JUnit的判断方法

         assertEquals(Object a,Object b);

     ()实例

     1.测试分支的实现

       源代码:

     

    1. public class Choose {
    2.        public Choose() {
    3.              super();
    4.               // TODO Auto-generated constructor stub
    5.        }
    6.        public String  c(int i) throws Exception{
    7.               int aaa=i;
    8.        if (aaa>0) {
    9.               return ">";
    10.        }
    11.        if (aaa<0) {
    12.               return "<";
    13.        }
    14.        if (aaa==0) {
    15.               return "=";
    16.        }
    17.        else 
    18.               return "null";
    19.        }}
    20. 测试代码:
    21. //判断测试覆盖率
    22. //判断测试分支
    23. import junit.framework.TestCase;
    24. public class TestChoose extends TestCase {
    25.     public Choose c;
    26.     public int i1,i2,i3;
    27.     String abc;
    28.     //测试中的三个值
    29.     String test;
    30.     //调用Choose类c方法后的返回值
    31.        
    32.        public static void main(String[] args) {
    33.        }
    34.        public TestChoose(String name) {
    35.               super(name);       
    36.        }
    37.        protected void setUp() throws Exception {
    38.               super.setUp();
    39.               this.c=new Choose();
    40.               i1=1;
    41.               i2=0;
    42.               i3=-1;
    43.               test=new String();
    44.               abc=new String("1");
    45.        }
    46.        public void testc() {
    47.               
    48.               try {
    49.                      test=c.c(i1);
    50.               assertEquals(">",test);
    51.               test=c.c(i2);
    52.               assertEquals("=",test);
    53.               test=c.c(i3);
    54.               assertEquals("<",test);
    55.                   //fail("没有异常");
    56.        }
    57.               catch(Exception e){
    58.                      
    59.               }
    60.        }
    61. }
    62. 2.数据流的实现
    63. 源代码A:
    64. //判断数据流
    65. public class A {
    66.        B b=new B();
    67.        String s=new String();
    68.        public A() {
    69.               super();
    70.               // TODO Auto-generated constructor stub
    71.        }
    72.        public static void main(String[] args) { 
    73.               // TODO Auto-generated method stub
    74.        }
    75.        public String pass(int i)
    76.        {
    77.      s=b.check(i);
    78.      return s;
    79.        }
    80. }
    81. 源代码B:
    82. //判断数据流
    83. public class B {
    84.        public B() {
    85.               super();
    86.               // TODO Auto-generated constructor stub
    87.        }
    88.        /**
    89.         * @param args
    90.         */
    91.        public static void main(String[] args) {
    92.               // TODO Auto-generated method stub
    93.        }
    94.        public String check(int i) {
    95.               try {
    96.               if (i>0return ">";
    97.               if (i==0return "=";
    98.               if (i<0return "<";
    99.        }
    100.               
    101.        catch (Exception e){
    102.        
    103.        }
    104.               return null;
    105.        }
    106. }
    107. 测试代码:
    108. import junit.framework.TestCase;
    109. public class ATest extends TestCase {
    110.         public A a;
    111.         String a1,a2,a3;
    112.        public static void main(String[] args) {
    113.        }
    114.        public ATest(String name) {
    115.               super(name);
    116.        }
    117.        protected void setUp() throws Exception {
    118.               super.setUp();
    119.               a=new A();
    120.               a1=new String(">");
    121.               a2=new String("=");
    122.               a3=new String("<");
    123.        }
    124.        protected void tearDown() throws Exception {
    125.               super.tearDown();
    126.        }
    127.        public void testpass() {
    128.        assertEquals(a1,this.a.pass(1));
    129.        System.out.println(this.a.pass(1));
    130.        assertEquals(a2,this.a.pass(0));
    131.        System.out.println(this.a.pass(0));
    132.        assertEquals(a3,this.a.pass(-1));
    133.        System.out.println(this.a.pass(-1));
    134.        
    135.        }}
    136. 4.       测试异常
    137. 源代码:
    138. //白盒边界测试及异常流测试
    139. public class Add {
    140.  int iqq=0;
    141.  String iString=new String();
    142.  String s=new String("X");
    143. public Add() {
    144.         super();
    145.         // TODO Auto-generated constructor stub
    146. }
    147.    public int intAdd(int a) throws Exception{
    148.    if (a < 0)
    149.    {
    150.            throw new Exception("aaaa");
    151.    }
    152.    this.iqq=a+10;
    153.    return this.iqq;
    154.    }
    155.   public String intString(String b) throws Exception {
    156.   return s+b;
    157.   }
    158. /**
    159.  * @param args
    160.  */
    161. }
    162. 单元测试代码:
    163. import junit.framework.Test;
    164. import junit.framework.TestCase;
    165. import junit.framework.TestSuite;
    166. //白盒边界测试及异常流测试
    167. public class TestAdd extends TestCase {
    168. public int int1,int2,int3,int4,int5;
    169. Add a;
    170. String a1,b1,c1,d1,e1;
    171. public static void main(String[] args) {
    172. }
    173. public TestAdd(String name) {
    174.         super(name);
    175. }
    176. protected void setUp() throws Exception {
    177.         super.setUp();
    178.         a=new Add();
    179.         int1=10;
    180.         int2=11;
    181.         int3=100010;
    182.         int4=-10;
    183.         int5=1;
    184.         a1=new String("X1");
    185.         b1=new String("X2");
    186.         c1=new String("Xaaa");
    187.         d1=new String("Xbbb");
    188.         e1=new String("X0");
    189.         
    190. }
    191. protected void tearDown() throws Exception {
    192.         super.tearDown();
    193. }
    194.     public void testintAdd() throws Exception{
    195.       this.assertEquals(int1,a.intAdd(0));
    196.       this.assertEquals(int2,a.intAdd(1)); 
    197.       this.assertEquals(int3,a.intAdd(100000));
    198.       try
    199.       {
    200.       
    201.       this.assertEquals(int4,a.intAdd(-20));
    202.       fail("发生错误");
    203.       }
    204.       catch(Exception e)
    205.       {
    206.       
    207.       }
    208.       
    209.       try {
    210.       this.assertEquals(int5,a.intAdd(-9));
    211.       fail();
    212.       }
    213.       catch(Exception e1)
    214.       {
    215.       }
    216.       }
    217.     
    218.     public static Test suite(){
    219.     return new TestSuite(TestAdd.class);
    220.     }
    221.     public void testintString() throws Exception{
    222.     this.assertEquals(a1,a.intString("1"));     
    223.     this.assertEquals(b1,a.intString("2"));    
    224.     this.assertEquals(c1,a.intString("aaa"));  
    225.     this.assertEquals(d1,a.intString("bbb")); 
    226.     this.assertEquals(e1,a.intString("0"));     
    227.        
    228.     }
    229. }
    230.   

       (九)DJUnit的单元测试覆盖度

    http://cmmi9.blogbus.com/files/1143003400.gif

     

    展开全文
  • 测试是软件发布重要环节,单元测试在实际开发中是一种常用测试方法,java单元测试主要用junit,最新是junit5,本人开发一般用junit4。因为单元测试能够在软件模块组合之前尽快发现问题,所以实际开发中投入产出...

    测试是软件发布的重要环节,单元测试在实际开发中是一种常用的测试方法,java单元测试主要用junit,最新是junit5,本人开发一般用junit4。因为单元测试能够在软件模块组合之前尽快发现问题,所以实际开发中投入产出比很高。实际使用难免会遇到异步操作的接口测试,最常用的情景是别人家的SDK封装了异步处理,需要用测试用例来验证SDK的流程,顺便测试参数的处理情况。由于异步testcase的会在调用后立即返回,异步线程执行完之前test线程已经结束了,无法验证测试最终结果。我们可以通过同步锁方法把异步接口转换为同步处理流程。
    一、什么是单元测试?
    单元测试是对软件最小实现单元进行的一种测试,例如C语言的函数,C++的类,java的类等。java有一套单元测试框架junit,Android中有AndroidTestCase等等。我们可以用junit对java函数,类,模块接口进行测试。

    二、java单元测试教程
    对于单元测试的教程网上有好多,这里就不再重复阐述了。
    eclipse单元测试
    http://tonl.iteye.com/blog/1948869
    gradle构建junit单元测试教程
    http://www.jianshu.com/p/e4e99b62a203

    三、如何处理异步类型的单元测试
    1. 能够获取Thread句柄的异步类型
    对于有java thread句柄的测试类型,我们使用使用Thread.join函数等待线程执行完毕。
        @Test
        public void testExplicitThread() {
            System.out.println("testExplicitThread");
            Thread thread = new Thread() {
                @Override
                public void run() {
                    System.out.println("thread start.");
                    try {
                        for (int i = 0; i < 5; i++) {
                            System.out.println("progress: " + i);
                            sleep(1000);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        System.out.println("thread finish.");
                    }
                }
            };
            thread.start();
            try {
                thread.join(); // 等待线程执行完毕
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("testExplicitThread exit");
        }

    测试用例输出:
    testExplicitThread
    thread start.
    progress: 0
    progress: 1
    progress: 2
    progress: 3
    progress: 4
    thread finish.
    testExplicitThread exit

     

    2. 没有thread句柄的异步单元测试
    因为没有thread句柄,所以无法使用 join 函数。只能手动操作同步锁对异步接口进行同步
    Object.wait 当前线程进入等待状态,直到其他线程调用 notify 或者 notifyAll 函数唤醒。
    具体实现如下:

        /**
         * 回调接口
         */
        interface Callback {
            void onStart();
            void onProgress(int progress);
            void onFinish();
        }
     
        /**
         * 异步方法
         */
        static class AsyncDemo {
            private int len = 0;
            private Callback callback = null;
            public AsyncDemo(int len, Callback cb) {
                this.len = len;
                this.callback = cb;
            }
     
            public void doJob() {
                new Thread() {
                    @Override
                    public void run() {
                        if (null != callback) {
                            callback.onStart();
                        }
                        try {
                            for (int i = 0; i < len; i++) {
                                if (null != callback) {
                                    callback.onProgress(i);
                                }
                                sleep(1000);
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } finally {
                            if (null != callback) {
                                callback.onFinish();
                            }
                        }
                    }
                }.start();
            }
        }
     
        private Object mLock = new Object(); // 同步锁
        private int mCount = 0; // 加解锁条件
     
        @Test
        public void testBlindCallback() {
            System.out.println("testBlindCallback");
            Callback cb = new Callback() {
     
                public void onStart() {
                    System.out.println("onStart");
                }
     
                public void onProgress(int progress) {
                    System.out.println("onProgress: " + progress);
                }
     
                public void onFinish() {
                    System.out.println("onFinish");
                    synchronized (mLock) {
                        mCount = 0;
                        mLock.notifyAll(); // 回调执行完毕,唤醒主线程
                    }
                }
            };
            System.out.println("before AsyncDemo doJob");
            AsyncDemo demo = new AsyncDemo(5, cb);
            demo.doJob();
            synchronized (mLock) {
                mCount = 1;  // 设置锁条件
                while (mCount > 0) {
                    try {
                    mLock.wait(); // 等待唤醒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("after AsyncDemo doJob");
        }

    测试输出结果:
    testBlindCallback
    before AsyncDemo doJob
    onStart
    onProgress: 0
    onProgress: 1
    onProgress: 2
    onProgress: 3
    onProgress: 4
    onFinish
    after AsyncDemo doJob


    处理方法就是在测试线程执行异步接口后进入wait,等待回调退出接口(onFinish)唤醒test线程。

     



    原文地址:https://blog.csdn.net/sweettool/article/details/75948237

     

    转载于:https://www.cnblogs.com/111testing/p/11111613.html

    展开全文
  • 山东理工职业学院单元教学过程设计首页 课程所属院部软件工程学院 2017--2018学年 第一学期 课程名称 Java语言编程基础 任课教师 单元标题 项目二任务2 学生成绩类操作接口实现 上课地点 学时 6 授课班级 授课时间...
  • Java单元测试

    2014-10-20 10:44:30
    对于单元测试中单元含义,要根据实际情况去判定其具体含义,Java单元一般是指一个类。总来说,单元就是人为规定最小被测功能模块。单元测试是在软件开发过程中要进行最低级别测试活动。   二、...

    一、概述

    单元测试(Unit Testing, UI),是指对软件中的最小可测试单元进行检查和验证。对于单元测试中单元的含义,要根据实际情况去判定其具体含义,Java里的单元一般是指一个类。总的来说,单元就是人为规定的最小的被测功能模块。单元测试是在软件开发过程中要进行的最低级别的测试活动。

     

    二、单元测试包括的具体测试点

    2.1 接口功能测试

    接口功能测试用来保证接口功能的正确性。接口功能测试范围主要包括:(1)新增接口的测试;(2)新增业务功能接口测试;(3)整个服务器的接口测试。

     

    2.2 边界条件测试

    边界值分析是一种黑盒测试方法,由长期的测试工作经验得知,大量的错误是发生在输入或输出的边界上,因此,针对边界进行测试是非常有必要的。

     

    2.3 独立执行通路测试

    独立执行通路测试的目标是保证每一条代码,每个分支都经过测试,这就引出了测试代码覆盖率的问题。

    代码覆盖可分为以下四种情况:(1)语句覆盖:保证每一个语句都执行到了;(2)判定覆盖(分支覆盖):保证每一个分支都执行到;(3)条件覆盖:保证每一个条件都覆盖到true和false(即if、while中的条件语句)(4)路径覆盖:保证每一个路径都覆盖到。

    Java代码覆盖率的相关分析软件:(1)Cobertura:语句覆盖;(2)Emma:Eclipse插件Eclemma。

     

    三、JUnit

    JUnit是Java单元测试框架,已经在Eclipse中默认安装。目前主流的有JUnit3和JUnit4。JUnit3中,测试用例需要继承TestCase类,而在JUnit4中,测试用例无需继承TestCase类,只需使用@Test等注解。JUnit3的package是junit.framework,而JUnit4是org.junit。

    因为平时大部分时候用的都是JUnit4,所以这里重点介绍一下JUnit4。与JUnit3不同,JUnit4通过注解的方式来识别测试方法。目前支持的主要注解有:

    @BeforeClass 全局只会执行一次,而且是第一个运行;

    @Before 在测试方法运行之前运行;

    @Test 测试方法;

    @After 在测试方法运行之后允许;

    @AfterClass 全局只会执行一次,而且是最后一个运行;

    @Ignore 忽略此方法。

    可以看到,执行次序是@BeforeClass -> @Before-> @Test -> @After -> @Before -> @Test -> @After ->@AfterClass。@Ignore注解的方法会被忽略。

     

    四、Mock和Stub

    Mock和Stub是Java测试代码中两种对外部依赖的处理方法。Mock侧重于对外部依赖功能的模拟,而Stub侧重于对功能的实现。例如,对于某外部依赖接口,Mock会直接对这个接口进行模拟,而Stub会新建一个实现了这个接口的类,并在其中填充数据实现外部依赖的功能。

    一般情况下,优先选择Mock方式,因为在Mock方式下,模拟代码与测试代码放在一起,易读性好,而且扩展性、灵活性也比Stub好。比较流行的Mock有JMock、EasyMock、Mockito和PowerMock。

    展开全文
  • Java连接mysql数据库

    2012-08-28 10:22:00
    首先当然是安装数据库软件了,这里使用是mysql,sqlsever那个乱七八糟东西老是出问题,于是决定改投mysql怀抱,这个挺好,而且免费开源。安装方法从前写过,不再写了。然后下载mysql驱动。这里要详细说...

    今天终于搞定用jdbc连接数据库了,太兴奋了,赶快写下来。
    首先当然是安装数据库软件了,这里使用的是mysql,sqlsever那个乱七八糟的东西老是出问题,于是决定改投mysql的怀抱,这个挺好的,而且免费开源。安装方法从前写过,不再写了。
    然后下载mysql的驱动。这里要详细说一下,SUN公司开发Java语言的时候,在数据库这里只是提供了一个标准的接口,或者说是规范,叫做JDBC,这个东西单独放在那里没有任何作用,根本无法连接任何的数据库,只有当你下载相应的数据库驱动程序之后,才可以用JDBC通过这个驱动程序和数据库通信。
    sqlsever就有它的专门的驱动程序,在微软网站上可以下载到。SUN公司自己也开发了数据库驱动程序,叫做JDBC-ODBC驱动程序,是通过建立ODBC桥来连接Windows数据库,但是因为效率低并且有限制,现在一般都不推荐使用。
    使用mysql当然要下载它的驱动了,这个在mysql的官方网站就可以下载到,新版本是mysql-connector-java-3.1.14.zip,下载完成后解压缩,把其中的mysql-connector-java-3.1.14-bin.jar文件和mysql-connector-java-3.1.14-bin-g.jar加到环境变量的classpath中,因为只有这样里面的类文件才可以使用。
    为了能够测试成功,应该新建一个数据库,我建的叫jspstudy,在里面建了一个表叫做addressbook,添加了一条记录,mysql> insert into addressbook (name,address,phone) values ('jjx','zhejiangyuyao','0574-2222222');
    建立一个java文件,输入如下代码:
    import java.sql.*;
    import com.mysql.jdbc.*;
    public class  Database
    {   
        public static void main(String[] args) throws Exception,SQLException
        {
            Class.forName("com.mysql.jdbc.Driver");
            java.sql.Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jspstudy?user=root&password=500158");
            java.sql.Statement sql=conn.createStatement();
            java.sql.ResultSet rs=sql.executeQuery("select * from addressbook");       
            while(rs.next())
            {
                System.out.println(rs.getString(3));
            }
        }
    }

    编译运行,如果可以看到输出结果的话说明数据库连接成功了。
    注:Class.forName("com.mysql.jdbc.Driver");用来加载驱动程序;jdbc:mysql://localhost:3306/jspstudy?user=root&password=******是数据库URL地址,前面都是固定的,3306是端口号,安装mysql的时候有提示,jspstudy是数据库的名字,user是用户名,password后面填写密码

    转载于:https://www.cnblogs.com/zhwl/archive/2012/08/28/2659832.html

    展开全文
  • 由硬件与软件组成。其中硬件主要包括:中央处理器 、内存 、存储设备、输入设备、输出设备 、通信设备。这些组件通过一个称为总线(bus ) 子系统连接。 1.中央处理器:CenturProcsing Unit CPU)是计算机大脑,它...
  • 单元3数据与异常处理程序设计 授课教师Java语言课程组 授课班级 兀总学时10 教学条件 软件开发平台投影设备广播软件 教学素材 参考教材课件授课录像 教学目标设计 知识目标 掌握数组声明和创建 掌握java.util....
  • java类文件单元测试

    千次阅读 2015-09-10 11:53:30
     1、概述 Junit测试是程序员测试,即所谓白盒测试,因为程序员知道被测试的软件如何(How)完成功能和完成什么样(What)的功能。 Junit本质上是一套框架,即开发者制定了一套条条框框,遵循这此条条框框要求编写...
  • 单元测试:从代码度验证业务流程覆盖实现减少BUG快速定位BUG提代码质量减少调试时间实现依赖:单元测试理论法挑选需要单元测试业务代码例管理和执框架Tip:下来就简单说明下单元测试相关理论知识1.1 测试法1....
  • 分层自动化测试5~10 年前,我们接触自动化测试更关注是 UI 层自动化测试,Mercury WinRunner/QTP 是那个时代商业性自动化测试产品典型代表,在那个...在《Google 软件测试之道》中,在 Google 70% 投...
  • 基于JAVA网络远程监控系统软件的实现(源码),可直接导入eclipse,服务器,客户端均可用。可上传、下载文件,类单独封装,代码注释详细,可同时连接多个。
  • 测是提升软件质量有力手段。然而,由于编程语言上支持不力,以及一些不好编程习惯,导致编写测很困难。 最容易理解最容易编写的单测,莫过于独立函数的单测。所谓独立函数,就是只依赖于传入参数,不...
  • Java单元测试和JUnit

    2020-09-02 22:14:18
    测试 -在规定的条件先对程序进行操作,以发现程序错误,衡量软件质量,并对其是否能满足设计要求进行评估的过程。...-一般从构成系统的最小单元开始,持续推进到单元之间的接口知道集成为一个完成的软件系统为止 -白
  • 就开发语言来说,就有JAVA,C++,C#,Perl,JavaScript,Visual Basic,VS.NET,R语言等等。各种语言内部复杂性和每种语言数据类型,数据结构亦不尽相同,各有各法则和编程规矩。在这里,我只讲一下,软件...
  • Java基础---接口

    2018-03-26 20:18:43
    1.接口引入 什么是接口?... 2)软件接口:在java中类是最小程序单元,所以接口是一种特殊类,用来表示一种规范,是N个方法特征集合。 在java中,接口表示一种规范/约束/要求实现类必须遵循该规范,...
  • 软件API 交互、通信、信息交换共享边界,内部修改不影响外部使用,实现解耦 类只能继承,但可以实现多个接口,于是一个类可能是一个混合类型 最高级抽象,也是一种类型,也可以称之为特殊类 抽象类可以添加...
  • 直线形 一层一层 要求严格 回溯难 可行性分析 风险分析(可行性分析报告) 需求分析 (管擦客户业务流程 需求分析说明书 技术实现细节) 设计阶段(概要设计 整体框架+详细设计 具体实现) 开发阶段(允许小...
  • 个人理解:每次软件做版本迭代,为防止引入新问题,需要对重要功能接口进行基本功能测试。此时可以考虑做成自动化(在版本迭代较快,主要功能基本不变化接口适用)eclipse中使用JUnit(JUnit3)之前本人测试...
  • 继承是面向对象三大特性之一,能够实现软件的复用。 Java子类继承父类语法格式如下 class SubClass extends SuperClass { //类定义部分 } Java继承特点: Java只有继承,即每个子类都只有一个直接父类。 ...
  • Java——数据库连接层

    千次阅读 2016-12-05 12:50:19
    之前忘了一个东西,之前提到,软件一般有三层架构,视图层,业务逻辑层和数据库连接层。视图层可以是Android中设计界面,业务逻辑就是...简单写一下代码:以之前图书销售单的例子来说,正规标准点的设计,base包下面
  • Spring中DAO层接口单元测试

    千次阅读 2016-05-08 21:30:57
    单元测试在软件开发流程中有着举足轻重作用,良好单元测试作用跟重要性不需多言。基本上所有的java应用都会跟数据库打交道,DAO层接口测试涉及到数据库测试数据准备、维护、验证及清理。单元测试应该要...
  • postman ...程序员不做设计怎么行,不会做设计程序员莫得灵魂,工欲善其事必先利其器,EA是你做设计好帮手。 XMind 这个可以配合EA一起使用,梳理场景之类事情,画个脑图别提多清晰了。 Outlook
  • Java-Mock简化单元测试

    2020-11-28 21:20:22
    单元测试(英语:Unit Testing)又称为模块测试,是针对程序模块(软件设计最小单位)来进行正确性检验测试工作。程序单元是应用最小可测试部件。在过程化编程中,一个单元就是单个程序、函数、过程等;对于...
  • java 聊天软件源码.zip

    2020-04-13 21:05:01
    一款类似于微信开源免费私有聊天软件,可以部署在任意服务器上,搭建自己聊天服务器,供自己与朋友、用户使用。 特性: 聊、群聊(含文字、图片、语音等) 端到端加密消息(服务端不可解密,服务器...
  • 在面向对象编程思想中,接口是一个非常重要概念。按书上介绍,使用接口,可以实现运行时多态、易维护、易拓展等等...这次使用java作为编写demo语言,主要原因有两个:java是最流行编程语言,基本上学过...
  • 前段时间做了一个工具发布给公司各部门使用后反馈了不少BUG,每次修改后均需要发邮件通知各用户替换最新版本,很不方便,因此后来就写了一个自动升级功能,这样每次发布新版本时只需要将其部署到自动升级...
  • jCpuTest 一个小小基于JAVA的系统测试软件 版本号 jCpuTest_0.01Alpha版 一.实现了CPU测试,包含了一些加减乘除方面运算。 二.实现了内存读写测试,包含连续写内存和读内存。 三.实现了文件读写测试,包含...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 867
精华内容 346
关键字:

java接单的软件

java 订阅