测试案例

(类来自 pyomo.common.unittest)

class pyomo.common.unittest.TestCase(methodName='runTest')[source]

基础类：TestCase

一个Pyomo特定的类，其实例是单个测试用例。

这个类继承自 unittest.TestCase 并提供以下额外功能：

additional assertions:
updated assertions:
- assertRaisesRegex()

`unittest.TestCase` 文档

一个类，其实例是单个测试用例。

默认情况下，测试代码本身应放置在名为‘runTest’的方法中。

如果夹具可以用于许多测试用例，根据需要创建尽可能多的测试方法。在实例化这样的TestCase子类时，在构造函数参数中指定实例要执行的测试方法的名称。

测试作者应该为他们的测试子类化TestCase。测试环境的构建和销毁（'fixture'）可以通过分别重写'setUp'和'tearDown'方法来实现。

如果需要重写__init__方法，必须始终调用基类的__init__方法。重要的是，子类不应更改其__init__方法的签名，因为类的实例是由框架的某些部分自动实例化的，以便运行。

当子类化TestCase时，你可以设置这些属性：

failureException:
确定当实例的断言方法失败时将引发哪个异常；引发此异常的测试方法将被视为“失败”而不是“错误”。
longMessage:
确定在失败时是否打印长消息（包括断言方法中使用的对象的repr），此外还会打印任何显式传递的消息。
maxDiff:
设置在使用difflib的assert方法时，失败消息中差异的最大长度。它被查找为实例属性，因此如果需要，可以由各个测试进行配置。

__init__(methodName='runTest')[source]: 创建一个类的实例，该实例在执行时将使用指定的测试方法。如果实例没有具有指定名称的方法，则引发ValueError。

方法

