tf.test.TestCase

Базовый класс для тестов, которые требуют проверки TensorFlow.

tf.test.TestCase(
    methodName='runTest'
)

Подклассы

class failureException

Методы

addCleanup

addCleanup(
    *args, **kwargs
)

Добавить функцию с аргументами, которая должна быть вызвана при завершении теста. Добавляемые функции вызываются в порядке LIFO и вызываются после tearDown при сбое или успешном завершении теста.

Элементы очистки вызываются даже если setUp завершился сбоем (в отличие от tearDown).

addTypeEqualityFunc

addTypeEqualityFunc(
    typeobj, function
)

Добавить функцию сравнения assertEqual для определённого типа.

Этот метод предназначен для использования подклассами TestCase, которым необходимо зарегистрировать собственные функции сравнения типов для предоставления более информативных сообщений об ошибках.

assertAllClose

Просмотреть исходный код

assertAllClose(
    a, b, rtol=1e-06, atol=1e-06, msg=None
)

Проверяет, что две структуры массивов NumPy или тензоров имеют близкие значения.

a и b могут быть произвольно вложенными структурами. Уровень вложенной структуры может быть dict, namedtuple, tuple или list.

Примечание: реализация следует numpy.allclose (и numpy.testing.assert_allclose). Она проверяет, являются ли два массива элемент-по-элементу равными в пределах определённой точности. Отклонение (rtol * abs(b)) и абсолютное отклонение atol складываются, чтобы сравнить их с абсолютным отклонением между a и b.

assertAllCloseAccordingToType

Просмотреть исходный код

assertAllCloseAccordingToType(
    a,
    b,
    rtol=1e-06,
    atol=1e-06,
    float_rtol=1e-06,
    float_atol=1e-06,
    half_rtol=0.001,
    half_atol=0.001,
    bfloat16_rtol=0.01,
    bfloat16_atol=0.01,
    msg=None
)

Как assertAllClose, но также подходит для сравнения массивов fp16.

В частности, точность уменьшается до 1e-3, если хотя бы один из аргументов имеет тип float16.

assertAllEqual

Просмотреть исходный код

assertAllEqual(
    a, b, msg=None
)

Проверяет, что два массива NumPy или тензоры имеют одинаковые значения.

assertAllGreater

Просмотреть исходный код

assertAllGreater(
    a, comparison_target
)

Проверяет, что все элементные значения больше целевого значения.

assertAllGreaterEqual

Просмотреть исходный код

assertAllGreaterEqual(
    a, comparison_target
)

Проверяет, что все элементные значения больше или равны целевому значению.

assertAllInRange

Просмотреть исходный код

assertAllInRange(
    target,
    lower_bound,
    upper_bound,
    open_lower_bound=False,
    open_upper_bound=False
)

Проверяет, что все элементы в тензоре находятся в заданном диапазоне.

assertAllInSet

Просмотреть исходный код

assertAllInSet(
    target, expected_set
)

Проверяет, что все элементы тензора находятся в заданном замкнутом множестве.

assertAllLess

Просмотреть исходный код

assertAllLess(
    a, comparison_target
)

Проверяет, что все элементные значения меньше целевого значения.

assertAllLessEqual

Просмотреть исходный код

assertAllLessEqual(
    a, comparison_target
)

Проверить, что все значения элементов меньше или равны целевому значению.

data-text="assertAlmostEqual" id="assertAlmostEqual">assertAlmostEqual

assertAlmostEqual(
    first, second, places=None, msg=None, delta=None
)

Не проходит, если два объекта не равны, как определяется их разницей, округлённой до заданного числа десятичных знаков (по умолчанию 7) и сравнением с нулём, или если разница между двумя объектами больше заданного дельты.

Обратите внимание, что десятичные знаки (от нуля) обычно не совпадают с значащими цифрами (измеренными с самой значимой цифры).

Если два объекта сравниваются как равные, они автоматически сравниваются как почти равные.

data-text="assertAlmostEquals" id="assertAlmostEquals">assertAlmostEquals

assertAlmostEquals(
    *args, **kwargs
)

data-text="assertArrayNear" id="assertArrayNear">assertArrayNear

Просмотреть исходный код

assertArrayNear(
    farray1, farray2, err, msg=None
)

Проверяет, что два массива с плавающей точкой близки друг к другу.

