code: def testByteSizeFunctions(self):
      # Test all numeric *ByteSize() functions.
      NUMERIC_ARGS = [
          # Int32ByteSize().
          [wire_format.Int32ByteSize, 0, 1],
          [wire_format.Int32ByteSize, 127, 1],
          [wire_format.Int32ByteSize, 128, 2],
          [wire_format.Int32ByteSize, -1, 10],
          # Int64ByteSize().
          [wire_format.Int64ByteSize, 0, 1],
          [wire_format.Int64ByteSize, 127, 1],
          [wire_format.Int64ByteSize, 128, 2],
          [wire_format.Int64ByteSize, -1, 10],
          # UInt32ByteSize().
          [wire_format.UInt32ByteSize, 0, 1],
          [wire_format.UInt32ByteSize, 127, 1],
          [wire_format.UInt32ByteSize, 128, 2],
          [wire_format.UInt32ByteSize, wire_format.UINT32_MAX, 5],
          # UInt64ByteSize().
          [wire_format.UInt64ByteSize, 0, 1],
          [wire_format.UInt64ByteSize, 127, 1],
          [wire_format.UInt64ByteSize, 128, 2],
          [wire_format.UInt64ByteSize, wire_format.UINT64_MAX, 10],
          # SInt32ByteSize().
          [wire_format.SInt32ByteSize, 0, 1],
          [wire_format.SInt32ByteSize, -1, 1],
          [wire_format.SInt32ByteSize, 1, 1],
          [wire_format.SInt32ByteSize, -63, 1],
          [wire_format.SInt32ByteSize, 63, 1],
          [wire_format.SInt32ByteSize, -64, 1],
          [wire_format.SInt32ByteSize, 64, 2],
          # SInt64ByteSize().
          [wire_format.SInt64ByteSize, 0, 1],
          [wire_format.SInt64ByteSize, -1, 1],
          [wire_format.SInt64ByteSize, 1, 1],
          [wire_format.SInt64ByteSize, -63, 1],
          [wire_format.SInt64ByteSize, 63, 1],
          [wire_format.SInt64ByteSize, -64, 1],
          [wire_format.SInt64ByteSize, 64, 2],
          # Fixed32ByteSize().
          [wire_format.Fixed32ByteSize, 0, 4],
          [wire_format.Fixed32ByteSize, wire_format.UINT32_MAX, 4],
          # Fixed64ByteSize().
          [wire_format.Fixed64ByteSize, 0, 8],
          [wire_format.Fixed64ByteSize, wire_format.UINT64_MAX, 8],
          # SFixed32ByteSize().
          [wire_format.SFixed32ByteSize, 0, 4],
          [wire_format.SFixed32ByteSize, wire_format.INT32_MIN, 4],
          [wire_format.SFixed32ByteSize, wire_format.INT32_MAX, 4],
          # SFixed64ByteSize().
          [wire_format.SFixed64ByteSize, 0, 8],
          [wire_format.SFixed64ByteSize, wire_format.INT64_MIN, 8],
          [wire_format.SFixed64ByteSize, wire_format.INT64_MAX, 8],
          # FloatByteSize().
          [wire_format.FloatByteSize, 0.0, 4],
          [wire_format.FloatByteSize, 1000000000.0, 4],
          [wire_format.FloatByteSize, -1000000000.0, 4],
          # DoubleByteSize().
          [wire_format.DoubleByteSize, 0.0, 8],
          [wire_format.DoubleByteSize, 1000000000.0, 8],
          [wire_format.DoubleByteSize, -1000000000.0, 8],
          # BoolByteSize().
          [wire_format.BoolByteSize, False, 1],
          [wire_format.BoolByteSize, True, 1],
          # EnumByteSize().
          [wire_format.EnumByteSize, 0, 1],
          [wire_format.EnumByteSize, 127, 1],
          [wire_format.EnumByteSize, 128, 2],
          [wire_format.EnumByteSize, wire_format.UINT32_MAX, 5],
      ]
      for args in NUMERIC_ARGS:
          self.NumericByteSizeTestHelper(*args)
  
      # Test strings and bytes.
      for byte_size_fn in (
          wire_format.StringByteSize,
          wire_format.BytesByteSize,
      ):
          # 1 byte for tag, 1 byte for length, 3 bytes for contents.
          self.assertEqual(5, byte_size_fn(10, "abc"))
          # 2 bytes for tag, 1 byte for length, 3 bytes for contents.
          self.assertEqual(6, byte_size_fn(16, "abc"))
          # 2 bytes for tag, 2 bytes for length, 128 bytes for contents.
          self.assertEqual(132, byte_size_fn(16, "a" * 128))
  
      # Test UTF-8 string byte size calculation.
      # 1 byte for tag, 1 byte for length, 8 bytes for content.
      self.assertEqual(
          10,
          wire_format.StringByteSize(
              5, b"\xd0\xa2\xd0\xb5\xd1\x81\xd1\x82".decode("utf-8")
          ),
      )
  
      class MockMessage(object):
          def __init__(self, byte_size):
              self.byte_size = byte_size
  
          def ByteSize(self):
              return self.byte_size
  
      message_byte_size = 10
      mock_message = MockMessage(byte_size=message_byte_size)
      # Test groups.
      # (2 * 1) bytes for begin and end tags, plus message_byte_size.
      self.assertEqual(
          2 + message_byte_size,
          wire_format.GroupByteSize(1, mock_message),
      )
      # (2 * 2) bytes for begin and end tags, plus message_byte_size.
      self.assertEqual(
          4 + message_byte_size,
          wire_format.GroupByteSize(16, mock_message),
      )
  
      # Test messages.
      # 1 byte for tag, plus 1 byte for length, plus contents.
      self.assertEqual(
          2 + mock_message.byte_size,
          wire_format.MessageByteSize(1, mock_message),
      )
      # 2 bytes for tag, plus 1 byte for length, plus contents.
      self.assertEqual(
          3 + mock_message.byte_size,
          wire_format.MessageByteSize(16, mock_message),
      )
      # 2 bytes for tag, plus 2 bytes for length, plus contents.
      mock_message.byte_size = 128
      self.assertEqual(
          4 + mock_message.byte_size,
          wire_format.MessageByteSize(16, mock_message),
      )
  
      # Test message set item byte size.
      # 4 bytes for tags, plus 1 byte for length, plus 1 byte for type_id,
      # plus contents.
      mock_message.byte_size = 10
      self.assertEqual(
          mock_message.byte_size + 6,
          wire_format.MessageSetItemByteSize(1, mock_message),
      )
  
      # 4 bytes for tags, plus 2 bytes for length, plus 1 byte for type_id,
      # plus contents.
      mock_message.byte_size = 128
      self.assertEqual(
          mock_message.byte_size + 7,
          wire_format.MessageSetItemByteSize(1, mock_message),
      )
  
      # 4 bytes for tags, plus 2 bytes for length, plus 2 byte for type_id,
      # plus contents.
      self.assertEqual(
          mock_message.byte_size + 8,
          wire_format.MessageSetItemByteSize(128, mock_message),
      )
  
      # Too-long varint.
      self.assertRaises(
          message.EncodeError, wire_format.UInt64ByteSize, 1, 1 << 128
      )
  
file_path: coremltools/deps/protobuf/python/google/protobuf/internal/wire_format_test.py
imports: from google.protobuf import message
  from google.protobuf.internal import wire_format
label_desc: Use image node_id 6 for calling the WireFormatTest obj's underlying member method code with example usage: obj.testByteSizeFunctions() and returns: self