Python match Examples

Example #1

File: parser_tests.py Project: BryanSWong/Python-1

def test_match():
	vector = lexicon.scan('princess')
	assert_equal(parser.match(vector, 'noun'), ('noun', 'princess'))
	vector = lexicon.scan('go')
	assert_equal(parser.match(vector, 'verb'), ('verb', 'go'))
	vector = lexicon.scan('the')
	assert_equal(parser.match(vector, 'error'), None)

Example #2

File: parser_tests.py Project: AdmiralAsshat/learn_python

def test_match():
	blank=[]
	assert_equal(parser.match(blank, None),(None))
	assert_equal(parser.match([('verb', 'eat'), ('stop','a'), 
							('noun', 'bagel')], 'verb'), ('verb', 'eat'))
	assert_equal(parser.match([('verb', 'eat'), ('stop','a'), 
							('noun', 'bagel')], 'noun'), (None))

Example #3

File: ex49_tests.py Project: yiqiyu/python-learning

def test_match():
    wordlist={'direction':"east", 'verb':"eat", 'stop':"in", 'noun':"princess", 'number':324, 'error':"err"}
    for (wtype,word) in wordlist.items():
        result=lexicon.scan(word)
        assert_equal(parser.match(result,wtype)[1], word)
        assert_equal(parser.match(result,wtype), None)
    result=lexicon.scan("kill")
    assert_equal(parser.match(result, 'noun'), None)

Example #4

File: parser_tests.py Project: jduan/learn_python_the_hard_way

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

Example #5

File: parser_tests.py Project: Wingedillidan/Learning-Archives

def test_match():
    # test successful returning case
    sentence = [('verb', 'go')]
    assert_equal(parser.match(sentence, 'verb'), ('verb', 'go'))

    # test with an incorrect expected case
    sentence = lexicon.scan("north and beyond the wall")
    assert_equal(parser.match(sentence, 'noun'), None)

    # test with passing an empty list
    assert_equal(parser.match([], 'direction'), None)

Example #6

File: parser_tests.py Project: relaxdiego/learnpythonthehardway

def test_match():
    word_list = [('verb', 'kill'),
                 ('stop', 'the'),
                 ('noun', 'bear')]

    # When there's a match
    word = parser.match(word_list[:], 'verb')
    assert_equal('verb', word[0])

    # When there's no match
    word = parser.match(word_list[:], 'stop')
    assert_is_none(word)

    # When word_list is null
    word = parser.match(None, 'stop')
    assert_is_none(word)

Example #7

File: parser_tests.py Project: benjross/LearnPythonTheHardWay

def test_match():
    word_list = lexicon.scan("bear eat cabinet")
    assert_equal(("noun", "bear"), parser.match(word_list, "noun"))
    assert_equal(("verb", "eat"), parser.match(word_list, "verb"))
    assert_equal(("noun", "cabinet"), parser.match(word_list, "noun"))
    assert_equal(None, parser.match(word_list, "noun"))
    assert_equal(None, parser.match(word_list, "asfdasdf"))
    word_list = lexicon.scan("eat north")
    assert_equal(None, parser.match(word_list, "safasdfa"))
    assert_equal(("direction", "north"), parser.match(word_list, "direction"))

Example #8

File: parser_tests.py Project: alesmana/learn-python

def test_match():
    #one word
    line1 = "bear"
    word_tuples1 = lexicon.scan(line1)
    assert_equal("bear", parser.match(word_tuples1, 'noun')[1])
    #Here we should get a None for any type since there is nothing in the word_list
    assert_equal(None, parser.match(word_tuples1, 'noun'))

    #multiple words
    #note that parser.match will 'cut' tupples one by one
    line2 = "bear eat the princess"
    word_tuples2 = lexicon.scan(line2)
    assert_equals(4, len(word_tuples2))
    assert_equal("bear", parser.match(word_tuples2, "noun")[1])
    assert_equals(3, len(word_tuples2))
    assert_equal("eat", parser.match(word_tuples2, "verb")[1])
    assert_equals(2, len(word_tuples2))
    assert_equal("the", parser.match(word_tuples2, 'stop')[1])
    assert_equals(1, len(word_tuples2))
    assert_equal("princess", parser.match(word_tuples2, 'noun')[1])
    assert_equals(0, len(word_tuples2))

Example #9

