Changeset 5809

Timestamp:

08/16/10 20:17:58 (3 years ago)

Author:

kosma

Message:

_fields.py: Working implementation of OptionsField?, with tests.

Location:

umpa/branches/protocols

Files:

• tests/a_unit/test_protocols/test__fields.py (modified) (5 diffs)
• umit/umpa/protocols/_fields.py (modified) (5 diffs)

umpa/branches/protocols/tests/a_unit/test_protocols/test__fields.py

@@ -741 +741 @@
         py.test.raises(UMPAException, f.fillout)
 
+class TestOptionsField(TestField):
+    cls_field = OptionsField
+
+    def test_init(self):
+        f = self.cls_field('options')
+        assert f.bits == 0
+
+    def test_set(self):
+        f = self.cls_field('options')
+
+        f.set(None)
+        assert f._value == None
+
+        f.set('payload')
+        assert len(f._value) == 1
+        assert f._value[0].get() == 'payload'
+
+        f.set( [ 'payload' ] )
+        assert len(f._value) == 1
+        assert f._value[0].get() == 'payload'
+
+        f.set( [ (1, ), (2, ''), (3, 'foo'), 'bar', None ] )
+        assert len(f._value) == 5
+        assert f._value[0].get() == (1, '')
+        assert f._value[1].get() == (2, '')
+        assert f._value[2].get() == (3, 'foo')
+        assert f._value[3].get() == 'bar'
+        assert f._value[4].get() == None
+
+    def test_get(self):
+        f = self.cls_field('options')
+        assert f.get() is None
+
+        f = self.cls_field('options', 'payload')
+        assert f.get() == [ 'payload' ]
+
+        f = self.cls_field('options', [ 'payload' ])
+        assert f.get() == [ 'payload' ]
+
+        f = self.cls_field('options', [ (1,), (2, ), (3, ''), (4, 'foo'), 'bar', None ] )
+        assert f.get() == [ (1, ''), (2, ''), (3, ''), (4, 'foo'), 'bar', None ]
+
+    def test_clear(self):
+        f = self.cls_field('options', 'payload')
+        assert f._value is not None
+        assert f.get() is not None
+        f.clear()
+        assert f._value is None
+        assert f.get() is None
+
+    def test_raw_value(self):
+        f = self.cls_field('foobar')
+    
+        f.set('test')
+        assert f._raw_value() == 0x74657374
+        assert f.bits == 32
+
+        f.set([ (1,) ])
+        assert f._raw_value() == 0x01
+        assert f.bits == 8
+
+        f.set([ (5, 'test') ])
+        assert f._raw_value() == 0x050674657374
+        assert f.bits == 48
+
+    def test_fillout(self):
+        f = self.cls_field('options')
+        assert f.fillout() == 0
+        assert f.bits == 0
+
 class TestOptionField(TestField):
     cls_field = OptionField
@@ -746 +816 @@
     def test_init(self):
         f = self.cls_field('foobar')
-        assert f.auto is False
+        assert f.auto is True
 
         f = self.cls_field('foobar', 'xxx')
         assert f.get() == 'xxx'
 
+    def test_set(self):
+        f = self.cls_field('foobar')
+        
+        f.set((1,))
+        assert f._value == (1, '')
+        f.set((1, ''))
+        assert f._value == (1, '')
+        f.set((1, 'foo'))
+        assert f._value == (1, 'foo')
+
+        f.set((2, ))
+        assert f._value == (2, '')
+        f.set((2, ''))
+        assert f._value == (2, '')
+        f.set((2, 'bar'))
+        assert f._value == (2, 'bar')
+
     def test_get(self):
         f = self.cls_field('foobar')
@@ -758 +845 @@
         assert f.get() == 'text'
 
-        f = self.cls_field('foobar', (0,))
-        assert f.get() == (0,)
-
-    def test_set(self):
-        f = self.cls_field('foobar')
-        
-        f.set((1,))
-        assert f.get() == (1,)
-        f.set((2, 'x'))
-        assert f.get() == (2, 'x')
+        f = self.cls_field('foobar', (4, 'test'))
+        assert f.get() == (4, 'test')
 
     def test_clear(self):
@@ -773 +852 @@
         f.set('foobarfoobar')
         assert f.get() == 'foobarfoobar'
-        assert f.bits == 96
         f.clear()
         assert f.get() is None
-        assert f.bits == 0
 
     def test_raw_value(self):
         f = self.cls_field('foobar')
-
+    
         f.set('test')
         assert f._raw_value() == 0x74657374
