def test_mimic(self):
""" Verify that the 'mimic' RPC method works correctly. """
g = Grammar("mimic_test")
g.add_rule(CompoundRule(name="compound", spec="testing mimicry",
exported=True))
g.load()
# Set the grammar as exclusive.
# The sapi5shared engine apparently requires this for mimic() to
# work, making the method kind of useless. This does not apply to
# sapi5inproc.
g.set_exclusiveness(True)
response = self.send_request("mimic", ["testing mimicry"])
try:
self.assertIn("result", response)
self.assertEqual(response["result"], True)
finally:
g.set_exclusiveness(False)
g.unload()
def test_exclusive_grammars(self):
""" Verify that the engine supports exclusive grammars. """
# This is here as grammar exclusivity is context related.
# Set up two grammars to test with.
class TestRule(CompoundRule):
def __init__(self, spec):
CompoundRule.__init__(self, spec=spec)
self.words = None
def _process_recognition(self, node, extras):
self.words = self.spec
grammar1 = Grammar(name="Grammar1")
grammar1.add_rule(TestRule(spec="grammar one"))
grammar2 = Grammar(name="Grammar2")
grammar2.add_rule(TestRule(spec="grammar two"))
grammar3 = Grammar(name="Grammar3")
grammar3.add_rule(TestRule(spec="grammar three"))
grammar1.load()
grammar2.load()
grammar3.load()
# Set grammar1 as exclusive and make some assertions.
grammar1.set_exclusiveness(True)
self.engine.mimic("grammar one")
assert grammar1.rules[0].words == "grammar one"
self.assertRaises(MimicFailure, self.engine.mimic, "grammar two")
# Set grammar2 as exclusive and make some assertions.
# Both exclusive grammars should be active.
grammar2.set_exclusiveness(True)
self.engine.mimic("grammar one")
assert grammar1.rules[0].words == "grammar one"
self.engine.mimic("grammar two")
assert grammar2.rules[0].words == "grammar two"
# Non-exclusive grammar 'grammar3' should not be active.
self.assertRaises(MimicFailure, self.engine.mimic, "grammar three")
# Set both grammars as no longer exclusive and make some assertions.
grammar1.set_exclusiveness(False)
grammar2.set_exclusiveness(False)
if get_engine().name == 'natlink':
self.temp_grammar.set_exclusiveness(False)
self.engine.mimic("grammar one")
assert grammar1.rules[0].words == "grammar one"
self.engine.mimic("grammar two")
assert grammar2.rules[0].words == "grammar two"
self.engine.mimic("grammar three")
assert grammar3.rules[0].words == "grammar three"
def test_mimic(self):
""" Verify that the 'mimic' RPC method works correctly. """
g = Grammar("mimic_test")
g.add_rule(
CompoundRule(name="compound",
spec="testing mimicry",
exported=True))
g.load()
# Set the grammar as exclusive.
# The sapi5shared engine apparently requires this for mimic() to
# work, making the method kind of useless. This does not apply to
# sapi5inproc.
g.set_exclusiveness(True)
response = self.send_request("mimic", ["testing mimicry"])
try:
self.assertIn("result", response)
self.assertEqual(response["result"], True)
finally:
g.set_exclusiveness(False)
g.unload()
def test_recognition_history_methods(self):
""" Verify that the recognition history RPC methods work correctly.
"""
# Load a grammar for testing that recognitions are saved.
g = Grammar("history_test")
g.add_rule(
CompoundRule(name="compound", spec="test history", exported=True))
g.load()
g.set_exclusiveness(True)
try:
# Test 'register_history()'.
response = self.send_request("register_history", [])
self.assertIn("result", response)
# Test that the method raises an error if used when the observer
# is already registered.
self.assertRaises(RuntimeError, self.send_request,
"register_history", [])
# Send a mimic and check that it is returned by the
# 'get_recognition_history()' method.
self.send_request("mimic", ["test history"])
response = self.send_request("get_recognition_history", [])
self.assertIn("result", response)
self.assertListEqual(response["result"], [["test", "history"]])
# Test 'unregister_observer()'.
response = self.send_request("unregister_history", [])
self.assertIn("result", response)
# Test that the method raises an error if used when the observer
# is not registered.
self.assertRaises(RuntimeError, self.send_request,
"unregister_history", [])
finally:
g.set_exclusiveness(False)
g.unload()
class TestRules(RuleTestCase):
def setUp(self):
RuleTestCase.setUp(self)
engine = get_engine()
if engine.name == 'natlink':
# Stop Dragon from dictating text for the duration of these
# tests. This is required when testing for mimic failures.
self.temp_grammar = Grammar("temp")
self.temp_grammar.add_rule(CompoundRule(spec="exclusive rule"))
self.temp_grammar.load()
self.temp_grammar.set_exclusiveness(True)
def tearDown(self):
RuleTestCase.tearDown(self)
engine = get_engine()
if engine.name == 'natlink':
self.temp_grammar.set_exclusiveness(False)
self.temp_grammar.unload()
def process_grammars_context(self):
engine = get_engine()
if engine.name.startswith("sapi5"):
engine.process_grammars_context()
def test_multiple_rules(self):
""" Verify that the engine successfully mimics each rule in a
grammar with multiple rules. """
self.add_rule(CompoundRule(name="r1", spec="hello"))
self.add_rule(CompoundRule(name="r2", spec="see you"))
assert self.recognize_node("hello").words() == ["hello"]
assert self.recognize_node("see you").words() == ["see", "you"]
def test_rule_context(self):
""" Verify that the engine works correctly with rule contexts. """
context = TestContext(True)
self.add_rule(
CompoundRule(name="r1", spec="test context", context=context))
self.grammar.load()
# Test that the rule matches when in-context.
results = self.recognize_node("test context").words()
assert results == ["test", "context"]
# Go out of context and test again.
# Use the engine's mimic method because recognize_node won't return
# RecognitionFailure like ElementTester.recognize does.
context.active = False
self.process_grammars_context()
try:
self.grammar.set_exclusiveness(True)
self.assertRaises(MimicFailure, self.engine.mimic, "test context")
finally:
self.grammar.set_exclusiveness(False)
# Test again after going back into context.
context.active = True
self.process_grammars_context()
results = self.recognize_node("test context").words()
assert results == ["test", "context"]
def test_grammar_context(self):
""" Verify that the engine works correctly with grammar
contexts."""
# Recreate the RuleTestGrammar using a context and add a rule.
context = TestContext(True)
self.grammar = RuleTestGrammar(context=context)
self.add_rule(CompoundRule(name="r1", spec="test context"))
self.grammar.load()
# Test that the rule matches when in-context.
results = self.recognize_node("test context").words()
assert results == ["test", "context"]
# Go out of context and test again.
context.active = False
self.process_grammars_context()
try:
self.grammar.set_exclusiveness(True)
self.assertRaises(MimicFailure, self.engine.mimic, "test context")
finally:
self.grammar.set_exclusiveness(False)
# Test again after going back into context.
context.active = True
self.process_grammars_context()
results = self.recognize_node("test context").words()
assert results == ["test", "context"]
def test_exclusive_grammars(self):
""" Verify that the engine supports exclusive grammars. """
# This is here as grammar exclusivity is context related.
# Set up two grammars to test with.
class TestRule(CompoundRule):
def __init__(self, spec):
CompoundRule.__init__(self, spec=spec)
self.words = None
def _process_recognition(self, node, extras):
self.words = self.spec
grammar1 = Grammar(name="Grammar1")
grammar1.add_rule(TestRule(spec="grammar one"))
grammar2 = Grammar(name="Grammar2")
grammar2.add_rule(TestRule(spec="grammar two"))
grammar3 = Grammar(name="Grammar3")
grammar3.add_rule(TestRule(spec="grammar three"))
grammar1.load()
grammar2.load()
grammar3.load()
# Set grammar1 as exclusive and make some assertions.
grammar1.set_exclusiveness(True)
self.engine.mimic("grammar one")
assert grammar1.rules[0].words == "grammar one"
self.assertRaises(MimicFailure, self.engine.mimic, "grammar two")
# Set grammar2 as exclusive and make some assertions.
# Both exclusive grammars should be active.
grammar2.set_exclusiveness(True)
self.engine.mimic("grammar one")
assert grammar1.rules[0].words == "grammar one"
self.engine.mimic("grammar two")
assert grammar2.rules[0].words == "grammar two"
# Non-exclusive grammar 'grammar3' should not be active.
self.assertRaises(MimicFailure, self.engine.mimic, "grammar three")
# Set both grammars as no longer exclusive and make some assertions.
grammar1.set_exclusiveness(False)
grammar2.set_exclusiveness(False)
if get_engine().name == 'natlink':
self.temp_grammar.set_exclusiveness(False)
self.engine.mimic("grammar one")
assert grammar1.rules[0].words == "grammar one"
self.engine.mimic("grammar two")
assert grammar2.rules[0].words == "grammar two"
self.engine.mimic("grammar three")
assert grammar3.rules[0].words == "grammar three"
