Java 用现有文件模拟简单解析器并检查它

我开始了解莫基托。我不知道如何模拟我的解析器并使用现有的文件，例如带有两个数字的“data.txt”，但保存为字符串（21.144-12.98等）。我想进一步检查这些数字是否不是字母或其他东西。我的解析器：

package model.utils;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.LinkedList;
import java.util.Scanner;

import model.data.HullPoint;
import model.data.HullPointContainer;

public class Parser {
public static HullPointContainer parseFile(File file) throws FileNotFoundException
{
    double a, b;
    String da, db;
    double minx = 0, miny = 0, maxx = 0, maxy = 0;
    int k = 0;
    LinkedList<HullPoint> list = new LinkedList<HullPoint>();
    try{
        Scanner scanner = new Scanner(file);    
        try {
            while (scanner.hasNextLine()){
                String line = scanner.nextLine();
                Scanner lineScanner = new Scanner(line);
                while (lineScanner.hasNext()){
                    da = (lineScanner.next());
                    db = (lineScanner.next());
                    a = Double.parseDouble(da);
                    b = Double.parseDouble(db);
                    HullPoint point = new HullPoint(a,b);
                    list.add(point);
                    if(k == 0){
                        minx = maxx = a;
                        miny = maxy = b;
                    } else {
                        if(a < minx)
                            minx = a;
                        if(a > maxx)
                            maxx = a;
                        if(b < miny)
                            miny = b;
                        if(b > maxy)
                            maxy = b;
                    }
                    k++;
                }
                lineScanner.close();
            }
            int i = list.size();    
            System.out.println(i);
            System.out.println("minX = " + minx +" and minY= " + miny);
            System.out.println("maxX = " + maxx +" and maxY= " + maxy);

            return new HullPointContainer(list, minx, miny, maxx, maxy);
        } catch (Exception e) {
            throw e;
        } finally {
            scanner.close();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        throw(e);
    } catch (Exception e) {
        e.printStackTrace();
        throw e;
    }
}

package model.utils；
导入java.io.File；
导入java.io.FileNotFoundException；
导入java.io.IOException；
导入java.util.LinkedList；
导入java.util.Scanner；
导入model.data.HullPoint；
导入model.data.HullPointContainer；
公共类解析器{
公共静态HullPointContainer解析文件（文件文件）引发FileNotFoundException
{
双a，b；
字符串da，db；
双minx=0，miny=0，maxx=0，maxy=0；
int k=0；
LinkedList=新建LinkedList（）；
试一试{
扫描仪=新扫描仪（文件）；
试一试{
while（scanner.hasNextLine（））{
字符串行=scanner.nextLine（）；
扫描仪行扫描仪=新扫描仪（行）；
while（lineScanner.hasNext（））{
da=（lineScanner.next（））；
db=（lineScanner.next（））；
a=Double.parseDouble（da）；
b=双精度。解析双精度（db）；
脱壳点=新脱壳点（a，b）；
列表。添加（点）；
如果（k==0）{
minx=maxx=a；
miny=maxy=b；
}否则{
if（amaxx）
maxx=a；
if（bmaxy）
maxy=b；
}
k++；
}
lineScanner.close（）；
}
int i=list.size（）；
系统输出打印LN（i）；
System.out.println（“minX=“+minX+”和minY=“+minY”）；
System.out.println（“maxX=“+maxX+”和maxY=“+maxY”）；
返回新的HullPointContainer（列表、最小值、最小值、最大值、最大值）；
}捕获（例外e）{
投掷e；
}最后{
scanner.close（）；
}
}catch（filenotfounde异常）{
e、 printStackTrace（）；
投掷（e）；
}捕获（例外e）{
e、 printStackTrace（）；
投掷e；
}
}

---

}为了模拟解析器，您必须创建一个模拟对象

Parser mockedparser=Mockito.mock（Parser.class）

然后，您可以告诉mockito，如果调用了
parseFile
方法，该怎么办。例如：

Mockito，when（mockedparser.parseFile（myFile））。然后返回（结果）

当使用
myFile
作为参数调用
parseFile
方法时，mock将返回
result

您可以
验证
hass benn调用的方法：

Mockito.verify（mockedparser）.parseFile（myFile）

如果使用此参数调用了一次
，检查将通过，如果没有，检查将失败，并显示描述性错误消息

PS：模拟是在没有对象的真实实例的情况下模拟对象的行为。
从你的问题来看，你应该问如何
单元测试你的解析器，而不是
模仿它
p>你在测试解析器，所以它是切入点。你不应该嘲笑切割，这会破坏测试它的目的。我将使用
URI
作为输入，而不是
文件
，并将测试用例存储在测试类路径中。然后您可以使用
ClassLoader
找到它并传入URI。