2

我是初学者，请自己掌握。我需要测试这个方法 - 写入/读取到/从文件。你能得到建议吗？我能做多好，只使用junit测试或更好的EasyMock？你可以推荐做什么？

public class AbsFigure {

public void write(String fileName, List<FigureGeneral> figuresList) {
    try {
        PrintWriter out = new PrintWriter(
                new File(fileName).getAbsoluteFile());
        try {
            for (int i = 0; i < figuresList.size(); i++) {
                out.println(figuresList.get(i).toString());
            }
        } finally {
            out.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
        System.out.println("Cannot write to file!");
    }
}

// read from file
private ArrayList<FigureGeneral> figureReader(String fileName) {
    String line = null;
    ArrayList<FigureGeneral> myListFigure = new ArrayList<FigureGeneral>();

    try {
        File myFile = new File(fileName);
        FileReader fileReader = new FileReader(myFile);
        BufferedReader bufferedReader = new BufferedReader(fileReader);

        while ((line = bufferedReader.readLine()) != null) {
            myListFigure.add(fromStringToFigureGeneral(line));
        }
        System.out.println(myListFigure);
        bufferedReader.close();

    } catch (FileNotFoundException e) {
        System.out.println("File which You loking for not found!");
    } catch (NumberFormatException e) {
        e.printStackTrace();
    } catch (IOException e) {
        System.out.println("Wrong input!");
    }

    return myListFigure;
}

// change from String to FigureGeneral(Triangle or Rectangle)
private FigureGeneral fromStringToFigureGeneral(String line) {
    String[] arrayLines = line.split(" ");
    FigureGeneral figures = null;

    if (arrayLines[0].equals("triangle")) {
        figures = new Triangle(Double.parseDouble(arrayLines[1]),
                Double.parseDouble(arrayLines[2]), "triangle");
    } else {
        figures = new Rectangle(Double.parseDouble(arrayLines[1]),
                Double.parseDouble(arrayLines[2]), "rectangle");
    }

    return figures;
}

public void launch(AbsFigure absFigure) {
    List<FigureGeneral> figuresList = absFigure.generateRandomFigures(5);

    AreaCompare areaCompare = new AreaCompare();
    Collections.sort(figuresList, areaCompare);

    absFigure.write("test.txt", figuresList);
    figureReader("test.txt");
}

public static void main(String[] args) {
    AbsFigure absFigure = new AbsFigure();
    absFigure.launch(absFigure);
}
}

我写了更多的代码，你可以更好地理解情况。我希望您可以推荐如何测试它（也许您可以显示两个变体）。

4

3 回答 3

3

通过使用内存 I/O，您可以完全避免使用磁盘 I/O。您不需要 EasyMock，只需不同的输入和输出流。您可以通过检查生成的输出流（写入）和生成的 FigureGeneral 对象列表（读取）来断言您的方法与 JUnit 一起正常工作。

一步步：

1) 注入写入方法将使用的输出流。

您可以添加另一个由现有的“write”方法调用的“write”方法，该方法采用具有如下签名的输出流：

public void write(OutputStream outputStream, List<FigureGeneral> figuresList);

您原来的 write 方法将通过像这样调用该方法来包装上述方法：

write(new FileOutputStream(new File(fileName).getAbsoluteFile()), figuresList);

2) 使用 InputStream 对 read 方法重复上述技巧。

这将为您提供一个带有如下签名的读取方法：

private ArrayList<FigureGeneral> figureReader(InputStream inputStream);

3) 现在编写使用 ByteArrayInputStream 和 ByteArrayOutputStream 的 JUnit 测试并调用上述方法。

您可以通过在 ByteArrayOutputStream 上调用 toByteArray() 并断言结果来检查 write 方法的结果。您可以通过在将某个 ByteArrayInputStream 传递给 List 后断言 List 中的值来检查 read 方法的结果。

这是一个（伪）方法，您可以添加到测试类中，以断言可以将不同性质的 FigureGeneral 对象列表写入输出流，从输入流中读回并且相等。 