Проверяет, что для всех элементов farray1 и farray2 |f1 - f2| < err. Проверяет ошибку теста, если это не так.

data-text="assertBetween" id="assertBetween">assertBetween

assertBetween(
    value, minv, maxv, msg=None
)

Проверяет, что значение находится между minv и maxv (включительно).

data-text="assertCommandFails" id="assertCommandFails">assertCommandFails

assertCommandFails(
    command, regexes, env=None, close_fds=True, msg=None
)

Проверяет, что команда оболочки завершается с ошибкой, и ошибка соответствует регулярному выражению в списке.

data-text="assertCommandSucceeds" id="assertCommandSucceeds">assertCommandSucceeds

assertCommandSucceeds(
    command, regexes=(b'',), env=None, close_fds=True, msg=None
)

Проверяет, что команда оболочки выполняется успешно (т. е. завершается с кодом 0).

data-text="assertContainsExactSubsequence" id="assertContainsExactSubsequence">assertContainsExactSubsequence

assertContainsExactSubsequence(
    container, subsequence, msg=None
)

Проверяет, что "container" содержит "subsequence" как точную подпоследовательность.

Проверяет, что "container" содержит все элементы "subsequence" в порядке и без других элементов между ними. Например, [1, 2, 3] является точной подпоследовательностью [0, 0, 1, 2, 3, 0], но не [0, 0, 1, 2, 0, 3, 0].

data-text="assertContainsInOrder" id="assertContainsInOrder">assertContainsInOrder

assertContainsInOrder(
    strings, target, msg=None
)

Проверяет, что указанные строки находятся в целевой строке в порядке.

Это может быть полезно для проверки HTML-вывода.

data-text="assertContainsSubsequence" id="assertContainsSubsequence">assertContainsSubsequence

assertContainsSubsequence(
    container, subsequence, msg=None
)

Проверяет, что "container" содержит "subsequence" в качестве подпоследовательности.

Проверяет, что "container" содержит все элементы "subsequence" в порядке, но, возможно, с другими элементами между ними. Например, [1, 2, 3] является подпоследовательностью [0, 0, 1, 2, 0, 3, 0], но не [0, 0, 1, 3, 0, 2, 0].

data-text="assertContainsSubset" id="assertContainsSubset">assertContainsSubset

assertContainsSubset(
    expected_subset, actual_set, msg=None
)

Проверяет, является ли actual iterable надмножеством expected iterable.

data-text="assertCountEqual" id="assertCountEqual">assertCountEqual

assertCountEqual(
    first, second, msg=None
)

Сравнение неупорядоченных последовательностей, утверждающее, что одинаковые элементы, независимо от порядка. Если один и тот же элемент встречается более одного раза, проверяется, что элементы встречаются одинаковое количество раз.

self.assertEqual(Counter(list(first)),
                 Counter(list(second)))

Пример:

- [0, 1, 1] and [1, 0, 1] compare equal.
- [0, 0, 1] and [0, 1] compare unequal.

data-text="assertDTypeEqual" id="assertDTypeEqual">assertDTypeEqual

Просмотреть исходный код

assertDTypeEqual(
    target, expected_dtype
)

Проверить, что тип данных ndarray равен ожидаемому.

data-text="assertDeviceEqual" id="assertDeviceEqual">assertDeviceEqual

Просмотреть исходный код

assertDeviceEqual(
    device1, device2, msg=None
)

Проверяет, что два заданных устройства одинаковы.

data-text="assertDictContainsSubset" id="assertDictContainsSubset">assertDictContainsSubset

assertDictContainsSubset(
    subset, dictionary, msg=None
)

Проверяет, является ли словарь надмножеством подмножества.

data-text="assertDictEqual" id="assertDictEqual">assertDictEqual

Просмотреть исходный код

assertDictEqual(
    a, b, msg=None
)

Проверить, что два заданных словаря тензоров одинаковы.

data-text="assertEmpty" id="assertEmpty">assertEmpty

assertEmpty(
    container, msg=None
)

Проверяет, что объект имеет нулевую длину.

data-text="assertEndsWith" id="assertEndsWith">assertEndsWith

assertEndsWith(
    actual, expected_end, msg=None
)

Проверяет, что actual.endswith(expected_end) равно True.

