精华内容
下载资源
问答
  • 白盒测试----六覆盖方法

    万次阅读 多人点赞 2017-12-03 19:02:44
    白盒测试又称结构测试,透明盒测试、逻辑驱动测试或基于代码的测试。白盒测试是一种测试用例设计方法,白盒指的是程序的内部结构和运作机制是可见的。...白盒测试的方法:大致分为静态方法动态方法两大类。A. 静

    定义:
      白盒测试又称结构测试,透明盒测试、逻辑驱动测试或基于代码的测试。白盒测试是一种测试用例设计方法,白盒指的是程序的内部结构和运作机制是可见的。

    白盒测试的目的:
      通过检查软件内部的逻辑结构,对软件中的逻辑路径进行覆盖测试;在程序不同地方设置检查点,检查程序的状态,以确定实际运行状态与预期状态是否一致。

    **白盒测试的方法:**大致分为静态方法和动态方法两大类。

    A. 静态分析:
      是一种不执行程序而进行测试的技术。静态分析的主要目的是检查软件的表示和描述是否一致,没有冲突或者没有歧义。

    B. 动态分析:
      当软件系统在模拟或真实的环境中执行前、过程中和执行后,对其行为分析。它显示了一个系统在检查状态下是否正确。在动态分析技术中,最重要的技术是路径和分支测试。下面要介绍的六种覆盖测试方法属于动态分析方法。

    符号说明:

    ^ 代表逻辑运算符 && 或者 ||
      
      T 代表 True F 代表 False
      
      A / B 代表条件表达式

    (1)语句覆盖

    使程序中的每个可执行语句都能执行一次的测试用例

    测试用例条件: A ^ B = T

    在这里插入图片描述

    (2)判定覆盖(分支覆盖)

    对于判断语句,在设计用例的时候,要设计判断语句结果为True和False的两种情况
      
    测试用例条件:
           A ^ B = T
           A ^ B = F
           在这里插入图片描述

    (3)条件覆盖

    设计用例时针对判断语句里面每个条件表达式true 和 false各取值一次,不考判断语句的计算结果

    测试用例条件:
           A=T     A=F
           B=T     B=F
           在这里插入图片描述

    (4)判定条件覆盖(分支条件覆盖)

    设计测试用例时,使得判断语句中每个条件表达式的所有可能结果至少出现一次,每个判断语句本身所有可能结果也至少出现一次。

    测试用例条件:
           A ^ B = T    A ^ B = F
           A=T     A=F
           B=T     B=F
    在这里插入图片描述

    (5)条件组合覆盖

    设计测试用例时,使得每个判断语句中条件结果的所有可能组合至少出现一次

    测试用例条件:
           A= T    B= T
           A= T    B= F
           A= F    B= T
           A= F    B= F
    在这里插入图片描述

    (6)路径覆盖

    设计测试用例时,覆盖程序中所有可能的执行路径

    优点:这种覆盖方法可以对程序进行彻底的测试用例覆盖,比前面讲的五种方法覆盖度都要高。

    缺点:于路径覆盖需要对所有可能的路径进行测试(包括循环、条件组合、分支选择等),那么需要设计大量、复杂的测试用例,使得工作量呈指数级增长。路径覆盖虽然是一种比较强的覆盖,但未必考虑判断语句中条件表达式结果的组合,并不能代替条件覆盖和条件组合覆盖。

    展开全文
  • 二、恢复测试环境种方法: 1、采用虚拟机,将Web应用及数据库都放到虚拟机上,通过快照方式恢复测试环境(最好) 2、开启数据库 三、实现方式 1.Ant方式(以编程方式动态调用Ant文件)   (1)新建Java...

    一、测试环境

    数据库:Oracle10g

    前台:Dojo

    二、恢复测试环境的三种方法:

    1、采用虚拟机,将Web应用及数据库都放到虚拟机上,通过快照的方式恢复测试环境(最好)

    2、开启数据库的

    三、实现方式

    1.Ant方式(以编程方式动态调用Ant文件)

     

    (1)新建Java文件,内容如下:

    package com.neusoft.server;
    import java.io.File;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    import org.apache.tools.ant.BuildException;
    import org.apache.tools.ant.DefaultLogger;
    import org.apache.tools.ant.Project;
    import org.apache.tools.ant.ProjectHelper;
    
    /** 
     * <p>Description: [还原数据库]</p>
     * @author  <a href="mailto: xxxx@xxxxxx.com">xxxx</a>
     * @version $Revision$ 
     */ 
    public class FlashBack {
    	private Project project;
    	private File buildFile;
    	private ProjectHelper helper;
    
    	/**
    	 * <p>Discription:[构造器方法描述]</p>
    	 * @coustructor 方法.
    	 */
    	public FlashBack() {
    		buildFile = new File("build.xml");
    		project = new Project();
    		DefaultLogger consoleLogger = new DefaultLogger();
    		consoleLogger.setErrorPrintStream(System.err);
    		consoleLogger.setOutputPrintStream(System.out);
    		consoleLogger.setMessageOutputLevel(Project.MSG_INFO);
    		project.addBuildListener(consoleLogger);
    		project.fireBuildStarted();
    		project.init();
    		helper = ProjectHelper.getProjectHelper();
    	}
    	
    	/**
    	 * <p>Discription:[闪回数据库]</p>
    	 * @param time
    	 * @return
    	 * @author:[xxxx]
    	 * @update:[日期YYYY-MM-DD] [更改人姓名][变更描述]
    	 */
    	public boolean flashBack(String time) {
    	    //验证时间格式
    	    Pattern p = Pattern.compile("\\d{4}-\\d{2}-\\d{2}:\\d{2}:\\d{2}:\\d{2}");  
    	    Matcher m = p.matcher(time);  
    	    boolean tag = false;
    	    if(m.matches())
    	    {
    	    	try {
    				project.setProperty("time", time);
    				helper.parse(project, buildFile);
    				project.executeTarget(project.getDefaultTarget());
    				project.fireBuildFinished(null);
    				tag = true;
    			} catch (BuildException e) {
    				project.fireBuildFinished(e);
    				e.printStackTrace();
    			}
    	    }
    		return tag;
    	}
    }
    

     

    (2)新建Ant文件,内容如下:

     

    <?xml version="1.0" encoding="UTF-8"?>
    <project name="flashBack" default="startVM" basedir="." xmlns:ora="antlib:net.sf.incanto">
    	<!-- 虚拟机镜像文件目录-->
    	<property name="vmware.dir" value=" E:\\UbuntuVM\\Ubuntu.vmx">
    	</property>
    	<!-- 虚拟机快照名称,名称之间不允许包含空格-->
    	<property name="snapshot" value="Snapshot3">
    	</property>
    	<!-- 方式1:通过执行SQL语句还原数据库 -->
    	<target name="runSql">
    		<ora:sqlplus logon="/NOLOG" silent="true" failοnerrοr="true">
    			<![CDATA[
            	--首先以DBA身份连接数据库;
            	conn system/tiger as sysdba;
            	--关闭数据库;
            	shutdown immediate;
            	--进入MOUNT状态;
            	startup mount;
            	--开始闪回数据;
            	flashback database to timestamp  to_date('${time}','yyyy-mm-dd:hh24:mi:ss'); 
            	--打开数据库;
            	alter database open resetlogs;
            	--退出;
            	exit;  
                ]]>
    		</ora:sqlplus>
    	</target>
    	<!-- 方式2:通过调用虚拟机的Vmrun命令,还原虚拟机快照-->
    	<target name="revertSnap">
    		<exec executable="cmd.exe">
    			<arg line="/c vmrun -t ws revertToSnapshot ${vmware.dir} ${snapshot}" />
    		</exec>
    	</target>
    	<target name="startVM" depends="revertSnap">
    		<exec executable="cmd.exe">
    			<arg line="/c vmrun -t ws start ${vmware.dir}" />
    		</exec>
    	</target>
    </project>

    参考资料:

     

    以编程方式调用 Apache Ant

     

    http://www.ibm.com/developerworks/cn/websphere/library/techarticles/0502_gawor/0502_gawor.html

     

    2.批处理方式(描述:使用批处理文件调用SQL文件)

    (1)新建FlashBack.bat文件,内容如下:

    @echo off 
    sqlplus /nolog @runSql.sql

    (2)新建runSql.sql文件,内容如下:

    --首先以DBA身份连接数据库;
    conn system/tiger as sysdba;
    --关闭数据库;
    shutdown immediate;
    --进入MOUNT状态;
    startup mount;
    --开始闪回数据;
    flashback database to timestamp  to_date('2011-08-09:16:53:01','yyyy-mm-dd:hh24:mi:ss'); 
    --打开数据库;
    alter database open resetlogs;
    --退出;
    exit;  
    展开全文
  • # Created by Jerry Wang, last modified on Sep 25, 2014 测试代码: ``` ...方法1在每一次循环里都会修改一次dom node,而...在动态插入子node p个数很小情况下,两种方法性能相差无几。 插入100个节点: ...

    Created by Jerry Wang, last modified on Sep 25, 2014

    测试代码:

    <html>
    <script src="C:\Users\i042416\Desktop\jquery_1.7.1.js">
    </script>
    <script>
      function insert1(number) {
       var parent = $("#way1");
       for( var i = 0 ; i < number; i++) {
       parent.append("<p>hh</p>");
       }
      }
      function insert2(number) {
       var parent = $("#way2");
       var content = "<div>way2";
       while(number--) {
       content += "<p>hh</p>";
       }
       content += "</div>";
       parent.html(content);
      }
      $(document).ready(function() {
       console.time("way1");
       insert1(1);
       console.timeEnd("way1");
       console.time("way2");
       insert2(1);
       console.timeEnd("way2");
      });
    </script>
    <body>
     <div id = "way1">way1</div>
     <div id = "way2">way2</div>
    </body>
    </html>
    

    方法1在每一次循环里都会修改一次dom node,而方法2只有在循环结束后才进行唯一的一次dom node修改。
    在动态插入子node p的个数很小的情况下,两种方法性能相差无几。
    插入100个节点:
    clipboard1
    当个数增加到1000个时:
    clipboard2
    个数10000个时:

    clipboard3

    展开全文
  • Java两种动态代理JDK动态代理和CGLIB动态代理

    万次阅读 多人点赞 2018-08-07 15:33:35
    代理模式是23设计模式,他是指一个对象A通过持有另一个对象B,可以具有B同样行为模式。为了对外开放协议,B往往实现了一个接口,A也会去实现接口。但是B是“真正”实现类,A则比较“虚”,他借用了B...

    目录

    代理模式

    JDK动态代理

    cglib动态代理

    测试


    代理模式

    代理模式是23种设计模式的一种,他是指一个对象A通过持有另一个对象B,可以具有B同样的行为的模式。为了对外开放协议,B往往实现了一个接口,A也会去实现接口。但是B是“真正”实现类,A则比较“虚”,他借用了B的方法去实现接口的方法。A虽然是“伪军”,但它可以增强B,在调用B的方法前后都做些其他的事情。Spring AOP就是使用了动态代理完成了代码的动态“织入”。

    使用代理好处还不止这些,一个工程如果依赖另一个工程给的接口,但是另一个工程的接口不稳定,经常变更协议,就可以使用一个代理,接口变更时,只需要修改代理,不需要一一修改业务代码。从这个意义上说,所有调外界的接口,我们都可以这么做,不让外界的代码对我们的代码有侵入,这叫防御式编程。代理其他的应用可能还有很多。

    上述例子中,类A写死持有B,就是B的静态代理。如果A代理的对象是不确定的,就是动态代理。动态代理目前有两种常见的实现,jdk动态代理和cglib动态代理。

    JDK动态代理

    jdk动态代理是jre提供给我们的类库,可以直接使用,不依赖第三方。先看下jdk动态代理的使用代码,再理解原理。

    首先有个“明星”接口类,有唱、跳两个功能:

    package proxy;
    
    public interface Star
    {
        String sing(String name);
        
        String dance(String name);
    }
    

    再有个明星实现类“刘德华”:

    package proxy;
    
    public class LiuDeHua implements Star
    {   
        @Override
        public String sing(String name)
        {
             System.out.println("给我一杯忘情水");
    
            return "唱完" ;
        }
        
        @Override
        public String dance(String name)
        {
            System.out.println("开心的马骝");
    
            return "跳完" ;
        }
    }
    

    明星演出前需要有人收钱,由于要准备演出,自己不做这个工作,一般交给一个经纪人。便于理解,它的名字以Proxy结尾,但他不是代理类,原因是它没有实现我们的明星接口,无法对外服务,它仅仅是一个wrapper。

    package proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class StarProxy implements InvocationHandler
    {
        // 目标类,也就是被代理对象
        private Object target;
        
        public void setTarget(Object target)
        {
            this.target = target;
        }
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
        {
            // 这里可以做增强
            System.out.println("收钱");
            
            Object result = method.invoke(target, args);
            
            return result;
        }
        
        // 生成代理类
        public Object CreatProxyedObj()
        {
            return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        }  
       
    }
    

    上述例子中,方法CreatProxyedObj返回的对象才是我们的代理类,它需要三个参数,前两个参数的意思是在同一个classloader下通过接口创建出一个对象,该对象需要一个属性,也就是第三个参数,它是一个InvocationHandler。需要注意的是这个CreatProxyedObj方法不一定非得在我们的StarProxy类中,往往放在一个工厂类中。上述代理的代码使用过程一般如下:

    1、new一个目标对象

    2、new一个InvocationHandler,将目标对象set进去

    3、通过CreatProxyedObj创建代理对象,强转为目标对象的接口类型即可使用,实际上生成的代理对象实现了目标接口。

            Star ldh = new LiuDeHua();
    
            StarProxy proxy = new StarProxy();
    
            proxy.setTarget(ldh); 
      
            Object obj = proxy.CreatProxyedObj();
            
            Star star = (Star)obj;

    Proxy(jdk类库提供)根据B的接口生成一个实现类,我们成为C,它就是动态代理类(该类型是 $Proxy+数字 的“新的类型”)。生成过程是:由于拿到了接口,便可以获知接口的所有信息(主要是方法的定义),也就能声明一个新的类型去实现该接口的所有方法,这些方法显然都是“虚”的,它调用另一个对象的方法。当然这个被调用的对象不能是对象B,如果是对象B,我们就没法增强了,等于饶了一圈又回来了。

    所以它调用的是B的包装类,这个包装类需要我们来实现,但是jdk给出了约束,它必须实现InvocationHandler,上述例子中就是StarProxy, 这个接口里面有个方法,它是所有Target的所有方法的调用入口(invoke),调用之前我们可以加自己的代码增强。

    看下我们的实现,我们在InvocationHandler里调用了对象B(target)的方法,调用之前增强了B的方法。

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
        {
            // 这里增强
            System.out.println("收钱");
            
            Object result = method.invoke(target, args);
            
            return result;
        }

    所以可以这么认为C代理了InvocationHandler,InvocationHandler代理了我们的类B,两级代理。

    整个JDK动态代理的秘密也就这些,简单一句话,动态代理就是要生成一个包装类对象,由于代理的对象是动态的,所以叫动态代理。由于我们需要增强,这个增强是需要留给开发人员开发代码的,因此代理类不能直接包含被代理对象,而是一个InvocationHandler,该InvocationHandler包含被代理对象,并负责分发请求给被代理对象,分发前后均可以做增强。从原理可以看出,JDK动态代理是“对象”的代理。

    下面看下动态代理类到底如何调用的InvocationHandler的,为什么InvocationHandler的一个invoke方法能为分发target的所有方法。C中的部分代码示例如下,通过反编译生成后的代码查看,摘自链接地址。Proxy创造的C是自己(Proxy)的子类,且实现了B的接口,一般都是这么修饰的:

    public final class XXX extends Proxy implements XXX
    

    一个方法代码如下:

    
      public final String SayHello(String paramString)
      {
        try
        {
          return (String)this.h.invoke(this, m4, new Object[] { paramString });
        }
        catch (Error|RuntimeException localError)
        {
          throw localError;
        }
        catch (Throwable localThrowable)
        {
          throw new UndeclaredThrowableException(localThrowable);
        }
    

    可以看到,C中的方法全部通过调用h实现,其中h就是InvocationHandler,是我们在生成C时传递的第三个参数。这里还有个关键就是SayHello方法(业务方法)跟调用invoke方法时传递的参数m4一定要是一一对应的,但是这些对我们来说都是透明的,由Proxy在newProxyInstance时保证的。留心看到C在invoke时把自己this传递了过去,InvocationHandler的invoke的第一个方法也就是我们的动态代理实例类,业务上有需要就可以使用它。(所以千万不要在invoke方法里把请求分发给第一个参数,否则很明显就死循环了)

    C类中有B中所有方法的成员变量

      private static Method m1;
      private static Method m3;
      private static Method m4;
      private static Method m2;
      private static Method m0;
    

    这些变量在static静态代码块初始化,这些变量是在调用invocationhander时必要的入参,也让我们依稀看到Proxy在生成C时留下的痕迹。

    static
      {
        try
        {
          m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
          m3 = Class.forName("jiankunking.Subject").getMethod("SayGoodBye", new Class[0]);
          m4 = Class.forName("jiankunking.Subject").getMethod("SayHello", new Class[] { Class.forName("java.lang.String") });
          m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
          m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
          return;
        }
        catch (NoSuchMethodException localNoSuchMethodException)
        {
          throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException localClassNotFoundException)
        {
          throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
        }
      }
    

    从以上分析来看,要想彻底理解一个东西,再多的理论不如看源码,底层的原理非常重要。

    jdk动态代理类图如下

    cglib动态代理

    我们了解到,“代理”的目的是构造一个和被代理的对象有同样行为的对象,一个对象的行为是在类中定义的,对象只是类的实例。所以构造代理,不一定非得通过持有、包装对象这一种方式。

    通过“继承”可以继承父类所有的公开方法,然后可以重写这些方法,在重写时对这些方法增强,这就是cglib的思想。根据里氏代换原则(LSP),父类需要出现的地方,子类可以出现,所以cglib实现的代理也是可以被正常使用的。

    先看下代码

    package proxy;
    
    import java.lang.reflect.Method;
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    public class CglibProxy implements MethodInterceptor
    {
        // 根据一个类型产生代理类,此方法不要求一定放在MethodInterceptor中
        public Object CreatProxyedObj(Class<?> clazz)
        {
            Enhancer enhancer = new Enhancer();
            
            enhancer.setSuperclass(clazz);
            
            enhancer.setCallback(this);
            
            return enhancer.create();
        }
        
        @Override
        public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable
        {
            // 这里增强
            System.out.println("收钱");
            
            return arg3.invokeSuper(arg0, arg2);
        } 
    }
    

    从代码可以看出,它和jdk动态代理有所不同,对外表现上看CreatProxyedObj,它只需要一个类型clazz就可以产生一个代理对象, 所以说是“类的代理”,且创造的对象通过打印类型发现也是一个新的类型。不同于jdk动态代理,jdk动态代理要求对象必须实现接口(三个参数的第二个参数),cglib对此没有要求。

    cglib的原理是这样,它生成一个继承B的类型C(代理类),这个代理类持有一个MethodInterceptor,我们setCallback时传入的。 C重写所有B中的方法(方法名一致),然后在C中,构建名叫“CGLIB”+“$父类方法名$”的方法(下面叫cglib方法,所有非private的方法都会被构建),方法体里只有一句话super.方法名(),可以简单的认为保持了对父类方法的一个引用,方便调用。

    这样的话,C中就有了重写方法、cglib方法、父类方法(不可见),还有一个统一的拦截方法(增强方法intercept)。其中重写方法和cglib方法肯定是有映射关系的。

    C的重写方法是外界调用的入口(LSP原则),它调用MethodInterceptor的intercept方法,调用时会传递四个参数,第一个参数传递的是this,代表代理类本身,第二个参数标示拦截的方法,第三个参数是入参,第四个参数是cglib方法,intercept方法完成增强后,我们调用cglib方法间接调用父类方法完成整个方法链的调用。

    这里有个疑问就是intercept的四个参数,为什么我们使用的是arg3而不是arg1?

        @Override
        public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable
        {
            System.out.println("收钱");
            
            return arg3.invokeSuper(arg0, arg2);
        }

     因为如果我们通过反射 arg1.invoke(arg0, ...)这种方式是无法调用到父类的方法的,子类有方法重写,隐藏了父类的方法,父类的方法已经不可见,如果硬调arg1.invoke(arg0, ...)很明显会死循环。

    所以调用的是cglib开头的方法,但是,我们使用arg3也不是简单的invoke,而是用的invokeSuper方法,这是因为cglib采用了fastclass机制,不仅巧妙的避开了调不到父类方法的问题,还加速了方法的调用。

    fastclass基本原理是,给每个方法编号,通过编号找到方法执行避免了通过反射调用。

    对比JDK动态代理,cglib依然需要一个第三者分发请求,只不过jdk动态代理分发给了目标对象,cglib最终分发给了自己,通过给method编号完成调用。cglib是继承的极致发挥,本身还是很简单的,只是fastclass需要另行理解。

    参考

    https://blog.csdn.net/jiankunking/article/details/52143504

    http://www.php.cn/java-article-407212.html

    https://www.cnblogs.com/chinajava/p/5880887.html

    https://rejoy.iteye.com/blog/1627405

    测试

       public static void main(String[] args)
        {
            int times = 1000000;
            
            Star ldh = new LiuDeHua();
            StarProxy proxy = new StarProxy();
            proxy.setTarget(ldh);
            
            long time1 = System.currentTimeMillis();
            Star star = (Star)proxy.CreatProxyedObj();
            long time2 = System.currentTimeMillis();
            System.out.println("jdk创建时间:" + (time2 - time1));
            
            CglibProxy proxy2 = new CglibProxy();
            long time5 = System.currentTimeMillis();
            Star star2 = (Star)proxy2.CreatProxyedObj(LiuDeHua.class);
            long time6 = System.currentTimeMillis();
            System.out.println("cglib创建时间:" + (time6 - time5));
            
            long time3 = System.currentTimeMillis();
            for (int i = 1; i <= times; i++)
            {
                star.sing("ss");
                
                star.dance("ss");
            }
            long time4 = System.currentTimeMillis();
            System.out.println("jdk执行时间" + (time4 - time3));
            
            long time7 = System.currentTimeMillis();
            for (int i = 1; i <= times; i++)
            {
                star2.sing("ss");
                
                star2.dance("ss");
            }
            
            long time8 = System.currentTimeMillis();
            
            System.out.println("cglib执行时间" + (time8 - time7));   
        }

    经测试,jdk创建对象的速度远大于cglib,这是由于cglib创建对象时需要操作字节码。cglib执行速度略大于jdk,所以比较适合单例模式。另外由于CGLIB的大部分类是直接对Java字节码进行操作,这样生成的类会在Java的永久堆中。如果动态代理操作过多,容易造成永久堆满,触发OutOfMemory异常。spring默认使用jdk动态代理,如果类没有接口,则使用cglib。

    展开全文
  • jq动态拼接标签的两种方法及其注意事项 测试动态生成标签 动态生成标签的位置 $(function(){ $('#btn').bind('click', function() { //正确方法1: 在标签...
  • 从国内外目前嵌入式系统软件测试研究现状来看,对于软件分支覆盖率、性能分析等重要指标获取,无外乎采用都是介入式[2]与非介入式[3]两种方法之一。介入式方法主要还是采用静态分析和产生可执行代码插桩式动态...
  • 下面将介绍两种方式实现动态添加和删除列表 1.不使用组件 <!DOCTYPE html> <html> <head> <meta charset=utf-8> <title>Vue 测试实例 - vue实现列表增加和删除</title> [removed]...
  • 现在就可以,在模拟器上运行,测试看看效果了; 2.通过java代码给Spinner添加下拉资源 事件监听 getSelectedItem()方法获取Spinner中被点击一项; getSelectedItemId()方法获取Spinner中被点击一项...
  • (四)动态白盒测试:基本路径测试方法

    万次阅读 多人点赞 2018-06-27 11:33:00
    基本路径方法设计测试用例步骤 1、画出控制流程图 2、计算圈复杂度(环路复杂度) 3、整理基本路径集合 4、导出测试用例 ...流图只有两种图形符号: - 每一个圆称为流图节点,代码一条...
  • 动态测试和静态测试 软件测试主要有两种基本方法,即:动态...在对软件进行动态测试时,一般会用到两种基本测试方法。至于到底该采用哪种方法则取决于测试需求。通常情况下,测试需求又分为高层级需求和低层级需求,人
  • 1.创建一WIN32动态链接库工程Dll1,添加一C++源文件Dll1.cpp,在源文件中编写一个测试函数 int _stdcall add(int a, int b) {  return (a+b); } 2.定义一模块定义文件Dll1.def,在里面添加如下内容: LIBRARY ...
  • 下面将介绍两种方式实现动态添加和删除列表1.不使用组件Vue 测试实例 - vue实现列表增加和删除添加{{list.title}} 删除var vm = new Vue({el: '#app',data: {newAddText:'',lists:[{id:1,title:'手机号码'},{id:2,...
  • 第一种方法:setAttribute() 例子: html部分:点击js部分: var a = document.getElementById("ID"); a.setAttribute("onclick","javacript:alert('测试')");  第二种方法:addEventListener() 例子: ...
  • 软件测试方法

    2020-12-23 20:18:40
    软件测试的方法 原则:穷尽测试是不可能的,即穷举法不可能在软件测试上使用。 按照执行测试时是否需要运行程序,软件测试可以划分为静态测试和...动态测试中有两种非常流行的测试技术,即黑盒测试和白盒测试。 ...
  • 测试方法 测试工具 测试自动化

    千次阅读 2012-07-26 16:18:04
    1.两种分类,四种方法: 黑盒测试:无需知道软件内部是怎么运行 白盒测试:需要知道软件内部是怎么运行 静态测试:测试软件不运行部分--(只是检查和审核) 动态测试:测试软件要运行部分--...
  • 什么是动态黑盒测试? 不深入代码细节的测试软件方法称为动态黑盒方法测试员不必知道程序如何运行,内部逻辑是怎样测试...测试软件有两种基本方法:通过性测试 test-to-past 和失效性测试 test-to-fail 在设计和
  • 2、 软件测试的两种极端情况: 第一种:知道产品的需求规格,但是不知道其内部逻辑实现,可以进行测试证明每个需求是否实现—黑盒测试—关心业务需求 第二种:知道产品的内部逻辑实现功能,可以通过测试证明每种...
  • 提出了一采用激光动态测量车轮直径的方法, 介绍了使用单个激光位移传感器和个激光位移传感器动态测量车轮直径工作原理, 并对影响测量精度主要误差因素进行了分析和仿真计算。结果表明, 采用个激光位移...
  • 加入我们参加4月2日(星期四)太平洋... 为了应对这一现实,越来越多组织在左移策略上进行投资,以改善其测试流程和试生产工具,以确保代码质量成为一开始首要任务。 诸如SonarQube之类静态分析工具和诸如...
  • 最近要写个程序,既有更新,也有删除,...网上讲述创建动态内表的方法大致有两种。我做了一下测试,源代码附后。在这里提醒大家一点,在做动态更新程序时候,要注意两点: 1.使用modify (p_tabname) from &l...
  • 多组测试数据,每组第一行给出N 第二行一个M( M 下面跟M行 每行一个数字(1,2,3)每个数字对应着一个操作 Output 对于每个询问操作,请输出结果,每次询问一行(每行最后没有多余空格,如果一行没有数字则为...

空空如也

空空如也

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

动态测试的两种测试方法