def buildSymmetricKey(block_encryption_algorithm=BLOCK_ENCRYPTION_AES128_CBC):
    sym_key = Object()
    block_encryption_props = blockEncryptionProperties[block_encryption_algorithm]
    sym_key.sym_key = ''.join([chr(random.getrandbits(8)) for i in range(0, block_encryption_props['key_size'])])
    sym_key.iv = ''.join([chr(random.getrandbits(8)) for i in range(0, block_encryption_props['iv_size'])])
    sym_key.block_encryption_algorithm = block_encryption_algorithm
    return sym_key

 def __init__(self, node, **kwargs):
     Object.__init__(self)
     self.node = node
     self.data = None
     self.text = None
     for k,v in kwargs.items():
         setattr(self, k, v)

    def __init__(self, name, expire, record_type, content):
        """
        Constructs a new DnsEntry of the form
        www  IN  86400   A       127.0.0.1
        mail IN  86400   CNAME   @

        Note that the IN class is always mandatory for this Entry and this is implied.

        :param name: the name of this DnsEntry, e.g. www, mail or @
        :param expire: the expiration period of the dns entry, in seconds. For example 86400 for a day
        :param record_type: the type of this entry, one of the TYPE_ constants in this class
        :param content: content of of the dns entry, for example '10 mail', '127.0.0.1' or 'www'
        :type name: basestring
        :type expire: int
        :type record_type: basestring
        :type content: basestring
        """

        # Call the parent __init__
        SudsObject.__init__(self)

        # Assign the fields
        self.name = name
        self.expire = expire
        self.type = record_type
        self.content = content

 def __init__(self):
     """ """
     Object.__init__(self)
     self.mustUnderstand = True
     self.tokens = []
     self.signatures = []
     self.references = []
     self.keys = []

 def __init__(self, options, sym_key=None):
     Object.__init__(self)
     self.key = options.key
     self.x509_issuer_serial = options.cert
     self.signed_parts = options.signedparts
     self.digest = options.digest
     self.keyReference = options.keyreference
     self.signatureAlgorithm = options.signaturealgorithm
     self.symmetricKey = sym_key

 def __init__(self, root):
     """
     @param root: An XML root element.
     @type root: L{Element}
     """
     Object.__init__(self)
     self.root = root
     pmd = Metadata()
     pmd.excludes = ['root']
     pmd.wrappers = dict(qname=repr)
     self.__metadata__.__print__ = pmd

    def test_error_handling(self):
        """See if our client returns the error properly"""
        # let's mock again
        self.locations.client.service.GetNearestLocations = mock.MagicMock()
        mock_error = SudsObject()
        mock_error.Fault = mock_error_result
        self.locations.client.service.GetNearestLocations.return_value = (500, mock_error)  # noqa

        # and call it
        result = self.locations.nearest_locations(postalcode="6821AD")
        self.assertEqual(result[0], 500)

 def __init__(self, ref=None):
     """
     @param ref: The schema reference being queried.
     @type ref: qref
     """
     Object.__init__(self)
     self.id = objid(self)
     self.ref = ref
     self.history = []
     self.resolved = False
     if not isqref(self.ref):
         raise Exception('%s, must be qref' % tostr(self.ref))

 def __init__(self, tag=None, value=None, **kwargs):
     """
     @param tag: The content tag.
     @type tag: str
     @param value: The content's value.
     @type value: I{any}
     """
     Object.__init__(self)
     self.tag = tag
     self.value = value
     for k,v in list(kwargs.items()):
         setattr(self, k, v)

 def __init__(self, root, definitions=None):
     """
     @param root: An XML root element.
     @type root: L{Element}
     @param definitions: A definitions object.
     @type definitions: L{Definitions}
     """
     Object.__init__(self)
     self.root = root
     pmd = SFactory.metadata()
     pmd.excludes = ['root']
     pmd.wrappers = dict(qname=lambda x: repr(x))
     self.__metadata__.__print__ = pmd

 def __init__(self, timestamp=False):
     """
     Create a new WS-Security object.
     @param timestamp: Whether or not to create a Security Timestamp
     @type timestamp: bool
     """
     Object.__init__(self)
     self.mustUnderstand = True
     self.timestamp = timestamp
     self.tokens = []
     self.signatures = []
     self.references = []
     self.keys = []

 def __init__(self, root, definitions=None):
     """
     @param root: An XML root element.
     @type root: L{Element}
     @param definitions: A definitions object.
     @type definitions: L{Definitions}
     """
     Object.__init__(self)
     self.root = root
     pmd = Metadata()
     pmd.excludes = ["root"]
     pmd.wrappers = dict(qname=repr)
     self.__metadata__.__print__ = pmd

 def __init__(self, tag=None, value=None, type=None):
     """
     @param tag: The content tag.
     @type tag: str
     @param value: The content's value.
     @type value: I{any}
     @param type: The (optional) content schema type.
     @type type: L{xsd.sxbase.SchemaObject}
     """
     Object.__init__(self)
     self.tag = tag
     self.value = value
     self.type = type

    def test_nearest_locations(self):
        """Test nearest PostNL Pickup locations based on postal code"""
        # first create a mock for the soap result
        mock_object = SudsObject()
        mock_object.GetLocationsResult = SudsObject()
        mock_object.GetLocationsResult.ResponseLocation = mock_result

        # mock the function call and return a almost like soap object
        self.locations.client.service.GetNearestLocations = mock.MagicMock()
        # the first param is the http status code
        self.locations.client.service.GetNearestLocations.return_value = (200, mock_object)  # noqa

        # do the call
        result = self.locations.nearest_locations(postalcode="6821AD")
        self.assertEqual(result, (200, mock_result))

    def __init__(self):
        Object.__init__(self)
        self.wsseEnabled = False
        self.includeTimestamp = False
        self.addressing = False
        self.headerLayout = None
        self.protectTokens = False
        self.onlySignEntireHeadersAndBody = False
        self.clientCertRequired = False
        self.blockEncryption = None
        self.digestAlgorithm = None
        self.keyTransport = None
        self.usernameRequired = False
        self.signatureRequired = False
        self.encryptionRequired = False
        self.encryptThenSign = False
        self.signedParts = []
        self.tokens = []
        self.signatures = []
        self.keys = []
	self.wsse11 = None

    def visitOther(self, elt):
        policy = self.policy
        wsdl_policy = self.wsdl_policy

        if elt.name == 'TransportBinding' or elt.name == 'SymmetricBinding' or elt.name == 'AsymmetricBinding':
            self.bindingType = elt.name
            binding = elt.getChild('Policy')

            policy.wsseEnabled = True
            if binding.getChild("IncludeTimestamp") is not None:
                policy.includeTimestamp = True
            if binding.getChild("EncryptBeforeSigning") is not None:
                policy.encryptThenSign = True
            if binding.getChild("EncryptSignature") is not None:
                if policy.encryptThenSign:
                    self.secondPassEncryptedParts.append(('signature',))
                else:
                    self.baseEncryptedParts.append(('signature',))
            if binding.getChild("OnlySignEntireHeadersAndBody") is not None:
                policy.onlySignEntireHeadersAndBody = True
            if binding.getChild("ProtectTokens") is not None:
                policy.protectTokens = True
            if binding.getChild("Layout") is not None:
                layout = binding.getChild("Layout").getChild("Policy")[0]
                policy.headerLayout = layout.name
            if elt.name == 'TransportBinding':
                transport_token = binding.getChild("TransportToken")
                if transport_token is not None:
                    if transport_token.getChild("Policy").getChild("HttpsToken") is not None:
                        https_token = transport_token.getChild("Policy").getChild("HttpsToken")
                        client_cert_req = https_token.get("RequireClientCertificate")
                        if client_cert_req is None or client_cert_req == "false":
                            policy.clientCertRequired = False
                        elif client_cert_req == "true":
                            policy.clientCertRequired = True
            if binding.getChild("InitiatorToken") is not None or binding.getChild("ProtectionToken") is not None:
                token = binding.getChild("InitiatorToken") or binding.getChild("ProtectionToken")
                if token.getChild("Policy").getChild("X509Token") is not None:
                    signature = Object()
                    signature.signedParts = self.buildParts(token.getChild("Policy").getChild("SignedParts"))
                    signature.signedParts.append(('timestamp',))
                    # This would technically be the correct behavior, but WCF specifies that thumbprint references
                    # are supported, but it can't use them for a primary signature.  Support for BinarySecurityTokens
                    # is always required, so just use them
                    #if token.getChild("Policy").getChild("X509Token").getChild("Policy").getChild("RequireThumbprintReference") is not None:
                    #    signature.keyReference = KEY_REFERENCE_FINGERPRINT
                    #elif token.getChild("Policy").getChild("X509Token").getChild("Policy").getChild("RequireIssuerSerialReference") is not None:
                    #    signature.keyReference = KEY_REFERENCE_ISSUER_SERIAL
                    #else:
                    #    signature.keyReference = KEY_REFERENCE_BINARY_SECURITY_TOKEN
                    if elt.name == 'AsymmetricBinding':
                        signature.keyReference = KEY_REFERENCE_BINARY_SECURITY_TOKEN
                        signature.signatureAlgorithm = SIGNATURE_RSA_SHA1
                    elif elt.name == 'SymmetricBinding':
                        signature.keyReference = KEY_REFERENCE_ENCRYPTED_KEY
                        signature.signatureAlgorithm = SIGNATURE_HMAC_SHA1
                    policy.signatures[0] = signature
            if (binding.getChild("InitiatorToken") is not None and binding.getChild("RecipientToken") is not None) or \
                binding.getChild("ProtectionToken") is not None:
                key = Object()
                token = binding.getChild("RecipientToken") or binding.getChild("ProtectionToken")
                if token.getChild("Policy").getChild("X509Token").getChild("Policy").getChild("RequireThumbprintReference") is not None:
                    key.keyReference = KEY_REFERENCE_FINGERPRINT
                elif token.getChild("Policy").getChild("X509Token").getChild("Policy").getChild("RequireIssuerSerialReference") is not None:
                    key.keyReference = KEY_REFERENCE_ISSUER_SERIAL
                else:
                    key.keyReference = KEY_REFERENCE_ISSUER_SERIAL
                if elt.name == 'AsymmetricBinding':
                    key.includeRefList = True
                elif elt.name == 'SymmetricBinding':
                    key.includeRefList = False
                key.encryptedParts = self.buildParts(token.getChild("Policy").getChild("EncryptedParts"))
                key.secondPassEncryptedParts = []
                policy.keys.append(key)
            if policy.blockEncryption is None:
                algorithm_suite = binding.getChild("AlgorithmSuite")
                if algorithm_suite is not None:
                    if algorithm_suite.getChild("Policy") is not None:
                        algorithm_policy_name = algorithm_suite.getChild("Policy").getChildren()[0].name
                        if "Basic128" in algorithm_policy_name:
                            policy.blockEncryption = BLOCK_ENCRYPTION_AES128_CBC
                        elif "Basic192" in algorithm_policy_name:
                            policy.blockEncryption = BLOCK_ENCRYPTION_AES192_CBC
                        elif "Basic256" in algorithm_policy_name:
                            policy.blockEncryption = BLOCK_ENCRYPTION_AES256_CBC
                        elif "TripleDes" in algorithm_policy_name:
                            policy.blockEncryption = BLOCK_ENCRYPTION_3DES_CBC
                        if "Sha256" in algorithm_policy_name:
                            policy.digestAlgorithm = DIGEST_SHA256
                        else:
                            policy.digestAlgorithm = DIGEST_SHA1
                        if "Rsa15" in algorithm_policy_name:
                            policy.keyTransport = KEY_TRANSPORT_RSA_1_5
                        else:
                            policy.keyTransport = KEY_TRANSPORT_RSA_OAEP

        if elt.name.endswith("Tokens") and self.initiator:
            type = None
            index = None
            if elt.getChild("Policy").getChild("UsernameToken") is not None:
#.........这里部分代码省略.........

 def __init__(self, ids):
     Object.__init__(self)
     self.EntityId = ids

except WebFault, f:
    errors += 1
    print f
    print f.fault
except Exception, e:
    errors += 1
    print e
    tb.print_exc()

try:
    array = client.factory.create('ArrayOf_xsd_string')
    print 'ArrayOf_xsd_string=\n%s' % array
    array.item = ['my', 'dog', 'likes', 'steak']
    result = client.service.printList(array)
    print '\nreply( %s )\n' % str(result)
    array = Object()
    print 'ArrayOf_xsd_string=\n%s' % array
    array.item = ['my', 'dog', 'likes', 'steak']
    result = client.service.printList(array)
    print '\nreply( %s )\n' % str(result)
except WebFault, f:
    errors += 1
    print f
    print f.fault
except Exception, e:
    errors += 1
    print e
    tb.print_exc()

try:
    s = 'hello'

 def __init__(self, node):
     Object.__init__(self)
     self.node = node
     self.data = None
     self.type = None
     self.text = None

 def __init__(self, method):
     Object.__init__(self)
     self.method = method