def test(Begin, End):
X = Interval(Begin, End)
print "-------------------------"
print "Interval: " + X.get_string(Option="hex")
print " .front --> " + pretty_sequence(X.begin)
print " .back --> " + pretty_sequence(X.end - 1)
print
L = len(trafo.unicode_to_utf8(X.begin))
assert L == len(trafo.unicode_to_utf8(X.end - 1))
result, p = trafo.split_interval_into_contigous_byte_sequence_range(X, L)
print "Result:"
previous_end = X.begin
for interval in result:
print " %s " % interval.get_string(Option="hex")
# All sub intervals must be adjacent
assert interval.begin == previous_end
print " .front --> " + pretty_sequence(interval.begin)
print " .back --> " + pretty_sequence(interval.end - 1)
previous_end = interval.end
# The whole interval has been spanned
assert result[0].begin == X.begin
assert result[-1].end == X.end
def test(Begin, End):
X = Interval(Begin, End)
print "-------------------------"
print "Interval: " + X.get_string(Option="hex")
print " .front --> " + pretty_sequence(X.begin)
print " .back --> " + pretty_sequence(X.end - 1)
print
L = len(trafo.unicode_to_utf8(X.begin))
assert L == len(trafo.unicode_to_utf8(X.end - 1))
result, p = trafo.split_interval_into_contigous_byte_sequence_range(X, L)
print "Result:"
previous_end = X.begin
for interval in result:
print " %s " % interval.get_string(Option="hex")
# All sub intervals must be adjacent
assert interval.begin == previous_end
print " .front --> " + pretty_sequence(interval.begin)
print " .back --> " + pretty_sequence(interval.end - 1)
previous_end = interval.end
# The whole interval has been spanned
assert result[0].begin == X.begin
assert result[-1].end == X.end
def check_negative(SM, ImpossibleIntervals):
"""Non of the given unicode values shall reach an acceptance state.
"""
print "Inverse Union Check:",
for interval in ImpossibleIntervals:
for i in [interval.begin, (interval.end + interval.begin) / 2, interval.end - 1]:
utf8_seq = unicode_to_utf8(i)
# Apply sequence to state machine
s_idx = result.init_state_index
for byte in utf8_seq:
s_idx = result.states[s_idx].target_map.get_resulting_target_state_index(byte)
if s_idx is None: break
if s_idx is None: continue
# An acceptance state cannot be reached by a unicode value in ImpossibleIntervals
for cmd in result.states[s_idx].single_entry:
assert not cmd.is_acceptance()
print " (OK)"
def check(self, SM):
"""This function throws an exception as soon as one single value
is not matched according to the expectation.
"""
print "Name = " + self.name,
for interval in self.charset.get_intervals(PromiseToTreatWellF=True):
for i in range(interval.begin, interval.end):
utf8_seq = unicode_to_utf8(i)
# Apply sequence to state machine
s_idx = result.init_state_index
for byte in utf8_seq:
s_idx = result.states[s_idx].target_map.get_resulting_target_state_index(byte)
# All acceptance flags must belong to the original state machine
for cmd in result.states[s_idx].single_entry:
if cmd.__class__ != SeAccept: continue
# HERE: As soon as something is wrong --> fire an exception
assert cmd.acceptance_id() == self.id
print " (OK=%i)" % self.id
def check(self, SM):
"""This function throws an exception as soon as one single value
is not matched according to the expectation.
"""
print "Name = " + self.name,
for interval in self.charset.get_intervals(PromiseToTreatWellF=True):
for i in range(interval.begin, interval.end):
utf8_seq = unicode_to_utf8(i)
# Apply sequence to state machine
s_idx = result.init_state_index
for byte in utf8_seq:
s_idx = result.states[
s_idx].target_map.get_resulting_target_state_index(
byte)
# All acceptance flags must belong to the original state machine
for cmd in result.states[s_idx].single_entry:
if cmd.__class__ != SeAccept: continue
# HERE: As soon as something is wrong --> fire an exception
assert cmd.acceptance_id() == self.id
print " (OK=%i)" % self.id
def check_negative(SM, ImpossibleIntervals):
"""Non of the given unicode values shall reach an acceptance state.
"""
print "Inverse Union Check:",
for interval in ImpossibleIntervals:
for i in [
interval.begin, (interval.end + interval.begin) / 2,
interval.end - 1
]:
utf8_seq = unicode_to_utf8(i)
# Apply sequence to state machine
s_idx = result.init_state_index
for byte in utf8_seq:
s_idx = result.states[
s_idx].target_map.get_resulting_target_state_index(byte)
if s_idx is None: break
if s_idx is None: continue
# An acceptance state cannot be reached by a unicode value in ImpossibleIntervals
for cmd in result.states[s_idx].single_entry:
assert not cmd.is_acceptance()
print " (OK)"
def pretty_sequence(Value):
txt = ""
for byte in trafo.unicode_to_utf8(Value):
txt += "%02X." % byte
return txt
def pretty_sequence(Value):
txt = ""
for byte in trafo.unicode_to_utf8(Value):
txt += "%02X." % byte
return txt