`__init__`([methodName])	创建一个类的实例，该实例在执行时将使用指定的测试方法。
`addClassCleanup`(function, /, args, *kwargs)	与addCleanup相同，不同之处在于即使setUpClass失败，清理项也会被调用（与tearDownClass不同）。
`addCleanup`(function, /, args, *kwargs)	添加一个带有参数的函数，在测试完成时调用。
`addTypeEqualityFunc`(typeobj, function)	添加一个特定类型的assertEqual样式函数来比较类型。
`assertAlmostEqual`(first, second[, places, ...])	如果两个对象不相等，则失败，判断依据是它们的差值四舍五入到给定的小数位数（默认为7）并与零比较，或者比较两个对象之间的差值是否超过给定的delta。
`assertAlmostEquals`(**kwargs)
`assertCountEqual`(first, second[, msg])	断言两个可迭代对象具有相同的元素，相同的次数，不考虑顺序。
`assertDictContainsSubset`(subset, dictionary)	检查字典是否是子集的超集。
`assertDictEqual`(d1, d2[, msg])
`assertEqual`(first, second[, msg])	如果两个对象通过'=='运算符判断为不相等，则失败。
`assertEquals`(**kwargs)
`assertExpressionsEqual`(a, b[, ...])	断言两个Pyomo表达式相等。
`assertExpressionsStructurallyEqual`(a, b[, ...])	断言两个Pyomo表达式在结构上是相等的。
`assertFalse`(expr[, msg])	检查表达式是否为假。
`assertGreater`(a, b[, msg])	就像 self.assertTrue(a > b) 一样，但带有更好的默认消息。
`assertGreaterEqual`(a, b[, msg])	就像self.assertTrue(a >= b)一样，但带有更好的默认消息。
`assertIn`(member, container[, msg])	就像self.assertTrue(a in b)一样，但带有更好的默认消息。
`assertIs`(expr1, expr2[, msg])	就像self.assertTrue(a is b)一样，但带有更好的默认消息。
`assertIsInstance`(obj, cls[, msg])	与self.assertTrue(isinstance(obj, cls))相同，但带有更好的默认消息。
`assertIsNone`(obj[, msg])	与 self.assertTrue(obj is None) 相同，但带有更好的默认消息。
`assertIsNot`(expr1, expr2[, msg])	就像self.assertTrue(a is not b)一样，但带有更好的默认消息。
`assertIsNotNone`(obj[, msg])	为了与assertIsNone保持对称而包含。
`assertLess`(a, b[, msg])	就像 self.assertTrue(a < b) 一样，但带有更好的默认消息。
`assertLessEqual`(a, b[, msg])	就像 self.assertTrue(a <= b) 一样，但带有更好的默认消息。
`assertListEqual`(list1, list2[, msg])	一个特定于列表的相等断言。
`assertLogs`([logger, level])	除非在logger_name或其子记录器上发出级别为level或更高的日志消息，否则失败。
`assertMultiLineEqual`(first, second[, msg])	断言两个多行字符串是相等的。
`assertNoLogs`([logger, level])	除非在logger_name或其子记录器上没有发出级别为level或更高级别的日志消息，否则失败。
`assertNotAlmostEqual`(first, second[, ...])	如果两个对象相等，则失败，这是通过将它们的差值四舍五入到给定的小数位数（默认为7）并与零进行比较，或者通过比较两个对象之间的差值是否小于给定的delta来确定的。
`assertNotAlmostEquals`(**kwargs)
`assertNotEqual`(first, second[, msg])	如果两个对象通过'!='运算符判断为相等，则失败。
`assertNotEquals`(**kwargs)
`assertNotIn`(member, container[, msg])	就像self.assertTrue(a not in b)一样，但带有更好的默认消息。
`assertNotIsInstance`(obj, cls[, msg])	为了与assertIsInstance保持对称而包含。
`assertNotRegex`(text, unexpected_regex[, msg])	如果文本与正则表达式匹配，则测试失败。
`assertNotRegexpMatches`(**kwargs)
`assertRaises`(expected_exception, args, *kwargs)	除非调用可调用对象时使用指定的位置参数和关键字参数引发预期异常类的异常，否则失败。
`assertRaisesRegex`(expected_exception, ...)	断言在引发的异常中的消息与正则表达式匹配。
`assertRaisesRegexp`(**kwargs)
`assertRegex`(text, expected_regex[, msg])	除非文本与正则表达式匹配，否则测试失败。
`assertRegexpMatches`(**kwargs)
`assertSequenceEqual`(seq1, seq2[, msg, seq_type])	用于有序序列（如列表和元组）的相等性断言。
`assertSetEqual`(set1, set2[, msg])	一个特定集合的相等断言。
`assertStructuredAlmostEqual`(first, second[, ...])	测试第一个和第二个在容差范围内是否相等
`assertTrue`(expr[, msg])	检查表达式是否为真。
`assertTupleEqual`(tuple1, tuple2[, msg])	一个特定于元组的相等断言。
`assertWarns`(expected_warning, args, *kwargs)	除非调用可调用对象时使用指定的位置参数和关键字参数触发了类为warnClass的警告，否则失败。
`assertWarnsRegex`(expected_warning, ...)	断言触发的警告消息与正则表达式匹配。
`assert_`(**kwargs)
`countTestCases`()
`debug`()	运行测试而不在TestResult中收集错误
`defaultTestResult`()
`doClassCleanups`()	执行所有类的清理函数。
`doCleanups`()	执行所有清理函数。
`enterClassContext`(cm)	与enterContext相同，但是是类范围的。
`enterContext`(cm)	进入提供的上下文管理器。
`fail`([msg])	立即失败，并显示给定的消息。
`failIf`(**kwargs)
`failIfAlmostEqual`(**kwargs)
`failIfEqual`(**kwargs)
`failUnless`(**kwargs)
`failUnlessAlmostEqual`(**kwargs)
`failUnlessEqual`(**kwargs)
`failUnlessRaises`(**kwargs)
`id`()
`run`([result])
`setUp`()	在测试之前设置测试夹具的钩子方法。
`setUpClass`()	在类中运行测试之前设置类夹具的钩子方法。
`shortDescription`()	返回测试的一行描述，如果没有提供描述则返回None。
`skipTest`(reason)	跳过这个测试。
`subTest`([msg])	返回一个上下文管理器，该管理器将在由可选消息和关键字参数标识的子测试中返回包含的代码块。
`tearDown`()	用于在测试后解构测试装置的钩子方法。
`tearDownClass`()	用于在运行类中的所有测试后解构类夹具的钩子方法。

属性

`longMessage`
`maxDiff`

成员文档

failureException: AssertionError 的别名

classmethod addClassCleanup(function, /, *args, **kwargs)[source]: 与addCleanup相同，不同之处在于即使setUpClass失败，清理项也会被调用（与tearDownClass不同）。

addCleanup(function, /, *args, **kwargs)[source]

添加一个带有参数的函数，在测试完成时调用。添加的函数按照后进先出的顺序调用，并在测试失败或成功后的tearDown之后调用。

即使setUp失败，也会调用清理项（与tearDown不同）。

addTypeEqualityFunc(typeobj, function)[source]

添加一个特定类型的assertEqual样式函数来比较类型。

此方法供需要注册自己的类型相等函数的TestCase子类使用，以提供更好的错误消息。

Parameters:

