Ejemplos de match en Python

Ejemplo n.º 1

Archivo: parser_test.py Proyecto: ChuckNorristown/PTHW

def test_match():

    test_list = [('noun', 'princess')]
    test_expecting = 'noun'
    result = parser.match(test_list, test_expecting)
    assert_equal(result, ('noun', 'princess'))

    test_list = [('verb', 'go'),
                ('noun', 'princess'),
                ('direction', 'east')]
    test_expecting = 'verb'
    result = parser.match(test_list, test_expecting)    
    assert_equal(result, ('verb', 'go'))

    test_list = [('verb', 'go'),
                ('noun', 'princess'),
                ('direction', 'east')]
    test_expecting = 'stop'
    result = parser.match(test_list, test_expecting)    
    assert_equal(result, None)

    test_list = []
    test_expecting = 'stop'
    result = parser.match(test_list, test_expecting)
    assert_equal(result, None)

Ejemplo n.º 2

def test_match():
    word_list = []
    assert None == parser.match(word_list, 'noun')

    word_list = lexicon.scan("bear eat princess")
    assert_equal(('noun', "bear"), parser.match(word_list, 'noun'))
    assert_equal(None, parser.match(word_list, 'noun'))

Ejemplo n.º 3

Archivo: parser_tests.py Proyecto: akierans/py-tut

def test_match():
    assert_equal(parser.match(lexicon.scan("kill stop bear"), "verb"),
                 ('verb', 'kill'))
    assert_equal(parser.match(lexicon.scan("Eat kill bear"), "verb"),
                 ('verb', 'Eat'))
    assert_equal(parser.match(lexicon.scan("kill stop bear"), "stop"), None)
    assert_equal(parser.match(lexicon.scan("bear walks in woods"), "noun"),
                 ('noun', 'bear'))

Ejemplo n.º 4

Archivo: parser_tests.py Proyecto: UnKn0wn27/PyhonLearning-2.7.13

def test_match():
    words = ['one', 'two', 'three']
    scanner = lexicon.scan("bear go north")

    assert_equal(parser.match(words, 'o'), 'one')
    assert_equal(parser.match(scanner, 'noun'), ('noun', 'bear'))
    assert_equal(parser.match(scanner, None), None)
    assert_equal(parser.match(None, 'noun'), None)
    assert_equal(parser.match(None, None), None)

Ejemplo n.º 5

Archivo: parser_tests.py Proyecto: jeffhow/learnpython3thehardway

def test_match():
    word_list = []

    assert None == parser.match(word_list, 'noun')

    word_list = lexicon.scan('princess kill bear')
    assert ('noun', 'princess') == parser.match(word_list, 'noun')

    word_list = lexicon.scan('princess kill bear')
    assert None == parser.match(word_list, 'verb')

Ejemplo n.º 6

Archivo: ex49_tests.py Proyecto: hjl901002/python_ex

def test_match():
    assert_equal(parser.match([('direction', 'north')], 'direction'),
                 ('direction', 'north'))
    assert_equal(parser.match([('direction', 'north')], 'verb'), None)
    assert_equal(
        parser.match([('verb', 'go'), ('direction', 'north')], 'verb'),
        ('verb', 'go'))
    assert_equal(
        parser.match([('stop', 'of'), ('number', 1234), ('noun', 'princess')],
                     'stop'), ('stop', 'of'))
    assert_equal(
        parser.match([('stop', 'of'), ('number', 1234), ('noun', 'princess')],
                     'verb'), None)

Ejemplo n.º 7

Archivo: parser_tests.py Proyecto: LiamThursfield/PythonTheHardWay

def test_match():
    # test an empty word_list returns None
    word_list = ()
    assert_equal(parser.match(word_list, 'verb'), None)
    
    # test a none empty word list but with a none matching word type returns None
    word_list = [('verb', 'run')]
    assert_equal(parser.match(word_list, 'noun'), None)
    
    # test a none empty word list with a matching word type returns correct word tuple and also pops off the word tuple
    word_list = [('verb', 'run'), ('noun', 'bear')]
    assert_equal(parser.match(word_list, 'verb'), ('verb', 'run'))
    assert_equal(parser.match(word_list, 'noun'), ('noun', 'bear'))

Ejemplo n.º 8

Archivo: parser_tests.py Proyecto: michsien/Learning_python

