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

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

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

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
)

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

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

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

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, все операции привязаны к процессору.

Пример:

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

captureWritesToStream

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

@contextlib.contextmanager
captureWritesToStream(
    stream
)

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

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

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

Пример:

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

checkedThread

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

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

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

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

countTestCases

countTestCases()

create_tempdir

create_tempdir(
    name=None, cleanup=None
)

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

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

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

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

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

create_tempfile

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

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

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

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

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

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

debug

debug()

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

defaultTestResult

defaultTestResult()

doCleanups

doCleanups()

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

enter_context

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

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.