def test_Fizz():
fizzbuzz = FizzBuzz()
for i in range(101):
number = fizzbuzz.getNumber(i)
for index, element in enumerate(number):
if ((index + 1) % 3 == 0 and (index + 1) % 5 != 0):
assert (element == "Fizz")
def test_pure_int():
# Test that when no pairings are supplied, all returned values are integers
fb = FizzBuzz()
index = 1
for token in fb.get_fizz_buzz():
assert token.isdecimal(), f'Expected integer for #{index}. Found {token} instead.'
assert int(token) == index, f'Expected {index}. Found "{token}" instead.'
index += 1
def test_FizzBuzz():
fizzbuzz = FizzBuzz()
for i in range(101):
number = fizzbuzz.getNumber(i)
for index, element in enumerate(number):
if ((index + 1) % 5 == 0 and (index + 1) % 3 == 0):
assert (element == "FizzBuzz")
else:
assert (element != "FizzBuzz")
#'ef' in ['phone','hans']
def main():
limit = 100
if len(sys.argv) == 2:
try:
limit = int(sys.argv[1])
except ValueError:
print(f'Unrecognized command line parameter: {sys.argv[1]}')
sys.exit(-1)
elif len(sys.argv) > 2:
print('At most one parameter can be specified')
sys.exit(-1)
fb = FizzBuzz({3: 'Fizz', 5: 'Buzz', 7: 'Taco'})
for token in fb.get_fizz_buzz(limit):
print(token)
def test_correct_string_is_returned_for_list_of_numbers(self):
fizz_buzz = FizzBuzz()
result = fizz_buzz.fizz_buzz([1, 3, 3, 5, 15, 30, 4, 8, 10])
self.assertEqual([
"1",
"Fizz",
"Fizz",
"Buzz",
"FizzBuzz",
"FizzBuzz",
"4",
"8",
"Buzz",
], result)
def test_invalid_pairing_key():
# Test pairing key < 1
with_invalid_key = fizz_buzz_example.copy()
with_invalid_key[-5] = 'Taco'
# Assert that ValueError exception is properly raised here
with pytest.raises(ValueError):
FizzBuzz(with_invalid_key)
def test_pairings():
# Test with generated pairings
pairings = generate_random_pairings()
fb = FizzBuzz(pairings)
limit = 10000
index = 1
for output in fb.get_fizz_buzz(limit):
pairing_match = False
for key, value in pairings.items():
if index % key == 0:
pairing_match = True
assert value in output, f'{index} is divisible by {key} and should contain {value} but does not. Found {output} instead.'
# If no pairing matched, test that output is a number and the correct one
if not pairing_match:
assert output.isdecimal(), f'Expected integer for #{index}. Found {output} instead.'
assert int(output) == index, f'Expected {index}. Found {output} instead.'
index += 1
def test_digit():
fizzbuzz = FizzBuzz()
for i in range(101):
number = fizzbuzz.getNumber(i)
for index, element in enumerate(number):
if (index + 1) % 5 != 0 and (index + 1) % 3 != 0:
digits = [
digit for digit in str(index + 1)
if digit == '3' or digit == '5'
]
if len(digits) > 0:
if digits[0] == '5':
assert (element == 'Buzz')
elif digits[0] == '3':
assert (element == 'Fizz')
else:
raise Exception("shouldn't happen")
#'ef' in ['phone','hans']
def testFizz(self):
fizzBuzz = FizzBuzz()
self.assertEqual(fizzBuzz.say(3), "Fizz", "Fizzzzz")
self.assertEqual(fizzBuzz.say(5), "Buzz", "Buzzzzz")
self.assertEqual(fizzBuzz.say(9), "Fizz", "9 should be Fizz")
self.assertEqual(fizzBuzz.say(10), "Buzz", "10 should be Buzz")
self.assertEqual(fizzBuzz.say(1), "1", "1 should be 1")
self.assertEqual(fizzBuzz.say(15),"FizzBuzz")
self.assertEqual(fizzBuzz.say(13),"Fizz","Should be fizz")
class FizzBuzzTest(unittest.TestCase):
def setUp(self):
self.fiBuzzCalculator = FizzBuzz()
def testReturNumber(self):
self.assertEqual(1, self.fiBuzzCalculator.getValue(1))
def testCheckFizz(self):
self.assertEqual("Fizz", self.fiBuzzCalculator.getValue(3))
def testCheckBuzz(self):
self.assertEqual("Buzz", self.fiBuzzCalculator.getValue(5))
def testCheckFizzBuzz(self):
self.assertEqual("FizzBuzz", self.fiBuzzCalculator.getValue(15))
def testCheckfrom1to15(self):
fizz_buzz_dict = {
1: 1,
2: 2,
3: "Fizz",
4: 4,
5: "Buzz",
6: "Fizz",
7: 7,
8: 8,
9: "Fizz",
10: "Buzz",
11: 11,
12: "Fizz",
13: 13,
14: 14,
15: "FizzBuzz"
}
for number in range(1, 16):
self.assertEqual(fizz_buzz_dict.get(number),
self.fiBuzzCalculator.getValue(number))
def test(self):
self.fizzBuzz = FizzBuzz(5, 5)
self.assertTrue(self.fizzBuzz.checkFizz())
self.assertTrue(self.fizzBuzz.checkBuzz())
self.fizzBuzz = FizzBuzz(18, 23)
self.assertFalse(self.fizzBuzz.checkFizz())
self.assertFalse(self.fizzBuzz.checkBuzz())
self.fizzBuzz = FizzBuzz(0, -1)
self.assertFalse(self.fizzBuzz.checkFizz())
self.assertFalse(self.fizzBuzz.checkBuzz())
self.fizzBuzz = FizzBuzz(3, 5)
self.assertTrue(self.fizzBuzz.checkFizz())
self.assertTrue(self.fizzBuzz.checkBuzz())
self.assertTrue(self.fizzBuzz.say(3) == "Fizz")
self.assertTrue(self.fizzBuzz.say(5) == "Buzz")
self.assertTrue(self.fizzBuzz.say(15) == "FizzBuzz")
self.assertTrue(self.fizzBuzz.say(33) == "Fizz")
self.assertTrue(self.fizzBuzz.say(53) == "FizzBuzz")
self.assertTrue(self.fizzBuzz.say(98) == 98)
def test_validateResult(input, expected):
"""
Use cases:
- Can I call FizzBuzz
- Get "1" when I pass in 1
- Get "2" when I pass in 2
- Get "Fizz" when I pass in 3
- Get "Buzz" when I pass in 5
- Get "Fizz" when I pass in 6 (a multiple of 3)
- Get "Buzz" when I pass in 10 (a multiple of 5)
- Get "FizzBuzz" when I pass in 15 (a multiple of 3 and 5)
:param input:
:param expected:
:return:
"""
value = FizzBuzz(input)
assert value == expected
def main():
print("-------------------------------")
print("play FizzBuzz")
print("-------------------------------")
playFizzBuzz = True
while playFizzBuzz:
try:
input_var = input("Please enter a natural number <q to quit>: ")
if ("q"==input_var):
playFizzBuzz = False
else:
FizzBuzz(int(input_var))
except ValueError:
print("Invalid entry")
playFizzBuzz = True
def test_turn(self):
testCases = [
[1, 1],
[2, 2],
[3, 'Fizz'],
[4, 4],
[5, 'Buzz'],
[6, 'Fizz'],
[10, 'Buzz'],
[14, 14],
[15, 'FizzBuzz'],
[29, 29],
[30, 'FizzBuzz'],
[31, 31],
[33, 'Fizz'],
]
for testCase in testCases:
self.assertEquals(testCase[1], FizzBuzz.turn(testCase[0]))
def createInputCSV(start, end, filename):
"""Creates data for a range of numbers and inserts it into a file.
Parameters
----------
start : int
Starting index for the data to be created
end : int
Last position for the data to be created
filename : string
Name of the file to store data into
"""
# Why list in Python?
inputData = []
outputData = []
# Why do we need training Data?
for i in range(start, end):
inputData.append(i)
outputData.append(FizzBuzz().func(i))
# Why Dataframe?
# Dataframes are pandas objects, which themselves are enhanced version of
# numpy structured arrays
# DataFrames are inherently multidimensional arrays with
# attached row and column labels, and added support for heterogeneous
# types and missing data.
dataset = {}
dataset["input"] = inputData
dataset["label"] = outputData
save_data(dataset, filename)
print(filename, "Created!")
def test_nombre_negatif(self):
nombre = "-5"
with self.assertRaises(errorException):
FizzBuzz.NombreMultiplicateur(nombre)
# Fizzbuzz tests
from assertions import assertEqual, printErrors
from FizzBuzz import FizzBuzz
assertEqual("Fizz", FizzBuzz(3))
assertEqual("Buzz", FizzBuzz(5))
assertEqual("FizzBuzz", FizzBuzz(15))
assertEqual("X", FizzBuzz(1))
printErrors()
def testTwo(self):
fizzBuzz = FizzBuzz()
result = fizzBuzz.run(2)
self.assertEquals(2, result)
def testThree(self):
fizzBuzz = FizzBuzz()
result = fizzBuzz.run(3)
self.assertEquals("fizz", result)
def test_number_of_items():
# Test expected number of items returned for all list sizes between 1 and 1000
fb = FizzBuzz()
for i in range(1, 1001):
fb_list = list(fb.get_fizz_buzz(limit=i))
assert len(fb_list) == i, f'Expected {i} items. Got {len(fb_list)}.'
def test_multipleFiz(self):
self.assertEqual(FizzBuzz(3), 'Fiz')
def test_fizz(self):
number = 6
result = FizzBuzz.fizzbuzz(number)
self.assertEqual(result, 'Fizz')
def test_five_multiplo_de_cinco(self):
self.assertTrue(FizzBuzz.isBuzz(5));
def test_print_fizz_when_six(self):
self.assertEquals("Fizz", FizzBuzz.printFizz(6));
def test_six_isfizz(self):
self.assertTrue(FizzBuzz.isFizz(6));
def test_three_isfizz(self):
self.assertTrue(FizzBuzz.isFizz(3));
def testTen(self):
fizzBuzz = FizzBuzz()
result = fizzBuzz.run(10)
self.assertEquals("buzz", result)
def testFifteen(self):
fizzBuzz = FizzBuzz()
result = fizzBuzz.run(15)
self.assertEquals("fizzbuzz", result)
def test_renvoie_fizzbuzz_si_multiple_de_3_ET_5(self) :
nombre = "15"
result = "FIZZBUZZ"
nombreRetourne = FizzBuzz.NombreMultiplicateur(nombre)
self.assertEqual(result, nombreRetourne)
def test_renvoie_nombre(self):
nombre = "8"
nombreRetourne = FizzBuzz.NombreMultiplicateur(nombre)
self.assertEqual(nombre, nombreRetourne)
def test_seven_isbuzz(self):
self.assertFalse(FizzBuzz.isBuzz(7));
def testThirty(self):
fizzBuzz = FizzBuzz()
result = fizzBuzz.run(30)
self.assertEquals("fizzbuzz", result)
def test_ten_isbuzz(self):
self.assertTrue(FizzBuzz.isBuzz(10));
def test_multipleBuz(self):
self.assertEqual(FizzBuzz(50), 'Buz')
def test_print_buzz_when_five(self):
self.assertEquals("Buzz", FizzBuzz.printBuzz(5));
def testFive(self):
fizzBuzz = FizzBuzz()
result = fizzBuzz.run(5)
self.assertEquals("buzz", result)
def testSix(self):
fizzBuzz = FizzBuzz()
result = fizzBuzz.run(6)
self.assertEquals("fizz", result)
def test_large_list():
# Test requesting a large list
fb = FizzBuzz(fizz_buzz_example)
fb1 = iter(fb.get_fizz_buzz(sys.maxsize))
next(fb1)
def test_fifteen_isfizz_and_isbuzz(self):
self.assertTrue(FizzBuzz.isFizzandisBuzz(15));
def test_sixteen_isfizz_and_isbuzz(self):
self.assertFalse(FizzBuzz.isFizzandisBuzz(16))
def test_print_fizz_and_buzz_when_fifteen(self):
self.assertEquals("FizzBuzz", FizzBuzz.printFizzBuzz(15));
def test_renvoie_Exception_si_nombre_egale_0(self):
nombre = "0"
with self.assertRaises(errorException):
FizzBuzz.NombreMultiplicateur(nombre)
def setUp(self):
self.fizzbuzz = FizzBuzz()
def test_renvoie_buzz_nombre_multiple_de_5(self) :
nombre = "10"
result = "BUZZ"
nombreRetourne = FizzBuzz.NombreMultiplicateur(nombre)
self.assertEqual(result, nombreRetourne)
def test_multipleFizBuz(self):
self.assertEqual(FizzBuzz(45), 'FizBuz')
self.assertEqual(FizzBuzz(15), 'FizBuz')
def test_renvoie_erreur_si_texte(self) :
nombre = "TEST"
with self.assertRaises(errorException):
FizzBuzz.NombreMultiplicateur(nombre)
def test_multipleNum(self):
self.assertEqual(FizzBuzz(1), 1)
from FizzBuzz import FizzBuzz
print("Welcome to FizzBuzz !")
print("Write an integer and press Return...")
number = input()
if FizzBuzz.check_input(number):
print(FizzBuzz.answer(int(number)))
print("La bise !")
def test_zero_value(self): self.assertEqual(FizzBuzz(0), 0)
def test_print_buzz_when_seven(self):
self.assertEquals(7, FizzBuzz.printBuzz(7));
def testOne(self):
fizzBuzz = FizzBuzz()
result = fizzBuzz.run(1)
self.assertEquals(1, result)