def test_match():
	# matching with a list with 0 items
	assert_equal(parser.match([], "verb"), None)

	# matching with a list with 1 item (items are poped when match found 
	# -> list need to be reconstructed)
	word_list = lexicon.scan("north")
	assert_equal(parser.match(word_list, "direction"), ("direction", "north"))
	word_list = lexicon.scan("north")
	assert_equal(parser.match(word_list, "noun"), None)

	# matching with a list with many items
	word_list = lexicon.scan("haha go up quickly")
	assert_equal(parser.match(word_list, "error"), ("error", "haha"))
	word_list = lexicon.scan("haha go up quickly")
	assert_equal(parser.match(word_list, "verb"), None)

Ejemplo n.º 9

Archivo: parser_test.py Proyecto: ChuckNorristown/PTHW

def test_match():

    test_list = [('noun', 'princess')]
    test_expecting = 'noun'
    result = parser.match(test_list, test_expecting)
    assert_equal(result, ('noun', 'princess'))

    test_list = [('verb', 'go'), ('noun', 'princess'), ('direction', 'east')]
    test_expecting = 'verb'
    result = parser.match(test_list, test_expecting)
    assert_equal(result, ('verb', 'go'))

    test_list = [('verb', 'go'), ('noun', 'princess'), ('direction', 'east')]
    test_expecting = 'stop'
    result = parser.match(test_list, test_expecting)
    assert_equal(result, None)

    test_list = []
    test_expecting = 'stop'
    result = parser.match(test_list, test_expecting)
    assert_equal(result, None)

Ejemplo n.º 10

Archivo: parser_tests.py Proyecto: ShakedFadi/lpthw

def test_match():
    word_list = lexicon.scan('eat the bear bla')
    assert_equal(parser.match(word_list, 'verb'), ('verb', 'eat'))
    assert_equal(parser.match(word_list, 'noun'), None)
    assert_equal(parser.match([], 'verb'), None)

Ejemplo n.º 11

Archivo: parser_tests.py Proyecto: crystalballz/LearnPythonTheHardWay

def test_match():
    word_list = [('noun', 'player')]
    assert_equal(parser.match(word_list, 'noun'), 'player')
    assert_equal(parser.match(None, 'noun'), None)

Ejemplo n.º 12

Archivo: parser_tests.py Proyecto: crystalballz/LearnPythonTheHardWay

def test_match():
	word_list = [('noun', 'player')]
	assert_equal(parser.match(word_list, 'noun'), 'player')
	assert_equal(parser.match(None, 'noun'), None)

Ejemplo n.º 13

Archivo: ex49_tests.py Proyecto: PzoHua/learnpython2

def test_match():
    
    assert_equal(parser.match(word_list, word_type), ('verb', 'open'))

Ejemplo n.º 14

def test_match():
	assert_equal(parser.match([('noun', 'princess')], 'noun'), ('noun', 'princess'))

Ejemplo n.º 15

Archivo: ex49_tests.py Proyecto: chmcphoy/LPTHW

def testing_match():
    '''testing the match function.'''
    word_list = lexicon.scan('bear')
    assert_equal(parser.match(word_list, 'noun'), ('noun', 'bear'))
    assert_equal(parser.match(word_list, 'direction'), None)
    assert_equal(parser.match(None, 'verb'), None)

Ejemplo n.º 16

Archivo: ex49_tests.py Proyecto: WangDrop/WangDropExercise

def test_match():
    assert_equal(parser.match([('verb', 'kill')], 'verb'), ('verb', 'kill'))
    assert_equal(parser.match([('noun', 'carrbinet')], 'noun'), ('noun', 'carrbinet'))
    assert_equal(parser.match(None, 'verb'), None)
    assert_equal(parser.match([('verb', 'like')], 'noun'), None)

Ejemplo n.º 17

Archivo: parser_tests.py Proyecto: FerruccioSisti/LearnPython3

def test_bad_match():
    x = parser.match([("noun", "bear")], "verb")
    assert_equal(x, None)

Ejemplo n.º 18

Archivo: parser_tests.py Proyecto: AmyOrchid188/Knowledge

def test_match():
    word_list = lexicon.scan("princess")
    assert_equal(parser.match(word_list, "noun"), ("noun", "princess"))
    assert_equal(parser.match(word_list, "stop"), None)
    assert_equal(parser.match(None, "noun"), None)

Ejemplo n.º 19

Archivo: parser_tests.py Proyecto: atticdweller/pythonthehardway

def TestMatch():
    inputsent = lexicon.scan("bear eat castle")
    assert_equal(('noun', 'bear'), parser.match(inputsent, 'noun'))
    assert_equal(None, parser.match(None, ''))
    assert_equal(None, parser.match(inputsent, 'failhere'))