File: parser_tests.py Project: randy-wittorp/projects-LPTHW

def test_match():
    assert_equal(parser.match(lexicon.scan("go"), 'verb'), ('verb', 'go'))
    result = parser.match(lexicon.scan("bear"), 'noun')
    assert_equal(result, ('noun', 'bear'))

Example #10

File: parser_tests.py Project: gitrobike/ex47

def test_match():
    print(lexicon.sentence)
    assert_equal(parser.match(lexicon.sentence, 'direction'), ('direction', 'north'))
    print(lexicon.sentence)
    assert_equal(parser.match(lexicon.sentence, 'direction'), ('direction', 'south'))
    print(lexicon.sentence)

Example #11

File: parser_tests.py Project: Toruitas/Python

def test_match():
    assert_equal(parser.match(word_list,'stop'), ('stop','a'))  # (word_list,word_list[0][0]) 'stop'
    assert_equal([parser.match(s, s[0][0]) for s in PHRASE_LIST], [('verb','stop'),('noun','princess'),('verb','open'),
                                                                  ('error','banana')])
    force_exception = lexicon.scan('banana banana banana')
    assert_equal(parser.match(force_exception, 'noun'), None)

Example #12

File: parser_tests.py Project: Micaiah-Chang/LPTHW

def test_match():
	assert_equal(parser.match(lexicon.scan("kill stop bear"), "verb"), ('verb', 'kill'))
	assert_equal(parser.match(lexicon.scan("kill stop bear"), "stop"), None)

Example #13

File: parser_tests.py Project: jimmybananas/LearnPythonTheHardWay

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)

Example #14

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

Example #15

def test_match():
    assert_equal(parser.match([('verb', 'run')], 'verb'), ('verb', 'run'))

Example #16

File: parser_tests.py Project: kaushik853/lpthw_python_3

def test_match():
    word_list = []
    assert None == parser.match(word_list, 'noun')
    word_list = lexicon.scan("Princess Kill Bear")
    assert None == parser.match(word_list, 'verb')
    assert ('verb', 'Kill') == parser.match(word_list, 'verb')

Example #17

File: parser_tests.py Project: hectron/lpthw

def test_match():
    match = parser.match(['test', 'hunt', 'kill'], 'hunt')
    assert_equal(match, 'h')

Example #18

File: parser_tests.py Project: phoenx97/learn-python

def match_tests():
    word_list = [('type_a', 'word_a'), ('type_b', 'word_b')]
    assert_equals(parser.match(word_list, 'type_a'), ('type_a', 'word_a'))
    assert_equals(parser.match(word_list, 'type_b'), ('type_b', 'word_b'))
    assert_equals(parser.match(word_list, 'type_c'), None)

Example #19

def test_match_with_no_matches():
    wordlist = [('noun', 'bear')]
    result = parser.match(wordlist, 'verb')
    assert_equal(result, None)
    assert_equal(wordlist, [])

Example #20

def test_match_with_none():
    result = parser.match(None, 'verb')
    assert_equal(result, None)

Example #21

def test_match():
    wordlist = [('verb', 'run')]
    result = parser.match(wordlist, 'verb')
    assert_equal(result, ('verb', 'run'))
    assert_equal(wordlist, [])

Example #22

File: parser_tests.py Project: BennyMcBenBen/learnpythonthehardway

def test_match_not_expecting():
    assert_is_none(parser.match([('error', 'SPAM')], 'noun'))

Example #23

File: parser_tests.py Project: reschaap/ex48

def test_match():
    assert_equal(parser.match([('verb', 'go')], 'verb'), ('verb', 'go'))
    assert_equal(parser.match([('stop', 'the')], 'noun'), None)
    assert_equal(parser.match(None, 'stop'), None)

Example #24

File: parser_tests.py Project: xaxoxaxi/Learn-Python-The-Hard-Way-ex48

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

Example #25

def test_match():

    word_list2 = lexicon.scan("in the west")
    result = parser.match(word_list2, 'stop')
    assert_equal(result, ('stop', 'in'))

Example #26

File: parser_tests.py Project: RanHuang/Hello-World

def test_match():
    result = parser.match(lexicon.scan("234 445"), 'number')
    assert_equal(result, ('number', '234'))
    result = parser.match(lexicon.scan("234 445"), 'noun')
    assert_equal(result, None)

