def testReturnValueIsBits(self):
uut = self.get_default_encoder()
encoded = uut.encode('abc')
self.assertIsInstance(encoded, Bits)
python类Bits()的实例源码
def testCorrectEncoding(self):
value = Bits(bin='01010011')
uut = self.get_default_encoder()
self.assertEqual(uut.encode(value), self._encode_func(value))
def _encode_func(self, bits):
remainder = len(bits) % 8
pad_len = (8 - remainder) % 8
return bits + Bits(pad_len)
def testPaddingNoPad(self):
value = Bits(bytes='\x01')
uut = self.get_default_encoder()
self.assertEqual(uut.encode(value), value)
def testPadding1(self):
value = Bits(bin='1111111')
expected = Bits(bin='11111110')
uut = self.get_default_encoder()
self.assertEqual(uut.encode(value), expected)
def testPadding4(self):
value = Bits(bin='1111')
expected = Bits(bin='11110000')
uut = self.get_default_encoder()
self.assertEqual(uut.encode(value), expected)
def testPadding7(self):
value = Bits(bin='1')
expected = Bits(bin='10000000')
uut = self.get_default_encoder()
self.assertEqual(uut.encode(value), expected)
def testExceptionWhenBitsNotByteAligned(self):
value = Bits(bin='1111111')
uut = self.get_default_encoder()
with self.assertRaises(KittyException):
uut.encode(value)
def _test_fields(self, init_fields=[], push_fields=[]):
all_fields = init_fields + push_fields
container = self.get_default_container(fields=init_fields, fuzzable=True)
for f in push_fields:
container.push(f)
if isinstance(f, Container):
# default is to pop the container immediatly in the tests...
container.pop()
fields_num_mutations = sum(f.num_mutations() for f in all_fields)
container_num_mutations = container.num_mutations()
self.assertEqual(fields_num_mutations, container_num_mutations)
field_default_values = []
for f in all_fields:
field_default_values.append(f.render())
fields_mutations = []
for i, field in enumerate(all_fields):
prefix = sum(field_default_values[:i])
postfix = sum(field_default_values[i + 1:])
if prefix == 0:
prefix = Bits()
if postfix == 0:
postfix = Bits()
while field.mutate():
fields_mutations.append(prefix + field.render() + postfix)
field.reset()
container_mutations = self.get_all_mutations(container)
self.assertListEqual(fields_mutations, container_mutations)
def testlways(self):
field = self.get_condition_field()
condition = self.get_not_applies_always_condition()
condition_container = self.cls(condition=condition, fields=[String(ConditionTest.inner_field_value)], fuzzable=True)
# This is done to allow field name resolution
enclosing = Container(fields=[field, condition_container])
rendered = condition_container.render()
self.assertEqual(rendered, Bits())
while condition_container.mutate():
rendered = condition_container.render()
self.assertEqual(rendered, Bits())
del enclosing
def _testValuePadded(self, field, uut, pad_length, pad_data):
fdata = field.render()
udata = uut.render()
actual_pad_len = max(0, pad_length - len(fdata))
expected_padding = Bits(bytes=pad_data * (actual_pad_len / 8 + 1))[:actual_pad_len]
self.assertEqual(fdata, udata[:len(fdata)])
self.assertEqual(expected_padding, udata[len(fdata):])
def testFixedWithPad(self):
data = 'abcd'
expected = Bits(bytes='abcd\xff\xff\xff\xff\xff\xff')
uut = Pad(pad_length=10 * 8, fields=Static(data), pad_data='\xff')
uut_num_mutations = uut.num_mutations()
self.assertEqual(uut_num_mutations, 0)
actual_num_mutations = 0
while uut.mutate():
actual_num_mutations += 1
self.assertEqual(actual_num_mutations, uut_num_mutations)
self.assertEqual(uut.render(), expected)
def testFixedWithoutPad(self):
data = 'abcdefghijklmnop'
expected = Bits(bytes=data)
uut = Pad(pad_length=10 * 8, fields=Static(data), pad_data='\xff')
uut_num_mutations = uut.num_mutations()
self.assertEqual(uut_num_mutations, 0)
actual_num_mutations = 0
while uut.mutate():
actual_num_mutations += 1
self.assertEqual(actual_num_mutations, uut_num_mutations)
self.assertEqual(uut.render(), expected)
def testRendersToEmptyBits(self):
uut = PseudoTemplate('uut')
self.assertEquals(uut.render(), Bits())
def render(self, ctx=None):
'''
Render the current value of the field
:rtype: Bits
:return: rendered value
'''
self._initialize()
if not self.is_default():
self._current_rendered = self._encode_value(self._current_value)
return self._current_rendered
def _mutate(self):
if self._step:
length = self._min_length + self._step * self._current_index
else:
length = self._random.randint(self._min_length, self._max_length)
current_bytes = ''
for i in range(length / 8 + 1):
current_bytes += chr(self._random.randint(0, 255))
self._current_value = Bits(bytes=current_bytes)[:length]
def _in_render_value(self):
'''
This method is called when rendered was called recursively.
This means that we are enclosed by the field we depend on.
So consider carefully what value are you going to return....
:rtype: Bits
:return: a dummy rendered value
'''
raise NotImplementedError('_in_render_value should be implemented in subclass (%s)' % type(self).__name__)
def _in_render_value(self):
'''
:return: a zeroed version of the field, good for some checksums and inclusive lengths
'''
return Bits(len(self._bit_field.render()))
def __init__(self, depends_on, length, algorithm='crc32', encoder=ENC_INT_DEFAULT, fuzzable=False, name=None):
'''
:param depends_on: (name of) field to be checksummed
:param length: length of the checksum field (in bits)
:param algorithm: checksum algorithm name (from Checksum._algos) or a function to calculate the value of the field. func(Bits) -> int
:type encoder: :class:`~kitty.model.low_level.encoder.BitFieldEncoder`
:param encoder: encoder for the field (default: ENC_INT_DEFAULT)
:param fuzzable: is field fuzzable (default: False)
:param name: (unique) name of the field (default: None)
:example:
::
Container(name='checksummed chunk', fields=[
RandomBytes(name='chunk', value='1234', min_length=0, max_length=75),
Checksum(name='CRC', depends_on='chunk', length=32)
])
'''
if algorithm in Checksum._algos:
func = Checksum._algos[algorithm]
else:
try:
res = algorithm(empty_bits)
kassert.is_of_types(res, types.IntType)
func = algorithm
except:
raise KittyException('algorithm should be a func(str)->int or one of the strings %s' % (Checksum._algos.keys(),))
def calc_func(x):
return func(x.bytes) & 0xffffffff
bit_field = BitField(value=0, length=length, encoder=encoder)
super(Checksum, self).__init__(depends_on=depends_on, bit_field=bit_field, calc_func=calc_func, fuzzable=fuzzable, name=name)
def render(self, ctx=None):
'''
:param ctx: rendering context in which the method was called
:rtype: `Bits`
:return: rendered value of the container
'''
self._initialize()
render_count = 1
if ctx is None:
ctx = RenderContext()
if self._need_second_pass:
render_count = 2
ctx.push(self)
if self.is_default():
self._current_rendered = self._default_rendered
else:
if self.offset is None:
self.offset = 0
for i in range(render_count):
offset = self.offset
rendered = BitArray()
for field in self._fields:
field.set_offset(offset)
frendered = field.render(ctx)
if not isinstance(frendered, Bits):
raise KittyException('the field %s:%s was rendered to type %s, you should probably wrap it with appropriate encoder' % (
field.get_name(), type(field), type(frendered)))
rendered.append(frendered)
offset += len(frendered)
self.set_current_value(rendered)
ctx.pop()
return self._current_rendered
