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.

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), сравнением с нулём или сравнением разности между двумя объектами с заданной погрешностью.

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

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

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
)

Утверждает, что "контейнер" содержит "подпоследовательность" как точную подпоследовательность.

Утверждает, что "контейнер" содержит все элементы "подпоследовательности" в порядке, без других элементов между ними. Например, [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
)

Утверждает, что "контейнер" содержит "подпоследовательность" как подпоследовательность.

Утверждает, что "контейнер" содержит все элементы "подпоследовательности" в порядке, но, возможно, с другими элементами между ними. Например, [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 надмножеством итерируемого объекта expected.

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
)

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

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) ложно.

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 при вызове его с указанными позиционными и ключевыми аргументами. Если возбуждается исключение другого типа, оно не перехватывается, и тест считается ошибочным, точно так же, как и при возникновении непредвиденного исключения.

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

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)

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
)

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

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

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

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(
    np_array, tf_tensor, msg=None
)

Утверждает, что у Numpy ndarray и 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 используется как объект контекста.

Объект контекста хранит ссылку на первое совпадающее предупреждение как атрибут 'warning'; аналогично, атрибуты 'filename' и 'lineno' предоставляют информацию о строке кода 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=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.

Example:

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(). Типичными примерами являются sys.stdout и sys.stderr Python.

Обратите внимание, что это не работает в 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.")

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

Объект 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

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

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

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

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

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