如何使用jUnit测试使用单例的类? [英] How can I use jUnit to test a class that uses a singleton?

问题描述

我正在为机器开发模拟器.它读取文件，并将其以字符串(作为二进制数)存储到应该模拟计算机内存的数组中.然后将其传递给解释器，该解释器获取数组的第一个元素，并基于前四个字符将其发送到另一个类.

其中一个此类的示例如下:

public class Add {
private String cell;

Add() {
    cell = null;
}

/**
 * Method that performs the operation add.
 */
public void addition() {
    // TODO Figure out 2's complement.
    Loader instance = Loader.Instance();
    cell = instance.getCell();

    Integer DR1num = Integer.parseInt(cell.substring(4, 6), 2);
    Integer SR1num = Integer.parseInt(cell.substring(7, 9), 2);

    if (cell.charAt(10) == '0') {
        Integer SR2num = Integer.parseInt(cell.substring(13, 15), 2);
        Integer addedval = instance.getRegister(SR1num)
                + instance.getRegister(SR2num);
        instance.setCCR(addedval);
        instance.setRegister(DR1num, addedval);
    } else if (cell.charAt(10) == '1') {
        Integer immediate = Integer.parseInt(cell.substring(11, 15), 2);
        Integer addedval = instance.getRegister(SR1num) + immediate;
        instance.setCCR(addedval);
        instance.setRegister(DR1num, addedval);
    } else {
        System.err.println("Invalid Char at Position 10. Expected 0 or 1");
    }

    instance.incrementPC();

}

public String getcell() {
    return cell;
}

}

变量说明: 实例是单例 单元格是存储在内存阵列中的二进制字符串 DR1num是目标寄存器. (又名R0，R1，... R7) SR1num是源寄存器

此操作的作用是获取两个源寄存器并将它们加在一起(如果条件代码寄存器为正，负或零，则将其设置为条件代码寄存器)，或者获取源寄存器和立即数并将这两个寄存器相加.结果存储在目标寄存器中.

我选择使用单例类，因为我需要使存储器，通用寄存器，条件代码寄存器和程序计数器在整个程序中保持同步.这带来的问题是我不知道如何测试我的程序(最好是使用jUnit).

我想到测试程序的唯一方法是编写一堆单独的文件供程序读取.除了这意味着，它不仅测试程序的一部分，而且至少测试三个类.程序中读取的类，包含用于单例的所有方法，确定要调用哪个类的类以及最终实际执行该部分的类(例如Add).

有人对更好的测试方法有什么建议吗?

解决方案

避免这种情况的方法传统上是使用控制反转(IoC)并将 inject 实例添加到客户端中班级.您的客户端类提供了其运行所需的所有依赖类，而与依赖类的生命周期无关.

Spring 是用于执行此操作的常见Java框架，但是您可以通过构造类来简单地进行注入并引用了单例(很简单).

如果singleton类实现了接口，则测试将变得更加容易，因为您可以注入 mock 变体而不是真实的实现，并构建模拟以为测试提供合适的测试数据. >

I am developing a simulator for a machine. It reads a file in, stores it in a string (as a binary number) to an array that is supposed to simulate the memory of a computer. Then it gets passed to an interpreter that takes gets the first element of the array, and based on the first 4 characters it gets sent to another class.

An example of one of those classes is below:

public class Add {
private String cell;

Add() {
    cell = null;
}

/**
 * Method that performs the operation add.
 */
public void addition() {
    // TODO Figure out 2's complement.
    Loader instance = Loader.Instance();
    cell = instance.getCell();

    Integer DR1num = Integer.parseInt(cell.substring(4, 6), 2);
    Integer SR1num = Integer.parseInt(cell.substring(7, 9), 2);

    if (cell.charAt(10) == '0') {
        Integer SR2num = Integer.parseInt(cell.substring(13, 15), 2);
        Integer addedval = instance.getRegister(SR1num)
                + instance.getRegister(SR2num);
        instance.setCCR(addedval);
        instance.setRegister(DR1num, addedval);
    } else if (cell.charAt(10) == '1') {
        Integer immediate = Integer.parseInt(cell.substring(11, 15), 2);
        Integer addedval = instance.getRegister(SR1num) + immediate;
        instance.setCCR(addedval);
        instance.setRegister(DR1num, addedval);
    } else {
        System.err.println("Invalid Char at Position 10. Expected 0 or 1");
    }

    instance.incrementPC();

}

public String getcell() {
    return cell;
}

}

Variable Descriptions: instance is the singleton cell is the binary string that is stored in the memory array DR1num is Destination Register. (aka R0, R1, ... R7) SR1num is Source Register

What this operation does is takes either two Source Registers and adds them together (then sets the Condition Code Register if it is positive, negative, or zero), or takes a Source Register and an immediate value and adds those two together. The result is stored in the Destination Register.

I chose to use a singleton class because I need the Memory, General Purpose Registers, Condition Code Register, and Program Counter to be in sync throughout the entire program. The problem that this presents is that I have no idea how to test my program (preferably with jUnit).

The only way I can think of testing the program is by writing a bunch of individual files for the program to read in. Except this means that instead of testing only one part of my program, at a minimum it tests three classes. The class that reads in the program and contains all the methods for the singleton, the class that determines which class to call, and finally the class that actually executes that portion (such as Add).

Does anyone have any suggestions for a better way to test?

解决方案

The way to avoid this is traditionally to use inversion of control (IoC) and inject an instance of your singleton class into the client class. Your client class is provided with all the dependent classes it requires to function, and not concerned with the lifecycle of the dependent classes.

Spring is the common Java framework used to do this, but you can inject simply by constructing your class with a reference to the singleton (it's that simple).

If the singleton class implements an interface then testing is made easier since you can inject mock variants rather than the real implementation, and build your mock to provide suitable test data for your tests.

这篇关于如何使用jUnit测试使用单例的类?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！