class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
def gameMain():
word = Word('words.txt')
guess = Guess(word.randFromDB())
hangman = Hangman()
while hangman.remainingLives > 0:
display = hangman.currentShape()
print(display)
display = guess.displayCurrent()
print('Current: ' + display)
display = guess.displayGuessed()
print('Already Used: ' + display)
guessedChar = input('Select a letter: ')
if len(guessedChar) != 1:
print('One character at a time!')
continue
if guessedChar in guess.guessedChars:
print('You already guessed \"' + guessedChar + '\"')
continue
success = guess.guess(guessedChar)
if success == False:
hangman.decreaseLife()
if guess.finished() == True:
print('**** ' + guess.displayCurrent() + ' ****')
print('Success')
break
else:
print(hangman.currentShape())
print('word [' + guess.secretWord + ']')
print('guess [' + guess.displayCurrent() + ']')
print('Fail')
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('apple')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), 'a _ _ _ _ ')
self.g1.guess('p')
self.assertEqual(self.g1.displayCurrent(), 'a p p _ _ ')
self.g1.guess('l')
self.assertEqual(self.g1.displayCurrent(), 'a p p l _ ')
def testDisplayGuessed(self):
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' t ')
self.g1.guess('q')
self.assertEqual(self.g1.displayGuessed(), ' q t ')
self.g1.guess('s')
self.assertEqual(self.g1.displayGuessed(), ' q s t ')
self.g1.guess('n')
self.assertEqual(self.g1.displayGuessed(), ' n q s t ')
def testFinish(self):
self.g1.secretWord = 'apple'
self.g1.currentStatus = 'apple'
self.assertTrue(self.g1.finished())
def gameMain():
word = Word('words.txt')
guess = Guess(word.randFromDB())
hangman = Hangman()
while hangman.remainingLives > 0:
display = hangman.currentShape()
print(display)
display = guess.displayCurrent()
print('Current: ' + display)
display = guess.displayGuessed()
print('Already Used: ' + display)
success = guess.guess(getChar())
if success == 1:
continue
elif success == 2:
continue
elif success == False:
hangman.decreaseLife()
if guess.finished():
break
if guess.finished() == True:
print('**** ' + guess.displayCurrent() + ' ****')
print('Success')
else:
print(hangman.currentShape())
print('word [' + guess.secretWord + ']')
print('guess [' + guess.displayCurrent() + ']')
print('Fail')
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('happy')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ _ _ _ _ ')
self.g1.guess('h')
self.assertEqual(self.g1.displayCurrent(), 'h _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), 'h a _ _ _ ')
self.g1.guess('p')
self.assertEqual(self.g1.displayCurrent(), 'h a p p _ ')
self.g1.guess('z')
self.assertEqual(self.g1.displayCurrent(), 'h a p p _ ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), '')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), 'a ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), 'a t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), 'a t u ')
class TestGuess(unittest.TestCase):
def setUp(self):
self.p1 = Guess('abcdedcba')
def tearDown(self):
pass
# test cases
def testDisplayCurrent(self):
self.p1.guess('e')
self.assertEqual(self.p1.displayCurrent(), '_ _ _ _ e _ _ _ _ ')
self.p1.guess('a')
self.assertEqual(self.p1.displayCurrent(), 'a _ _ _ e _ _ _ a ')
self.p1.guess('t')
self.assertEqual(self.p1.displayCurrent(), 'a _ _ _ e _ _ _ a ')
self.p1.guess('a') # 이미 시도한 문자 입력시
self.assertEqual(self.p1.displayCurrent(), 'a _ _ _ e _ _ _ a ')
def testDisplayGuessed(self):
self.p1.guess('e')
self.p1.guess('n')
self.assertEqual(self.p1.displayGuessed(), 'e n ')
self.p1.guess('a')
self.assertEqual(self.p1.displayGuessed(), 'a e n ')
self.p1.guess('t')
self.assertEqual(self.p1.displayGuessed(), 'a e n t ')
self.p1.guess('u')
self.assertEqual(self.p1.displayGuessed(), 'a e n t u ')
self.p1.guess('c') #틀린 소문자
self.assertEqual(self.p1.displayGuessed(), 'a c e n t u ')
def testGuess(self):
self.assertEqual(self.p1.guess('e'), True)
self.assertEqual(self.p1.currentStatus, '____e____')
self.assertEqual(self.p1.guessedChars, ['e'])
self.assertEqual(self.p1.guess('a'), True)
self.assertEqual(self.p1.currentStatus, 'a___e___a')
self.assertEqual(self.p1.guessedChars, ['e', 'a'])
self.assertEqual(self.p1.guess('d'), True)
self.assertEqual(self.p1.currentStatus, 'a__ded__a')
self.assertEqual(self.p1.guessedChars, ['e', 'a', 'd'])
self.assertEqual(self.p1.guess('u'), False)
self.assertEqual(self.p1.currentStatus, 'a__ded__a')
self.assertEqual(self.p1.guessedChars, ['e', 'a', 'd', 'u'])
def testFinished(self): # 단어의 전체를 다 맞춘경우 True를 반환하는지 테스트
self.p1.guess('a')
self.p1.guess('b')
self.p1.guess('c')
self.p1.guess('d')
self.p1.guess('e')
self.p1.guess('d')
self.p1.guess('c')
self.p1.guess('b')
self.p1.guess('a')
self.assertTrue(self.p1.finished())
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
self.g2 = Guess('test')
def tearDown(self):
pass
#생성자가 잘 작동되나 확인
def testConstruct(self):
self.assertEqual(self.g2.secretWord, 'test')
self.assertEqual(self.g2.currentStatus, '_e__')
self.assertEqual(self.g2.guessedChars, {'', 'e', 'n'})
#guess함수 확인, False 와 True리턴값 확인
def testGuess(self):
self.assertEqual(self.g1.guess('q'), False)
self.assertEqual(self.g1.guessedChars, {'', 'q', 'e', 'n'})
self.assertEqual(self.g1.guess('D'), True)
self.assertEqual(self.g1.currentStatus, 'de_____')
self.assertEqual(self.g1.guess('a'), True)
self.assertEqual(self.g1.currentStatus, 'de_a___')
#정답을 맞췄을 때와 아닐 때 리턴값확인
def testFinished(self):
word_list = ['d', 'a', 'f', 'a', 'u', 'l', 't']
self.assertEqual(self.g1.finished(), False)
for w in word_list:
self.g1.guess(w)
self.assertEqual(self.g1.finished(), True)
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
#없는 문자 추가되었을 때
self.g1.guess('q')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
#중복된 문자추가
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
#len(charater) > 1인 문자
self.g1.guess('aa')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
def testGuess(self):
self.assertEqual(self.g1.secretWord, 'default')
self.assertEqual(self.g1.guess('a'), True)
self.assertEqual(self.g1.currentStatus, '_e_a___')
self.g1.guess('a')
self.assertEqual(self.g1.guess('u'), True)
self.g1.guess('u')
self.assertEqual(self.g1.currentStatus, '_e_au__')
self.assertEqual(self.g1.guess('w'), False)
self.assertEqual(self.g1.secretWord, 'default')
self.g1.guess('w')
self.assertEqual(self.g1.secretWord, 'default')
self.assertEqual(self.g1.currentStatus, '_e_au__')
self.g1.guess('d')
self.g1.guess('f')
self.g1.guess('l')
self.assertEqual(self.g1.finished(), False)
self.g1.guess('t')
self.assertEqual(self.g1.finished(), True)
def testHangman(self):
hang = hangman.Hangman()
self.assertEqual(hang.remainingLives, 6)
hang.decreaseLife()
self.assertEqual(hang.remainingLives, 5)
def testWord(self):
wor = word.Word('words.txt')
self.assertEqual(wor.test(), 'default')
self.assertEqual(type(wor.randFromDB()), str)
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
print('display test ended')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
print('guessed test ended')
def testfinished(self):
t1 = Guess('a')
self.assertEqual(t1.secretWord, 'a')
t2 = Guess('toomuchhomework')
self.assertEqual(t2.secretWord, 'toomuchhomework')
t3 = Guess('chicken')
self.assertEqual(t3.secretWord, 'chicken')
print('finished test ended')
def testguess(self):
self.assertFalse(self.g1.guess('k'), msg='There is no k')
self.assertFalse(self.g1.guess('o'), msg='There is no o')
self.assertFalse(self.g1.guess('p'), msg='There is no p')
self.assertTrue(self.g1.guess('d'), msg='guess method error')
self.assertTrue(self.g1.guess('e'), msg='guess method error')
print('guess method test ended')
def testInputIsAlpha(self):
self.assertFalse(self.g1.guess('1'),
msg='Please input Alphabet not integer')
self.assertFalse(self.g1.guess('ㅂ'),
msg='Please input Alphabet not korean')
self.assertFalse(self.g1.guess('*'),
msg='Please input Alphabet not symbol')
print('input test ended')
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
def testguess(self):
#리턴 값이 올바른가
self.assertTrue(self.g1.guess('d'))
self.assertFalse(self.g1.guess('r'))
#부분적으로 맞추어진 단어의 상태가 올바르게 유지되는가
#이용된 글자들의 집합을 나타내는 데이터는 올바르게 유지되는가
self.assertEqual(self.g1.currentStatus, 'de_____')
self.g1.guess('a')
self.assertEqual(self.g1.currentStatus, 'de_a___')
self.g1.guess('t')
self.assertEqual(self.g1.currentStatus, 'de_a__t')
self.g1.guess('u')
self.assertEqual(self.g1.currentStatus, 'de_au_t')
def testfinished(self):
#단어 전체를 다 맞춘 경우에 대한 처리가 올바른가?
self.assertFalse(self.g1.finished())
self.g1.guess('d')
self.g1.guess('r')
self.g1.guess('a')
self.g1.guess('t')
self.g1.guess('u')
self.g1.guess('f')
self.g1.guess('l')
self.assertTrue(self.g1.finished())
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
self.g2 = Guess('self')
self.g3 = Guess
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g1.guess('x')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
self.g1.guess('x')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u x ')
def testGuess(self):
self.assertIsNotNone(self.g1.guessedChars)
self.assertEqual(self.g1.guessedChars, { '', 'e', 'n'})
self.assertEqual(self.g1.currentStatus, '_e_____')
self.assertTrue(self.g1.guess('a'))
self.assertEqual(self.g1.guessedChars, {'a', '', 'e', 'n'})
self.assertEqual(self.g1.currentStatus, '_e_a___')
self.assertTrue(self.g1.guess('t'))
self.assertEqual(self.g1.guessedChars, {'t', 'a', '', 'e', 'n'})
self.assertEqual(self.g1.currentStatus, '_e_a__t')
self.assertTrue(self.g1.guess('u'))
self.assertEqual(self.g1.guessedChars, {'u', 't', 'a', '', 'e', 'n'})
self.assertEqual(self.g1.currentStatus, '_e_au_t')
self.assertFalse(self.g1.guess('z'))
self.assertEqual(self.g1.guessedChars, {'z', 'u', 't', 'a', '', 'e', 'n'})
self.assertEqual(self.g1.currentStatus, '_e_au_t')
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess(self.secretWord)
def tearDown(self):
pass
def wordcorrect(self): #단어의 전체를 다 맞춘 경우 처리
if self.currentStatus == self.secretWord:
self.assertEqual(self.g1.finished(), True)
else:
self.assertEqual(self.g1.finished(), False)
def testDisplayCurrent(self): #부분적으로 맞추어진 단어의 상태가 올바르게 유지되는가?
i = 0
while i < 7:
self.assertEqual(self.g1.displayCurrent(), self.g1.currentStatus)
# self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
# self.g1.guess('a')
# self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
# self.g1.guess('t')
# self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
# self.g1.guess('u')
# self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
def testDisplayGuessed(self): #이용된 글자들의 집합을 나타내는 데이터 유지 경우 처리
i = 0
string = ' e n '
while i < 7:
self.assertEqual(self.g1.displayGuessed(), string)
self.g1.guess('guessedChar')
string += ' ' + 'guessedChar' + ' '
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def testDisplayCurrent(self):
self.assertEqual(self.g1.secretWord, 'default')
self.assertEqual(self.g1.currentStatus, '_e____')
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.currentStatus, '_e_a___')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.assertEqual(self.g1.guess('d'),
True) #단어에 있는 글자가 들어갔을 때 Guess 리턴 값
self.g1.guess('f')
self.assertEqual(self.g1.guess('j'), False) #단어에 없는 글자가 들어갔을 때 리턴 값
self.g1.guess('l')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u l t ')
def testFinished(self):
self.g1.guess('d')
self.g1.guess('e')
self.g1.guess('f')
self.assertNotEqual(
self.g1.finished(),
True) #finished함수가 secretWord를 완성시키지 않았을 때 종료하지 않는지
self.g1.guess('a')
self.g1.guess('u')
self.g1.guess('l')
self.g1.guess('t')
self.assertEqual(self.g1.finished(), True) #종료가 잘 되는지
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
self.g1.guess('u') #전에 입력되었던 값이 입력되었을 때
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
self.g1.guess('U') #대문자가 입력이 되었을때
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
def gameMain():
word = Word('words.txt')
guess = Guess(word.randFromDB())
finished = False
hangman = Hangman()
print(hangman.currentShape())
print(guess.displayGuessed())
while hangman.is_live():
guessedChar = input('Select a letter: ')
system('clear')
if len(guessedChar) != 1:
print(hangman.currentShape())
print(guess.displayCurrent())
print("tried : [" + guess.displayGuessed() + "]")
print('One character at a time!')
continue
if guess.is_usedChar(guessedChar):
print(hangman.currentShape())
print(guess.displayCurrent())
print("tried : [" + guess.displayGuessed() + "]")
print('You already guessed \"' + guessedChar + '\"')
continue
correct = guess.guess(guessedChar)
if not correct:
hangman.decreaseLife()
if guess.is_finish():
finished = True
break
print(hangman.currentShape())
print(guess.displayCurrent())
print("tried : [" + guess.displayGuessed() + "]")
if finished:
print(hangman.currentShape())
print('Success' + '[' + guess.displayGuessWord() + ']')
else:
print(hangman.currentShape())
print('word [' + guess.displayGuessWord() + ']')
print('guess [' + guess.displayCurrent() + ']')
print('Fail')
def gameMain():
word = Word('words.txt')
guess = Guess(word.randFromDB())
finished = False
hangman = Hangman()
while hangman.remainingLives > 0:
display = hangman.currentShape()
print(display)
guess.displayCurrent()
print("used letter: ")
print()
for i in string.ascii_lowercase:
if i in guess.guessedChars:
print(colored(i, 'red'), end=' ')
else:
print(colored(i, 'green'), end=' ')
print()
print()
guessedChar = input('Select a letter: ')
if len(guessedChar) != 1:
print('One character at a time!')
continue
if guessedChar in guess.guessedChars:
print('You already guessed \"' + guessedChar + '\"')
continue
success = guess.guess(guessedChar)
print(success)
if not success:
hangman.decreaseLife()
if guess.finished():
break
if guess.finished():
print(guess.displayCurrent())
print('Success')
else:
print(hangman.currentShape())
print(guess.secretWord)
guess.displayCurrent()
print('Fail')
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.g1.guess('e')
self.assertEqual(self.g1.displayCurrent(),
list('▢ e ▢ ▢ ▢ ▢ ▢'.split(' ')))
self.assertFalse(self.g1.finished())
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(),
list('▢ e ▢ a ▢ ▢ ▢'.split(' ')))
self.assertFalse(self.g1.finished())
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(),
list('▢ e ▢ a ▢ ▢ t'.split(' ')))
self.assertFalse(self.g1.finished())
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(),
list('▢ e ▢ a u ▢ t'.split(' ')))
self.assertFalse(self.g1.finished())
self.g1.guess('l')
self.assertEqual(self.g1.displayCurrent(),
list('▢ e ▢ a u l t'.split(' ')))
self.assertFalse(self.g1.finished())
self.g1.guess('d')
self.assertEqual(self.g1.displayCurrent(),
list('d e ▢ a u l t'.split(' ')))
self.assertFalse(self.g1.finished())
self.g1.guess('f')
self.assertEqual(self.g1.displayCurrent(),
list('d e f a u l t'.split(' ')))
self.assertTrue(self.g1.finished())
def testDisplayGuessed(self):
self.g1.guess('e')
self.assertEqual(self.g1.displayGuessed(), [('e', 1)])
self.g1.guess('d')
self.assertEqual(self.g1.displayGuessed(), [('e', 1), ('d', 0)])
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), [('e', 1), ('d', 0),
('a', 3)])
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), [('e', 1), ('d', 0),
('a', 3), ('t', 6)])
self.g1.guess('l')
self.assertEqual(self.g1.displayGuessed(),
[('e', 1), ('d', 0), ('a', 3), ('t', 6), ('l', 5)])
self.g1.guess('f')
self.assertEqual(self.g1.displayGuessed(),
[('e', 1), ('d', 0), ('a', 3), ('t', 6), ('l', 5),
('f', 2)])
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(),
[('e', 1), ('d', 0), ('a', 3), ('t', 6), ('l', 5),
('f', 2), ('u', 4)])
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
self.g2 = Hangman()
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.currentStatus, '_e_____')
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.currentStatus, '_e_a___')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.currentStatus, '_e_a__t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.currentStatus, '_e_au_t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g1.guess('f')
self.assertEqual(self.g1.currentStatus, '_efau_t')
self.assertEqual(self.g1.displayCurrent(), '_ e f a u _ t ')
self.g1.guess('d')
self.assertEqual(self.g1.currentStatus, 'defau_t')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u _ t ')
self.g1.guess('l')
self.assertEqual(self.g1.currentStatus, 'default')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u l t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
self.g1.guess('d')
self.assertEqual(self.g1.displayGuessed(), ' a d e n t u ')
self.g1.guess('f')
self.assertEqual(self.g1.displayGuessed(), ' a d e f n t u ')
self.g1.guess('l')
self.assertEqual(self.g1.displayGuessed(), ' a d e f l n t u ')
def testDecreaseLife(self):
self.assertEqual(self.g2.remainingLives, 6)
self.g2.decreaseLife()
self.assertEqual(self.g2.remainingLives, 5)
self.g2.decreaseLife()
self.assertEqual(self.g2.remainingLives, 4)
self.g2.decreaseLife()
self.assertEqual(self.g2.remainingLives, 3)
class TestGuess(unittest.TestCase):
def setUp(self):
#일단 default라는 단어가지고 실험할 것임..
#(추가)다른 단어로도 해보자..
self.g1 = Guess('default')
#(추가)같은알파벳이 두개이상 들어있는 단어
self.g2 = Guess('anaconda')
def tearDown(self):
pass
def testDisplayCurrent(self):
#1.처음 상태에서 e를 알려주었나?
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
#2.있는 문자를 입력했을때 반영을 하나?
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
#3.(추가)없는 문자를 입력했을때 제대로 되나?
self.g1.guess('x')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
#4.(추가)잘못 입력을 했을때 무시하나?
self.g1.guess('!')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
#5.(추가)빈 문자를 입력했을때 무시하나?
self.g1.guess(' ')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
#(추가) 다른 단어
self.assertEqual(self.g2.displayCurrent(), '_ n _ _ _ n _ _ ')
self.g2.guess('a')
self.assertEqual(self.g2.displayCurrent(), 'a n a _ _ n _ a ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
self.g2 = Guess('test')
self.g3 = Guess('ttt')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_______')
self.g1.guess('e')
self.assertEqual(self.g1.displayCurrent(), '_e_____')
def testDisplayGuessWord(self):
self.assertEqual(self.g2.displayGuessed(), '')
self.g2.guess('z')
self.assertEqual(self.g2.displayGuessed(), 'z')
def testIsFinish(self):
self.assertEqual(self.g3.is_finish(), False)
self.g3.guess('t')
self.assertEqual(self.g3.is_finish(), True)
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.finished(), False)
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g1.guess('d')
self.assertEqual(self.g1.displayCurrent(), 'd e _ a u _ t ')
self.g1.guess('f')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u _ t ')
self.g1.guess('k')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u _ t ')
self.g1.guess('l')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u l t ')
self.assertEqual(self.g1.finished(), True)
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
self.g1.guess('d')
self.assertEqual(self.g1.displayGuessed(), ' a d e n t u ')
self.g1.guess('f')
self.assertEqual(self.g1.displayGuessed(), ' a d e f n t u ')
self.g1.guess('k')
self.assertEqual(self.g1.displayGuessed(), ' a d e f k n t u ')
self.g1.guess('l')
self.assertEqual(self.g1.displayGuessed(), ' a d e f k l n t u ')
self.g1.guess('a')
self.assertEqual(self.g1.guess('a'), True)
self.g1.guess('b')
self.assertEqual(self.g1.guess('b'), False)
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
self.g2 = Guess('success')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g1.guess('i')
self.assertEqual(self.g1.displayCurrent(),
'_ e _ a u _ t ') # defalt에 없는 문자가 들어왔을 때
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(),
'_ e _ a u _ t ') # 예전에 입력했던 알파벳이 다시 들어왔을 때
self.assertEqual(self.g2.displayCurrent(), '_ _ _ _ e _ _ ')
self.g2.guess('s')
self.assertEqual(self.g2.displayCurrent(),
's _ _ _ e s s ') # 같은 알파벳이 많이 있을 때, 모두 들어갔는지 확인
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
self.g1.guess('i')
self.assertEqual(self.g1.displayGuessed(), ' a e i n t u ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e i n t u ')
self.assertEqual(self.g2.displayGuessed(), ' e n ')
self.g2.guess('s')
self.assertEqual(self.g2.displayGuessed(), ' e n s ')
def testGuess(self):
self.assertTrue(self.g1.guess('a'))
self.assertFalse(self.g1.guess('i'))
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g1.guess('d')
self.assertEqual(self.g1.displayCurrent(), 'd e _ a u _ t ')
self.g1.guess('f')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u _ t ')
self.g1.guess('l')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u l t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
def testGuess(self):
self.assertTrue(self.g1.guess('d'))
self.assertFalse(self.g1.guess('z'))
# 리턴값이 올바른가?
self.assertEqual('de%s' % ("_" * (len('default') - 2)), self.g1.currentStatus)
# 부분적으로 맞추어진 단어의 상태가 올바르게 유지되는가?
self.assertEqual({'e', '', 'n', 'd', 'z'}, self.g1.guessedChars)
# 이용된 글자들의 집합을 나타내는 데이터는 올바르게 유지되는가?
for c in "efault":
self.g1.guess(c)
is_finished = self.g1.finished()
self.assertTrue(is_finished)
# 단어의 전체를 다 맞춘 경우에 대한 처리가 올바른가?
if __name__ == '__main__':
unittest.main()
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
self.g2 = Guess("aaaaaaaa")
def tearDown(self):
pass
def testDisplayCurrent(self):
self.g1.guess('e')
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
def testDisplayGuessed(self):
self.g1.guess("e")
self.g1.guess("n")
self.assertEqual(self.g1.displayGuessed(), 'e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), 'a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), 'a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), 'a e n t u ')
def testDisplayCurrent2(self):
self.g2.guess("bbb")
self.assertEqual(self.g2.displayCurrent(), "_ _ _ _ _ _ _ _ ")
self.g2.guess(":")
self.assertEqual(self.g2.displayCurrent(), "_ _ _ _ _ _ _ _ ")
self.g2.guess("a")
self.assertEqual(self.g2.displayCurrent(), "a a a a a a a a ")
def testDisplayGuessed2(self):
self.g2.guess("b")
self.assertEqual(self.g2.displayGuessed(), "b ")
self.g2.guess(":")
self.assertEqual(self.g2.displayGuessed(), "b ")
self.g2.guess("a")
self.assertEqual(self.g2.displayGuessed(), "a b ")
def testFinished(self):
self.g1.guess("e")
self.assertEqual(self.g1.finished(), False)
self.assertEqual(self.g2.finished(), False)
self.g2.guess("a")
self.assertEqual(self.g2.finished(), True)
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def tearDown(self):
pass
def testGuessCase(self): # using Assert to test cases of guess()
alphabetList = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
default_alphabet_List = ['d','e','f','a','u','l','t']
not_default_alphabet_List = alphabetList - default_alphabet_List
self.assertTrue(self.g1.guess(x for x in default_alphabet_List))
self.assertFalse(Self.g1.guess(x for x in not_default_alphabet_List))
self.assertEqual(self.g1.currentStatus, self.g1.secretWord)
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ') # test init status
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g1.guess('l')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u l t ')
self.g1.guess('d')
self.assertEqual(self.g1.displayCurrent(), 'd e _ a u l t ')
self.g1.guess('c')
self.assertEqual(self.g1.displayCurrent(), 'd e _ a u l t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
self.g1.guess('l')
self.assertEqual(self.g1.displayGuessed(), ' a e l n t u ')
self.g1.guess('d')
self.assertEqual(self.g1.displayGuessed(), ' a d e l n t u ')
self.g1.guess('c')
self.assertEqual(self.g1.displayGuessed(), ' a c d e l n t u ')
def testGuess(self, character):
self.g1.guess('a')
self.assertTrue(self.g1.guess())
self.g1.guess('t')
self.assertTrue(self.g1.guess())
self.g1.guess('u')
self.assertTrue(self.g1.guess())
self.g1.guess('l')
self.assertTrue(self.g1.guess())
self.g1.guess('d')
self.assertTrue(self.g1.guess())
self.g1.guess('c')
self.assertFalse(self.g1.guess())
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
def tearDown(self):
pass
def testGuess(self):
self.assertFalse(self.g1.guess('p'))
self.assertTrue(self.g1.guess('d'))
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g1.guess('d')
self.assertEqual(self.g1.displayCurrent(), 'd e _ a u _ t ')
self.g1.guess('f')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u _ t ')
# 'p' is not in secretWord
self.g1.guess('p')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u _ t ')
self.g1.guess('l')
self.assertEqual(self.g1.displayCurrent(), 'd e f a u l t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
# 'u' is already in guessed set.
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
def testFinished(self):
self.assertFalse()
def gameMain():
word = Word('words.txt')
guess = Guess(word.randFromDB())
print('%d words in DB' % word.count)
finished = False
hangman = Hangman()
while hangman.remainingLives > 0:
display = hangman.currentShape()
print(display)
display = guess.displayCurrent()
print('Current: ' + display)
display = guess.displayGuessed()
print('Already Used: ' + display)
guessedChar = input("Select a Letter: ")
if len(guessedChar) == 1:
if 65 <= ord(guessedChar) <= 90 or 97 <= ord(
guessedChar) <= 122:
if 65 <= ord(guessedChar) <= 90:
guessedChar = chr(ord(guessedChar) + 32)
if guessedChar not in guess.used_set:
success = guess.guess(guessedChar)
if not success:
hangman.decreaseLife()
finished = guess.finished()
if finished:
break
if finished:
print('Success')
print('word [' + guess.word + ']')
else:
print('word [' + guess.word + ']')
print("Guess:", end=" ")
for i in range(len(guess.current)):
print(guess.current[i], end=" ")
print()
print('Fail')
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
self.g2 = Guess('self')
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g1.guess('r') # 속하지 않을때
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g2.guess('t')
self.assertEqual(self.g2.displayCurrent(), '_ e _ _ ')
self.g2.guess('f')
self.assertEqual(self.g2.displayCurrent(), '_ e _ f ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
self.g1.guess('r') # 상관없이 새로운 문자가 들어가야할 곳에 들어가는지?
self.assertEqual(self.g1.displayGuessed(), ' a e n r t u ')
self.g2.guess('t')
self.assertEqual(self.g2.displayGuessed(), ' e n t ')
self.g2.guess('f')
self.assertEqual(self.g2.displayGuessed(), ' e f n t ')
def testGuess(self):
self.assertEqual(self.g1.guess('a'), True)
self.assertEqual(self.g1.guess('g'), False)
self.assertEqual(self.g1.guess('x'), False)
self.assertEqual(self.g2.guess('t'), False)
self.assertEqual(self.g2.guess('f'), True)
class TestGuess(unittest.TestCase):
def setUp(self):
self.g1 = Guess('default')
self.g2 = Hangman()
def tearDown(self):
pass
def testDisplayCurrent(self):
self.assertEqual(self.g1.displayCurrent(), '_ e _ _ _ _ _ ')
self.g1.guess('a')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ _ ')
self.g1.guess('t')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a _ _ t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g1.guess('1') # 1일때는 영어가 아니므로 출력이 되면 안된다.
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
self.g1.guess('&') # & 기호일때도 영어가 아니므로 출력이 안된다.
self.assertEqual(self.g1.displayCurrent(), '_ e _ a u _ t ')
def testDisplayGuessed(self):
self.assertEqual(self.g1.displayGuessed(), ' e n ')
self.g1.guess('a')
self.assertEqual(self.g1.displayGuessed(), ' a e n ')
self.g1.guess('t')
self.assertEqual(self.g1.displayGuessed(), ' a e n t ')
self.g1.guess('u')
self.assertEqual(self.g1.displayGuessed(), ' a e n t u ')
self.g1.guess('1')
self.assertEqual(self.g1.displayGuessed(), ' 1 a e n t u ')
self.g1.guess('&')
self.assertEqual(self.g1.displayGuessed(), ' & 1 a e n t u ')
def testDecreaseLife(self):
self.assertEqual(self.g2.remainingLives, 7)
self.g2.decreaseLife()
self.assertEqual(self.g2.remainingLives, 6)
self.g2.decreaseLife()
self.assertEqual(self.g2.remainingLives, 5)
self.g2.decreaseLife()
self.assertEqual(self.g2.remainingLives, 4)
self.g2.decreaseLife()
self.assertEqual(self.g2.remainingLives, 3)
class HangmanGame(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
# Initialize word database
self.word = Word('words.txt')
# Hangman display window
self.hangmanWindow = QTextEdit()
self.hangmanWindow.setReadOnly(True)
self.hangmanWindow.setAlignment(Qt.AlignLeft)
font = self.hangmanWindow.font()
font.setFamily('Courier New')
self.hangmanWindow.setFont(font)
# Layout
hangmanLayout = QGridLayout()
hangmanLayout.addWidget(self.hangmanWindow, 0, 0)
# Status Layout creation
statusLayout = QGridLayout()
# Display widget for current status
self.currentWord = QLineEdit()
self.currentWord.setReadOnly(True)
self.currentWord.setAlignment(Qt.AlignCenter)
font = self.currentWord.font()
font.setPointSize(font.pointSize() + 8)
self.currentWord.setFont(font)
statusLayout.addWidget(self.currentWord, 0, 0, 1, 2)
# Display widget for already used characters
self.guessedChars = QLineEdit()
self.guessedChars.setReadOnly(True)
self.guessedChars.setAlignment(Qt.AlignLeft)
self.guessedChars.setMaxLength(52)
statusLayout.addWidget(self.guessedChars, 1, 0, 1, 2)
# Display widget for message output
self.message = QLineEdit()
self.message.setReadOnly(True)
self.message.setAlignment(Qt.AlignLeft)
self.message.setMaxLength(52)
statusLayout.addWidget(self.message, 2, 0, 1, 2)
# Input widget for user selected characters
self.charInput = QLineEdit()
self.charInput.setMaxLength(1)
statusLayout.addWidget(self.charInput, 3, 0)
# Button for submitting a character
self.guessButton = QToolButton()
self.guessButton.setText('Guess!')
self.guessButton.clicked.connect(self.guessClicked)
statusLayout.addWidget(self.guessButton, 3, 1)
# Button for a new game
self.newGameButton = QToolButton()
self.newGameButton.setText('New Game')
self.newGameButton.clicked.connect(self.startGame)
statusLayout.addWidget(self.newGameButton, 4, 0)
# Layout placement
mainLayout = QGridLayout()
mainLayout.setSizeConstraint(QLayout.SetFixedSize)
mainLayout.addLayout(hangmanLayout, 0, 0)
mainLayout.addLayout(statusLayout, 0, 1)
self.setLayout(mainLayout)
self.setWindowTitle('Hangman Game')
# Start a new game on application launch!
self.startGame()
def startGame(self):
self.hangman = Hangman()
self.guess = Guess(self.word.randFromDB())
font = self.currentWord.font()
if len(self.guess.secretWord) > 13:
#font.setPointSize(font.pointSize() - 8)
font.setPointSize(8)
else:
#font.setPointSize(font.pointSize() + 8)
font.setPointSize(12)
self.currentWord.setFont(font)
self.gameOver = False
self.hangmanWindow.setPlaceholderText(self.hangman.currentShape())
self.currentWord.setText(self.guess.displayCurrent())
self.guessedChars.setText(self.guess.displayGuessed())
self.message.clear()
def displayCurrentStatus(self):
str = ''
for i in self.guess.currentStatus:
str += i
str += ' '
return str
def displayGuessedChars(self):
str = ''
for i in self.guess.guessedChars:
str += i
str += ' '
return str
def guessClicked(self):
guessedChar = self.charInput.text()
self.charInput.clear()
self.message.clear()
if self.gameOver == True:
# 메시지 출력하고 - message.setText() - 리턴
self.message.setText("Game_Over")
return "gameover"
# 입력의 길이가 1 인지를 판단하고, 아닌 경우 메시지 출력, 리턴
if len(guessedChar) != 1:
self.message.setText("Not a len 1 char")
return "lengthError"
# 이미 사용한 글자인지를 판단하고, 아닌 경우 메시지 출력, 리턴
if guessedChar in self.guess.guessedChars:
self.message.setText("Used char")
return "Used char"
success = self.guess.guess(guessedChar)
if success == False:
# 남아 있는 목숨을 1 만큼 감소
self.hangman.decreaseLife()
# 메시지 출력
self.message.setText(guessedChar +" not in word")
# hangmanWindow 에 현재 hangman 상태 그림을 출력
self.hangmanWindow.setPlaceholderText(self.hangman.currentShape())
# currentWord 에 현재까지 부분적으로 맞추어진 단어 상태를 출력
self.currentWord.setText(self.displayCurrentStatus())
# guessedChars 에 지금까지 이용한 글자들의 집합을 출력
self.guessedChars.setText(self.displayGuessedChars())
if self.guess.finished():
# 메시지 ("Success!") 출력하고, self.gameOver 는 True 로
self.message.setText("Success!")
self.gameOver = True
elif self.hangman.getRemainingLives() == 0:
# 메시지 ("Fail!" + 비밀 단어) 출력하고, self.gameOver 는 True 로
self.message.setText("Fail" + self.word)
self.gameOver = True
