def uniqueness(A): """Uniqueness of complement: A u B = Universal and A n B = Empty => A = complement B and vice versa Involution: A = complement(complement(A)) """ global count B = difference(DFA.Universal(), A) # => A u B = Universal and A n B = Empty assert identity(union([A, B]), DFA.Universal()) assert identity(intersection([A, B]), DFA.Empty()) # Uniqueness of complement assert identity(A, complement(B)) assert identity(B, complement(A)) # Involution/Double Complement assert identity(A, complement(complement(A))) assert identity(B, complement(complement(B))) count += 1
def domination(A): global count first = union([A, DFA.Universal()]) assert identity(first, DFA.Universal()) first = intersection([A, DFA.Empty()]) assert identity(first, DFA.Empty()) count += 1
def complement_laws(A): global count first = union([A.clone(), complement(A.clone())]) assert identity(first, DFA.Universal()) first = intersection([A.clone(), complement(A.clone())]) assert identity(first, DFA.Empty()) count += 1
def identity_vs_empty_and_universal(A): global count count += 1 # if count != 3: return first = union([A.clone(), DFA.Empty()]) assert identity(first, A.clone()) first = intersection([A.clone(), DFA.Universal()]) assert identity(first, A)
def unary_checks(Q, operation): Q_plus = beautifier.do(repeat.do(Q)) Q_star = beautifier.do(repeat.do(Q, min_repetition_n=0)) Q_is_Q_star = identity.do(Q, Q_star) Q_is_Q_plus = identity.do(Q, Q_plus) # \Cut{Q Q} = \Nothing y = operation(Q, Q) assert y.is_Nothing() # if Q != Q+: \CutBegin{Q+ Q} = Q* if not Q_is_Q_plus: y = operation(Q_plus, Q) assert identity.do(y, Q_star) # if Q != Q*: \CutBegin{Q* Q} = Q* if not Q_is_Q_star: y = operation(Q_star, Q) assert identity.do(y, Q_star) # \Cut{Q \Nothing} = Q y = operation(Q, DFA.Nothing()) assert identity.do(y, Q) # \Cut{\Nothing Q} = \Nothing y = operation(DFA.Nothing(), Q) assert y.is_Nothing() # \Cut{Q \Universal} = \Nothing y = operation(Q, DFA.Universal()) assert y.is_Nothing() # NOT: \Cut{\Universal Q} = \Universal if not Q_is_Q_star and not Q_is_Q_plus: y = operation(Q, DFA.Universal()) assert y.is_Nothing() return Q_star, Q_plus
from quex.engine.state_machine.check.identity import do as identity from quex.engine.state_machine.check.superset import do as superset from quex.engine.state_machine.core import DFA import quex.input.regular_expression.engine as regex import quex.engine.state_machine.TEST_help.many_shapes as shapes shapes.set_unique_transition_f() def dfa(Str): return regex.do(Str, {}, AllowNothingIsNecessaryF=True).extract_sm() __dfa_list = [ DFA.Universal(), # Matches all lexemes DFA.Empty(), # Matches the lexeme of zero length # dfa('a'), dfa('ab'), dfa('a(b?)'), dfa('ab|abcd'), # "Branches" dfa('12|AB'), dfa('x(12|AB)'), dfa('(12|AB)x'), dfa('x(12|AB)x'), dfa('x(1?2|A?B)x'), dfa('x(1?2?|A?B?)x'), # "Loops" dfa('A+'),
elif "Loops" in sys.argv: test('A+') test('A(B*)') test('A((BC)*)') test('((A+)B+)C+') test('(ABC|BC|C)+') elif "BranchesLoops" in sys.argv: test('(AB|XY)+') test('(AB|XY)((DE|FG)*)') test('(((AB|XY)+)(DE|FG)+)(HI|JK)+') test('((AB|XY)(DE|FG)(HI|JK)|(DE|FG)(HI|JK)|(HI|JK))+') elif "Misc" in sys.argv: test('((((((((p+)r)+i)+)n)+t)+e)+r)+') test('(printer|rinter|inter|nter|ter|er|r)+') test('(p?r?i?n?t?e?r|rinter|inter|nter|ter|er|r)+') test( '(((((((((p+)r)+i)+)p)+r)+i)+n)+|(priprin|riprin|iprin|prin|rin|in|n)+)x?' ) elif "Special" in sys.argv: test(DFA.Empty()) test(DFA.Universal()) sm = DFA.Universal() sm.get_init_state().set_acceptance(True) sm = beautifier.do(sm) test(sm) else: test('a|ab')
def anything_containing(Q): tmp = sequentialize.do([DFA.Universal(), Q, DFA.Universal()]) return beautifier.do(tmp)
def anything_ending_with(Q): tmp = sequentialize.do([DFA.Universal(), Q]) return beautifier.do(tmp)
def anything_beginning_with(Q): tmp = sequentialize.do([Q, DFA.Universal()]) return beautifier.do(tmp)
def least_and_greatest(A): global count assert superset(A, DFA.Empty()) assert superset(DFA.Universal(), A) count += 1
def snap_universal(stream, PatternDict): return DFA.Universal()