tf.test.TestCase

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

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

Подклассы

class failureException

Методы

addClassCleanup

@classmethod
addClassCleanup(
    function, *args, /, **kwargs
)

Аналогично addCleanup, за исключением того, что элементы очистки вызываются даже при неудаче setUpClass (в отличие от tearDownClass).

addCleanup

addCleanup(
    function, *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), и сравнением с нулём, или сравнением разности между двумя объектами с заданным дельта.

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

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

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 равен ожидаемому.

assertDataclassEqual

assertDataclassEqual(
    first, second, msg=None
)

Проверяет, что две структуры данных dataclass равны с более информативными ошибками.

Аргументы должны быть структурами данных dataclass. Это сравнивает равенство отдельных полей и заботится о том, чтобы не сравнивать поля, помеченные как несравнимые. Он предоставляет различия по каждому полю, которые легче анализировать, чем сравнение строковых представлений из assertEqual.

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

assertDeviceEqual

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

assertDeviceEqual(
    device1, device2, msg=None
)

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

assertDictContainsSubset

assertDictContainsSubset(
    subset, dictionary, msg=None
)

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

assertDictEqual

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

assertDictEqual(
    a, b, msg=None
)

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

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, 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) равно 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, relative_tolerance=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)

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, этот метод не заботится о дубликатах в ожидаемых и фактических последовательностях::

# Doesn't raise an AssertionError
assertSameElements([1, 1, 1, 0, 0, 0], [0, 1])

Если возможно, используйте 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 не соответствует ему.

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 should come before everything else.
    [1],  # Integers sort earlier.
    [A(1, 'a')],
    [A(2, 'b')],  # 2 is after 1.
    [A(3, 'c'), A(3, 'd')],  # The second argument is irrelevant.
    [A(4, 'z')],
    ['foo'])  # Strings sort last.

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

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

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

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

assertWarnsRegex

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

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

assert_

assert_(
    *args, **kwargs
)

cached_session

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

@contextlib.contextmanager
cached_session(
    graph: Optional[tf.Graph] = None,
    config: Optional[tf.compat.v1.ConfigProto] = None,
    use_gpu: bool = True,
    force_gpu: bool = False
) -> Iterator[tf.compat.v1.Session]

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

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

Используйте параметры use_gpu и force_gpu для управления местом выполнения операций. Если force_gpu имеет значение True, все операции привязаны к /device:GPU:0. В противном случае, если use_gpu имеет значение True, TensorFlow пытается выполнить как можно больше операций на GPU. Если оба force_gpu and `use_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
) -> Iterator[CapturedWrites]

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

Этот менеджер контекста захватывает все записи в заданный поток внутри объекта 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: Callable[..., Any],
    args: Optional[tuple[Any, ...]] = None,
    kwargs: Optional[dict[str, Any]] = None
) -> _CheckedThread

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

См. также: :meth: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())

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

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

debug

debug()

Выполнить тест без сбора ошибок в TestResult

defaultTestResult

defaultTestResult()

doClassCleanups

@classmethod
doClassCleanups()

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

doCleanups

doCleanups()

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

enter_context

enter_context()

evaluate

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

evaluate(
    tensors
) -> Union[ragged_tensor_value.RaggedTensorValue, sparse_tensor.
    SparseTensorValue, None]

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

evaluate_if_both_tensors

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

evaluate_if_both_tensors(
    a, b
)

fail

fail(
    msg=None, user_msg=None
) -> NoReturn

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

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

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

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

id

id()

run

run(
    result=None
)

session

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

@contextlib.contextmanager
session(
    graph: Optional[tf.Graph] = None,
    config: Optional[tf.compat.v1.ConfigProto] = None,
    use_gpu: bool = True,
    force_gpu: bool = False
) -> Iterator[tf.compat.v1.Session]

Менеджер контекста для сеанса 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: Optional[tf.Graph] = None,
    config: Optional[tf.compat.v1.ConfigProto] = None,
    use_gpu: bool = True,
    force_gpu: bool = False
) -> Iterator[tf.compat.v1.Session]

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

__call__

__call__(
    *args, **kwds
)

Вызов self как функции.

__eq__

__eq__(
    other
)

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