public virtual void TestNamedRelation()
{
SemanticGraph graph = SemanticGraph.ValueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
SemgrexPattern pattern = SemgrexPattern.Compile("{idx:0}=gov >>=foo {idx:3}=dep");
SemgrexMatcher matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual("ate", matcher.GetNode("gov").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("dep").ToString());
NUnit.Framework.Assert.AreEqual("compound", matcher.GetRelnString("foo"));
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{idx:3}=dep <<=foo {idx:0}=gov");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual("ate", matcher.GetNode("gov").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("dep").ToString());
NUnit.Framework.Assert.AreEqual("dobj", matcher.GetRelnString("foo"));
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{idx:3}=dep <=foo {idx:2}=gov");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("gov").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("dep").ToString());
NUnit.Framework.Assert.AreEqual("compound", matcher.GetRelnString("foo"));
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{idx:2}=gov >=foo {idx:3}=dep");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("gov").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("dep").ToString());
NUnit.Framework.Assert.AreEqual("compound", matcher.GetRelnString("foo"));
NUnit.Framework.Assert.IsFalse(matcher.Find());
}
public static void ComparePatternToString(string pattern)
{
SemgrexPattern semgrex = SemgrexPattern.Compile(pattern);
string tostring = semgrex.ToString();
tostring = tostring.ReplaceAll(" +", " ");
NUnit.Framework.Assert.AreEqual(pattern.Trim(), tostring.Trim());
}
public virtual void TestSerialization()
{
SemgrexPattern pat3 = SemgrexPattern.Compile("({word:LIKE}=parent >>nn {word:/do/}=node)");
File tempfile = File.CreateTempFile("temp", "file");
tempfile.DeleteOnExit();
IOUtils.WriteObjectToFile(pat3, tempfile);
SemgrexPattern pat4 = IOUtils.ReadObjectFromFile(tempfile);
NUnit.Framework.Assert.AreEqual(pat3, pat4);
}
public virtual void TestEqualsRelation()
{
SemanticGraph graph = SemanticGraph.ValueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
SemgrexPattern pattern = SemgrexPattern.Compile("{} >> ({}=a == {}=b)");
SemgrexMatcher matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
// This split pattern should also work
pattern = SemgrexPattern.Compile("{} >> {}=a >> {}=b : {}=a == {}=b");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
}
public virtual void TestMatchAll()
{
SemanticGraph graph = SemanticGraph.ValueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
ICollection <IndexedWord> words = graph.VertexSet();
SemgrexPattern pattern = SemgrexPattern.Compile("{}");
SemgrexMatcher matcher = pattern.Matcher(graph);
string[] expectedMatches = new string[] { "ate", "Bill", "muffins", "blueberry" };
for (int i = 0; i < expectedMatches.Length; ++i)
{
NUnit.Framework.Assert.IsTrue(matcher.FindNextMatchingNode());
}
NUnit.Framework.Assert.IsFalse(matcher.FindNextMatchingNode());
}
public virtual void TestExactDepthRelations()
{
SemanticGraph graph = MakeComplicatedGraph();
RunTest("{} 2,3<< {word:A}", graph, "E", "F", "G", "I");
RunTest("{} 2,2<< {word:A}", graph, "E");
RunTest("{} 1,2<< {word:A}", graph, "B", "C", "D", "E");
RunTest("{} 0,2<< {word:A}", graph, "B", "C", "D", "E");
RunTest("{} 0,10<< {word:A}", graph, "B", "C", "D", "E", "F", "G", "H", "I", "J");
RunTest("{} 0,10>> {word:J}", graph, "A", "B", "C", "D", "E", "F", "G", "H", "I");
RunTest("{} 2,3>> {word:J}", graph, "B", "C", "D", "E", "F", "G", "H");
RunTest("{} 2,2>> {word:J}", graph, "E", "H");
// use this method to avoid the toString() test, since we expect it
// to use 2,2>> instead of 2>>
RunTest(SemgrexPattern.Compile("{} 2>> {word:J}"), graph, "E", "H");
RunTest("{} 1,2>> {word:J}", graph, "E", "H", "I");
}
public virtual void TestPrettyPrint()
{
// SemgrexPattern pat = SemgrexPattern.compile("{} >sub {} & ?>ss {w:w}");
// SemgrexPattern pat =
// SemgrexPattern.compile("({} </nsubj|agent/ {pos:/VB.*/}=hypVerb) @ ({#} </nsubj|agent/ {pos:/VB.*/}=txtVerb)");
// SemgrexPattern pat =
// SemgrexPattern.compile("({sentIndex:4} <=hypReln {sentIndex:2}=hypGov) @ ({} <=hypReln ({} >conj_and ({} @ {}=hypGov)))");
SemgrexPattern pat = SemgrexPattern.Compile("({}=partnerOne [[<prep_to ({word:/married/} >nsubjpass {}=partnerTwo)] | [<nsubjpass ({word:married} >prep_to {}=partnerTwo)]]) @ ({} [[>/nn|appos/ {lemma:/wife|husband/} >poss ({}=txtPartner @ {}=partnerTwo)] | [<poss (({}=txtPartner @ {}=partnerTwo) >/appos|nn/ {lemma:/wife|husband/})]])"
);
// SemgrexPattern pat =
// SemgrexPattern.compile("({pos:/VB.*/}=hVerb @ {pos:/VB.*/}=tVerb) >/nsubj|nsubjpass|dobj|iobj|prep.*/=hReln ({}=hWord @ ({}=tWord [ [ >/nsubj|nsubjpass|dobj|iobj|prep.*/=tReln {}=tVerb] | [ >appos ({} >/nsubj|nsubjpass|dobj|iobj|prep.*/=tReln {}=tVerb) ] | [ <appos ({} >/nsubj|nsubjpass|dobj|iobj|prep.*/=tReln {}=tVerb)] | ![> {}=tVerb]]))");
// SemgrexPattern pat =
// SemgrexPattern.compile("({}=partnerOne [[<prep_to ({word:married} >nsubjpass {}=partnerTwo)] | [<nsubjpass ({word:married} >prep_to {}=partnerTwo)]]) @ ({} [[>nn {lemma:/wife|husband/} >poss {}=txtPartner] | [<poss ({}=txtPartner >nn {lemma:/wife|husband/})]])");
// @ ({} </nsubj|agent/ {pos:/VB.*/}=txtVerb)
pat.PrettyPrint();
}
public virtual void TestNamedNode()
{
SemanticGraph graph = MakeComplicatedGraph();
RunTest("{} >dobj ({} >expl {})", graph, "A");
SemgrexPattern pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo)");
SemgrexMatcher matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(1, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("foo").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo) >mod {}");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(1, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("foo").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo) >mod ({} >mark {})");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(1, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("foo").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo) >mod ({} > {})");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(1, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("foo").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo) >mod ({} > {}=foo)");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(1, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("foo").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
pattern = SemgrexPattern.Compile("{} >dobj ({} >expl {}=foo) >mod ({}=foo > {})");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsFalse(matcher.Find());
}
public virtual void TestInitialConditions()
{
SemanticGraph graph = MakeComplicatedGraph();
SemgrexPattern pattern = SemgrexPattern.Compile("{}=a >> {}=b : {}=a >> {}=c");
IDictionary <string, IndexedWord> variables = new Dictionary <string, IndexedWord>();
variables["b"] = graph.GetNodeByIndex(5);
variables["c"] = graph.GetNodeByIndex(2);
SemgrexMatcher matcher = pattern.Matcher(graph, variables);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(3, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("A", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("E", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.AreEqual("B", matcher.GetNode("c").ToString());
NUnit.Framework.Assert.AreEqual("A", matcher.GetMatch().ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
}
/// <exception cref="System.IO.IOException"/>
private static IList <SemgrexPattern> Parse(BufferedReader reader, IDictionary <string, string> macros, Env env)
{
IList <SemgrexPattern> patterns = new List <SemgrexPattern>();
for (string line; (line = reader.ReadLine()) != null;)
{
line = line.Trim();
if (line.IsEmpty() || line.StartsWith("#"))
{
continue;
}
if (line.StartsWith("macro "))
{
continue;
}
line = ReplaceMacros(line, macros);
SemgrexPattern pattern = SemgrexPattern.Compile(line, env);
patterns.Add(pattern);
}
return(patterns);
}
public static void RunTest(string pattern, SemanticGraph graph, params string[] expectedMatches)
{
ComparePatternToString(pattern);
RunTest(SemgrexPattern.Compile(pattern), graph, expectedMatches);
}
public static void OutputResults(string pattern, SemanticGraph graph, params string[] ignored)
{
OutputResults(SemgrexPattern.Compile(pattern), graph);
}
public virtual void TestNotEquals()
{
SemanticGraph graph = SemanticGraph.ValueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
SemgrexPattern pattern = SemgrexPattern.Compile("{} >> {}=a >> {}=b : {}=a !== {}=b");
SemgrexMatcher matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
// same as the first test, essentially, but with a more compact expression
pattern = SemgrexPattern.Compile("{} >> {}=a >> ({}=b !== {}=a)");
matcher = pattern.Matcher(graph);
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("Bill", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsTrue(matcher.Find());
NUnit.Framework.Assert.AreEqual(2, matcher.GetNodeNames().Count);
NUnit.Framework.Assert.AreEqual("ate", matcher.GetMatch().ToString());
NUnit.Framework.Assert.AreEqual("blueberry", matcher.GetNode("a").ToString());
NUnit.Framework.Assert.AreEqual("muffins", matcher.GetNode("b").ToString());
NUnit.Framework.Assert.IsFalse(matcher.Find());
}
public virtual void TestFind()
{
SemanticGraph h = SemanticGraph.ValueOf("[married/VBN nsubjpass>Hughes/NNP auxpass>was/VBD prep_to>Gracia/NNP]");
SemanticGraph t = SemanticGraph.ValueOf("[loved/VBD\nnsubj>Hughes/NNP\ndobj>[wife/NN poss>his/PRP$ appos>Gracia/NNP]\nconj_and>[obsessed/JJ\ncop>was/VBD\nadvmod>absolutely/RB\nprep_with>[Elicia/NN poss>his/PRP$ amod>little/JJ compound>daughter/NN]]]"
);
string s = "(ROOT\n(S\n(NP (DT The) (NN chimney) (NNS sweeps))\n(VP (VBP do) (RB not)\n(VP (VB like)\n(S\n(VP (VBG working)\n(PP (IN on)\n(NP (DT an) (JJ empty) (NN stomach)))))))\n(. .)))";
Tree tree = Tree.ValueOf(s);
SemanticGraph sg = SemanticGraphFactory.MakeFromTree(tree, SemanticGraphFactory.Mode.Collapsed, GrammaticalStructure.Extras.Maximal, null);
SemgrexPattern pat = SemgrexPattern.Compile("{}=gov ![>det {}] & > {word:/^(?!not).*$/}=dep");
sg.PrettyPrint();
// SemgrexPattern pat =
// SemgrexPattern.compile("{} [[<prep_to ({word:married} >nsubjpass {})] | [<nsubjpass ({word:married} >prep_to {})]]");
pat.PrettyPrint();
SemgrexMatcher mat = pat.Matcher(sg);
while (mat.Find())
{
// String match = mat.getMatch().word();
string gov = mat.GetNode("gov").Word();
// String reln = mat.getRelnString("reln");
string dep = mat.GetNode("dep").Word();
// System.out.println(match);
System.Console.Out.WriteLine(dep + ' ' + gov);
}
SemgrexPattern pat2 = SemgrexPattern.Compile("{} [[>/nn|appos/ ({lemma:/wife|husband|partner/} >/poss/ {}=txtPartner)] | [<poss ({}=txtPartner >/nn|appos/ {lemma:/wife|husband|partner/})]" + "| [<nsubj ({$} >> ({word:/wife|husband|partner/} >poss {word:/his|her/} >/nn|appos/ {}))]]"
);
SemgrexMatcher mat2 = pat2.Matcher(t);
while (mat2.Find())
{
string match = mat2.GetMatch().Word();
// String gov = mat.getNode("gov").word();
// String reln = mat.getRelnString("reln");
// String dep = mat.getNode("dep").word();
System.Console.Out.WriteLine(match);
}
// System.out.println(dep + " " + gov);
Dictionary <IndexedWord, IndexedWord> map = new Dictionary <IndexedWord, IndexedWord>();
map[h.GetNodeByWordPattern("Hughes")] = t.GetNodeByWordPattern("Hughes");
map[h.GetNodeByWordPattern("Gracia")] = t.GetNodeByWordPattern("Gracia");
Alignment alignment = new Alignment(map, 0, string.Empty);
SemgrexPattern fullPat = SemgrexPattern.Compile("({}=partnerOne [[<prep_to ({word:married} >nsubjpass {}=partnerTwo)] | [<nsubjpass ({word:married} >prep_to {}=partnerTwo)]]) @ ({} [[>/nn|appos/ ({lemma:/wife|husband|partner/} >/poss/ {}=txtPartner)] | [<poss ({}=txtPartner >/nn|appos/ {lemma:/wife|husband|partner/})]"
+ "| [<nsubj ({$} >> ({word:/wife|husband|partner/} >poss {word:/his|her/} >/nn|appos/ {}=txtPartner))]])");
fullPat.PrettyPrint();
SemgrexMatcher fullMat = fullPat.Matcher(h, alignment, t);
if (fullMat.Find())
{
System.Console.Out.WriteLine("woo: " + fullMat.GetMatch().Word());
System.Console.Out.WriteLine(fullMat.GetNode("txtPartner"));
System.Console.Out.WriteLine(fullMat.GetNode("partnerOne"));
System.Console.Out.WriteLine(fullMat.GetNode("partnerTwo"));
}
else
{
System.Console.Out.WriteLine("boo");
}
SemgrexPattern pat3 = SemgrexPattern.Compile("({word:LIKE}=parent >>/aux.*/ {word:/do/}=node)");
System.Console.Out.WriteLine("pattern is ");
pat3.PrettyPrint();
System.Console.Out.WriteLine("tree is ");
sg.PrettyPrint();
//checking if ignoring case or not
SemgrexMatcher mat3 = pat3.Matcher(sg, true);
if (mat3.Find())
{
string parent = mat3.GetNode("parent").Word();
string node = mat3.GetNode("node").Word();
System.Console.Out.WriteLine("Result: parent is " + parent + " and node is " + node);
NUnit.Framework.Assert.AreEqual(parent, "like");
NUnit.Framework.Assert.AreEqual(node, "do");
}
else
{
NUnit.Framework.Assert.Fail();
}
}
public virtual void TestSiblingPatterns()
{
SemanticGraph sg = SemanticGraph.ValueOf("[loved/VBD-2\nnsubj>Hughes/NNP-1\ndobj>[wife/NN-4 nmod:poss>his/PRP$-3 appos>Gracia/NNP-5]\nconj:and>[obsessed/JJ-9\ncop>was/VBD-7\nadvmod>absolutely/RB-8\nnmod:with>[Elicia/NN-14 nmod:poss>his/PRP$-11 amod>little/JJ-12 compound>daughter/NN-13]]]"
);
/* Test "." */
SemgrexPattern pat1 = SemgrexPattern.Compile("{tag:NNP}=w1 . {tag:VBD}=w2");
SemgrexMatcher matcher = pat1.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
string w2 = matcher.GetNode("w2").Word();
NUnit.Framework.Assert.AreEqual("Hughes", w1);
NUnit.Framework.Assert.AreEqual("loved", w2);
}
else
{
throw new Exception("failed!");
}
/* Test "$+" */
SemgrexPattern pat2 = SemgrexPattern.Compile("{word:was}=w1 $+ {}=w2");
matcher = pat2.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
string w2 = matcher.GetNode("w2").Word();
NUnit.Framework.Assert.AreEqual("was", w1);
NUnit.Framework.Assert.AreEqual("absolutely", w2);
}
else
{
throw new Exception("failed!");
}
/* Test "$-" */
SemgrexPattern pat3 = SemgrexPattern.Compile("{word:absolutely}=w1 $- {}=w2");
matcher = pat3.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
string w2 = matcher.GetNode("w2").Word();
NUnit.Framework.Assert.AreEqual("absolutely", w1);
NUnit.Framework.Assert.AreEqual("was", w2);
}
else
{
throw new Exception("failed!");
}
/* Test "$++" */
SemgrexPattern pat4 = SemgrexPattern.Compile("{word:his}=w1 $++ {tag:NN}=w2");
matcher = pat4.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
string w2 = matcher.GetNode("w2").Word();
NUnit.Framework.Assert.AreEqual("his", w1);
NUnit.Framework.Assert.AreEqual("daughter", w2);
}
else
{
throw new Exception("failed!");
}
/* Test "$--" */
SemgrexPattern pat6 = SemgrexPattern.Compile("{word:daughter}=w1 $-- {tag:/PRP./}=w2");
matcher = pat6.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
string w2 = matcher.GetNode("w2").Word();
NUnit.Framework.Assert.AreEqual("daughter", w1);
NUnit.Framework.Assert.AreEqual("his", w2);
}
else
{
throw new Exception("failed!");
}
/* Test for not matching. */
SemgrexPattern pat5 = SemgrexPattern.Compile("{word:his}=w1 $-- {}=w2");
matcher = pat5.Matcher(sg);
if (matcher.Find())
{
throw new Exception("failed!");
}
/* Test for negation. */
SemgrexPattern pat7 = SemgrexPattern.Compile("{word:his}=w1 !$-- {}");
matcher = pat7.Matcher(sg);
if (matcher.Find())
{
string w1 = matcher.GetNode("w1").Word();
NUnit.Framework.Assert.AreEqual("his", w1);
}
else
{
throw new Exception("failed!");
}
SemgrexPattern pat8 = SemgrexPattern.Compile("{word:his}=w1 !$++ {}");
matcher = pat8.Matcher(sg);
if (matcher.Find())
{
throw new Exception("failed!");
}
}