Mojom: Add some tests for mojom.parse.ast.

mojo/public/tools/bindings/pylib/mojom/parse/ast.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Node classes for the AST for a Mojo IDL file."""
 
 # Note: For convenience of testing, you probably want to define __eq__() methods
 # for all node types; it's okay to be slightly lax (e.g., not compare filename
 # and lineno). You may also define __repr__() to help with analyzing test
 # failures, especially for more complex types.
 
 
 class NodeBase(object):
   """Base class for nodes in the AST."""
 
   def __init__(self, filename=None, lineno=None):
     self.filename = filename
     self.lineno = lineno
 
   def __eq__(self, other):
     return type(self) == type(other)
 
+  # Make != the inverse of ==. (Subclasses shouldn't have to override this.)
+  def __ne__(self, other):
+    return not self == other
+
 
 # TODO(vtl): Some of this is complicated enough that it should be tested.
 class NodeListBase(NodeBase):
   """Represents a list of other nodes, all having the same type. (This is meant
   to be subclassed, with subclasses defining _list_item_type to be the class (or
   classes, in a tuple) of the members of the list.)"""
 
   def __init__(self, item_or_items=None, **kwargs):
     super(NodeListBase, self).__init__(**kwargs)
     self.items = []
     if item_or_items is None:
       pass
       self.items = []
     elif isinstance(item_or_items, list):
       for item in item_or_items:
         assert isinstance(item, self._list_item_type)
         self.Append(item)
     else:
       assert isinstance(item_or_items, self._list_item_type)
       self.Append(item_or_items)
 
   # Support iteration. For everything else, users should just access |items|
   # directly. (We intentionally do NOT supply |__len__()| or |__nonzero__()|, so
   # |bool(NodeListBase())| is true.)
   def __iter__(self):
     return self.items.__iter__()
 
   def __eq__(self, other):
     return super(NodeListBase, self).__eq__(other) and \
-           len(self.items) == len(other.items) and \
-           all(self.items[i] == other.items[i] for i in xrange(len(self.items)))
+           self.items == other.items
 
   # Implement this so that on failure, we get slightly more sensible output.
   def __repr__(self):
     return self.__class__.__name__ + "([" + \
            ", ".join([repr(elem) for elem in self.items]) + "])"
 
   def Insert(self, item):
     """Inserts item at the front of the list."""
 
     assert isinstance(item, self._list_item_type)
@@ skipping 279 matching lines @@
            self.ordinal == other.ordinal and \
            self.typename == other.typename and \
            self.default_value == other.default_value
 
 
 # This needs to be declared after |StructField|.
 class StructBody(NodeListBase):
   """Represents the body of (i.e., list of definitions inside) a struct."""
 
   _list_item_type = (Const, Enum, StructField)