@@ -798 +875 @@
 
         f = self.cls_field('foobar')
-        py.test.raises(UMPAException, f.fillout)
+        assert f.fillout() == 0x01

umpa/branches/protocols/umit/umpa/protocols/_fields.py

@@ -950 +950 @@
         return str_to_bits(self._value)
 
+class OptionsField(Field):
+    """
+    A field holding IP/TCP options. This field contains a list of zero or more
+    Fields in a format understood by the OptionField class. Example:
+
+        [ (4, 'foo'), '\4\5bar', (5, ), (0, ) ]
+    """
+
+    bits = 0    # dynamic, changes depending on the content
+
+    def _is_valid(self, value):
+        """
+        Validate each value independently; return True only if all pass.
+        """
+
+        if value is None:
+            return True
+        of = OptionField('option')
+        for opt in value:
+            if not of._is_valid(opt):
+                return False
+        return True
+
+    def set(self, value):
+        """
+        Set the field value.
+        """
+
+        # allow the user to set a single raw string value
+        if isinstance(value, str):
+            value = [value]
+
+        super(OptionsField, self).set(value)
+
+        if self._value is None or len(value) == 0:
+            self.clear()
+            return
+
+        # the above sets _value to the user-supplied list; convert it to 
+        # a list of OptionField objects
+        fields = []
+        for opt in value:
+            fields.append(OptionField('option', opt))
+        self._value = fields
+
+    def get(self):
+        """
+        Get the field value.
+        """
+
+        if self._value is None:
+            return None
+
+        # build a list of values and return it to the user
+        values = []
+        for field in self._value:
+            values.append(field.get())
+        return values
+
+    def _generate_value(self):
+        """
+        No options are included by default.
+        """
+
+        return []
+
+    def _raw_value(self):
+        """
+        Convert the value to the raw mode and update bits field.
+        """
+
+        raw = 0
+        bits = 0
+
+        for field in self._value:
+            field_raw = field.fillout()
+            raw <<= field.bits
+            raw |= field_raw
+            bits += field.bits
+
+        self.bits = bits
+        return raw
+
 class OptionField(Field):
     """
@@ -955 +1038 @@
 
     1. A (option-kind, option-value) tuple. The option-length octet will be
-       generated automatically. The option-value should be a raw string value.
-       Options 0 and 1 don't have option-value.
+       generated automatically. The option-value should be a raw string value;
+       if it's not supplied, an empty value will be used.
     2. A string value which will be inserted as-is without any validation.
     """
 
     bits = 0    # dynamic, changes depending on the content
+    auto = True
 
     def _is_valid(self, value):
         """
-        Ensure that the value is either a string or a valid tuple.
+        Ensure that the value is either a string or a non-empty sequence.
         """
 
@@ -971 +1055 @@
         if len(value) == 0:
             return False
-        if value[0] in (0, 1):
-            return True
-        if len(value) == 1:
-            return False
-        if not isinstance(value[1], str):
-            return False
         return True
 
     def set(self, value):
         """
-        Calculate the bit length after setting the value.
-        """
-
+        Canonicalize the field value and recalculate bit length.
+        """
+
+        # validate and set value
         super(OptionField, self).set(value)
-        if value is None:
-            self.bits = 0
-        elif isinstance(value, str):
-            # use a raw value as-is
-            self.bits = BYTE * len(value)
-        else:
-            if value[0] in (0, 1):
-                # options 0 and 1 have no option-length field
-                self.bits = BYTE
-            else:
-                self.bits = BYTE * (2 + len(value[1]))
+
+        # canonicalize value field: always store as ( kind, value ) pair
+        if self._value is not None and len(self._value) < 2:
+            self._value = ( self._value[0], '' )
 
     def clear(self):
         """
+        Clear the field.
+        
         Reset the bit length after clearing the value.
         """
@@ -1007 +1081 @@
     def _raw_value(self):
         """
-        Convert the value to the raw mode.
-        """
-
+        Convert the value to the raw mode and update bits field.
+        """
+
+        # generate raw value
         if isinstance(self._value, str):
             data = self._value
@@ -1017 +1092 @@
             else:
                 data = "%c%c%s" % ( self._value[0], len(self._value[1]) + 2,
-                                    self._value[1] )
+                                     self._value[1] )
+
+        # update field length
+        self.bits = BYTE * len(data)
 
         return str_to_bits(data)
+
+    def _generate_value(self):
+        """
+        Return a NOP option by default.
+        """
+
+        return (1, '')