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]