typeobj – 在assertEqual()中当两个值类型相同时，调用此函数的数据类型。
function – 可调用对象，接受两个参数和一个可选的 msg= 参数，当两个参数不相等时，会抛出一个带有有用错误信息的 self.failureException。

assertAlmostEqual(first, second, places=None, msg=None, delta=None)[source]

如果两个对象不相等，则失败，根据它们四舍五入到给定小数位数（默认7位）的差值并与零比较，或者通过比较两个对象之间的差值是否大于给定的delta。

请注意，小数位数（从零开始）通常与有效数字（从最高有效位开始测量）不同。

如果两个对象比较相等，那么它们将自动比较几乎相等。

assertCountEqual(first, second, msg=None)[source]

断言两个可迭代对象具有相同的元素，相同的次数，不考虑顺序。

self.assertEqual(Counter(list(first)),
计数器(列表(第二)))

Example:

[0, 1, 1] 和 [1, 0, 1] 比较相等。

[0, 0, 1] 和 [0, 1] 比较不相等。

assertDictContainsSubset(subset, dictionary, msg=None)[source]: 检查字典是否是子集的超集。

assertEqual(first, second, msg=None)[source]: 如果两个对象通过‘==’运算符判断为不相等，则失败。

assertExpressionsEqual(a, b, include_named_exprs=True, places=None)[source]

断言两个Pyomo表达式相等。

这将表达式 a 和 b 转换为前缀表示法，然后比较结果列表。树中的所有节点都使用 py:meth:assertEqual（或 py:meth:assertAlmostEqual）进行比较。

Parameters:

a (ExpressionBase 或 原生类型)
b (ExpressionBase 或 原生类型)
include_named_exprs (bool) – 如果为True（默认值），则在生成前缀表示法时，比较会展开所有命名表达式
places (float) – 表达式中浮点数相等所需的小数位数。如果为 None（默认值），则表达式必须完全相等。

assertExpressionsStructurallyEqual(a, b, include_named_exprs=True, places=None)[source]

断言两个Pyomo表达式在结构上是相等的。

这将表达式 a 和 b 转换为前缀表示法，然后比较结果列表。在前缀表示法中，运算符和（非原生类型的）叶节点在比较之前被转换为字符串（以便可以跨克隆或pickle比较变量等）。

Parameters:

a (ExpressionBase 或 原生类型)
b (ExpressionBase 或 原生类型)
include_named_exprs (bool) – 如果为True（默认值），则在生成前缀表示法时，比较会展开所有命名表达式
places (float) – 表达式中浮点数相等所需的小数位数。如果为 None（默认值），则表达式必须完全相等。

assertFalse(expr, msg=None)[源代码]: 检查表达式是否为假。

assertGreater(a, b, msg=None)[source]: 就像 self.assertTrue(a > b) 一样，但带有更好的默认消息。

assertGreaterEqual(a, b, msg=None)[source]: 就像self.assertTrue(a >= b)一样，但带有更好的默认消息。

assertIn(member, container, msg=None)[source]: 就像self.assertTrue(a in b)一样，但带有更好的默认消息。

assertIs(expr1, expr2, msg=None)[source]: 就像self.assertTrue(a is b)一样，但带有更好的默认消息。

assertIsInstance(obj, cls, msg=None)[source]: 与 self.assertTrue(isinstance(obj, cls)) 相同，但带有更好的默认消息。

assertIsNone(obj, msg=None)[source]: 与 self.assertTrue(obj is None) 相同，但带有更好的默认消息。

assertIsNot(expr1, expr2, msg=None)[source]: 就像self.assertTrue(a is not b)一样，但带有更好的默认消息。

assertIsNotNone(obj, msg=None)[source]: 为了与assertIsNone保持对称而包含。

assertLess(a, b, msg=None)[source]: 就像 self.assertTrue(a < b) 一样，但带有更好的默认消息。

assertLessEqual(a, b, msg=None)[source]: 就像 self.assertTrue(a <= b) 一样，但带有更好的默认消息。

assertListEqual(list1, list2, msg=None)[source]

一个特定于列表的相等断言。

Parameters:

list1 – 要比较的第一个列表。
list2 – 要比较的第二个列表。
msg – 可选的消息，用于在失败时使用，而不是显示差异列表。

assertLogs(logger=None, level=None)[source]

除非在logger_name或其子记录器上发出级别为level或更高的日志消息，否则失败。如果省略，level默认为INFO，logger默认为根记录器。

