def add_that_to_node(self, that_element, base_node):
try:
current_node = PatternThatNode()
current_node = base_node.add_that(current_node)
head_text = self.get_text_from_element(that_element)
if head_text is not None:
current_node = self._parse_text(
TextUtils.strip_whitespace(head_text), current_node)
added_child = False
for sub_element in that_element:
new_node = PatternGraph.node_from_element(sub_element)
current_node = current_node.add_child(new_node)
tail_text = self.get_tail_from_element(sub_element)
if tail_text is not None:
current_node = self._parse_text(tail_text, current_node)
added_child = True
if head_text is None:
if added_child is False:
raise ParserException("That node text is empty",
xml_element=that_element)
return current_node
except ParserException as parser_excep:
parser_excep._xml_element = that_element
raise parser_excep
def test_that_to_that(self):
node1 = PatternThatNode()
node2 = PatternThatNode()
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertEqual(str(raised.exception), "Cannot add that node to that node")
def test_root_to_that(self):
node1 = PatternThatNode()
node2 = PatternRootNode()
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertEqual(str(raised.exception), "Cannot add root node to that node")
def test_multiple_thats(self):
node1 = PatternThatNode()
node2 = PatternThatNode()
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertEqual(str(raised.exception), "Cannot add that node to that node")
def test_equivalent(self):
node1 = PatternThatNode()
node2 = PatternThatNode()
node3 = PatternTopicNode()
node4 = PatternThatNode(userid="testid")
self.assertTrue(node1.equivalent(node2))
self.assertFalse(node1.equivalent(node3))
self.assertFalse(node1.equivalent(node4))
def test_that_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
new_node1 = PatternThatNode()
self.assertIsNone(node._that_node_exist(new_node1))
node.add_that(new_node1)
self.assertIsNotNone(node._that_node_exist(new_node1))
new_node2 = PatternThatNode(userid="testid2")
self.assertIsNotNone(node._that_node_exist(new_node2))
node.add_that(new_node2)
self.assertIsNotNone(node._that_node_exist(new_node2))
def test_consume_search_time_exceeded(self):
node = PatternThatNode()
self.assertIsNotNone(node)
match_context = MatchContext(max_search_depth=100,
max_search_timeout=0)
words = Sentence(self._client_context)
result = node.consume(self._client_context,
match_context,
words,
0,
Match.WORD,
1,
parent=False)
self.assertIsNone(result)
def test_that_to_template(self):
node1 = PatternTemplateNode(TemplateNode())
node2 = PatternThatNode()
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertEqual(str(raised.exception),
"Cannot add 'that' node to template node")
def test_to_xml(self):
node1 = PatternThatNode()
self.assertEqual('<that></that>\n', node1.to_xml(self._client_context))
self.assertEqual('<that userid="*"></that>\n',
node1.to_xml(self._client_context, include_user=True))
node2 = PatternThatNode(userid="testid")
self.assertEqual('<that></that>\n', node2.to_xml(self._client_context))
self.assertEqual('<that userid="testid"></that>\n',
node2.to_xml(self._client_context, include_user=True))
def test_init(self):
node = PatternThatNode()
self.assertIsNotNone(node)
self.assertFalse(node.is_root())
self.assertFalse(node.is_priority())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternThatNode()))
self.assertEqual(node.to_string(), "THAT [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
def test_equivalent(self):
node1 = PatternTopicNode()
node2 = PatternTopicNode()
node3 = PatternThatNode()
node4 = PatternTopicNode(userid="testid")
self.assertTrue(node1.equivalent(node2))
self.assertFalse(node1.equivalent(node3))
self.assertFalse(node1.equivalent(node4))
def test_to_string(self):
node1 = PatternThatNode()
self.assertEqual(node1.to_string(verbose=False), "THAT")
self.assertEqual(node1.to_string(verbose=True),
"THAT [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
node2 = PatternThatNode(userid="testid")
self.assertEqual(node2.to_string(verbose=False), "THAT")
self.assertEqual(
node2.to_string(verbose=True),
"THAT [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
def test_that_nodes(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assertFalse(node.has_nodes())
self.assertFalse(node.has_that())
node = PatternNode()
node.add_that(PatternThatNode())
self.assertFalse(node.has_nodes())
self.assertTrue(node.has_that())
def test_to_string(self):
node1 = PatternThatNode()
self.assertEqual(node1.to_string(verbose=False), "THAT")
self.assertEqual(node1.to_string(verbose=True), "THAT [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
node2 = PatternThatNode(userid="testid")
self.assertEqual(node2.to_string(verbose=False), "THAT")
self.assertEqual(node2.to_string(verbose=True), "THAT [testid] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
def test_to_xml(self):
node1 = PatternThatNode()
self.assertEqual('<that></that>\n', node1.to_xml(self._client_context))
self.assertEqual('<that userid="*"></that>\n', node1.to_xml(self._client_context, include_user=True))
node2 = PatternThatNode(userid="testid")
self.assertEqual('<that></that>\n', node2.to_xml(self._client_context))
self.assertEqual('<that userid="testid"></that>\n', node2.to_xml(self._client_context, include_user=True))
def add_that_to_node(self, that_element, base_node):
current_node = PatternThatNode()
current_node = base_node.add_that(current_node)
head_text = self.get_text_from_element(that_element)
if head_text is not None:
current_node = self._parse_text(TextUtils.strip_whitespace(head_text), current_node)
added_child = False
for sub_element in that_element:
new_node = PatternGraph.node_from_element(sub_element)
current_node = current_node.add_child(new_node)
tail_text = self.get_tail_from_element(sub_element)
if tail_text is not None:
current_node = self._parse_text(tail_text, current_node)
added_child = True
if head_text is None:
if added_child is False:
raise ParserException("That node text is empty", xml_element=that_element)
return current_node
def test_consume_that(self):
node = PatternNode()
self.assertIsNotNone(node)
node.add_that(PatternThatNode())
match_context = MatchContext(max_search_depth=100,
max_search_timeout=100)
words = Sentence(self._client_context, text="__THAT__")
result = node.consume(self._client_context,
match_context,
words,
0,
Match.WORD,
1,
parent=False)
self.assertIsNone(result)
def test_node_exists(self):
node = PatternNode()
self.assertIsNotNone(node)
self.assert_child_node_exists(node, PatternWordNode("word"),
PatternWordNode("word"))
self.assert_child_node_exists(node,
PatternPriorityWordNode("priority"),
PatternPriorityWordNode("priority"))
self.assert_child_node_exists(node, PatternOneOrMoreWildCardNode('_'),
PatternOneOrMoreWildCardNode('_'))
self.assert_child_node_exists(node, PatternOneOrMoreWildCardNode('*'),
PatternOneOrMoreWildCardNode('*'))
self.assert_child_node_exists(node, PatternZeroOrMoreWildCardNode('#'),
PatternZeroOrMoreWildCardNode('#'))
self.assert_child_node_exists(node, PatternZeroOrMoreWildCardNode('^'),
PatternZeroOrMoreWildCardNode('^'))
self.assert_child_node_exists(node, PatternSetNode({}, "setname"),
PatternSetNode([], "setname"))
self.assert_child_node_exists(node, PatternBotNode({}, "botname"),
PatternBotNode([], "botname"))
self.assert_child_node_exists(node, PatternISetNode({}, "word1 word2"),
PatternISetNode([], "word1 word2"))
self.assert_child_node_exists(
node, PatternRegexNode({"pattern": "^LEGION$"}, None),
PatternRegexNode({"pattern": "^LEGION$"}, None))
self.assert_child_node_exists(
node, PatternRegexNode({"template": "LEGION"}, None),
PatternRegexNode({"template": "LEGION"}, None))
topic1 = PatternTopicNode()
topic2 = PatternTopicNode()
self.assertIsNone(node._node_exists(topic1))
node.add_topic(topic1)
new_node = node._node_exists(topic1)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, topic1)
new_node = node.add_topic(topic2)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, topic1)
that1 = PatternThatNode()
that2 = PatternThatNode()
self.assertIsNone(node._node_exists(that1))
node.add_that(that1)
new_node = node._node_exists(that1)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, that1)
new_node = node.add_that(that2)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, that1)
template1 = PatternTemplateNode(None)
template2 = PatternTemplateNode(None)
self.assertIsNone(node._node_exists(template1))
node.add_template(template1)
new_node = node._node_exists(template1)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, template1)
new_node = node.add_template(template2)
self.assertIsNotNone(new_node)
self.assertEquals(new_node, template1)
node.dump("")
self.assertEqual(
node.to_xml(None, None), """<priority word="priority"></priority>
<zerormore wildcard="^">
</zerormore>
<zerormore wildcard="#">
</zerormore>
<oneormore wildcard="_">
</oneormore>
<oneormore wildcard="*">
</oneormore>
<topic></topic>
<that></that>
<template></template>
<word word="word"></word>
<set name="SETNAME">
</set><bot property="botname">
</bot><iset words="WORD1 WORD2"></iset>
<regex pattern="^LEGION$"></regex>
<regex template="LEGION"></regex>
""")
def test_init(self):
node = PatternThatNode()
self.assertIsNotNone(node)
self.assertFalse(node.is_root())
self.assertFalse(node.is_priority())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternThatNode()))
self.assertEqual(node.to_string(),
"THAT [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
def test_init(self):
node = PatternThatNode()
self.assertIsNotNone(node)
self.assertFalse(node.is_root())
self.assertFalse(node.is_priority())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertFalse(node.is_set())
self.assertFalse(node.is_bot())
self.assertFalse(node.is_template())
self.assertTrue(node.is_that())
self.assertFalse(node.is_topic())
self.assertFalse(node.is_wildcard())
self.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternThatNode()))
self.assertEqual(node.to_string(), "THAT [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
self.assertEqual(node.to_string(verbose=False), "THAT")
self.assertEqual("<that></that>\n", node.to_xml(self._client_context))
def test_init(self):
node = PatternThatNode()
self.assertIsNotNone(node)
self.assertFalse(node.is_root())
self.assertFalse(node.is_priority())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertFalse(node.is_set())
self.assertFalse(node.is_bot())
self.assertFalse(node.is_template())
self.assertTrue(node.is_that())
self.assertFalse(node.is_topic())
self.assertFalse(node.is_wildcard())
self.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternThatNode()))
self.assertEqual(node.to_string(),
"THAT [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
self.assertEqual(node.to_string(verbose=False), "THAT")
self.assertEqual("<that></that>\n", node.to_xml(self._client_context))