data-text="assertEqual" id="assertEqual">assertEqual

assertEqual(
    first, second, msg=None
)

Не проходит, если два объекта не равны, как определяется оператором '=='.

data-text="assertEquals" id="assertEquals">assertEquals

assertEquals(
    *args, **kwargs
)

data-text="assertFalse" id="assertFalse">assertFalse

assertFalse(
    expr, msg=None
)

Проверить, что выражение ложно.

data-text="assertGreater" id="assertGreater">assertGreater

assertGreater(
    a, b, msg=None
)

Аналогично self.assertTrue(a > b), но с более удобным сообщением по умолчанию.

data-text="assertGreaterEqual" id="assertGreaterEqual">assertGreaterEqual

assertGreaterEqual(
    a, b, msg=None
)

Аналогично self.assertTrue(a >= b), но с более удобным сообщением по умолчанию.

data-text="assertIn" id="assertIn">assertIn

assertIn(
    member, container, msg=None
)

Аналогично self.assertTrue(a in b), но с более удобным сообщением по умолчанию.

data-text="assertIs" id="assertIs">assertIs

assertIs(
    expr1, expr2, msg=None
)

Аналогично self.assertTrue(a is b), но с более удобным сообщением по умолчанию.

data-text="assertIsInstance" id="assertIsInstance">assertIsInstance

assertIsInstance(
    obj, cls, msg=None
)

То же самое, что и self.assertTrue(isinstance(obj, cls)), но с более приятным сообщением по умолчанию.

assertIsNone

assertIsNone(
    obj, msg=None
)

То же самое, что и self.assertTrue(obj is None), но с более приятным сообщением по умолчанию.

assertIsNot

assertIsNot(
    expr1, expr2, msg=None
)

Так же, как self.assertTrue(a is not b), но с более приятным сообщением по умолчанию.

assertIsNotNone

assertIsNotNone(
    obj, msg=None
)

Включено для симметрии с assertIsNone.

assertItemsEqual

assertItemsEqual(
    first, second, msg=None
)

Сравнение неупорядоченных последовательностей, утверждающее, что элементы одинаковые, независимо от порядка. Если один и тот же элемент встречается более одного раза, проверяется, что элементы встречаются одинаковое количество раз.

self.assertEqual(Counter(list(first)),
                 Counter(list(second)))

Пример:

- [0, 1, 1] and [1, 0, 1] compare equal.
- [0, 0, 1] and [0, 1] compare unequal.

assertJsonEqual

assertJsonEqual(
    first, second, msg=None
)

Утверждает, что JSON-объекты, определённые в двух строках, равны.

Резюме различий будет включено в сообщение об ошибке с использованием assertSameStructure.

assertLen

assertLen(
    container, expected_len, msg=None
)

Утверждает, что объект имеет ожидаемую длину.

assertLess

assertLess(
    a, b, msg=None
)

То же самое, что и self.assertTrue(a < b), но с более приятным сообщением по умолчанию.

assertLessEqual

assertLessEqual(
    a, b, msg=None
)

То же самое, что и self.assertTrue(a <= b), но с более приятным сообщением по умолчанию.

assertListEqual

assertListEqual(
    list1, list2, msg=None
)

Утверждение равенства, специфичное для списков.

assertLogs

assertLogs(
    logger=None, level=None
)

Не выполняется, если не выводится сообщение протоколирования уровня level или выше для logger_name или его дочерних элементов. Если опущено, 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

assertMultiLineEqual(
    first, second, msg=None, **kwargs
)

Утверждает, что две многострочные строки равны.

assertNDArrayNear

Посмотреть исходный код

assertNDArrayNear(
    ndarray1, ndarray2, err, msg=None
)

Утверждает, что два массива NumPy имеют близкие значения.

assertNear

Посмотреть исходный код

assertNear(
    f1, f2, err, msg=None
)

Утверждает, что два вещественных числа близки друг к другу.

Проверяет, что |f1 - f2| < err, и утверждает ошибку теста, если это не так.

assertNoCommonElements

assertNoCommonElements(
    expected_seq, actual_seq, msg=None
)

Проверяет, являются ли итерируемые actual и expected disjoint.

assertNotAllClose

Посмотреть исходный код

assertNotAllClose(
    a, b, rtol=1e-06, atol=1e-06, msg=None
)