此方法必须用作上下文管理器，并将生成一个具有两个属性的记录对象：output 和 records。在上下文管理器结束时，output 属性将是匹配的格式化日志消息的列表，而 records 属性将是相应的 LogRecord 对象的列表。

示例：

with self.assertLogs('foo', level='INFO') as cm:
    logging.getLogger('foo').info('first message')
    logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
                             'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)[source]: 断言两个多行字符串是相等的。

assertNoLogs(logger=None, level=None)[source]

除非在logger_name或其子记录器上没有发出级别为level或更高级别的日志消息，否则失败。

此方法必须用作上下文管理器。

assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)[source]

如果两个对象相等，则失败，这是通过将它们的差异四舍五入到给定的小数位数（默认为7）并与零比较，或者通过比较两个对象之间的差异小于给定的增量来确定的。

请注意，小数位数（从零开始）通常与有效数字（从最高有效位开始测量）不同。

相等的对象会自动失败。

assertNotEqual(first, second, msg=None)[source]: 如果两个对象通过‘!=’运算符判断为相等，则失败。

assertNotIn(member, container, msg=None)[source]: 就像self.assertTrue(a not in b)一样，但带有更好的默认消息。

assertNotIsInstance(obj, cls, msg=None)[source]: 为了与assertIsInstance保持对称而包含。

assertNotRegex(text, unexpected_regex, msg=None)[source]: 如果文本与正则表达式匹配，则测试失败。

assertRaises(expected_exception, *args, **kwargs)[source]

除非调用可调用对象时使用指定的位置参数和关键字参数引发预期异常类的异常，否则失败。如果引发不同类型的异常，它将不会被捕获，并且测试用例将被视为发生了错误，就像未预期的异常一样。

如果调用时省略了可调用对象和参数，将返回一个上下文对象，如下所示：

with self.assertRaises(SomeException):
    do_something()

当assertRaises作为上下文对象使用时，可以提供一个可选的关键字参数‘msg’。

上下文管理器将异常作为‘exception’属性保留引用。这允许你在断言后检查异常：

with self.assertRaises(SomeException) as cm:
    do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)[source]

断言在引发的异常中的消息与正则表达式匹配。

这是一个轻量级的封装，围绕 unittest.TestCase.assertRaisesRegex()，它增加了对normalize_whitespace关键字的处理，该关键字在检查正则表达式之前将异常消息中的所有连续空白字符规范化为单个空格。

Parameters:

expected_exception (Exception) – 预期会抛出的异常类。
expected_regex (re.Pattern 或 str) – 预期在错误消息中找到的正则表达式。
*args – 要调用的函数和额外的位置参数。
**kwargs – 额外的关键字参数。
msg (str) – 可选的消息，用于在失败时使用。只能在将assertRaisesRegex用作上下文管理器时使用。
normalize_whitespace (bool, default=False) – 如果为True，则在检查正则表达式之前将连续的空白（包括换行符）折叠为单个空格

assertRegex(text, expected_regex, msg=None)[source]: 除非文本与正则表达式匹配，否则测试失败。

assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)[source]

用于有序序列（如列表和元组）的相等性断言。

对于此函数的目的，一个有效的有序序列类型是可以被索引、具有长度并且具有相等运算符的类型。

Parameters:

seq1 – 要比较的第一个序列。
seq2 – 要比较的第二个序列。
seq_type – 序列的预期数据类型，如果不需要强制执行数据类型，则为 None。
msg – 可选的消息，用于在失败时使用，而不是显示差异列表。

assertSetEqual(set1, set2, msg=None)[source]

一个特定集合的相等断言。

Parameters:

set1 – 要比较的第一个集合。
set2 – 要比较的第二个集合。
msg – 可选的消息，用于在失败时使用，而不是显示差异列表。

assertSetEqual 使用鸭子类型来支持不同类型的集合，并且专门为集合进行了优化（参数必须支持差异方法）。

assertStructuredAlmostEqual(first, second, places=None, msg=None, delta=None, reltol=None, abstol=None, allow_second_superset=False, item_callback=<function _floatOrCall>)[source]

测试第一个和第二个在容差范围内是否相等

这使用绝对（abstol）和相对（reltol）容差来比较第一个和第二个。它将递归地深入到序列和映射容器中（允许对包括列表和字典在内的结构化数据进行相对比较）。

places 和 delta 是为了与 assertAlmostEqual 兼容而支持的。如果提供了 places，则 abstol 计算为 10**-places。delta 是 abstol 的别名。

如果未指定{abstol, reltol, places, delta}中的任何一个， reltol默认为1e-7。

如果 allow_second_superset 为 True，则：

