I created a small library Python library to randomly create primitive types and collections. The primitive types are int, float, and string. The collections are tuples of 2, tuples of 3, a list, a 2d list, a set, and a dictionary. The odds are all equal in the random library. Notably, the collections take a function to call which allows a random function of primitive types inside. Below is the code.
import random
def make_int(start, stop):
"""
:param start: int, start is not None
:param stop: int, stop is not None and stop > start
:return: int, return is not None and start <= returns < stop
"""
return random.randrange(start, stop)
def test_make_int():
start = 0
stop = 10
assert start <= make_int(start, stop) < stop
def make_float(start, stop):
"""
:param start: float, start is not None
:param stop: float, stop is not None and stop >= 0
:return: float, returns is not None and start <= returns < stop
"""
return random.randrange(start, stop)
def test_make_float():
start = 0.0
stop = 10.0
assert start <= make_float(start, stop) < stop
def make_str(rows, string):
"""
:param rows: int, rows is not None and rows >= 0
:param string: str, string is not None
:return: str, returns is not None and returns[row] in string
"""
return [random.choice(string) for _ in range(rows)]
def test_make_str():
letters = "abcd"
rows = 4
answer = make_str(rows, letters)
for char in answer:
assert char in letters
def make_tuple2(random_inside):
"""
:param random_inside: Callable[[], Any], random_inside is not None
:return: Tuple[Any, Any], returns is not None
"""
return random_inside(), random_inside()
def test_make_tuple2():
def dice():
return 4
assert make_tuple2(dice) == (4, 4)
def make_tuple3(random_inside):
"""
:param random_inside: Callable[[], Any], random_inside is not None
:return: Tuple[Any, Any, Any], returns is not None
"""
return random_inside(), random_inside(), random_inside()
def test_make_tuple3():
def dice():
return 4
assert make_tuple3(dice) == (4, 4, 4)
def make_1d_list(rows, random_inside):
"""
:param rows: int,rows is not None and rows >= 0
:param random_inside: Callable[[], Any], random_inside is not None
:return: List[Any], returns is not None and len(returns) == None
"""
return [random_inside() for _ in range(rows)]
def test_make_1d_list():
def random_str():
return "a"
rows = 2
assert make_1d_list(rows, random_str) == ["a", "a"]
def make_2d_list(rows, cols, random_inside):
return [[random_inside() for _ in range(rows)] for _ in range(cols)]
def test_make_2d_list():
def number():
return 9
rows = 2
cols = 2
assert make_2d_list(rows, cols, number) == [[9, 9], [9, 9]]
def make_set(rows, random_inside):
"""
:param rows: int, rows is not None and rows >= 0
:param random_inside: Callable[[], Any], random_inside is not None
:return: Set[Any], returns is not None and len(set) == rows
"""
answer = set()
col = 0
for _ in range(rows):
col = random.randrange(0, rows)
answer.add(random_inside())
return answer
def test_make_set():
def random_letter():
return "c"
rows = 1
assert make_set(rows, random_letter) == {"c"}
def make_random_dict(number_of_keys, random_key_function, random_value_function):
"""
:param number_of_keys: int, number_of_keys is not None and number_of_keys >= 0
:param random_key_function: Callable[[], Any], random_key_function is not None
:param random_value_function: Callable[[], Any], random_value_function is not None
:return: Set[Any], returns is not None and len(returns) == number_of_keys
"""
answer = dict()
for _ in range(number_of_keys):
answer[random_key_function()] = random_value_function()
return answer
def test_make_random_dict():
def random_key():
return "a"
def random_value():
return 4
number_of_keys = 3
make_random_dict(number_of_keys, random_key, random_value) == {"a": 4}
def tests():
test_make_int()
test_make_float()
test_make_str()
test_make_tuple2()
test_make_tuple3()
test_make_1d_list()
test_make_2d_list()
test_make_set()
test_make_random_dict()
if __name__ == "__main__":
tests()
