Dart如何模拟程序

如何模拟一个过程（与函数相关），请参见

例如，给定以下类型定义和过程

typedef整数加法器（inta，intb）；
整数加法器（加法器加法器）{
返回加法器（1，2）；
}

如何编写一个mock来测试userAdder过程是否调用了mock函数

这是我的尝试，但失败的消息是test failed:捕获的null对象没有方法“call”

类MyMock扩展了Mock{
MyMock（）{
when（callsTo（'call'））.alwaysCall（this.foo）；
}
intfoo（inta，intb）=>a+b；
}
void main（）{
测试（“bb”，（）{
var mockf=new MyMock（）；
expect（useAdder（mockf.call），3）；
mockf.getLogs（callsTo（'call'，1，2））.verify（happenedOnce）；
});
}

如果我改变

expect（useAdder（mockf.call），3）；

到

expect（useAdder（mockf.foo），3）；

方法调用未出现在日志中

我的尝试

import'包：unittest/unittest.dart'；
导入“package:mock/mock.dart”；
类型定义整数加法器（整数a、整数b）；
整数加法器（加法器加法器）{
返回加法器（1，2）；
}
类MyMock扩展了Mock{
MyMock（）{
when（callsTo（'call'））.alwaysCall（this.foo）；
}
intfoo（inta，intb）=>a+b；
int call（inta，intb）=>super.call（a，b）；
}
void main（）{
测试（“bb”，（）{
var mockf=new MyMock（）；
expect（使用加法器（mockf作为加法器），3）；
mockf.getLogs（callsTo（'call'，1，2））.verify（happenedOnce）；
});
}

---

似乎调用方法必须实际存在，才能使MyMock被接受为加法器。

我用Günter Zöchbauer解决方案的核心思想更新了代码

库函数模拟测试；
导入“包：unittest/unittest.dart”；
导入“包：mock/mock.dart”；
导入“dart:math”作为数学；
typedef int binarynttoint（int a，int b）；
typedef double BinaryIntToDouble（int a，int b）；
typedef int DoubleIntToInt（双a，双b）；
int usebnaryintotoint（binaryintotoint加法器）=>加法器（1,2）；
void main（）{
test（'来自“dart:math”的Mock[min]函数，（）{
var min=新函数mock（math.min）；
期望值（min（2,1），1）；
期望值（min（1,2），1）；
最小呼叫（'call'，1，2）。验证（偶然事件）；
});
测试（“功能模拟”，（）{
var adder2=新函数mock（（a，b）=>a+b）；
var adder3=新函数模拟（（a、b、c）=>a+b+c）；
expect（adder2为函数，true）；
expect（使用二进制输入（加法器2），3）；
expect（加法器3（1,2,3），6）；
adder2.调用（'call'，1，2）.验证（偶然事件）；
});
组（“函数模拟的类型检查：，（）{
测试（“应抛出[TypeError]\n”
“if函数的参数数目错误”，（）{
打字错误；
试一试{
var adder3=新函数模拟（（a、b、c）=>a+b+c）；
}
捕获（例外）{
expect（异常为TypeError，true）；
错误=异常；
}
expect（错误！=null，true）；
});
测试（“应抛出[TypeError]\n”
“if函数的参数类型错误”，（）{
打字错误；
试一试{
var adder3=新函数模拟（（双a，b）=>10）；
}
捕获（例外）{
expect（异常为TypeError，true）；
错误=异常；
}
expect（错误！=null，true）；
});
测试（“不引发typedef不匹配\n”
“无类型注释”，（）{
二进制双foo=（c，d）=>c/d；
双输入条=（c，d）=>c+d；
var ErrorTypeDefReturnType=新函数模拟（foo）；
var ErrorTypeDefargumentType=新函数模拟（条形）；
错误类型DefReturnType（1.1,2.1）；
错误类型争议类型（1.1,2.1）；
});
测试（“带类型注释的抛出”，（）{
双foo_u2;（intc，intd）=>c/d；
BinaryIntToDouble foo=foo；
整数条（双c，整数d）=>10；
DoubleIntToInt条=条；
TypeError返回TypeError，argumentTypeError；
试一试{
var ErrorTypeDefReturnType=新函数模拟（foo）；
}
捕获（例外）{
expect（异常为TypeError，true）；
returnTypeError=异常；
}
试一试{
var ErrorTypeDefargumentType=新函数模拟（条形）；
}
捕获（例外）{
expect（异常为TypeError，true）；
argumentTypeError=异常；
}
expect（returnTypeError！=null，true）；
expect（argumentTypeError！=null，true）；
});
}
);
}
阶级哨兵{
const_Sentinel（）；
}
常量NO_ARG=const_Sentinel（）；
类FunctionMock扩展了Mock实现函数{
最终函数类型defu可调用；
FunctionMock.\u内部（FunctionTypedef函数）：\u可调用=函数{
when（callsTo（'call'））.alwaysCall（_callable）；
}
//如有需要，可放置“铲入”黑魔法。
工厂函数模拟（函数类型定义函数）{
返回新函数mock.\u内部（函数）；
}
调用（[arg0=NO_ARG，
arg1=无_ARG，
arg2=无_ARG，
arg3=无_ARG，
arg4=无_ARG，
arg5=无_ARG，
arg6=无_ARG，
arg7=无_ARG，
arg8=无_ARG，
arg9=无（ARG]）{
if（idential（arg0，NO_ARG））返回super.call（）；
if（idential（arg1，NO_ARG））返回超级调用（arg0）；
if（idential（arg2，NO_ARG））返回超级调用（arg0，arg1）；
if（idential（arg3，NO_ARG））返回超级调用（arg0，arg1，arg2）；
if（idential（arg4，NO_ARG））返回超级调用（arg0，arg1，arg2，arg3）；
if（idential（arg5，NO_ARG））返回超级调用（arg0，arg1，arg2，arg3，arg4）；
if（idential（arg6，NO_ARG））返回超级调用（arg0，arg1，arg2，arg3，arg4，
arg5）；
if（idential（arg7，NO_ARG））返回超级调用（arg0，arg1，arg2，arg3，arg4，
arg5、arg6）；
if（idential（arg8，NO_ARG））返回超级调用（arg0，arg1，arg2，arg3，arg4，
arg5、arg6、arg7）；
if（idential（arg9，NO_ARG））返回超级调用（arg0，arg1，arg2，arg3，arg4，
arg5、arg6、arg7、arg8）；
返回s