只有在first中的映射中找到的键/值对才会与second进行比较（允许second中的映射包含额外的键）

只有在first序列中找到的值才会与second进行比较（允许second序列包含额外的值）

相对误差是针对数值计算的，公式如下：

abs(first - second) / max(abs(first), abs(second))

只有当 first != second 时（从而避免除以零的错误）。

项目（除了序列/映射容器、匹配字符串和满足first is second的项目之外的条目）在测试相等性和相对容差之前传递给item_callback。

如果 first 和 second 在容差范围内不相等，则引发 exception。

Parameters:

first – 要比较的第一个值
second – 要比较的第二个值
places (int) – 如果first和second的差值在places位小数之间，则认为它们是等价的；等同于abstol = 10**-places（为了与assertAlmostEqual兼容而包含）
msg (str) – 失败时引发的消息
delta (float) – abstol 的别名
abstol (float) – 绝对容差。如果first和second的绝对差小于abstol，则认为它们是等价的。
reltol (float) – 相对容差。如果first和second的绝对差除以first和second中较大的一个小于reltol，则认为它们是等价的。
allow_second_superset (bool) – 如果为True，则在第二个容器中找到的额外条目不会触发失败。
item_callback (function) – 除了序列/映射容器、匹配字符串和满足is条件的项之外，其他项都会传递给此回调函数，以生成用于比较的（名义上为浮点数的）值。

assertTrue(expr, msg=None)[源代码]: 检查表达式是否为真。

assertTupleEqual(tuple1, tuple2, msg=None)[source]

一个特定于元组的相等断言。

Parameters:

tuple1 – 要比较的第一个元组。
tuple2 – 要比较的第二个元组。
msg – 可选的消息，用于在失败时使用，而不是显示差异列表。

assertWarns(expected_warning, *args, **kwargs)[source]

除非调用可调用对象时触发了类为warnClass的警告，否则失败。如果触发了不同类型的警告，它将不会被处理：根据生效的其他警告过滤规则，它可能会被静默、打印出来或作为异常抛出。

如果调用时省略了可调用对象和参数，将返回一个上下文对象，如下所示：

with self.assertWarns(SomeWarning):
    do_something()

当assertWarns作为上下文对象使用时，可以提供一个可选的关键字参数‘msg’。

上下文管理器将第一个匹配的警告作为‘warning’属性保留引用；同样，‘filename’和‘lineno’属性提供了触发警告的Python代码行的信息。这允许你在断言后检查警告：

with self.assertWarns(SomeWarning) as cm:
    do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)[source]

断言触发的警告消息与正则表达式匹配。基本功能与assertWarns()类似，但增加了只有消息也匹配正则表达式的警告才被认为是成功的匹配。

Parameters:

expected_warning – 预期触发的警告类。
expected_regex – 预期在错误信息中找到的正则表达式（re.Pattern对象或字符串）。
args – 要调用的函数和额外的位置参数。
kwargs – 额外的kwargs。
msg – 在失败时使用的可选消息。只能在将assertWarnsRegex用作上下文管理器时使用。

debug()[源代码]: 运行测试而不在TestResult中收集错误

classmethod doClassCleanups()[source]: 执行所有类的清理函数。通常在tearDownClass之后为你调用。

doCleanups()[source]: 执行所有清理函数。通常在tearDown之后为你调用。

classmethod enterClassContext(cm)[source]: 与enterContext相同，但是是类范围的。

enterContext(cm)[source]

进入提供的上下文管理器。

如果成功，还会将其 __exit__ 方法添加为清理函数，并返回 __enter__ 方法的结果。

fail(msg=None)[source]: 立即失败，并显示给定的消息。

setUp()[source]: 在测试之前设置测试夹具的钩子方法。

classmethod setUpClass()[source]: 在类中运行测试之前设置类夹具的钩子方法。

shortDescription()[source]

返回测试的一行描述，如果没有提供描述则返回None。

此方法的默认实现返回指定测试方法的文档字符串的第一行。

skipTest(reason)[source]: 跳过这个测试。

subTest(msg=<object object>, **params)[source]: 返回一个上下文管理器，它将在由可选消息和关键字参数标识的子测试中返回包含的代码块。子测试中的失败将测试用例标记为失败，但在包含的代码块末尾恢复执行，允许执行进一步的测试代码。

tearDown()[source]: 用于在测试后解构测试装置的钩子方法。

classmethod tearDownClass()[source]: 用于在运行类中的所有测试后解构类夹具的钩子方法。

maxDiff = None

测试案例

unittest.TestCase 文档

`unittest.TestCase` 文档