public Dfa(AutomataState startState)
{
_startState = startState;
_transitions = new Dictionary<AutomataState, Dictionary<char, AutomataState>>();
_defaults = new Dictionary<AutomataState, AutomataState>();
_finalStates = new List<AutomataState>();
}
public char FindNextEdge(AutomataState s, char x)
{
Dictionary<char, AutomataState> set;
AutomataState automataState;
if (x == '\0')
x = '\u0001';
x = (char)(x + 1);
if (s == null || !_transitions.TryGetValue(s, out set))
set = new Dictionary<char, AutomataState>();
if (set.TryGetValue(x, out automataState) || (s != null && _defaults.TryGetValue(s, out automataState)))
return x;
List<char> orderedSet = set.Keys.OrderBy(y => y).ToList();
if (orderedSet.Count == 0)
return '\0';
if (x < orderedSet[0])
return orderedSet[0];
if (x > orderedSet[orderedSet.Count - 1])
return '\0';
//where would x go in the sorted list?
int j = 1 + orderedSet.TakeWhile(item => x < item).Count();
return orderedSet[j];
}
public void Add_AddingSameInputTwice_ThrowsException()
{
AutomataState<int> q1 = new AutomataState<int>("Q1", true);
int inputToSelf = 1;
q1.Add(inputToSelf, q1);
q1.Add(inputToSelf, q1);
}
public void Add_AddingSameInputTwice_ThrowsException()
{
AutomataState<int> q1 = new AutomataState<int>("Q1", true);
int inputToSelf = 1;
q1.Add(inputToSelf, q1);
Assert.Throws<ArgumentException>(() => q1.Add(inputToSelf, q1));
}
public void Transit_UnknownInput_ReturnSelf()
{
AutomataState<int> q1 = new AutomataState<int>("Q1", true);
int unknownInput = -1;
IAutomataState<int> transitedState = q1.Transit(unknownInput);
Assert.That(transitedState, Is.SameAs(q1));
}
public void Transit_InputToSelf_ReturnSelf()
{
AutomataState<int> q1 = new AutomataState<int>("Q1", true);
int knownInput = 1;
q1.Add(knownInput, q1);
IAutomataState<int> transitedState = q1.Transit(knownInput);
Assert.That(transitedState, Is.SameAs(q1));
}
public void NfaCanAddValidFinalState()
{
Tuple <int, int> final = Tuple.Create(1, 0);
_nfa.AddFinalState(final);
AutomataState expected =
new AutomataState(final);
Assert.AreEqual(expected, _nfa.FinalStates);
}
public void Transit_InputToSecondState_ReturnSecondState()
{
AutomataState<int> q1 = new AutomataState<int>("Q1", true);
AutomataState<int> q2 = new AutomataState<int>("Q2", true);
int inputToSecondState = 1;
q1.Add(inputToSecondState, q2);
IAutomataState<int> transitedState = q1.Transit(inputToSecondState);
Assert.That(transitedState, Is.SameAs(q2));
}
public void Add_SingleElement_CurrentStateChanged()
{
DeterministicAutomata<int> automata =
new DeterministicAutomata<int>();
AutomataState<int> state =
new AutomataState<int>("Root", true);
automata.Add(state);
Assert.That(automata.CurrentState, Is.SameAs(state));
}
public void GetEnumerator_SingleTransition_EnumeratesTransition()
{
AutomataState<int> state = new AutomataState<int>("Root", true);
AutomataState<int> state1 = new AutomataState<int>("State1", true);
state.Add(1, state1);
Dictionary<int, IAutomataState<int>> exceptedEnumeration =
new Dictionary<int, IAutomataState<int>>()
{
{1, state1}
};
Assert.IsTrue(state.SequenceEqual(exceptedEnumeration));
}
public void AddTransition(AutomataState src, char input, AutomataState dest)
{
Dictionary<char, AutomataState> set;
if (_transitions.TryGetValue(src, out set))
{
if (set.ContainsKey(input))
set[input] = dest;
else
set.Add(input, dest);
}
else
{
set = new Dictionary<char, AutomataState> {{input, dest}};
_transitions.Add(src, set);
}
}
public void Add_FewElements_RootIsFirst()
{
DeterministicAutomata<int> automata =
new DeterministicAutomata<int>();
AutomataState<int> root =
new AutomataState<int>("Root", true);
AutomataState<int> state1 =
new AutomataState<int>("State1", true);
AutomataState<int> state2 =
new AutomataState<int>("State2", true);
automata.Add(root);
automata.Add(state1);
automata.Add(state2);
Assert.That(automata.Root, Is.SameAs(root));
}
public void Reset_TwoStatesSingleInput_Root()
{
DeterministicAutomata<int> automata =
new DeterministicAutomata<int>();
AutomataState<int> valid =
new AutomataState<int>("Valid", true);
AutomataState<int> invalid =
new AutomataState<int>("Invalid", false);
automata.Add(valid);
automata.Add(invalid);
valid.Add(3, invalid);
valid.Add(4, valid);
automata.Read(3);
automata.Reset();
Assert.That(automata.CurrentState, Is.SameAs(valid));
}
private AutomataState _FindNextState(AutomataState src, char input)
{
AutomataState nextState;
if(_transitions.ContainsKey(src))
{
Dictionary<char, AutomataState> stateTransitions = _transitions[src];
if (stateTransitions.TryGetValue(input, out nextState))
return nextState;
if (_defaults.TryGetValue(src, out nextState))
return nextState;
return null;
}
if (_defaults.TryGetValue(src, out nextState))
return nextState;
return null;
}
public void SetDefaultTransition(AutomataState src, AutomataState dest)
{
if (_defaults.ContainsKey(src))
_defaults[src] = dest;
else
_defaults.Add(src, dest);
}
public void Read_TwoStatesTwoInputs_FirstState()
{
DeterministicAutomata<int> automata =
new DeterministicAutomata<int>();
AutomataState<int> valid =
new AutomataState<int>("Valid", true);
AutomataState<int> invalid =
new AutomataState<int>("Invalid", false);
automata.Add(valid);
automata.Add(invalid);
valid.Add(3, invalid);
invalid.Add(4, valid);
automata.Read(3);
automata.Read(4);
Assert.That(automata.CurrentState, Is.SameAs(valid));
Assert.That(automata.IsValid, Is.EqualTo(true));
}
public void GetEnumerator_FewElements_ExpectedEnumeration()
{
DeterministicAutomata<int> automata =
new DeterministicAutomata<int>();
AutomataState<int> root =
new AutomataState<int>("Root", true);
AutomataState<int> state1 =
new AutomataState<int>("State1", true);
AutomataState<int> state2 =
new AutomataState<int>("State2", true);
automata.Add(root);
automata.Add(state1);
automata.Add(state2);
HashSet<IAutomataState<int>> expectedEnumeration =
new HashSet<IAutomataState<int>>()
{
root,
state1,
state2
};
Assert.IsTrue(expectedEnumeration.SetEquals(automata));
}
private IEnumerable<char> _GetInputs(AutomataState states)
{
HashSet<char> inputs = new HashSet<char>();
foreach (Tuple<int, int> state in states.State)
{
Dictionary<char, AutomataState> set;
if (!_transitions.TryGetValue(state, out set)) continue;
foreach (char key in set.Keys)
inputs.Add(key);
}
return inputs;
}
private AutomataState _Expand(AutomataState states)
{
List<Tuple<int, int>> frontier = new List<Tuple<int, int>>();
frontier.AddRange(states.State);
while (frontier.Count > 0)
{
Tuple<int, int> state = frontier[frontier.Count - 1];
frontier.RemoveAt(frontier.Count - 1);
Dictionary<char, AutomataState> set;
if (_transitions.TryGetValue(state, out set))
{
AutomataState innerSet;
if (set.TryGetValue(Epsilon, out innerSet))
{
IList<Tuple<int, int>> newStates = innerSet.State.Except(states.State).ToList();
frontier.AddRange(newStates);
foreach (var entry in newStates)
states.Add(entry);
}
}
}
return states;
}
public void GetEnumerator_AddingFewTransition_EnumeratesTransition()
{
AutomataState<int> state = new AutomataState<int>("Root", true);
AutomataState<int> state1 = new AutomataState<int>("State1", true);
AutomataState<int> state2 = new AutomataState<int>("State2", true);
AutomataState<int> state3 = new AutomataState<int>("State3", true);
state.Add(1, state1);
state.Add(2, state2);
state.Add(3, state3);
HashSet<KeyValuePair<int, IAutomataState<int>>> exceptedEnumeration =
new HashSet<KeyValuePair<int, IAutomataState<int>>>()
{
new KeyValuePair<int, IAutomataState<int>>(1, state1),
new KeyValuePair<int, IAutomataState<int>>(2, state2),
new KeyValuePair<int, IAutomataState<int>>(3, state3)
};
Assert.IsTrue(exceptedEnumeration.SetEquals(state));
}
public void GetEnumerator_NoTransitions_NoEnumeration()
{
AutomataState<int> state = new AutomataState<int>("Root", true);
Assert.IsTrue(!state.Any());
}
public void Add_AddingNullState_ThrowsException()
{
AutomataState<int> q1 = new AutomataState<int>("Q1", true);
Assert.Throws<ArgumentNullException>(() => q1.Add(1, null));
}
private bool _IsFinal(AutomataState state)
{
return _finalStates.Contains(state);
}
public void AddFinalState(AutomataState states)
{
_finalStates.Add(states);
}
private bool _IsFinal(AutomataState states)
{
return _finalStates.State.Intersect(states.State).Any();
}
public void Reset_SingleState_Root()
{
DeterministicAutomata<int> automata =
new DeterministicAutomata<int>();
AutomataState<int> valid =
new AutomataState<int>("Valid", true);
automata.Add(valid);
automata.Reset();
Assert.That(automata.CurrentState, Is.SameAs(valid));
}
private AutomataState _NextState(AutomataState states, char input)
{
AutomataState deststates = new AutomataState();
foreach (Tuple<int, int> state in states.State)
{
Dictionary<char, AutomataState> stateTransitions;
if (!_transitions.TryGetValue(state, out stateTransitions)) continue;
AutomataState set;
if (stateTransitions.TryGetValue(input, out set))
{
foreach (var item in set.State)
deststates.Add(item);
}
if (!stateTransitions.TryGetValue(Any, out set)) continue;
foreach (var item in set.State)
deststates.Add(item);
}
return _Expand(deststates);
}
public void Read_SingleState_Self()
{
DeterministicAutomata<int> automata =
new DeterministicAutomata<int>();
AutomataState<int> root =
new AutomataState<int>("Root", true);
automata.Add(root);
automata.Read(3);
Assert.That(automata.CurrentState, Is.SameAs(root));
Assert.That(automata.IsValid, Is.EqualTo(root.IsValid));
}
public bool HasDefaultTransition(AutomataState src, AutomataState dest)
{
return _defaults.ContainsKey(src) && _defaults[src].Equals(dest);
}
public Nfa()
{
_startState = Tuple.Create(0, 0);
_transitions = new Dictionary<Tuple<int, int>, Dictionary<char, AutomataState>>();
_finalStates = new AutomataState();
}
public bool HasTransition(AutomataState src, char input, AutomataState dest)
{
return _transitions.ContainsKey(src) &&
_transitions[src].ContainsKey(input) &&
_transitions[src][input].Equals(dest);
}
