质量属性 可测试性战术

　　软件可测试性是指通过测试（通常是基于运行的测试）揭示软件缺陷的容易程度。在开发设计良好的系统的成本中，至少有40%是用在了测试上。如果我们能够降低此成本，那带回的回报将是巨大的。当然，如果要对系统进行正确的测试，必须能够“控制”每个组件的内部状态及其输入，然后“观察”其输出。这通常通过使用“测试工具”进行，这是一种专门设计的软件，用于执行所测试的软件。这可能会如同在各种接口上回放已记录的数据一样简单，也可能会像测试发动机的燃烧室一样复杂。

 

• 可测试性战术的目标是允许在完成软件开发的一个增量后，较轻松地对软件进行测试。

　　所以为了提高软件的可测试性，首先我们应该遵守“高内聚，低耦合”的设计原则。

　　在例01中使用了单一职责原则，一个类只负责一项职责。它是我们在写代码时必须遵守的原则，他能提高类的可读性，提高系统的可维护性。变更是必然的，如果单一职责原则遵守的好，当修改一个功能时，可以显著降低对其他功能的影响。 需要说明的一点是单一职责原则不只是面向对象编程思想所特有的，只要是模块化的程序设计，都适用单一职责原则。

class Animal{
    public void breathe(String animal){
        System.out.println(animal+"呼吸空气");
    }

    public void breathe2(String animal){
        System.out.println(animal+"呼吸水");
    }
}

public class Client{
    public static void main(String[] args){
        Animal animal = new Animal();
        animal.breathe("牛");
        animal.breathe("羊");
        animal.breathe("猪");
        animal.breathe2("鱼");
    }例01

例01

• 记录回放。

　　记录回放是指捕获跨接口的信息，并将其作为测试专用软件的输入。在正常操作中操作中跨一个接口的信息保存在某个存储库中，它代表来自一个组件的输出和传到一个组件的输入。记录该信息使得能够生成对其中一个组件的测试输入，并保存用于以后比较测试输出。

　　这个功能其实十分常见，按下Ctrl+Z就实现了一次回放的功能。回放大多离不开缓冲区处理和对变量/内存读取，它是实现对一个或一组操作的记录和演示，目的是为了便于进行回归验证，以降低手工重复操作的工作量和能在性能场景中，模拟用户真实操作而进行的前期工作。

　　实现回放功能需要使用到命令模式，命令模式类图如下

 

 

　　新的命令可以很容易地加入到系统中。由于增加新的具体命令类不会影响到其他类，因此增加新的具体命令类很容易，无须修改原有系统源代码，甚至客户类代码，满足“开闭原则”的要求，也符合可测试性战术。

　　例02是对风扇档位的一个控制和恢复，整个过程中，最关键部分是命令对象的封装以及控制类与具体工厂类耦合的解除。

 

public class Control
{
    List<ICommand> onCommands;
    Stack<ICommand> undoCommands;
    Stack<ICommand> redoCommands;  // 记录前一个命令, 便于 undo

    public Control()
    {
        onCommands = new List<ICommand>();
        undoCommands = new Stack<ICommand>();
        redoCommands = new Stack<ICommand>();
    }

    public void SetCommand(int slot, ICommand onCmd)
    {
        onCommands[slot] = onCmd;
    }

    public void OnButtonWasPressed(int slot)
    {
        if (onCommands[slot] != null)
        {
            onCommands[slot].execute();
            undoCommands.Push(onCommands[slot]);
        }
    }

    public void UndoButtonWasPressed() // 撤销,此处用 stack 后进先出的特性
    {
        if (undoCommands.Count > 0)
        {
            ICommand cmd = undoCommands.Pop();
            redoCommands.Push(cmd);
            cmd.undo();
        }
    }

    public void RedoButtonWasPressed()
    {
        if(redoCommands.Count > 0)
        {
            ICommand cmd = redoCommands.Pop();
            undoCommands.Push(cmd);
            cmd.execute();
        }
    }
}

 

•  将接口与实现分离。

　　将接口与实现分离允许实现的代替，以支持各种测试目的。占位实现允许在缺少被占用的组件时，对系统的剩余部分进行测试。用一个组件代替某个专门的组件能够使被代替的组件充当系统剩余部分的测试工具。有了标准的接口，进行有效的隔离，能够极大程度的减少测试员的工作量，模块化测试，单元测试极大地减少了测试过程中用例的原则，如果没有接口隔离，不管用的是极值分析法还是等价划分法，都对测试员的工作造成了极大的负担，相对而言，单元测试更加简化了工作量，让白盒测试过程中的逻辑复杂度降低了不少。

public interface ImageLoader {