Ejemplo n.º 20

Archivo: parser_tests.py Proyecto: razukorz/Learn_Python

def test_match():
    word_list = lexicon.scan("bear eat cake")
    assert_equal(parser.match(word_list,"noun"),("noun","bear"))
    assert_equal(parser.match(word_list,"noun"),None)
    assert_equal(parser.match(None,"noun"),None)

Ejemplo n.º 21

Archivo: parser_tests.py Proyecto: morisy/Python-the-Hard-Way

def test_match():
    word_list = [('noun', 'Dog'), ('verb', 'ran'), ('stop', 'to'), ('stop', 'the'), ('noun', 'cow')]
    assert_equal(parser.match(word_list, 'noun'), ('noun', 'Dog'))

Ejemplo n.º 22

Archivo: parser_tests.py Proyecto: whymog/lp3thw

def test_match():
    assert_equal(parser.match([('direction', 'up')], 'direction'),
                 ('direction', 'up'))
    assert_equal(parser.match([('something', 'nope')], 'nah'), None)

Ejemplo n.º 23

Archivo: parser_tests.py Proyecto: cldershem/pythonthehardway

def test_match():
	word_list = lexicon.scan(sentence)
	assert_equal(parser.match(word_list, 'noun'), ('noun', 'princess'))

Ejemplo n.º 24

Archivo: parser_tests.py Proyecto: rhlass/LearnPythonTheHardWay

def test_match():
    word_list = lexicon.scan("open the door")
    assert_equal(parser.match(word_list, "verb"), ("verb", "open"))
    assert_equal(word_list, [("stop", "the"), ("noun", "door")])

Ejemplo n.º 25

def test_match():
    wordlist = wordlist = [("verb", "kill"), ("stop", "the"),
                           ("noun", "princess")]
    assert_equal(parser.match(wordlist, "verb"), ("verb", "kill"))
    assert_equal(parser.match(wordlist, "stop"), ("stop", "the"))
    assert_equal(parser.match(wordlist, "run"), None)

Ejemplo n.º 26

Archivo: parser_tests.py Proyecto: FerruccioSisti/LearnPython3

def test_match():
    x = parser.match([("noun", "bear")], "noun")
    assert_equal(x, ("noun", "bear"))

Ejemplo n.º 27

Archivo: parser_tests.py Proyecto: BryanSWong/Python

def test_match():
  test = [('noun', 'bear')]
  assert_equal(parser.match(test, 'noun'), ('noun', 'bear'))
  assert_equal(parser.match(test, 'stop'), None)
  assert_equal(parser.match(None, 'noun'), None)

Ejemplo n.º 28

Archivo: parser_tests.py Proyecto: William-Samster/LearnPythonTheHardWay-1

def test_match():
    word_list = lexicon.scan("open the door")
    assert_equal(parser.match(word_list, 'verb'), ('verb', 'open'))
    assert_equal(word_list, [('stop', 'the'), ('noun', 'door')])

Ejemplo n.º 29

def test_match():
    word_list = lexicon.scan('princess')
    assert_equal(parser.match(word_list, 'noun'), ('noun', 'princess'))
    assert_equal(parser.match(word_list, 'stop'), None)
    assert_equal(parser.match(None, 'noun'), None)

Ejemplo n.º 30

Archivo: ex49_tests.py Proyecto: BenJGMay/lpthw

def test_match():
    assert_equal(parser.match([], 'verb'), None)  # Nothing expected
    result = parser.match([('verb', 'run'), ('direction', 'north')], 'verb')
    assert_equal(result, ('verb', 'run'))
    result = parser.match([('verb', 'run'), ('direction', 'north')], 'noun')
    assert result == None

Ejemplo n.º 31

Archivo: ex49_tests.py Proyecto: SunGoodBoy/LPTHW

def test_match():
    word_list = lexicon.scan('princess')
    assert_equal(parser.match(word_list, 'noun'), ('noun', 'princess'))
    assert_equal(parser.match(word_list, 'stop'), None)
    assert_equal(parser.match(None, 'noun'), None)

Ejemplo n.º 32

Archivo: parser_test.py Proyecto: klion26/LearnPythonTheHardWay

def test_match():
	result = lexicon.scan("bear eat the xxx eat ... bear")
	sen = parser.match(result, "noun")
	assert_equal(sen, ("noun", "bear"))