public void Intersect2()
{
/*
* A : ABCD..GHIJKLMN....
* B : ..CDEFGH..KL....QR
* A i B: ..CD..GH..KL......
* B i A: ..CD..GH..KL......
*/
var a = CharSet.New(new CharRange[]
{
new CharRange('A', 'D'),
new CharRange('G', 'N'),
});
var b = CharSet.New(new CharRange[]
{
new CharRange('C', 'H'),
new CharRange('K', 'L'),
new CharRange('Q', 'R'),
});
Assert.That(a.Intersection(b).ToString(), Is.EqualTo("[C-D,G-H,K-L]"), "A intersect B");
Assert.That(b.Intersection(a).ToString(), Is.EqualTo("[C-D,G-H,K-L]"), "B intersect A");
}
public void Union2()
{
/*
* A : ABCD..GHIJKLMN....
* B : ..CDEFGH..KL....QR
* A u B: ABCDEFGHIJKLMN..QR
* B u A: ABCDEFGHIJKLMN..QR
*/
var a = CharSet.New(new CharRange[]
{
new CharRange('A', 'D'),
new CharRange('G', 'N'),
});
var b = CharSet.New(new CharRange[]
{
new CharRange('C', 'H'),
new CharRange('K', 'L'),
new CharRange('Q', 'R'),
});
Assert.That(a.Union(b).ToString(), Is.EqualTo("[A-N,Q-R]"), "A union B");
Assert.That(b.Union(a).ToString(), Is.EqualTo("[A-N,Q-R]"), "B union A");
}
public void Subtract2()
{
/*
* A : ABCD..GHIJKLMN....
* B : ..CDEFGH..KL....QR
* A - B: AB......IJ..MN....
* B - A: ....EF..........QR
*/
var a = CharSet.New(new CharRange[]
{
new CharRange('A', 'D'),
new CharRange('G', 'N'),
});
var b = CharSet.New(new CharRange[]
{
new CharRange('C', 'H'),
new CharRange('K', 'L'),
new CharRange('Q', 'R'),
});
Assert.That(a.Subtract(b).ToString(), Is.EqualTo("[A-B,I-J,M-N]"), "A subtract B");
Assert.That(b.Subtract(a).ToString(), Is.EqualTo("[E-F,Q-R]"), "B subtract A");
}
public void SubsetConstruction_Label()
{
var nfaGraphBuilder = new Graph.Builder();
var lead = new CharRange[] { new CharRange('A', 'Z'), new CharRange('a', 'z') };
var tail = new CharRange[] { new CharRange('A', 'Z'), new CharRange('a', 'z'), new CharRange('0', '9'), new CharRange('_', '_') };
NFAHelper.Graph(
nfaGraphBuilder,
NFAHelper.Series(
nfaGraphBuilder,
NFAHelper.CreateSimplePath(nfaGraphBuilder, CharSet.New(lead)),
NFAHelper.Optional(
nfaGraphBuilder,
NFAHelper.Repeat(
nfaGraphBuilder,
NFAHelper.CreateSimplePath(nfaGraphBuilder, CharSet.New(tail))))));
var dfaGraph = FATools.CreateDfa(nfaGraphBuilder.Graph);
const string expected =
"0 (S:S0) -- [A-Z,a-z] --> 1 (L:E0)\r\n" +
"1 (L:E0) -- [0-9,A-Z,_,a-z] --> 1 (L:E0)\r\n" +
"";
Assert.That(FARenderer.Render(dfaGraph), Is.EqualTo(expected));
}
public void SplitDistinctGraphs_MultiStart()
{
var chars = "012345678";
var graphBuilder = new Graph.Builder();
var states = new Graph.State[12];
for (var i = 0; i < 12; i++)
{
int?startState;
int?endState;
if (i < 3)
{
startState = i;
endState = null;
}
else if (i > 8)
{
startState = null;
endState = i - 9;
}
else
{
startState = null;
endState = null;
}
states[i] = graphBuilder.NewState(startState.HasValue, new NodeData(startState, endState));
if (i >= 3)
{
graphBuilder.AddTransition(states[i - 3], states[i], CharSet.New(chars[i - 3]));
}
}
graphBuilder.AddTransition(states[3], states[7], CharSet.New('X'));
var expected1 =
"0 (S:S2) -- [2] --> 1\r\n" +
"1 -- [5] --> 2\r\n" +
"2 -- [8] --> 3 (L:E2)\r\n";
var expected2 =
"0 (S:S1) -- [1] --> 1\r\n" +
"2 (S:S0) -- [0] --> 3\r\n" +
"1 -- [4] --> 4\r\n" +
"3 -- [3] --> 5\r\n" +
"3 -- [X] --> 4\r\n" +
"4 -- [7] --> 6 (L:E1)\r\n" +
"5 -- [6] --> 7 (L:E0)\r\n";
var results = FATools.SplitDistinctGraphs(graphBuilder.Graph);
Assert.AreEqual(2, results.Length);
Assert.AreEqual(expected1, FARenderer.Render(results[0]));
Assert.AreEqual(expected2, FARenderer.Render(results[1]));
}
public void Contains()
{
var set1 = CharSet.New(new CharRange[] { new CharRange('A', 'D') });
Assert.That(set1.ContainsChar('A'), Is.EqualTo(true));
Assert.That(set1.ContainsChar('B'), Is.EqualTo(true));
Assert.That(set1.ContainsChar('C'), Is.EqualTo(true));
Assert.That(set1.ContainsChar('D'), Is.EqualTo(true));
Assert.That(set1.ContainsChar('E'), Is.EqualTo(false));
}
public void GenerateNFA()
{
var element = new ReSingleton(CharSet.New('1'));
const string expected =
"0 -- [1] --> 1\r\n" +
"";
Assert.That(FARenderer.Render(ReUtils.Build(element)), Is.EqualTo(expected));
}
public void Intersects()
{
var bc = new CharRange[] { new CharRange('B', 'C') };
var cd = new CharRange[] { new CharRange('C', 'D') };
var de = new CharRange[] { new CharRange('D', 'E') };
Assert.That(CharSet.New(bc).Intersects(CharSet.New(bc)), Is.EqualTo(true));
Assert.That(CharSet.New(bc).Intersects(CharSet.New(cd)), Is.EqualTo(true));
Assert.That(CharSet.New(bc).Intersects(CharSet.New(de)), Is.EqualTo(false));
}
public void Singleton()
{
var element = ReFactory.NewSingleton(CharSet.New('1'));
Assert.That(element, Is.Not.EqualTo(null));
Assert.That(element, Is.TypeOf(typeof(ReSingleton)));
var singleton = (ReSingleton)element;
Assert.That(singleton.Label, Is.EqualTo(CharSet.New('1')));
}
public static NFASegment <NodeData, CharSet> CreateSimplePath(Graph <NodeData, CharSet> .Builder graphBuilder, char fromChar, char toChar, bool invert)
{
var set = CharSet.New(new CharRange[] { new CharRange(fromChar, toChar) });
if (invert)
{
set = CharSet.Universal.Subtract(set);
}
return(CreateSimplePath <NodeData, CharSet>(graphBuilder, set));
}
public void New()
{
Assert.That(CharSet.New('A').ToString(), Is.EqualTo("[A]"));
Assert.That(CharSet.New(System.Array.Empty <CharRange>()).ToString(), Is.EqualTo("[]"));
Assert.That(CharSet.New(new CharRange[] { new CharRange('A', 'Z') }).ToString(), Is.EqualTo("[A-Z]"));
Assert.That(CharSet.New(new CharRange[] { new CharRange('N', 'Z'), new CharRange('A', 'L') }).ToString(), Is.EqualTo("[A-L,N-Z]"));
Assert.That(CharSet.New(new CharRange[] { new CharRange('N', 'Z'), new CharRange('A', 'M') }).ToString(), Is.EqualTo("[A-Z]"));
Assert.That(CharSet.New(new CharRange[] { new CharRange('N', 'Z'), new CharRange('A', 'N') }).ToString(), Is.EqualTo("[A-Z]"));
Assert.That(CharSet.New(new CharRange[] { new CharRange('N', 'Z'), new CharRange('A', 'O') }).ToString(), Is.EqualTo("[A-Z]"));
}
public void SubsetConstruction_MultipleEntrypoints()
{
var nfaBuilder = new Graph.Builder();
NFASegment segment;
var s1 = nfaBuilder.NewState(true, new NodeData(1, null));
var s2 = nfaBuilder.NewState(true, new NodeData(2, null));
var e1 = nfaBuilder.NewState(false, new NodeData(null, 1));
var e2 = nfaBuilder.NewState(false, new NodeData(null, 2));
segment = NFAHelper.Series(
nfaBuilder,
NFAHelper.CreateSimplePath(nfaBuilder, 'c'),
NFAHelper.CreateSimplePath(nfaBuilder, 'a'),
NFAHelper.CreateSimplePath(nfaBuilder, 't'));
nfaBuilder.AddTransition(s1, segment.FromState);
nfaBuilder.AddTransition(segment.ToState, e1);
segment = NFAHelper.Repeat(
nfaBuilder,
NFAHelper.CreateSimplePath(
nfaBuilder,
CharSet.New(new CharRange[]
{
new CharRange('a', 'z'),
new CharRange('A', 'Z'),
})));
nfaBuilder.AddTransition(s1, segment.FromState);
nfaBuilder.AddTransition(s2, segment.FromState);
nfaBuilder.AddTransition(segment.ToState, e2);
var dfaGraph = FATools.CreateDfa(nfaBuilder.Graph);
const string expected =
"0 (S:S1) -- [A-Z,a-b,d-z] --> 1 (L:E2)\r\n" +
"0 (S:S1) -- [c] --> 2 (L:E2)\r\n" +
"3 (S:S2) -- [A-Z,a-z] --> 1 (L:E2)\r\n" +
"1 (L:E2) -- [A-Z,a-z] --> 1 (L:E2)\r\n" +
"2 (L:E2) -- [A-Z,b-z] --> 1 (L:E2)\r\n" +
"2 (L:E2) -- [a] --> 4 (L:E2)\r\n" +
"4 (L:E2) -- [t] --> 5 (L:E1)\r\n" +
"4 (L:E2) -- [A-Z,a-s,u-z] --> 1 (L:E2)\r\n" +
"5 (L:E1) -- [A-Z,a-z] --> 1 (L:E2)\r\n" +
"";
Assert.That(FARenderer.Render(dfaGraph), Is.EqualTo(expected));
}
public void IsSuperSetOf()
{
var abcd = new CharRange[] { new CharRange('A', 'D') };
var abc = new CharRange[] { new CharRange('A', 'C') };
var bc = new CharRange[] { new CharRange('B', 'C') };
var cd = new CharRange[] { new CharRange('C', 'D') };
var de = new CharRange[] { new CharRange('D', 'E') };
Assert.That(CharSet.New(abc).IsSupersetOf(CharSet.New(abcd)), Is.EqualTo(false));
Assert.That(CharSet.New(abc).IsSupersetOf(CharSet.New(abc)), Is.EqualTo(true));
Assert.That(CharSet.New(abc).IsSupersetOf(CharSet.New(bc)), Is.EqualTo(true));
Assert.That(CharSet.New(abc).IsSupersetOf(CharSet.New(cd)), Is.EqualTo(false));
Assert.That(CharSet.New(abc).IsSupersetOf(CharSet.New(de)), Is.EqualTo(false));
}
public void Intersect()
{
var abc = new CharRange[] { new CharRange('A', 'C') };
var abd = new CharRange[] { new CharRange('A', 'B'), new CharRange('D', 'D') };
var acd = new CharRange[] { new CharRange('A', 'A'), new CharRange('C', 'D') };
var bcd = new CharRange[] { new CharRange('B', 'D') };
var set1 = CharSet.New(abc);
var set2 = CharSet.New(abd);
var set3 = CharSet.Universal.Subtract(CharSet.New(acd));
var set4 = CharSet.Universal.Subtract(CharSet.New(bcd));
Assert.That(set1.Intersection(set2).ToString(), Is.EqualTo("[A-B]"));
Assert.That(set2.Intersection(set3).ToString(), Is.EqualTo("[B]"));
Assert.That(set3.Intersection(set4).ToString(), Is.EqualTo("![A-D]"));
Assert.That(set4.Intersection(set1).ToString(), Is.EqualTo("[A]"));
}
public void ExtractAlphabet()
{
var graphBuilder = new Graph.Builder();
var state1 = graphBuilder.NewState(true, new NodeData(0, null));
var state2 = graphBuilder.NewState(false, new NodeData(null, 0));
var state3 = graphBuilder.NewState(false, new NodeData(null, 1));
graphBuilder.AddTransition(state1, state2);
graphBuilder.AddTransition(state2, state3, CharSet.New(new CharRange[] { new CharRange('A', 'Z') }));
graphBuilder.AddTransition(state3, state2, CharSet.New(new CharRange[] { new CharRange('M', 'N') }));
const string expected =
"![A-Z]\r\n" +
"[A-L,O-Z]\r\n" +
"[M-N]\r\n" +
"";
Assert.That(Renderer.Render(FATools.ExtractAlphabet(graphBuilder.Graph)), Is.EqualTo(expected));
}
public static ReElement NewDummy(char c)
{
var mock = new Mock <ReElement>(MockBehavior.Strict);
mock
.Setup(x => x.GenerateNFA(It.IsNotNull <Graph.Builder>(), It.IsNotNull <Graph.State>(), It.IsNotNull <Graph.State>()))
.Callback((Graph.Builder g, Graph.State s1, Graph.State s2) => g.AddTransition(s1, s2, CharSet.New(c)));
mock.Setup(x => x.Kind).Returns((ReElementKind)(-1));
mock.Setup(x => x.MatchesEmptyString).Returns(false);
return(mock.Object);
}
public void Constructor()
{
var element = new ReSingleton(CharSet.New('1'));
Assert.That(element.Label, Is.EqualTo(CharSet.New('1')));
}
public void MatchesEmptyString()
{
var singleton = new ReSingleton(CharSet.New('1'));
Assert.That(singleton.MatchesEmptyString, Is.EqualTo(false));
}