    /**
     * 初始化ImageLoader
     * @param appContext ApplicatonContext
     */
    void init(@NonNull Context appContext);

    /**
     * 展示图片
     * @param targetView
     * @param uri
     * @param listener
     */
    void displayImage(@NonNull ImageView targetView, @NonNull Uri uri, @Nullable LoadListener listener);

    /**
     * 取消图片展示
     * @param targetView
     */
    void cancelDisplay(ImageView targetView);

    /**
     * 销毁ImageLoader, 回收资源
     */
    void destroy();

}

 

　　3.特化访问路线/接口。具有特化的测试接口允许通过测试工具并独立于其正常操作，来捕获或指定组件的变量值。例如，可以通过允许特化的接口提供原数据，测试工具利用该接口推动其活动。

 

二、内部监视

　　内置监视器。组件可以维持状态、性能负载、容量、安全性或其他可通过接口访问的信息。此接口可以是该组件的一个永久接口，也可以是通过instrumentation技巧临时引入的接口，如面向方面编程或预处理程序宏。一个常见的技巧就是当监视状态被激活时记录事件。监视状态实际上会增加测试工作，因为随着监视的关闭，可能必须重复测试。尽管额外测试需要一定的开销，但这却使组件活动的可见性得以提高，这样做是值得的。

public class ThreadDemo10 {
    public static void main(String[] args){
        Buffer buffer=new Buffer();
        Productor p = new Productor("生产者",buffer);
        Consumer c=new Consumer("生产者",buffer);
        p.start();
        c.start();
    }

}
//生产者
class Productor extends Thread{
    private String name;
    private Buffer buffer;
    public Productor(String name,Buffer buffer){
        this.name=name;
        this.buffer=buffer;
    }
    public void run(){
        int i=0;
        while(true){
            buffer.add(i++);   //生产者线程往缓冲区里面添加数
            try{
                Thread.sleep(50);;
            }
            catch(Exception e){
                e.printStackTrace();   //打印栈跟踪信息
            }
            System.out.println("add: "+i+"");
        }
    }
}
//消费者
class Consumer extends Thread{
    private String name;
    private Buffer buffer;
    public Consumer(String name,Buffer buffer){
        this.name=name;
        this.buffer=buffer;
    }
    public void run(){
            while(true){
            int i=buffer.remove();  //消费者从缓冲区里面取出数
            try{
                Thread.sleep(100);;
            }
            catch(Exception e){
                e.printStackTrace();
            }
            System.out.println("remove: "+i);

        }
    }
}
class Buffer{
    private java.util.List<Integer> list=new java.util.ArrayList<Integer>();
    private int MAX=100;
    public void add(int n){
        synchronized(this){
            try{
                while(list.size()>=MAX){
                    try{
                        this.wait();   //当缓冲区中的数超出最大值时，调用wait()方法释放锁的监控权，线程进入等待队列
                    }
                    catch(Exception e){
                        e.printStackTrace();
                    }

                }
                list.add(n);
                System.out.println("size: "+list.size());
                this.notify();
            }
            catch(Exception e){
                e.printStackTrace();
            }

        }
    }
    public int remove(){
        synchronized(this){
            try{
                while(list.size()==0){
                    try{
                        this.wait();   // //当缓冲区中的数为0时，调用wait()方法释放锁的监控权，线程进入等待队列
                    }
                    catch(Exception e){
                        e.printStackTrace();
                    }
                }
                int i=list.remove(0);
                this.notify();
                return i;
            }
            catch(Exception e){
                e.printStackTrace();
            }
            return -1;
        }
    }
}

wait()、notify()和notifyAll()方法必须在这些方法的接收对象的同步方法或同步块中调用。否则就会出现IlleagalMonitorStateException异常。
当调用wait()方法时，它终止线程同时释放对象的锁。当线程被通知之后重新启动时，锁就被重新自动获取。
考虑典型的生产者与消费者的例子。假设使用缓冲区存储整数。缓冲区的大小是受限的。缓冲区提供add(int)方法将一个int值添加到缓冲区中，还提供remove()方法从缓冲区中取出值