diff --git a/apitools/base/protorpclite/protojson_test.py b/apitools/base/protorpclite/protojson_test.py
index 9ac7c8e4..2eb46fa8 100644
--- a/apitools/base/protorpclite/protojson_test.py
+++ b/apitools/base/protorpclite/protojson_test.py
@@ -207,9 +207,7 @@ def testNumericEnumerationNegativeTest(self):
         self.assertEquals(expected_message, message)
         # The roundtrip should result in equivalent encoded
         # message.
-        self.assertEquals(
-            '{"an_enum": 89}',
-            protojson.encode_message(message))
+        self.assertEquals('{"an_enum": 89}', protojson.encode_message(message))
 
     def testAlphaEnumeration(self):
         """Test that alpha enum values work."""
@@ -229,26 +227,20 @@ def testAlphaEnumerationNegativeTest(self):
         expected_message = MyMessage()
 
         self.assertEquals(expected_message, message)
-        # The roundtrip should result in equivalent encoded
-        # message.
-        self.assertEquals(
-            '{"an_enum": "IAMINVALID"}',
-            protojson.encode_message(message))
+        # The roundtrip should result in equivalent encoded message.
+        self.assertEquals('{"an_enum": "IAMINVALID"}',
+                          protojson.encode_message(message))
 
     def testEnumerationNegativeTestWithEmptyString(self):
         """The enum value is an empty string."""
         # The message should successfully decode.
-        message = protojson.decode_message(MyMessage,
-                                           '{"an_enum": ""}')
+        message = protojson.decode_message(MyMessage, '{"an_enum": ""}')
 
         expected_message = MyMessage()
 
         self.assertEquals(expected_message, message)
-        # The roundtrip should result in equivalent encoded
-        # message.
-        self.assertEquals(
-            '{"an_enum": ""}',
-            protojson.encode_message(message))
+        # The roundtrip should result in equivalent encoded message.
+        self.assertEquals('{"an_enum": ""}', protojson.encode_message(message))
 
     def testNullValues(self):
         """Test that null values overwrite existing values."""
diff --git a/apitools/base/protorpclite/test_util.py b/apitools/base/protorpclite/test_util.py
index 1f604e1d..90a7aa1c 100644
--- a/apitools/base/protorpclite/test_util.py
+++ b/apitools/base/protorpclite/test_util.py
@@ -583,12 +583,11 @@ def testDecodeInvalidEnumType(self):
         # successfully decoded even if the enum value is invalid. Encoding the
         # decoded message should result in equivalence with the original
         # encoded message containing an invalid enum.
-        decoded = self.PROTOLIB.decode_message(
-            OptionalMessage, self.encoded_invalid_enum)
+        decoded = self.PROTOLIB.decode_message(OptionalMessage,
+                                               self.encoded_invalid_enum)
         message = OptionalMessage()
         self.assertEqual(message, decoded)
-        encoded = self.PROTOLIB.encode_message(
-            decoded)
+        encoded = self.PROTOLIB.encode_message(decoded)
         self.assertEqual(self.encoded_invalid_enum, encoded)
 
     def testDateTimeNoTimeZone(self):
diff --git a/apitools/base/py/encoding_test.py b/apitools/base/py/encoding_test.py
index 6120c4bf..caf3ebb1 100644
--- a/apitools/base/py/encoding_test.py
+++ b/apitools/base/py/encoding_test.py
@@ -233,9 +233,7 @@ def testCopyProtoMessageAdditionalProperties(self):
 
     def testCopyProtoMessageMappingInvalidEnum(self):
         json_msg = '{"key_one": {"field_one": "BAD_VALUE"}}'
-        orig_msg = encoding.JsonToMessage(
-            MapToMessageWithEnum,
-            json_msg)
+        orig_msg = encoding.JsonToMessage(MapToMessageWithEnum, json_msg)
         new_msg = encoding.CopyProtoMessage(orig_msg)
         for msg in (orig_msg, new_msg):
             self.assertEqual(
@@ -326,12 +324,9 @@ def testDateTimeEncodingInAMap(self):
 
     def testInvalidEnumEncodingInAMap(self):
         json_msg = '{"key_one": {"field_one": "BAD_VALUE"}}'
-        msg = encoding.JsonToMessage(
-            MapToMessageWithEnum,
-            json_msg)
+        msg = encoding.JsonToMessage(MapToMessageWithEnum, json_msg)
         new_msg = encoding.MessageToJson(msg)
-        self.assertEqual('{"key_one": {"field_one": "BAD_VALUE"}}',
-                         new_msg)
+        self.assertEqual('{"key_one": {"field_one": "BAD_VALUE"}}', new_msg)
 
     def testIncludeFields(self):
         msg = SimpleMessage()
@@ -482,11 +477,10 @@ def testUnknownNestedRoundtrip(self):
                          json.loads(encoding.MessageToJson(message)))
 
     def testUnknownEnumNestedRoundtrip(self):
-        json_with_typo = (
-            '{"outer_key": {"key_one": {"field_one": "VALUE_OEN",'
-            ' "field_two": "VALUE_OEN"}}}')
-        msg = encoding.JsonToMessage(
-            NestedAdditionalPropertiesWithEnumMessage, json_with_typo)
+        json_with_typo = ('{"outer_key": {"key_one": {"field_one": "VALUE_OEN",'
+                          ' "field_two": "VALUE_OEN"}}}')
+        msg = encoding.JsonToMessage(NestedAdditionalPropertiesWithEnumMessage,
+                                     json_with_typo)
         self.assertEqual(json.loads(json_with_typo),
                          json.loads(encoding.MessageToJson(msg)))