public void assertCanBeWrittenAndReaback(List<FigureGeneral> inputFigure) {
  ByteArrayOutputStream outStream = new ByteArrayOutputStream();
  absFigure.write(outStream, inputFigures);
  List<FigureGeneral> outputFigure = absFigure.figureReader(new ByteArrayInputStream(outStream.toByteArray()));
  assertEqualsFigureGeneralLists(inputFigure, outputFigure);
}

4）这会给你一个很好的测试覆盖率。尽管如此，如果您想实现 100% 的测试覆盖率，您仍然必须测试现在已成为包装器的原始 write 和 readFigure 方法。

原始方法只不过是重定向到使用输入和输出流的同名方法。您可以使用 EasyMock 来检查它们的重定向，方法是覆盖（或者如果将这些方法放在接口后面则实现）这两个重定向方法并断言它们接收到正确的 FileInputStream 和 FileOutputStream 对象。不过，您需要一些临时文件，因为 FileOutputStream 构造函数需要一个现有文件。但是，我没有看到在测试用例中使用临时文件有任何重大问题。

于 2013-01-06T11:06:55.460 回答
1

最好只制作一个临时测试文件，然后检查其内容，类似于这个 SO question。

于 2013-01-06T10:52:53.023 回答
1

我向您建议，这是在这种情况下更好的覆盖范围之一：

setUp()您在注释中制作临时方法@Before.

并在此方法中初始化您需要的所有内容。

您制作了拆卸方法 -releaseResources()在 annotation@After中，您删除了您的临时文件。

并@Test为所有机会情况做出准备，如果测试失败抛出new RuntimeException():

public class AbsFigureTest {

    public static final String defaultTestPath = "unittest.tmp";
    private List<FigureGeneral> inputFigures;
    private List<FigureGeneral> outputFigures;
    private DeepCompare deepCompare;

    @Before
    public void setUp() throws FigureGeneralFilesFoundException,
            FigureGeneralFormatException {
        inputFigures = absFigure.generateRandomFigures(5);
        absFigure.write(defaultTestPath, inputFigures);
        outputFigures = absFigure.figureReader(defaultTestPath);
        deepCompare = new DeepCompare();
}

    @After
    public void releaseResources() {
        new File(defaultTestPath).delete();
    }

    @Test
    public void assertEquals_FigureGeneralLists_ReturnZero() {
        for (int i = 0; i < inputFigures.size(); i++) {
            FigureGeneral inputValue = inputFigures.get(i);
            FigureGeneral outputValue = outputFigures.get(i);

            if (deepCompare.compare(inputValue, outputValue) != 0)
                throw new RuntimeException("not equal");
        }

    }

    @Test
    public void testDeepCompRectangle_EqualResult_ReturnZero() {
        FigureGeneral oneFigure = new Rectangle(2.0, 2.0, "rectangle");
        FigureGeneral twoFigure = new Rectangle(2.0, 2.0, "rectangle");
        int result = deepCompare.compare(oneFigure, twoFigure);
        assertTrue("expected to be equal", result == 0);
    }

    @Test
    public void testDeepCompTriangle_EqualResult_ReturnZero() {
        FigureGeneral oneFigure = new Triangle(2.0, 2.0, "rectangle");
        FigureGeneral twoFigure = new Triangle(2.0, 2.0, "rectangle");
        int result = deepCompare.compare(oneFigure, twoFigure);
        assertTrue("expected to be equal", result == 0);
    }

    @Test
    public void testDeepComp_GreaterThan_ReturnOne() {
        FigureGeneral oneFigure = new Triangle(2.0, 2.0, "triangle");
        FigureGeneral twoFigure = new Rectangle(1.0, 1.0, "rectangle");
        int result = deepCompare.compare(oneFigure, twoFigure);
        assertTrue("expected to be greater than", result >= 1);

        if (deepCompare.compare(oneFigure, twoFigure) != 0)
            throw new RuntimeException("not equal");
    }
}
于 2013-01-26T08:24:02.703 回答