Утверждает, что два массива NumPy или тензоры не имеют близких значений.

assertNotAllEqual

Посмотреть исходный код

assertNotAllEqual(
    a, b, msg=None
)

Утверждает, что два массива NumPy или тензоры не имеют одинаковых значений.

assertNotAlmostEqual

assertNotAlmostEqual(
    first, second, places=None, msg=None, delta=None
)

Не выполняется, если два объекта равны, как определено их разницей, округлённой до заданного числа десятичных знаков (по умолчанию 7) и сравнением с нулём, или сравнением разницы между двумя объектами с заданным дельтой.

Обратите внимание, что десятичные знаки (от нуля) обычно не совпадают с значащими цифрами (измеренными от наиболее значащей цифры).

Объекты, которые равны, автоматически отклоняются.

assertNotAlmostEquals

assertNotAlmostEquals(
    *args, **kwargs
)

assertNotEmpty

assertNotEmpty(
    container, msg=None
)

Утверждает, что объект имеет ненулевую длину.

assertNotEndsWith

assertNotEndsWith(
    actual, unexpected_end, msg=None
)

Утверждает, что actual.endswith(unexpected_end) ложно.

assertNotEqual

assertNotEqual(
    first, second, msg=None
)

Прерывание, если два объекта равны, как определено оператором '!='.

assertNotEquals

assertNotEquals(
    *args, **kwargs
)

assertNotIn

assertNotIn(
    member, container, msg=None
)

То же самое, что и self.assertTrue(a not in b), но с более приятным сообщением по умолчанию.

assertNotIsInstance

assertNotIsInstance(
    obj, cls, msg=None
)

Включено для симметрии с assertIsInstance.

assertNotRegex

assertNotRegex(
    text, unexpected_regex, msg=None
)

Прервать тест, если текст соответствует регулярному выражению.

assertNotRegexpMatches

assertNotRegexpMatches(
    *args, **kwargs
)

assertNotStartsWith

assertNotStartsWith(
    actual, unexpected_start, msg=None
)

Утверждает, что actual.startswith(unexpected_start) ложно.

assertProtoEquals

Посмотреть исходный код

assertProtoEquals(
    expected_message_maybe_ascii, message, msg=None
)

Утверждает, что сообщение такое же, как проанализированное expected_message_ascii.

Создаёт другую копию прототипа message, считывает ascii сообщение в неё и затем сравнивает их с помощью self._AssertProtoEqual().

assertProtoEqualsVersion

Просмотреть исходный код

assertProtoEqualsVersion(
    expected,
    actual,
    producer=versions.GRAPH_DEF_VERSION,
    min_consumer=versions.GRAPH_DEF_VERSION_MIN_CONSUMER,
    msg=None
)

assertRaises

assertRaises(
    expected_exception, *args, **kwargs
)

Проверяет, что вызов передаваемой функции с указанными позиционными и именованными аргументами не вызывает исключение указанного класса. Если вызывается другой тип исключения, тест будет считаться ошибочным так же, как и при возникновении неожидаемого исключения.

Если вызов выполнен без передаваемых аргументов, возвращает объект контекста, используемый следующим образом::

with self.assertRaises(SomeException):
    do_something()

Необязательный именованный аргумент «msg» может быть передан, если assertRaises используется как объект контекста.

Объект контекста сохраняет ссылку на исключение в атрибуте «исключение». Это позволяет просмотреть исключение после проверки::

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

assertRaisesIncompatibleShapesError

Просмотреть исходный код

assertRaisesIncompatibleShapesError(
    exception_type=tf.errors.InvalidArgumentError
)

assertRaisesOpError

Просмотреть исходный код

assertRaisesOpError(
    expected_err_re_or_predicate
)

assertRaisesRegex

assertRaisesRegex(
    expected_exception, expected_regex, *args, **kwargs
)

Проверяет, что сообщение в поднятом исключении соответствует регулярному выражению.

assertRaisesRegexp

assertRaisesRegexp(
    expected_exception, expected_regex, *args, **kwargs
)

Проверяет, что сообщение в поднятом исключении соответствует регулярному выражению.

assertRaisesWithLiteralMatch

assertRaisesWithLiteralMatch(
    expected_exception,
    expected_exception_message,
    callable_obj=None,
    *args,
    **kwargs
)

