Python test Examples

Example #1

import types, functools
from pytape import test
from keys_only import keys_only


def keys_only_test(t):
    t.true(
        isinstance(keys_only, (types.BuiltinFunctionType, types.FunctionType,
                               functools.partial)), 'keys_only is a function')


test('Testing keys_only', keys_only_test)

Example #2

import types, functools
from pytape import test
from difference import difference


def difference_test(t):
    t.true(
        isinstance(difference, (types.BuiltinFunctionType, types.FunctionType,
                                functools.partial)),
        'difference is a function')


test('Testing difference', difference_test)

Example #3

import types,functools
from pytape import test
from min_n import min_n
def min_n_test(t):
    t.true(isinstance(min_n, (types.BuiltinFunctionType, types.FunctionType, functools.partial)),'min_n is a function')
test('Testing min_n',min_n_test)

Example #4

File: byte_size.test.py Project: willismonroe/30-seconds-of-python-code

import types, functools
from pytape import test
from byte_size import byte_size


def byte_size_test(t):
    t.true(
        isinstance(byte_size, (types.BuiltinFunctionType, types.FunctionType,
                               functools.partial)), 'byte_size is a function')


test('Testing byte_size', byte_size_test)

Example #5

File: capitalize_every_word.test.py Project: zzzlxhhh/30-seconds-of-python-code

import types, functools
from pytape import test
from capitalize_every_word import capitalize_every_word


def capitalize_every_word_test(t):
    t.true(
        isinstance(capitalize_every_word,
                   (types.BuiltinFunctionType, types.FunctionType,
                    functools.partial)), 'capitalize_every_word is a function')


test('Testing capitalize_every_word', capitalize_every_word_test)

Example #6

import types, functools
from pytape import test
from count_by import count_by


def count_by_test(t):
    t.true(
        isinstance(count_by, (types.BuiltinFunctionType, types.FunctionType,
                              functools.partial)), 'count_by is a function')


test('Testing count_by', count_by_test)

Example #7

File: factorial.test.py Project: zzzlxhhh/30-seconds-of-python-code

import types, functools
from pytape import test
from factorial import factorial


def factorial_test(t):
    t.true(
        isinstance(factorial, (types.BuiltinFunctionType, types.FunctionType,
                               functools.partial)), 'factorial is a function')


test('Testing factorial', factorial_test)

Example #8

import types, functools
from pytape import test
from lcm import lcm


def lcm_test(t):
    t.true(
        isinstance(lcm, (types.BuiltinFunctionType, types.FunctionType,
                         functools.partial)), 'lcm is a function')


test('Testing lcm', lcm_test)

Example #9

import types, functools
from pytape import test
from insertion_sort import insertion_sort


def insertion_sort_test(t):
    t.true(
        isinstance(insertion_sort, (types.BuiltinFunctionType,
                                    types.FunctionType, functools.partial)),
        'insertion_sort is a function')


test('Testing insertion_sort', insertion_sort_test)

Example #10

File: has_duplicates.test.py Project: zzzlxhhh/30-seconds-of-python-code

import types, functools
from pytape import test
from has_duplicates import has_duplicates


def has_duplicates(t):
    t.true(
        isinstance(has_duplicates, (types.BuiltinFunctionType,
                                    types.FunctionType, functools.partial)),
        'has_duplicates is a function')


test('Testing has_duplicates', has_duplicates_test)

Example #11

File: gcd.test.py Project: zzzlxhhh/30-seconds-of-python-code

import types, functools
from pytape import test
from gcd import gcd


def gcd_test(t):
    t.true(
        isinstance(gcd, (types.BuiltinFunctionType, types.FunctionType,
                         functools.partial)), 'gcd is a function')


test('Testing gcd', gcd_test)

Example #12

File: difference_by.test.py Project: zzzlxhhh/30-seconds-of-python-code

import types, functools
from pytape import test
from difference_by import difference_by


def difference_by_test(t):
    t.true(
        isinstance(difference_by, (types.BuiltinFunctionType,
                                   types.FunctionType, functools.partial)),
        'difference_by is a function')


test('Testing difference_by', difference_by_test)

Example #13

File: deep_flatten.test.py Project: willismonroe/30-seconds-of-python-code

import types, functools
from pytape import test
from deep_flatten import deep_flatten


def deep_flatten_test(t):
    t.true(
        isinstance(deep_flatten, (types.BuiltinFunctionType,
                                  types.FunctionType, functools.partial)),
        'deep_flatten is a function')


test('Testing deep_flatten', deep_flatten_test)

Example #14

File: bubble_sort.test.py Project: zzzlxhhh/30-seconds-of-python-code

def bubble_sort_test(t):
t.true(isinstance(bubble_sort, (types.BuiltinFunctionType, types.FunctionType, functools.partial)),'<util.read_snippets.<locals>.snippet object at 0x7fc8ea4c6978> is a function')
test('Testing bubble_sort',bubble_sort_test)

Example #15

File: bubble_sort.test.py Project: winsomexjs/30-seconds-of-python-code

import types
import functools
from pytape import test
from bubble_sort import bubble_sort


def bubble_sort_test(t):
    t.true(
        isinstance(bubble_sort, (types.BuiltinFunctionType, types.FunctionType,
                                 functools.partial)),
        '<util.read_snippets.<locals>.snippet object at 0x7fc8ea4c6978> is a function'
    )


