def test_is_integer():
"""
### Step 1:
Write a test that asserts that when `generate_prime_factors` is called with a
data type that is not an integer (e.g. a string or float), a ValueError is
raised. Write the appropriate code to solve this and then commit the changes.
"""
with pytest.raises(ValueError):
generate_prime_factors("test")
def test_empty_list():
"""
### Step 2:
Write a test that asserts that when `generate_prime_factors` is called with
`1`, an empty list is returned. Solve & commit.
"""
generate_prime_factors(1)
assert generate_prime_factors(1) == []
def test_list_of_two():
"""
### Step 3:
Write a test that asserts that when `generate_prime_factors` is called with
`2`, the list `[2]` is returned. Solve & commit.
"""
generate_prime_factors(2)
assert generate_prime_factors(2) == [2]
def test_list_of_three():
"""
### Step 4:
Write a test that asserts that when `generate_prime_factors` is called with
`3`, the list `[3]` is returned. Solve & commit.
"""
generate_prime_factors(3)
assert generate_prime_factors(3) == [3]
def test_factor_four():
"""
### Step 5:
Write a test that asserts that when `generate_prime_factors` is called with
`4`, the list `[2, 2]` is returned. Solve & commit.
"""
generate_prime_factors(4)
assert generate_prime_factors(4) == [2, 2]
def test_factor_six():
"""
### Step 6:
Write a test that asserts that when `generate_prime_factors` is called with
`6`, the list `[2, 3]` is returned. Solve & commit.
"""
generate_prime_factors(6)
assert generate_prime_factors(6) == [2, 3]
def test_factor_eight():
"""
### Step 7:
Write a test that asserts that when `generate_prime_factors` is called with
`8`, the list `[2, 2, 2]` is returned. Solve & commit.
"""
generate_prime_factors(8)
assert generate_prime_factors(8) == [2, 2, 2]
def test_factor_nine():
"""
### Step 8:
Write a test that asserts that when `generate_prime_factors` is called with
`9`, the list `[3, 3]` is returned. Solve & commit.
"""
generate_prime_factors(9)
assert generate_prime_factors(9) == [3, 3]
def test_integer():
"""
STEP 1: Given anything but an integer value, a ValueError should be raised.
appended.
"""
factors = []
value_types = ["abcd1234", 2.54, 3.14J]
for value in value_types:
with pytest.raises(ValueError):
generate_prime_factors(value, factors)
def test_data_type_not_integer():
"""Step 1:Checks if the to be evaluated value is not an integer and raise a value error"""
with pytest.raises(ValueError):#raises an error of function called for any type but integer
if not isinstance(generate_prime_factors(2.2), int):
raise ValueError("Function only workS for Integers")
def test_input_6():
"""
Given an input of 6 all contributing prime factors, i.e. 2 * 3
this is an example of the orginal requirement to solve at the beginning
of the assignment (solved for this from the beginning, exludes 1
prime factor)
"""
assert generate_prime_factors(6) == [2, 3]
def test_param_one():
"""
STEP 2: Given 1 as a parameter, an empty list should be returned.
"""
factors = []
value = 1
assert len(generate_prime_factors(value, factors)) == 0
def test_param_two():
"""
STEP 3: Given 2 as a parameter, a list containing one value of
2 should be returned.
"""
factors = []
value = 2
output_list = generate_prime_factors(value, factors)
assert len(output_list) == 1 and output_list[0] == 2
def test_param_three():
"""
STEP 4: Given 3 as a parameter, a list containing one value of
3 should be returned.
"""
factors = []
value = 3
output_list = generate_prime_factors(value, factors)
# Assert only one value of 3:
assert len(output_list) == 1 and output_list[0] == 3
def test_param_four():
"""
STEP 5: Given 4 as a parameter, a list containing 2 values of
2 should be returned.
"""
factors = []
value = 4
output_list = generate_prime_factors(value, factors)
# Assert only 2 values of 2 [2, 2]:
assert len(
output_list) == 2 and output_list[0] == 2 and output_list[1] == 2
def test_param_eight():
"""
STEP 7: Given 8 as a parameter, a list containing 3 values of
2 should be returned.
"""
factors = []
value = 8
output_list = generate_prime_factors(value, factors)
# Assert only 3 values - [2, 2, 2]:
assert len(output_list) == 3 and output_list[0] == 2 and output_list[
1] == 2 and output_list[2] == 2
def test_param_nine():
"""
STEP 8: Given 9 as a parameter, a list containing 2 values of
3 & 3 should be returned.
"""
factors = []
value = 9
output_list = generate_prime_factors(value, factors)
# Assert only 2 values - [2, 3]:
assert len(
output_list) == 2 and output_list[0] == 3 and output_list[1] == 3
def test_8():
assert generate_prime_factors(8) == [2, 2, 2]
def test_6():
assert generate_prime_factors(6) == [2, 3]
def test_4():
assert generate_prime_factors(4) == [2, 2]
def test_3():
assert generate_prime_factors(3) == [3]
def test_2():
assert generate_prime_factors(2) == [2]
def test_1():
assert generate_prime_factors(1) == []
def test_step8():
"""
Write a test that asserts that when generate_prime_factors is called with 9,
the list [3, 3] is returned. Solve & commit.
"""
assert generate_prime_factors(9) == [3, 3]
def test_prime_factor_9():
primes = [3, 3]
assert generate_prime_factors(9) == primes
def test_prime_factor_1():
primes = []
assert generate_prime_factors(1) == primes
def test_step2():
"""
Write a test that asserts that when generate_prime_factors is called with 1
, an empty list is returned. Solve & commit.
"""
assert generate_prime_factors(1) == []
def test_9():
assert generate_prime_factors(9) == [3, 3]
def test_incorrect_dat_type():
with pytest.raises(ValueError):
generate_prime_factors("string")
generate_prime_factors(6.6)
def test_step7():
"""
Write a test that asserts that when generate_prime_factors is called with 8,
the list [2, 2, 2] is returned. Solve & commit.
"""
assert generate_prime_factors(8) == [2, 2, 2]