Проверяет, что сообщение в поднятом исключении равно заданной строке.

В отличие от assertRaisesRegex, этот метод принимает не регулярное выражение, а строку.

с self.assertRaisesWithLiteralMatch(ExType, 'message'): DoSomething()

assertRaisesWithPredicateMatch

Просмотреть исходный код

@contextlib.contextmanager
assertRaisesWithPredicateMatch(
    exception_type, expected_err_re_or_predicate
)

Возвращает менеджер контекста для заключения кода, ожидающего поднятия исключения.

Если исключение является OpError, стек операций также включён в поиск соответствия в сообщении.

assertRegex

assertRegex(
    text, expected_regex, msg=None
)

Отклонить тест, если текст не соответствует регулярному выражению.

assertRegexMatch

assertRegexMatch(
    actual_str, regexes, message=None
)

Проверяет, что хотя бы одно регулярное выражение из regexes соответствует str.

Если это возможно, используйте assertRegex, что является упрощённой версией этого метода. assertRegex принимает одно регулярное выражение (строка или скомпилированный объект re) вместо списка.

Примечания:

1. Эта функция использует соответствие по подстрокам, т.е. соответствие происходит, если любая подстрока сообщения об ошибке соответствует любому регулярному выражению в списке. Это удобнее для пользователя, чем полное соответствие.

2. Если regexes пустой список, соответствие всегда будет неудачным.

3. Используйте regexes=[''] для регулярного выражения, которое всегда будет проходить.

4. '.' соответствует любому символу кроме новой строки. Для соответствия любому символу, используйте '(.|\n)'.

5. '^' соответствует началу каждой строки, а не только началу строки. Аналогично, '$' соответствует концу каждой строки.

6. Если regexes содержит недопустимое регулярное выражение, будет выброшено исключение.

assertRegexpMatches

assertRegexpMatches(
    *args, **kwargs
)

assertSameElements

assertSameElements(
    expected_seq, actual_seq, msg=None
)

Проверяет, что две последовательности содержат одинаковые элементы (в любом порядке).

В отличие от assertCountEqual, этот метод не учитывает дубликаты в ожидаемой и фактической последовательностях.

assertSameElements([1, 1, 1, 0, 0, 0], [0, 1]) # Не вызывает AssertionError

Если возможно, следует использовать assertCountEqual вместо assertSameElements.

assertSameStructure

assertSameStructure(
    a, b, aname='a', bname='b', msg=None
)

Проверяет, что два значения содержат одинаковое структурное содержимое.

Два аргумента должны быть древовидными данными, состоящими из деревьев словарей и списков. Они будут сравниваться глубоко, проходя по содержимому словарей и списков; другие элементы будут сравниваться с помощью оператора ==. Если структуры различаются по содержимому, сообщение об ошибке укажет место в структурах, где обнаружено первое различие. Это может быть полезно при сравнении больших структур.

Поддерживаются смешанные типы последовательностей и множеств. Поддерживаются смешанные типы отображений, но порядок ключей при сравнении не учитывается.

assertSequenceAlmostEqual

assertSequenceAlmostEqual(
    expected_seq, actual_seq, places=None, msg=None, delta=None
)

Проверка приблизительного равенства для упорядоченных последовательностей.

Отклонит тест, если две последовательности не равны, как определено по разнице их значений, округленных до заданного количества десятичных знаков (по умолчанию 7) и сравненных с нулём, или по сравнению, что разница между каждым значением в двух последовательностях больше заданного дельты.

Обратите внимание, что десятичные знаки (от нуля) обычно не совпадают с значащими цифрами (измеренными от самой значимой цифры).

Если две последовательности сравниваются как равные, они автоматически сравнятся как приблизительно равные.

assertSequenceEqual

assertSequenceEqual(
    seq1, seq2, msg=None, seq_type=None
)

Утверждение о равенстве для упорядоченных последовательностей (например, списков и кортежей).

Для целей этой функции допустимый тип упорядоченной последовательности — это тип, который может быть индексирован, имеет длину и имеет оператор равенства.

assertSequenceStartsWith

assertSequenceStartsWith(
    prefix, whole, msg=None
)

Утверждение о равенстве для начала упорядоченных последовательностей.

Если префикс является пустой последовательностью, он сгенерирует ошибку, если whole также не является пустой последовательностью.

