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
)

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

assertAlmostEqual

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

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

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

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

assertAlmostEquals

assertAlmostEquals(
    *args, **kwargs
)

assertArrayNear

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

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

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

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

assertBetween

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

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

assertCommandFails

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

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

assertCommandSucceeds

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

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

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].

assertContainsInOrder

assertContainsInOrder(
    strings, target, msg=None
)

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

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

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].

assertContainsSubset

assertContainsSubset(
    expected_subset, actual_set, msg=None
)

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

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.

assertDTypeEqual

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

assertDTypeEqual(
    target, expected_dtype
)

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

assertDeviceEqual

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

assertDeviceEqual(
    device1, device2, msg=None
)

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

assertDictContainsSubset

assertDictContainsSubset(
    subset, dictionary, msg=None
)

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

assertDictEqual

assertDictEqual(
    a, b, msg=None
)

Вызывает AssertionError, если a и b не являются равными словарями.

assertEmpty

assertEmpty(
    container, msg=None
)

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

assertEndsWith

assertEndsWith(
    actual, expected_end, msg=None
)

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

assertEqual

assertEqual(
    first, second, msg=None
)

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

assertEquals

assertEquals(
    *args, **kwargs
)

assertFalse

assertFalse(
    expr, msg=None
)

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

assertGreater

assertGreater(
    a, b, msg=None
)

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

assertGreaterEqual

assertGreaterEqual(
    a, b, msg=None
)

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

assertIn

assertIn(
    member, container, msg=None
)

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

assertIs

assertIs(
    expr1, expr2, msg=None
)

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

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 непересекающимися.

assertNotAllClose

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

assertNotAllClose(
    a, b, **kwargs
)

Утверждает, что два массива 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) равно False.

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) равно False.

assertProtoEquals

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

assertProtoEquals(
    expected_message_maybe_ascii, message, msg=None
)

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

Создаёт другой прототип сообщения, считывает 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
)

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

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

with self.assertRaises(SomeException):
    do_something()

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

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

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

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, этот метод принимает строку, а не регулярное выражение.

with 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
)

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

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

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

data-text="assertSequenceAlmostEqual" id="assertSequenceAlmostEqual" tabindex="0">assertSequenceAlmostEqual

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

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

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

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

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

data-text="assertSequenceEqual" id="assertSequenceEqual" tabindex="0">assertSequenceEqual

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

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

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

data-text="assertSequenceStartsWith" id="assertSequenceStartsWith" tabindex="0">assertSequenceStartsWith

assertSequenceStartsWith(
    prefix, whole, msg=None
)

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

Если префикс — пустая последовательность, будет вызвана ошибка, если вся последовательность тоже не пуста.

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

data-text="assertSetEqual" id="assertSetEqual" tabindex="0">assertSetEqual

assertSetEqual(
    set1, set2, msg=None
)

Утверждение о равенстве множеств.

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

data-text="assertShapeEqual" id="assertShapeEqual" tabindex="0">assertShapeEqual

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

assertShapeEqual(
    np_array, tf_tensor, msg=None
)

Проверяет, что у Numpy ndarray и TensorFlow тензора одинаковая форма.

data-text="assertStartsWith" id="assertStartsWith" tabindex="0">assertStartsWith

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

assertStartsWith(
    actual, expected_start, msg=None
)

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

data-text="assertTotallyOrdered" id="assertTotallyOrdered" tabindex="0">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']) # Строки сортируются последними.

data-text="assertTrue" id="assertTrue" tabindex="0">assertTrue

assertTrue(
    expr, msg=None
)

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

data-text="assertTupleEqual" id="assertTupleEqual" tabindex="0">assertTupleEqual

assertTupleEqual(
    tuple1, tuple2, msg=None
)

Утверждение о равенстве кортежей.

data-text="assertUrlEqual" id="assertUrlEqual" tabindex="0">assertUrlEqual

assertUrlEqual(
    a, b, msg=None
)

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

data-text="assertWarns" id="assertWarns" tabindex="0">assertWarns

assertWarns(
    expected_warning, *args, **kwargs
)

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

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

with self.assertWarns(SomeWarning):
    do_something()

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

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

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

data-text="assertWarnsRegex" id="assertWarnsRegex" tabindex="0">assertWarnsRegex

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

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

data-text="assert_" id="assert_" tabindex="0">assert_

assert_(
    *args, **kwargs
)

data-text="cached_session" id="cached_session" tabindex="0">cached_session

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

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

Возвращает сеанс TensorFlow для использования в выполнении тестов.

Этот метод ведет себя иначе, чем 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(use_gpu=True) 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()

Возвращаемое значение:

Объект Session, который должен использоваться как менеджер контекста для окружения кода построения и выполнения графа в случае теста.

captureWritesToStream

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

@contextlib.contextmanager
captureWritesToStream(
    stream
)

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

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

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

Пример:

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.")

Возвращаемое значение:

Объект CapturedWrites, содержащий все записи в указанный поток, сделанные во время этого контекста.

checkedThread

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

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

Возвращает обёртку Thread, которая проверяет успешное завершение '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(
    manager
)

Возвращает значение CM после его регистрации в стеке выхода.

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

Это полезно для устранения шаблонного кода на уровне каждого теста при использовании менеджеров контекста. Например, вместо декорирования каждого теста с @mock.patch, просто выполните self.foo = self.enter_context(mock.patch(...))' insetUp()`.

Примечание: Менеджеры контекста всегда выходят без какой-либо информации об ошибке. Это неудачная реализация из-за внутренних особенностей того, как unittest запускает тесты.

evaluate

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

evaluate(
    tensors
)

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

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=False, 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(use_gpu=True):
      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()

Возвращаемое значение:

Объект Session, который должен использоваться как менеджер контекста для окружения кода построения графа и выполнения в случае теста.

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=False, force_gpu=False
)

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

__call__

__call__(
    *args, **kwds
)

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

__eq__

__eq__(
    other
)

Возвращает self==value.

Переменные класса

• longMessage = True
• maxDiff = 1600
• tempfile_cleanup