Example #27

def test_match():
    assert_equal(parser.match(word_list1, 'direction'), None)
    assert_equal(parser.match(word_list3, 'assss'), ('assss', 'ddddd'))

Example #28

File: parser_tests.py Project: TomF84/pythonTraining

def test_match():
    assert_equal(parser.match([('direction', 'north')], 'direction'),
                 ('direction', 'north'))
    assert_equal(parser.match([('direction', 'north')], 'verb'), None)
    assert_equal(parser.match([], ''), None)

Example #29

File: parser_tests.py Project: theguyisnoone/learnpythonthehardway

def test_match():
    assert_equal(parser.match([('obj', 'apple')], 'obj'), ('obj', 'apple'))

Example #30

def test_match():
	assert_equal(parser.match(word_list, 'stop'), ('stop', 'the'))
	assert_equal(parser.match(word_list, 'verb'), None)

Example #31

File: parser_tests.py Project: keqiliu/LearnPython

def test_match():
    assert_equal(parser.match([], 'what is that'), None)
    assert_equal(parser.match([('oh', 'run'), ('direction', 'up')], 'oh'),
                 ('oh', 'run'))
    assert_equal(parser.match([('aiyo', 'aiya'), ('direction', 'up')], 'verb'),
                 None)

Example #32

File: parser_tests.py Project: BennyMcBenBen/learnpythonthehardway

def test_none_word_list():
    assert_is_none(parser.match(None, 'noun'))

Example #33

File: parser_tests.py Project: reschaap/ex48

def test_skip():
     word_list = [('stop', 'will'), ('stop', 'the'), ('noun', 'bear')]
     
     parser.skip(word_list, 'stop')
     match = parser.match(word_list, 'noun')
     assert_equal(match, ('noun', 'bear'))

Example #34

File: parser_tests.py Project: mlennon3/Learn-Python-The-Hard-Way

def test_match():
    assert_equal(parser.match(word_list_2,'noun'), ('noun', 'princess'))
    assert_equal(parser.match(word_list_2, 'stop'), None)
    assert_equal(parser.match('', 'noun'), None)

Example #35

File: parser_tests.py Project: robertreichner/lpthw

def test_match_empty_word_list():
   empty_word_list = []
   assert_equal(parser.match(empty_word_list, 'noun'), None)

Example #36

File: parser_tests.py Project: huegli/Learning_Python

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

Example #37

File: parser_tests.py Project: dancole42/LPTHW

def test_match():
  assert_equal(parser.match(lexicon.scan(test_sentence), 'error'), (('error', 'this')))

Example #38

def test_match():
    result = parser.match(lexicon.scan("234 445"), 'number')
    assert_equal(result, ('number', '234'))
    result = parser.match(lexicon.scan("234 445"), 'noun')
    assert_equal(result, None)

Example #39

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)

Example #40

File: parser_tests.py Project: huegli/Learning_Python

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

Example #41

File: parser_tests.py Project: alagram/lpthw

def test_match():
    assert_equal(parser.match([('stop', 'the'), ('direction', 'north')], 'stop'), ('stop', 'the'))
    assert_equal(parser.match([('verb', 'run'), ('direction', 'north')], 'noun'), None)
    match = parser.match([], 'verb')
    assert_equal(match, None)

Example #42

File: parser_tests.py Project: algough/lpthw

def test_match():
	word_list = [('verb', 'go'), ('direction', 'north'), ('stop', 'at'), ('noun', 'door')]
	assert_equal(parser.match(word_list, 'verb'), ('verb', 'go'))
	assert_equal(parser.match(word_list, 'stop'), None)
	assert_equal(parser.match(None, 'noun'), None)

Example #43

def test_match():
    assert_equal(
        parser.match([['verb', 'go'], ['direction', 'north']], 'verb'),
        ['verb', 'go'])

Example #44

File: parser_tests.py Project: gmgmgod/learn-sth-everyday

def test_match():
    assert_equal(parser.match(word_list, 'noun'),( 'noun', 'bear'))

Example #45

File: parser_tests.py Project: robertreichner/lpthw

def test_match_not_equal():
   word_list = [('noun', 'princess'), ('verb', 'throws'), ('object', 'coins')]
   match_not_equal = parser.match(word_list, ('foo'))
   assert_equal(match_not_equal, None)