Если префикс не является последовательностью, он сгенерирует ошибку, если первый элемент whole не совпадает.

assertSetEqual

assertSetEqual(
    set1, set2, msg=None
)

Утверждение о равенстве, специфичное для множеств.

assertSetEqual использует подтипизацию для поддержки различных типов множеств и оптимизирован для множеств (параметры должны поддерживать метод difference).

assertShapeEqual

Просмотреть исходный код

assertShapeEqual(
    input_a, input_b, msg=None
)

Утверждает, что две NumPy- или TensorFlow-объекты имеют одинаковую форму.

Для тензоров это сравнивает статически известные формы во время компиляции, а не динамические формы во время выполнения.

assertStartsWith

Просмотреть исходный код

assertStartsWith(
    actual, expected_start, msg=None
)

Утверждает, что actual.startswith(expected_start) равно True.

assertTotallyOrdered

assertTotallyOrdered(
    *groups, **kwargs
)

Утверждает, что полное упорядочение реализовано правильно.

Например, предположим, что у вас есть класс A, который сравнивает только по своему атрибуту x. Сравнения, отличные от lt, опущены для краткости.

class A(object): def init(self, x, y): self.x = x self.y = y

def hash(self): return hash(self.x)

def lt(self, other): try: return self.x < other.x except AttributeError: return NotImplemented

assertTotallyOrdered проверит, что экземпляры могут быть упорядочены правильно. Например,