test('Testing bubble_sort', bubble_sort_test)

Example #16

File: chunk.test.py Project: willismonroe/30-seconds-of-python-code

import types,functools
from pytape import test
from chunk import chunk
def chunk_test(t):
    t.true(isinstance(chunk, (types.BuiltinFunctionType, types.FunctionType, functools.partial)),'chunk is a function')
test('Testing chunk',chunk_test)

Example #17

File: shuffle.test.py Project: willismonroe/30-seconds-of-python-code

import types, functools
from pytape import test
from shuffle import shuffle


def shuffle_test(t):
    t.true(
        isinstance(shuffle, (types.BuiltinFunctionType, types.FunctionType,
                             functools.partial)), 'shuffle is a function')


test('Testing shuffle', shuffle_test)

Example #18

File: max_n.test.py Project: zzzlxhhh/30-seconds-of-python-code

import types, functools
from pytape import test
from max_n import max_n


def max_n_test(t):
    t.true(
        isinstance(max_n, (types.BuiltinFunctionType, types.FunctionType,
                           functools.partial)), 'max_n is a function')


test('Testing max_n', max_n_test)

Example #19

File: palindrome.test.py Project: willismonroe/30-seconds-of-python-code

import types, functools
from pytape import test
from palindrome import palindrome


def palindrome_test(t):
    t.true(
        isinstance(palindrome, (types.BuiltinFunctionType, types.FunctionType,
                                functools.partial)),
        'palindrome is a function')


test('Testing palindrome', palindrome_test)

Example #20

import types, functools
from pytape import test
from capitalize import capitalize


def capitalize_test(t):
    t.true(
        isinstance(capitalize, (types.BuiltinFunctionType, types.FunctionType,
                                functools.partial)),
        'capitalize is a function')


test('Testing capitalize', capitalize_test)

Example #21

import types,functools
from pytape import test
from is_lower_case import is_lower_case
def is_lower_case_test(t):
    t.true(isinstance(is_lower_case, (types.BuiltinFunctionType, types.FunctionType, functools.partial)),'is_lower_case is a function')
test('Testing is_lower_case',is_lower_case_test)

Example #22

import types,functools
from pytape import test
from is_upper_case import is_upper_case
def is_upper_case_test(t):
    t.true(isinstance(is_upper_case, (types.BuiltinFunctionType, types.FunctionType, functools.partial)),'is_upper_case is a function')
test('Testing is_upper_case',is_upper_case_test)

Example #23

import types, functools
from pytape import test
from values_only import values_only


def values_only_test(t):
    t.true(
        isinstance(values_only, (types.BuiltinFunctionType, types.FunctionType,
                                 functools.partial)),
        'values_only is a function')


test('Testing values_only', values_only_test)

Example #24

File: zip.test.py Project: zzzlxhhh/30-seconds-of-python-code

import types, functools
from pytape import test
from zip import zip


def zip_test(t):
    t.true(
        isinstance(zip, (types.BuiltinFunctionType, types.FunctionType,
                         functools.partial)), 'zip is a function')


test('Testing zip', zip_test)

Example #25

File: count_occurences.test.py Project: zzzlxhhh/30-seconds-of-python-code

import types, functools
from pytape import test
from count_occurences import count_occurences


def count_occurences_test(t):
    t.true(
        isinstance(count_occurences, (types.BuiltinFunctionType,
                                      types.FunctionType, functools.partial)),
        'count_occurences is a function')


test('Testing count_occurences', count_occurences_test)

Example #26

File: compact.test.py Project: willismonroe/30-seconds-of-python-code

import types, functools
from pytape import test
from compact import compact


def compact_test(t):
    t.true(
        isinstance(compact, (types.BuiltinFunctionType, types.FunctionType,
                             functools.partial)), 'compact is a function')


test('Testing compact', compact_test)

Example #27

File: average.test.py Project: willismonroe/30-seconds-of-python-code

import types, functools
from pytape import test
from average import average


def average_test(t):
    t.true(
        isinstance(average, (types.BuiltinFunctionType, types.FunctionType,
                             functools.partial)), 'average is a function')


test('Testing average', average_test)

Example #28

import types, functools
from pytape import test
from decapitalize import decapitalize


def decapitalize_test(t):
    t.true(
        isinstance(decapitalize, (types.BuiltinFunctionType,
                                  types.FunctionType, functools.partial)),
        'decapitalize is a function')


test('Testing decapitalize', decapitalize_test)

Example #29

File: count_vowels.test.py Project: zzzlxhhh/30-seconds-of-python-code

import types, functools
from pytape import test
from count_vowels import count_vowels


def count_vowels_test(t):
    t.true(
        isinstance(count_vowels, (types.BuiltinFunctionType,
                                  types.FunctionType, functools.partial)),
        'count_vowels is a function')


test('Testing count_vowels', count_vowels_test)

Example #30

File: spread.test.py Project: willismonroe/30-seconds-of-python-code

import types,functools
from pytape import test
from spread import spread
def spread_test(t):
    t.true(isinstance(spread, (types.BuiltinFunctionType, types.FunctionType, functools.partial)),'spread is a function')
test('Testing spread',spread_test)