def test_the_index_of_simple_csc_and_an_lsa_definition(self):
wciSay = WhatCanISay.WhatCanISay()
interp = CmdInterp()
# do one csc and one lsa:
interp.add_csc(
CSCmd(["equals"],
meanings={contAny: ActionInsert("====")},
name="equals csc"))
interp.add_lsa(
LSAlias(["plus"],
meanings={all_languages: " + "},
name="plus sign"))
wciSay.load_commands_from_interpreter(self._app(), interp, 'C')
expected = \
{'C': {'equals': [[{'action': "Inserts '====^' in current buffer",
'doc': None,
'equiv': 'Any',
'scope': 'global',
'setdescription': 'no description',
'setname': 'cscs'}]],
'plus': [{'description': 'no description',
'name': 'plus sign',
'new_symbol': None,
'setname': 'lsas',
'spacing': 0,
'written_form': ' + '}]}}
self.assert_equal(
expected, wciSay.index,
"index of one CSC and one LSA command is not as expected")
def test_This_is_how_you_create_a_WhatCanISay_instance(self):
wciSay = WhatCanISay.WhatCanISay()
interp = CmdInterp()
# load one lsa and one csc:
interp.add_csc(CSCmd(["equals"], meanings={contAny: ActionInsert("====")}, name="equals csc"))
interp.add_lsa(LSAlias(["plus"], meanings={all_languages: " + "}, name="plus sign"))
wciSay.load_commands_from_interpreter(self._app(), interp, 'C')
def test_This_is_how_you_can_make_a_special_case_for_one_language(self):
interp = CmdInterp()
## In next test all languages are first set to "ccc",
## and then for python is changed to 'qqq'.
interp.add_lsa(LSAlias(['spoken', 'form'],
{'python': 'qqq', all_languages: 'ccc'}))
all_lsas = interp.language_specific_aliases
python_lsas = all_lsas['python']
# extract and check only one item:
for an_LSA in python_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'qqq'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
c_lsas = all_lsas['C']
# extract and check only one item:
for an_LSA in c_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'ccc'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
def test_This_is_how_you_create_a_LSAlias__instance(self):
interp = CmdInterp()
interp.add_lsa(LSAlias(['spoken', 'form'],
{'C': 'sss', 'python': 'ppp'}))
all_lsas = interp.language_specific_aliases
languages = all_lsas.keys()
languages.sort()
expected = list(all_languages) # list (of keys)
self.assert_equal(expected, languages, "LSAs, all languages should have a key, this was not as expected")
expected = all_languages # tuple
self.assert_equal(expected, interp.supported_languages(),
"LSAs, languages not as expected through interp method")
python_lsas = all_lsas['python']
# extract and check only one item:
for an_LSA in python_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'ppp'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
def test_This_is_how_you_can_make_a_special_case_c_style_languages(self):
interp = CmdInterp()
## In next test all languages are first set to "aaa",
## next c_style_languages to ccc, and
## after that java and python to something more specific
## and then for python is changed to 'qqq'.
interp.add_lsa(
LSAlias(
['spoken', 'form'], {
'java': 'jjj',
'python': 'pppp',
all_languages: 'aaa',
c_style_languages: 'ccc'
}))
all_lsas = interp.language_specific_aliases
python_lsas = all_lsas['python']
# extract and check only one item:
for an_LSA in python_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'pppp'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
c_lsas = all_lsas['C']
# extract and check only one item:
for an_LSA in c_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'ccc'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
java_lsas = all_lsas['java']
# extract and check only one item:
for an_LSA in java_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'jjj'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
def test_the_index_of_c_else_with_different_csc_set_name_as_python_else(self):
wciSay = WhatCanISay.WhatCanISay()
interp = CmdInterp()
# do a csc set for python and a csc set for c
# note: for try all went well in C, except for the setname
cscs1 = CSCmdSet('try command python', description='description of CSCS')
cscs2 = CSCmdSet('try command C', description='description duplicates of CSCS')
cscs2.add_csc(CSCmd(spoken_forms=csc_else_spoken_forms,
meanings=csc_c_else_meanings,
docstring=csc_c_else_docstring))
cscs1.add_csc(CSCmd(spoken_forms=csc_else_spoken_forms,
meanings=csc_python_else_meanings,
docstring=csc_python_else_docstring))
interp.add_csc_set(cscs2)
interp.add_csc_set(cscs1)
interp.add_lsa(LSAlias(["plus"], meanings={all_languages: " + "}, name="plus sign"))
wciSay.load_commands_from_interpreter(self._app(), interp, 'C')
expected = \
{'C': {'else': [[{'action': 'else clause of a C conditional',
'doc': 'else clause only c',
'equiv': 'Language: C',
'scope': 'buffer',
'setdescription': 'description duplicates of CSCS',
'setname': 'try command C'}]],
'plus': [{'description': 'no description',
'name': 'plus sign',
'new_symbol': None,
'setname': 'lsas',
'spacing': 0,
'written_form': ' + '}]}}
self.assert_equal(expected, wciSay.index, "index of else csc set in C different from expected")
wciSay.load_commands_from_interpreter(self._app(), interp, 'python')
expected = \
{'python': {'else': [[{'action': 'no docstring available',
'doc': 'else clause only python',
'equiv': 'BlankLine: python',
'scope': 'immediate',
'setdescription': 'description of CSCS',
'setname': 'try command python'},
{'action': "Inserts 'else on non blank line^' in current buffer",
'doc': 'else clause only python',
'equiv': 'Language: python',
'scope': 'buffer',
'setdescription': 'description of CSCS',
'setname': 'try command python'}]],
'plus': [{'description': 'no description',
'name': 'plus sign',
'new_symbol': None,
'setname': 'lsas',
'spacing': 0,
'written_form': ' + '}]}}
self.assert_equal(expected, wciSay.index, "index of else csc set in python different from expected")
def test_This_is_how_you_can_make_a_special_case_c_style_languages(self):
interp = CmdInterp()
## In next test all languages are first set to "aaa",
## next c_style_languages to ccc, and
## after that java and python to something more specific
## and then for python is changed to 'qqq'.
interp.add_lsa(LSAlias(['spoken', 'form'],
{'java': 'jjj','python': 'pppp', all_languages: 'aaa',
c_style_languages: 'ccc'}))
all_lsas = interp.language_specific_aliases
python_lsas = all_lsas['python']
# extract and check only one item:
for an_LSA in python_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'pppp'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
c_lsas = all_lsas['C']
# extract and check only one item:
for an_LSA in c_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'ccc'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
java_lsas = all_lsas['java']
# extract and check only one item:
for an_LSA in java_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'jjj'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
def test_This_is_how_you_create_a_WhatCanISay_instance(self):
wciSay = WhatCanISay.WhatCanISay()
interp = CmdInterp()
# load one lsa and one csc:
interp.add_csc(
CSCmd(["equals"],
meanings={contAny: ActionInsert("====")},
name="equals csc"))
interp.add_lsa(
LSAlias(["plus"],
meanings={all_languages: " + "},
name="plus sign"))
wciSay.load_commands_from_interpreter(self._app(), interp, 'C')
def test_the_index_of_simple_csc_and_an_lsa_definition(self):
wciSay = WhatCanISay.WhatCanISay()
interp = CmdInterp()
# do one csc and one lsa:
interp.add_csc(CSCmd(["equals"], meanings={contAny: ActionInsert("====")}, name="equals csc"))
interp.add_lsa(LSAlias(["plus"], meanings={all_languages: " + "}, name="plus sign"))
wciSay.load_commands_from_interpreter(self._app(), interp, 'C')
expected = \
{'C': {'equals': [[{'action': "Inserts '====^' in current buffer",
'doc': None,
'equiv': 'Any',
'scope': 'global',
'setdescription': 'no description',
'setname': 'cscs'}]],
'plus': [{'description': 'no description',
'name': 'plus sign',
'new_symbol': None,
'setname': 'lsas',
'spacing': 0,
'written_form': ' + '}]}}
self.assert_equal(expected, wciSay.index, "index of one CSC and one LSA command is not as expected")
def test_the_index_of_c_else_with_different_csc_set_name_as_python_else(
self):
wciSay = WhatCanISay.WhatCanISay()
interp = CmdInterp()
# do a csc set for python and a csc set for c
# note: for try all went well in C, except for the setname
cscs1 = CSCmdSet('try command python',
description='description of CSCS')
cscs2 = CSCmdSet('try command C',
description='description duplicates of CSCS')
cscs2.add_csc(
CSCmd(spoken_forms=csc_else_spoken_forms,
meanings=csc_c_else_meanings,
docstring=csc_c_else_docstring))
cscs1.add_csc(
CSCmd(spoken_forms=csc_else_spoken_forms,
meanings=csc_python_else_meanings,
docstring=csc_python_else_docstring))
interp.add_csc_set(cscs2)
interp.add_csc_set(cscs1)
interp.add_lsa(
LSAlias(["plus"],
meanings={all_languages: " + "},
name="plus sign"))
wciSay.load_commands_from_interpreter(self._app(), interp, 'C')
expected = \
{'C': {'else': [[{'action': 'else clause of a C conditional',
'doc': 'else clause only c',
'equiv': 'Language: C',
'scope': 'buffer',
'setdescription': 'description duplicates of CSCS',
'setname': 'try command C'}]],
'plus': [{'description': 'no description',
'name': 'plus sign',
'new_symbol': None,
'setname': 'lsas',
'spacing': 0,
'written_form': ' + '}]}}
self.assert_equal(
expected, wciSay.index,
"index of else csc set in C different from expected")
wciSay.load_commands_from_interpreter(self._app(), interp, 'python')
expected = \
{'python': {'else': [[{'action': 'no docstring available',
'doc': 'else clause only python',
'equiv': 'BlankLine: python',
'scope': 'immediate',
'setdescription': 'description of CSCS',
'setname': 'try command python'},
{'action': "Inserts 'else on non blank line^' in current buffer",
'doc': 'else clause only python',
'equiv': 'Language: python',
'scope': 'buffer',
'setdescription': 'description of CSCS',
'setname': 'try command python'}]],
'plus': [{'description': 'no description',
'name': 'plus sign',
'new_symbol': None,
'setname': 'lsas',
'spacing': 0,
'written_form': ' + '}]}}
self.assert_equal(
expected, wciSay.index,
"index of else csc set in python different from expected")
class LSAliasTest(VoiceCodeRootTest.VoiceCodeRootTest):
"""tests of CSCmd and CSCmdDict
"""
def __init__(self, name):
VoiceCodeRootTest.VoiceCodeRootTest.__init__(self, name)
def setUp(self):
self.interp = CmdInterp()
self.interp = CmdInterp()
self.interp.add_lsa(LSAlias(lsa_multiply_spoken_forms, lsa_multiply_meanings))
self.interp.add_lsa(LSAlias(lsa_not_spoken_forms, lsa_not_meanings))
##########################################################
# Documentation tests
#
# These tests illustrate how to use the class.
##########################################################
def test_This_is_how_you_create_a_LSAlias__instance(self):
interp = CmdInterp()
interp.add_lsa(LSAlias(['spoken', 'form'],
{'C': 'sss', 'python': 'ppp'}))
all_lsas = interp.language_specific_aliases
languages = all_lsas.keys()
languages.sort()
expected = list(all_languages) # list (of keys)
self.assert_equal(expected, languages, "LSAs, all languages should have a key, this was not as expected")
expected = all_languages # tuple
self.assert_equal(expected, interp.supported_languages(),
"LSAs, languages not as expected through interp method")
python_lsas = all_lsas['python']
# extract and check only one item:
for an_LSA in python_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'ppp'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
def test_This_is_how_you_can_make_a_special_case_for_one_language(self):
interp = CmdInterp()
## In next test all languages are first set to "ccc",
## and then for python is changed to 'qqq'.
interp.add_lsa(LSAlias(['spoken', 'form'],
{'python': 'qqq', all_languages: 'ccc'}))
all_lsas = interp.language_specific_aliases
python_lsas = all_lsas['python']
# extract and check only one item:
for an_LSA in python_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'qqq'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
c_lsas = all_lsas['C']
# extract and check only one item:
for an_LSA in c_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'ccc'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
def test_This_is_how_you_can_make_a_special_case_c_style_languages(self):
interp = CmdInterp()
## In next test all languages are first set to "aaa",
## next c_style_languages to ccc, and
## after that java and python to something more specific
## and then for python is changed to 'qqq'.
interp.add_lsa(LSAlias(['spoken', 'form'],
{'java': 'jjj','python': 'pppp', all_languages: 'aaa',
c_style_languages: 'ccc'}))
all_lsas = interp.language_specific_aliases
python_lsas = all_lsas['python']
# extract and check only one item:
for an_LSA in python_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'pppp'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
c_lsas = all_lsas['C']
# extract and check only one item:
for an_LSA in c_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'ccc'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
java_lsas = all_lsas['java']
# extract and check only one item:
for an_LSA in java_lsas.items():
wordList, entry = an_LSA
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
expected_spoken_form = 'spoken'
expected_written_form = 'jjj'
self.assert_equal(expected_spoken_form, spoken_form_text,
"LSA spoken form is not as expected")
self.assert_equal(expected_written_form, written_form_text,
"LSA written form is not as expected")
break
##########################################################
# Unit tests lsa and general commands
#
# These tests check the internal workings of the class.
##########################################################
def test_Test_contents_of_test_LSAliases(self):
aliases_visible = {}
for lang in self.interp.language_specific_aliases:
aliases_visible[lang] = []
for wordList, entry in self.interp.language_specific_aliases[lang].items():
spoken_form_text = ' '.join(wordList)
written_form_text = getattr(entry, 'written_form', '')
aliases_visible[lang].append( (spoken_form_text, written_form_text) )
self.assert_equal(expected_lsa_index, aliases_visible,
"testcase language_specific_aliases (made visible) not as expected")
def test_Test_erroneous_definitions(self):
interp = CmdInterp()
# unknown language 'D'
self.assertRaises(ValueError, LSAlias, (['wrong'],), {'D': 'oops'})
self.assertRaises(DeprecationError, LSAlias, (['deprecated'],), {None: 'oops'})
