Support checking structs for equality.

Also:

- Rename _fields to _fieldnames, because the history of this
  CL shows that _fields is confusing
- Fix some lint errors.

Change-Id: I23d0191e6a588820b3697b2d36d70880ea921d8a

Author: lcolitti

tests/net_test/cstruct.py

@@ -57,7 +57,7 @@ def CalcNumElements(fmt):
   return len(elements)
 
 
-def Struct(name, fmt, fields, substructs={}):
+def Struct(name, fmt, fieldnames, substructs={}):
   """Function that returns struct classes."""
 
   class Meta(type):
@@ -77,12 +77,12 @@ class CStruct(object):
     # Name of the struct.
     _name = name
     # List of field names.
-    _fields = fields
+    _fieldnames = fieldnames
     # Dict mapping field indices to nested struct classes.
     _nested = {}
 
-    if isinstance(_fields, str):
-      _fields = _fields.split(" ")
+    if isinstance(_fieldnames, str):
+      _fieldnames = _fieldnames.split(" ")
 
     # Parse fmt into _format, converting any S format characters to "XXs",
     # where XX is the length of the struct type's packed representation.
@@ -121,14 +121,14 @@ def __init__(self, values):
         self._Parse(values)
       else:
         # Initializing from a tuple.
-        if len(values) != len(self._fields):
-          raise TypeError("%s has exactly %d fields (%d given)" %
-                          (self._name, len(self._fields), len(values)))
+        if len(values) != len(self._fieldnames):
+          raise TypeError("%s has exactly %d fieldnames (%d given)" %
+                          (self._name, len(self._fieldnames), len(values)))
         self._SetValues(values)
 
     def _FieldIndex(self, attr):
       try:
-        return self._fields.index(attr)
+        return self._fieldnames.index(attr)
       except ValueError:
         raise AttributeError("'%s' has no attribute '%s'" %
                              (self._name, attr))
@@ -143,6 +143,15 @@ def __setattr__(self, name, value):
     def __len__(cls):
       return cls._length
 
+    def __ne__(self, other):
+      return not self.__eq__(other)
+
+    def __eq__(self, other):
+      return (isinstance(other, self.__class__) and
+              self._name == other._name and
+              self._fieldnames == other._fieldnames and
+              self._values == other._values)
+
     @staticmethod
     def _MaybePackStruct(value):
       if hasattr(value, "__metaclass__"):# and value.__metaclass__ == Meta:
@@ -156,12 +165,14 @@ def Pack(self):
 
     def __str__(self):
       def FieldDesc(index, name, value):
-        if isinstance(value, str) and any (c not in string.printable for c in value):
+        if isinstance(value, str) and any(
+            c not in string.printable for c in value):
           value = value.encode("hex")
         return "%s=%s" % (name, value)
 
       descriptions = [
-          FieldDesc(i, n, v) for i, (n, v) in enumerate(zip(self._fields, self._values))]
+          FieldDesc(i, n, v) for i, (n, v) in
+          enumerate(zip(self._fieldnames, self._values))]
 
       return "%s(%s)" % (self._name, ", ".join(descriptions))
 

tests/net_test/cstruct_test.py

@@ -0,0 +1,60 @@
+#!/usr/bin/python
+#
+# Copyright 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import cstruct
+
+
+# These aren't constants, they're classes. So, pylint: disable=invalid-name
+TestStructA = cstruct.Struct("TestStructA", "=BI", "byte1 int2")
+TestStructB = cstruct.Struct("TestStructB", "=BI", "byte1 int2")
+
+
+class CstructTest(unittest.TestCase):
+
+  def CheckEquals(self, a, b):
+    self.assertEquals(a, b)
+    self.assertEquals(b, a)
+    assert a == b
+    assert b == a
+    assert not (a != b)  # pylint: disable=g-comparison-negation,superfluous-parens
+    assert not (b != a)  # pylint: disable=g-comparison-negation,superfluous-parens
+
+  def CheckNotEquals(self, a, b):
+    self.assertNotEquals(a, b)
+    self.assertNotEquals(b, a)
+    assert a != b
+    assert b != a
+    assert not (a == b)  # pylint: disable=g-comparison-negation,superfluous-parens
+    assert not (b == a)  # pylint: disable=g-comparison-negation,superfluous-parens
+
+  def testEqAndNe(self):
+    a1 = TestStructA((1, 2))
+    a2 = TestStructA((2, 3))
+    a3 = TestStructA((1, 2))
+    b = TestStructB((1, 2))
+    self.CheckNotEquals(a1, b)
+    self.CheckNotEquals(a2, b)
+    self.CheckNotEquals(a1, a2)
+    self.CheckNotEquals(a2, a3)
+    for i in [a1, a2, a3, b]:
+      self.CheckEquals(i, i)
+    self.CheckEquals(a1, a3)
+
+
+if __name__ == "__main__":
+  unittest.main()