self.assertTotallyOrdered( [None], # None должен предшествовать всем остальным. [1], # Целые числа сортируются раньше. [A(1, 'a')], [A(2, 'b')], # 2 следует за 1. [A(3, 'c'), A(3, 'd')], # Второй аргумент несущественен. [A(4, 'z')], ['foo']) # Строки сортируются последними.

assertTrue

assertTrue(
    expr, msg=None
)

Проверить, что выражение истинно.

assertTupleEqual

assertTupleEqual(
    tuple1, tuple2, msg=None
)

Утверждение о равенстве, специфичное для кортежей.

assertUrlEqual

assertUrlEqual(
    a, b, msg=None
)

Утверждает, что URL-адреса равны, игнорируя порядок параметров запроса.

assertWarns

assertWarns(
    expected_warning, *args, **kwargs
)

Не проходит, если предупреждение класса warnClass не вызывается вызываемым объектом при вызове с указанными позиционными и ключевыми аргументами. Если вызывается предупреждение другого типа, оно не обрабатывается: в зависимости от других правил фильтрации предупреждений, оно может быть отключено, напечатано или вызвано как исключение.

Если вызывается с вызываемым объектом и опущенными аргументами, возвращает объект контекста, используемый так::

with self.assertWarns(SomeWarning):
    do_something()

Необязательный ключевой аргумент «msg» может быть передан, когда assertWarns используется как объект контекста.

Объект контекста сохраняет ссылку на первое соответствующее предупреждение как атрибут «предупреждение»; аналогично, атрибуты «имя файла» и «номер строки» предоставляют вам информацию о строке кода Python, из которой было сгенерировано предупреждение. Это позволяет вам просмотреть предупреждение после утверждения::

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

assertWarnsRegex

assertWarnsRegex(
    expected_warning, expected_regex, *args, **kwargs
)

Утверждает, что сообщение в вызвавшем предупреждении соответствует регулярному выражению. Основной принцип работы аналогичен assertWarns() с добавлением, что только предупреждения, сообщения которых также соответствуют регулярному выражению, считаются успешными совпадениями.

assert_

assert_(
    *args, **kwargs
)

cached_session

Просмотреть исходный код

@contextlib.contextmanager
cached_session(
    graph=None, config=None, use_gpu=True, force_gpu=False
)

Возвращает объект TensorFlow Session для использования в тестах.

Этот метод отличается от self.session(): по соображениям производительности cached_session по умолчанию повторно использует ту же сессию в рамках одного теста. Сессия, возвращаемая этой функцией, будет закрыта только в конце теста (в функции TearDown).

Используйте параметры use_gpu и force_gpu, чтобы управлять местоположением выполнения операций. Если force_gpu равно True, все операции привязаны к /device:GPU:0. В противном случае, если use_gpu равно True, TensorFlow пытается выполнить как можно больше операций на GPU. Если оба force_gpu anduse_gpu` равны False, все операции привязаны к CPU.

Пример:

class MyOperatorTest(test_util.TensorFlowTestCase):
  def testMyOperator(self):
    with self.cached_session() as sess:
      valid_input = [1.0, 2.0, 3.0, 4.0, 5.0]
      result = MyOperator(valid_input).eval()
      self.assertEqual(result, [1.0, 2.0, 3.0, 5.0, 8.0]
      invalid_input = [-1.0, 2.0, 7.0]
      with self.assertRaisesOpError("negative input not supported"):
        MyOperator(invalid_input).eval()

captureWritesToStream

Просмотреть исходный код

@contextlib.contextmanager
captureWritesToStream(
    stream
)

Менеджер контекста, который захватывает записи в заданный поток.

Этот менеджер контекста захватывает все записи в заданный поток внутри объекта CapturedWrites. При создании этого менеджера контекста он возвращает объект CapturedWrites. Захваченное содержимое можно получить, вызвав .contents() на объекте CapturedWrites.

Для работы этой функции поток должен иметь дескриптор файла, который можно изменить с помощью os.dup и os.dup2, а также поток должен поддерживать метод .flush(). Примерами являются стандартные python sys.stdout и sys.stderr. Обратите внимание, что в Colab или Jupyter notebooks это не работает, так как там используются альтернативные потоки stdout.

Пример:

class MyOperatorTest(test_util.TensorFlowTestCase):
  def testMyOperator(self):
    input = [1.0, 2.0, 3.0, 4.0, 5.0]
    with self.captureWritesToStream(sys.stdout) as captured:
      result = MyOperator(input).eval()
    self.assertStartsWith(captured.contents(), "This was printed.")

checkedThread

Посмотреть исходный код

checkedThread(
    target, args=None, kwargs=None
)

Возвращает обёртку потока, которая проверяет, что «target» завершился успешно.

Этот метод следует использовать для создания всех потоков в тестовых случаях, так как в противном случае существует риск того, что поток потерпит молчаливое поражение, и/или утверждения, сделанные в потоке, не будут учтены.

countTestCases

countTestCases()

create_tempdir

create_tempdir(
    name=None, cleanup=None
)

Создаёт временную директорию, специфичную для теста.

Примечание: Директория и её содержимое будут рекурсивно очищены перед созданием. Это гарантирует отсутствие предварительного состояния.

Это создаёт именованную директорию на диске, изолированную для этого теста, и будет правильно очищена тестом. Это позволяет избежать нескольких проблем при создании временных директорий для целей тестирования, а также упрощает настройку директорий и проверку их содержимого. Например:

def test_foo(self):
  out_dir = self.create_tempdir()
  out_log = out_dir.create_file('output.log')
  expected_outputs = [
      os.path.join(out_dir, 'data-0.txt'),
      os.path.join(out_dir, 'data-1.txt'),
  ]
  code_under_test(out_dir)
  self.assertTrue(os.path.exists(expected_paths[0]))
  self.assertTrue(os.path.exists(expected_paths[1]))
  self.assertEqual('foo', out_log.read_text())

См. также: create_tempfile() для создания временных файлов.

create_tempfile

create_tempfile(
    file_path=None,
    content=None,
    mode='w',
    encoding='utf8',
    errors='strict',
    cleanup=None
)

Создаёт временный файл, специфичный для теста.

Это создаёт именованный файл на диске, изолированный для этого теста, и будет правильно очищен тестом. Это позволяет избежать нескольких проблем при создании временных файлов для целей тестирования, а также упрощает настройку файлов, их данных, считывание их обратно и проверку при сбое теста. Например:

def test_foo(self):
  output = self.create_tempfile()
  code_under_test(output)
  self.assertGreater(os.path.getsize(output), 0)
  self.assertEqual('foo', output.read_text())

Примечание: Файл будет обнулён. Это гарантирует отсутствие предварительного состояния. ВАЖНО: Если файл уже существует, он будет сделан доступным для записи и перезаписан.

См. также: create_tempdir() для создания временных директорий и _TempDir.create_file для создания файлов внутри временной директории.

debug

debug()

Запускает тест без сбора ошибок в TestResult

defaultTestResult

defaultTestResult()

doCleanups

doCleanups()

Выполняет все функции очистки. Обычно вызывается за вами после tearDown.

enter_context

enter_context()

evaluate

Посмотреть исходный код

evaluate(
    tensors
)

Вычисляет тензоры и возвращает значения numpy.

evaluate_if_both_tensors

Посмотреть исходный код

evaluate_if_both_tensors(
    a, b
)

fail

fail(
    msg=None, prefix=None
)

Немедленно завершается с указанным сообщением, необязательно с префиксом.

failIf

failIf(
    *args, **kwargs
)

failIfAlmostEqual

failIfAlmostEqual(
    *args, **kwargs
)

failIfEqual

failIfEqual(
    *args, **kwargs
)

failUnless

failUnless(
    *args, **kwargs
)

failUnlessAlmostEqual

failUnlessAlmostEqual(
    *args, **kwargs
)

failUnlessEqual

failUnlessEqual(
    *args, **kwargs
)

failUnlessRaises

failUnlessRaises(
    *args, **kwargs
)

get_temp_dir

Посмотреть исходный код

get_temp_dir()

Возвращает уникальную временную директорию для использования тестом.

Если вы вызываете этот метод несколько раз во время теста, он вернёт ту же папку. Однако в разных запусках директории будут разными. Это гарантирует, что в разных запусках тесты не смогут загрязнять среду друг друга. Если вам нужны несколько уникальных директорий в одном тесте, используйте tempfile.mkdtemp следующим образом: tempfile.mkdtemp(dir=self.get_temp_dir()):

id

id()

run

run(
    result=None
)

session

Посмотреть исходный код

@contextlib.contextmanager
session(
    graph=None, config=None, use_gpu=True, force_gpu=False
)

Менеджер контекста для сессии TensorFlow для использования в выполнении тестов.

Обратите внимание, что это установит эту сессию и граф в качестве глобальных значений по умолчанию.

Используйте опции use_gpu и force_gpu для управления тем, где выполняются операции. Если force_gpu равно True, все операции привязаны к /device:GPU:0. В противном случае, если use_gpu равно True, TensorFlow пытается выполнить как можно больше операций на GPU. Если оба force_gpu anduse_gpu` равны False, все операции привязаны к CPU.

Пример:

class MyOperatorTest(test_util.TensorFlowTestCase):
  def testMyOperator(self):
    with self.session():
      valid_input = [1.0, 2.0, 3.0, 4.0, 5.0]
      result = MyOperator(valid_input).eval()
      self.assertEqual(result, [1.0, 2.0, 3.0, 5.0, 8.0]
      invalid_input = [-1.0, 2.0, 7.0]
      with self.assertRaisesOpError("negative input not supported"):
        MyOperator(invalid_input).eval()

setUp

Посмотреть исходный код

setUp()

Метод установки для подготовки тестового фикстура перед его применением.

setUpClass

@classmethod
setUpClass()

Метод-обработчик для настройки фикстуры класса перед запуском тестов в классе.

shortDescription

shortDescription()

Форматирует имя метода теста и первую строку его документации.

Если документация не указана, возвращает только имя метода.

Этот метод переопределяет unittest.TestCase.shortDescription(), который возвращает только первую строку документации, скрывая имя теста при сбое.

skipTest

skipTest(
    reason
)

Пропустить этот тест.

subTest

@contextlib.contextmanager
subTest(
    msg=_subtest_msg_sentinel, **params
)

Возвращает менеджер контекста, который вернет заключенный блок кода в подтесте, идентифицированный необязательными параметрами сообщения и ключевых слов. Сбой в подтесте отмечает тестовый случай как неудачный, но возобновляет выполнение в конце заключенного блока, позволяя выполнить дальнейший тестовый код.

tearDown

Просмотреть исходный код

tearDown()

Метод-обработчик для разборки фикстуры теста после её тестирования.

tearDownClass

@classmethod
tearDownClass()

Метод-обработчик для разборки фикстуры класса после выполнения всех тестов в классе.

test_session

Просмотреть исходный код

@contextlib.contextmanager
test_session(
    graph=None, config=None, use_gpu=True, force_gpu=False
)

Используйте cached_session вместо этого. (устарело)

__call__

__call__(
    *args, **kwds
)

Вызвать self как функцию.

__eq__

__eq__(
    other
)

Вернуть self==value.