Revert "Add gsutil 4.13 to telemetry/third_party"

tools/telemetry/third_party/gsutil/third_party/protorpc/protorpc/protojson_test.py

Index: tools/telemetry/third_party/gsutil/third_party/protorpc/protorpc/protojson_test.py
diff --git a/tools/telemetry/third_party/gsutil/third_party/protorpc/protorpc/protojson_test.py b/tools/telemetry/third_party/gsutil/third_party/protorpc/protorpc/protojson_test.py
deleted file mode 100644
index 1ed23e201a3dd8a02c40f9b0ac0fe8485c78c2ff..0000000000000000000000000000000000000000
--- a/tools/telemetry/third_party/gsutil/third_party/protorpc/protorpc/protojson_test.py
+++ /dev/null
@@ -1,554 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2010 Google Inc.
-#
-# 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.
-#
-
-"""Tests for protorpc.protojson."""
-
-__author__ = 'rafek@google.com (Rafe Kaplan)'
-
-
-import datetime
-import imp
-import sys
-import unittest
-
-from protorpc import message_types
-from protorpc import messages
-from protorpc import protojson
-from protorpc import test_util
-
-import simplejson
-
-
-class CustomField(messages.MessageField):
-  """Custom MessageField class."""
-
-  type = int
-  message_type = message_types.VoidMessage
-
-  def __init__(self, number, **kwargs):
-    super(CustomField, self).__init__(self.message_type, number, **kwargs)
-
-  def value_to_message(self, value):
-    return self.message_type()
-
-
-class MyMessage(messages.Message):
-  """Test message containing various types."""
-
-  class Color(messages.Enum):
-
-    RED = 1
-    GREEN = 2
-    BLUE = 3
-
-  class Nested(messages.Message):
-
-    nested_value = messages.StringField(1)
-
-  a_string = messages.StringField(2)
-  an_integer = messages.IntegerField(3)
-  a_float = messages.FloatField(4)
-  a_boolean = messages.BooleanField(5)
-  an_enum = messages.EnumField(Color, 6)
-  a_nested = messages.MessageField(Nested, 7)
-  a_repeated = messages.IntegerField(8, repeated=True)
-  a_repeated_float = messages.FloatField(9, repeated=True)
-  a_datetime = message_types.DateTimeField(10)
-  a_repeated_datetime = message_types.DateTimeField(11, repeated=True)
-  a_custom = CustomField(12)
-  a_repeated_custom = CustomField(13, repeated=True)
-
-
-class ModuleInterfaceTest(test_util.ModuleInterfaceTest,
-                          test_util.TestCase):
-
-  MODULE = protojson
-
-
-# TODO(rafek): Convert this test to the compliance test in test_util.
-class ProtojsonTest(test_util.TestCase,
-                    test_util.ProtoConformanceTestBase):
-  """Test JSON encoding and decoding."""
-
-  PROTOLIB = protojson
-
-  def CompareEncoded(self, expected_encoded, actual_encoded):
-    """JSON encoding will be laundered to remove string differences."""
-    self.assertEquals(simplejson.loads(expected_encoded),
-                      simplejson.loads(actual_encoded))
-
-  encoded_empty_message = '{}'
-
-  encoded_partial = """{
-    "double_value": 1.23,
-    "int64_value": -100000000000,
-    "int32_value": 1020,
-    "string_value": "a string",
-    "enum_value": "VAL2"
-  }
-  """
-
-  encoded_full = """{
-    "double_value": 1.23,
-    "float_value": -2.5,
-    "int64_value": -100000000000,
-    "uint64_value": 102020202020,
-    "int32_value": 1020,
-    "bool_value": true,
-    "string_value": "a string\u044f",
-    "bytes_value": "YSBieXRlc//+",
-    "enum_value": "VAL2"
-  }
-  """
-
-  encoded_repeated = """{
-    "double_value": [1.23, 2.3],
-    "float_value": [-2.5, 0.5],
-    "int64_value": [-100000000000, 20],
-    "uint64_value": [102020202020, 10],
-    "int32_value": [1020, 718],
-    "bool_value": [true, false],
-    "string_value": ["a string\u044f", "another string"],
-    "bytes_value": ["YSBieXRlc//+", "YW5vdGhlciBieXRlcw=="],
-    "enum_value": ["VAL2", "VAL1"]
-  }
-  """
-
-  encoded_nested = """{
-    "nested": {
-      "a_value": "a string"
-    }
-  }
-  """
-
-  encoded_repeated_nested = """{
-    "repeated_nested": [{"a_value": "a string"},
-                        {"a_value": "another string"}]
-  }
-  """
-
-  unexpected_tag_message = '{"unknown": "value"}'
-
-  encoded_default_assigned = '{"a_value": "a default"}'
-
-  encoded_nested_empty = '{"nested": {}}'
-
-  encoded_repeated_nested_empty = '{"repeated_nested": [{}, {}]}'
-
-  encoded_extend_message = '{"int64_value": [400, 50, 6000]}'
-
-  encoded_string_types = '{"string_value": "Latin"}'
-
-  encoded_invalid_enum = '{"enum_value": "undefined"}'
-
-  def testConvertIntegerToFloat(self):
-    """Test that integers passed in to float fields are converted.
-
-    This is necessary because JSON outputs integers for numbers with 0 decimals.
-    """
-    message = protojson.decode_message(MyMessage, '{"a_float": 10}')
-
-    self.assertTrue(isinstance(message.a_float, float))
-    self.assertEquals(10.0, message.a_float)
-
-  def testConvertStringToNumbers(self):
-    """Test that strings passed to integer fields are converted."""
-    message = protojson.decode_message(MyMessage,
-                                       """{"an_integer": "10",
-                                           "a_float": "3.5",
-                                           "a_repeated": ["1", "2"],
-                                           "a_repeated_float": ["1.5", "2", 10]
-                                           }""")
-
-    self.assertEquals(MyMessage(an_integer=10,
-                                a_float=3.5,
-                                a_repeated=[1, 2],
-                                a_repeated_float=[1.5, 2.0, 10.0]),
-                      message)
-
-  def testWrongTypeAssignment(self):
-    """Test when wrong type is assigned to a field."""
-    self.assertRaises(messages.ValidationError,
-                      protojson.decode_message,
-                      MyMessage, '{"a_string": 10}')
-    self.assertRaises(messages.ValidationError,
-                      protojson.decode_message,
-                      MyMessage, '{"an_integer": 10.2}')
-    self.assertRaises(messages.ValidationError,
-                      protojson.decode_message,
-                      MyMessage, '{"an_integer": "10.2"}')
-
-  def testNumericEnumeration(self):
-    """Test that numbers work for enum values."""
-    message = protojson.decode_message(MyMessage, '{"an_enum": 2}')
-
-    expected_message = MyMessage()
-    expected_message.an_enum = MyMessage.Color.GREEN
-
-    self.assertEquals(expected_message, message)
-
-  def testNumericEnumerationNegativeTest(self):
-    """Test with an invalid number for the enum value."""
-    self.assertRaisesRegexp(
-        messages.DecodeError,
-        'Invalid enum value "89"',
-        protojson.decode_message,
-        MyMessage,
-        '{"an_enum": 89}')
-
-  def testAlphaEnumeration(self):
-    """Test that alpha enum values work."""
-    message = protojson.decode_message(MyMessage, '{"an_enum": "RED"}')
-
-    expected_message = MyMessage()
-    expected_message.an_enum = MyMessage.Color.RED
-
-    self.assertEquals(expected_message, message)
-
-  def testAlphaEnumerationNegativeTest(self):
-    """The alpha enum value is invalid."""
-    self.assertRaisesRegexp(
-        messages.DecodeError,
-        'Invalid enum value "IAMINVALID"',
-        protojson.decode_message,
-        MyMessage,
-        '{"an_enum": "IAMINVALID"}')
-
-  def testEnumerationNegativeTestWithEmptyString(self):
-    """The enum value is an empty string."""
-    self.assertRaisesRegexp(
-        messages.DecodeError,
-        'Invalid enum value ""',
-        protojson.decode_message,
-        MyMessage,
-        '{"an_enum": ""}')
-
-  def testNullValues(self):
-    """Test that null values overwrite existing values."""
-    self.assertEquals(MyMessage(),
-                      protojson.decode_message(MyMessage,
-                                               ('{"an_integer": null,'
-                                                ' "a_nested": null,'
-                                                ' "an_enum": null'
-                                                '}')))
-
-  def testEmptyList(self):
-    """Test that empty lists are ignored."""
-    self.assertEquals(MyMessage(),
-                      protojson.decode_message(MyMessage,
-                                               '{"a_repeated": []}'))
-
-  def testNotJSON(self):
-    """Test error when string is not valid JSON."""
-    self.assertRaises(ValueError,
-                      protojson.decode_message, MyMessage, '{this is not json}')
-
-  def testDoNotEncodeStrangeObjects(self):
-    """Test trying to encode a strange object.
-
-    The main purpose of this test is to complete coverage.  It ensures that
-    the default behavior of the JSON encoder is preserved when someone tries to
-    serialized an unexpected type.
-    """
-    class BogusObject(object):
-
-      def check_initialized(self):
-        pass
-
-    self.assertRaises(TypeError,
-                      protojson.encode_message,
-                      BogusObject())
-
-  def testMergeEmptyString(self):
-    """Test merging the empty or space only string."""
-    message = protojson.decode_message(test_util.OptionalMessage, '')
-    self.assertEquals(test_util.OptionalMessage(), message)
-
-    message = protojson.decode_message(test_util.OptionalMessage, ' ')
-    self.assertEquals(test_util.OptionalMessage(), message)
-
-  def testProtojsonUnrecognizedFieldName(self):
-    """Test that unrecognized fields are saved and can be accessed."""
-    decoded = protojson.decode_message(MyMessage,
-                                       ('{"an_integer": 1, "unknown_val": 2}'))
-    self.assertEquals(decoded.an_integer, 1)
-    self.assertEquals(1, len(decoded.all_unrecognized_fields()))
-    self.assertEquals('unknown_val', decoded.all_unrecognized_fields()[0])
-    self.assertEquals((2, messages.Variant.INT64),
-                      decoded.get_unrecognized_field_info('unknown_val'))
-
-  def testProtojsonUnrecognizedFieldNumber(self):
-    """Test that unrecognized fields are saved and can be accessed."""
-    decoded = protojson.decode_message(
-        MyMessage,
-        '{"an_integer": 1, "1001": "unknown", "-123": "negative", '
-        '"456_mixed": 2}')
-    self.assertEquals(decoded.an_integer, 1)
-    self.assertEquals(3, len(decoded.all_unrecognized_fields()))
-    self.assertTrue(1001 in decoded.all_unrecognized_fields())
-    self.assertEquals(('unknown', messages.Variant.STRING),
-                      decoded.get_unrecognized_field_info(1001))
-    self.assertTrue('-123' in decoded.all_unrecognized_fields())
-    self.assertEquals(('negative', messages.Variant.STRING),
-                      decoded.get_unrecognized_field_info('-123'))
-    self.assertTrue('456_mixed' in decoded.all_unrecognized_fields())
-    self.assertEquals((2, messages.Variant.INT64),
-                      decoded.get_unrecognized_field_info('456_mixed'))
-
-  def testProtojsonUnrecognizedNull(self):
-    """Test that unrecognized fields that are None are skipped."""
-    decoded = protojson.decode_message(
-        MyMessage,
-        '{"an_integer": 1, "unrecognized_null": null}')
-    self.assertEquals(decoded.an_integer, 1)
-    self.assertEquals(decoded.all_unrecognized_fields(), [])
-
-  def testUnrecognizedFieldVariants(self):
-    """Test that unrecognized fields are mapped to the right variants."""
-    for encoded, expected_variant in (
-        ('{"an_integer": 1, "unknown_val": 2}', messages.Variant.INT64),
-        ('{"an_integer": 1, "unknown_val": 2.0}', messages.Variant.DOUBLE),
-        ('{"an_integer": 1, "unknown_val": "string value"}',
-         messages.Variant.STRING),
-        ('{"an_integer": 1, "unknown_val": [1, 2, 3]}', messages.Variant.INT64),
-        ('{"an_integer": 1, "unknown_val": [1, 2.0, 3]}',
-         messages.Variant.DOUBLE),
-        ('{"an_integer": 1, "unknown_val": [1, "foo", 3]}',
-         messages.Variant.STRING),
-        ('{"an_integer": 1, "unknown_val": true}', messages.Variant.BOOL)):
-      decoded = protojson.decode_message(MyMessage, encoded)
-      self.assertEquals(decoded.an_integer, 1)
-      self.assertEquals(1, len(decoded.all_unrecognized_fields()))
-      self.assertEquals('unknown_val', decoded.all_unrecognized_fields()[0])
-      _, decoded_variant = decoded.get_unrecognized_field_info('unknown_val')
-      self.assertEquals(expected_variant, decoded_variant)
-
-  def testDecodeDateTime(self):
-    for datetime_string, datetime_vals in (
-        ('2012-09-30T15:31:50.262', (2012, 9, 30, 15, 31, 50, 262000)),
-        ('2012-09-30T15:31:50', (2012, 9, 30, 15, 31, 50, 0))):
-      message = protojson.decode_message(
-          MyMessage, '{"a_datetime": "%s"}' % datetime_string)
-      expected_message = MyMessage(
-          a_datetime=datetime.datetime(*datetime_vals))
-
-      self.assertEquals(expected_message, message)
-
-  def testDecodeInvalidDateTime(self):
-    self.assertRaises(messages.DecodeError, protojson.decode_message,
-                      MyMessage, '{"a_datetime": "invalid"}')
-
-  def testEncodeDateTime(self):
-    for datetime_string, datetime_vals in (
-        ('2012-09-30T15:31:50.262000', (2012, 9, 30, 15, 31, 50, 262000)),
-        ('2012-09-30T15:31:50.262123', (2012, 9, 30, 15, 31, 50, 262123)),
-        ('2012-09-30T15:31:50', (2012, 9, 30, 15, 31, 50, 0))):
-      decoded_message = protojson.encode_message(
-          MyMessage(a_datetime=datetime.datetime(*datetime_vals)))
-      expected_decoding = '{"a_datetime": "%s"}' % datetime_string
-      self.CompareEncoded(expected_decoding, decoded_message)
-
-  def testDecodeRepeatedDateTime(self):
-    message = protojson.decode_message(
-        MyMessage,
-        '{"a_repeated_datetime": ["2012-09-30T15:31:50.262", '
-        '"2010-01-21T09:52:00", "2000-01-01T01:00:59.999999"]}')
-    expected_message = MyMessage(
-        a_repeated_datetime=[
-            datetime.datetime(2012, 9, 30, 15, 31, 50, 262000),
-            datetime.datetime(2010, 1, 21, 9, 52),
-            datetime.datetime(2000, 1, 1, 1, 0, 59, 999999)])
-
-    self.assertEquals(expected_message, message)
-
-  def testDecodeCustom(self):
-    message = protojson.decode_message(MyMessage, '{"a_custom": 1}')
-    self.assertEquals(MyMessage(a_custom=1), message)
-
-  def testDecodeInvalidCustom(self):
-    self.assertRaises(messages.ValidationError, protojson.decode_message,
-                      MyMessage, '{"a_custom": "invalid"}')
-
-  def testEncodeCustom(self):
-    decoded_message = protojson.encode_message(MyMessage(a_custom=1))
-    self.CompareEncoded('{"a_custom": 1}', decoded_message)
-
-  def testDecodeRepeatedCustom(self):
-    message = protojson.decode_message(
-        MyMessage, '{"a_repeated_custom": [1, 2, 3]}')
-    self.assertEquals(MyMessage(a_repeated_custom=[1, 2, 3]), message)
-
-  def testDecodeBadBase64BytesField(self):
-    """Test decoding improperly encoded base64 bytes value."""
-    self.assertRaisesWithRegexpMatch(
-        messages.DecodeError,
-        'Base64 decoding error: Incorrect padding',
-        protojson.decode_message,
-        test_util.OptionalMessage,
-        '{"bytes_value": "abcdefghijklmnopq"}')
-
-
-class CustomProtoJson(protojson.ProtoJson):
-
-  def encode_field(self, field, value):
-    return '{encoded}' + value
-
-  def decode_field(self, field, value):
-    return '{decoded}' + value
-
-
-class CustomProtoJsonTest(test_util.TestCase):
-  """Tests for serialization overriding functionality."""
-
-  def setUp(self):
-    self.protojson = CustomProtoJson()
-
-  def testEncode(self):
-    self.assertEqual('{"a_string": "{encoded}xyz"}',
-                     self.protojson.encode_message(MyMessage(a_string='xyz')))
-
-  def testDecode(self):
-    self.assertEqual(
-        MyMessage(a_string='{decoded}xyz'),
-        self.protojson.decode_message(MyMessage, '{"a_string": "xyz"}'))
-
-  def testDecodeEmptyMessage(self):
-    self.assertEqual(
-        MyMessage(a_string='{decoded}'),
-        self.protojson.decode_message(MyMessage, '{"a_string": ""}'))
-
-  def testDefault(self):
-    self.assertTrue(protojson.ProtoJson.get_default(),
-                    protojson.ProtoJson.get_default())
-
-    instance = CustomProtoJson()
-    protojson.ProtoJson.set_default(instance)
-    self.assertTrue(instance is protojson.ProtoJson.get_default())
-
-
-class InvalidJsonModule(object):
-  pass
-
-
-class ValidJsonModule(object):
-  class JSONEncoder(object):
-    pass
-
-
-class TestJsonDependencyLoading(test_util.TestCase):
-  """Test loading various implementations of json."""
-
-  def get_import(self):
-    """Get __import__ method.
-
-    Returns:
-      The current __import__ method.
-    """
-    if isinstance(__builtins__, dict):
-      return __builtins__['__import__']
-    else:
-      return __builtins__.__import__
-
-  def set_import(self, new_import):
-    """Set __import__ method.
-
-    Args:
-      new_import: Function to replace __import__.
-    """
-    if isinstance(__builtins__, dict):
-      __builtins__['__import__'] = new_import
-    else:
-      __builtins__.__import__ = new_import
-
-  def setUp(self):
-    """Save original import function."""
-    self.simplejson = sys.modules.pop('simplejson', None)
-    self.json = sys.modules.pop('json', None)
-    self.original_import = self.get_import()
-    def block_all_jsons(name, *args, **kwargs):
-      if 'json' in name:
-        if name in sys.modules:
-          module = sys.modules[name]
-          module.name = name
-          return module
-        raise ImportError('Unable to find %s' % name)
-      else:
-        return self.original_import(name, *args, **kwargs)
-    self.set_import(block_all_jsons)
-
-  def tearDown(self):
-    """Restore original import functions and any loaded modules."""
-
-    def reset_module(name, module):
-      if module:
-        sys.modules[name] = module
-      else:
-        sys.modules.pop(name, None)
-    reset_module('simplejson', self.simplejson)
-    reset_module('json', self.json)
-    imp.reload(protojson)
-
-  def testLoadProtojsonWithValidJsonModule(self):
-    """Test loading protojson module with a valid json dependency."""
-    sys.modules['json'] = ValidJsonModule
-
-    # This will cause protojson to reload with the default json module
-    # instead of simplejson.
-    imp.reload(protojson)
-    self.assertEquals('json', protojson.json.name)
-
-  def testLoadProtojsonWithSimplejsonModule(self):
-    """Test loading protojson module with simplejson dependency."""
-    sys.modules['simplejson'] = ValidJsonModule
-
-    # This will cause protojson to reload with the default json module
-    # instead of simplejson.
-    imp.reload(protojson)
-    self.assertEquals('simplejson', protojson.json.name)
-
-  def testLoadProtojsonWithInvalidJsonModule(self):
-    """Loading protojson module with an invalid json defaults to simplejson."""
-    sys.modules['json'] = InvalidJsonModule
-    sys.modules['simplejson'] = ValidJsonModule
-
-    # Ignore bad module and default back to simplejson.
-    imp.reload(protojson)
-    self.assertEquals('simplejson', protojson.json.name)
-
-  def testLoadProtojsonWithInvalidJsonModuleAndNoSimplejson(self):
-    """Loading protojson module with invalid json and no simplejson."""
-    sys.modules['json'] = InvalidJsonModule
-
-    # Bad module without simplejson back raises errors.
-    self.assertRaisesWithRegexpMatch(
-        ImportError,
-        'json library "json" is not compatible with ProtoRPC',
-        imp.reload,
-        protojson)
-
-  def testLoadProtojsonWithNoJsonModules(self):
-    """Loading protojson module with invalid json and no simplejson."""
-    # No json modules raise the first exception.
-    self.assertRaisesWithRegexpMatch(
-        ImportError,
-        'Unable to find json',
-        imp.reload,
-        protojson)
-
-
-if __name__ == '__main__':
-  unittest.main()