How to use the websockify.websockifyserver.WebSockifyServer.EClose function in websockify

def test_empty_handshake_fails(self):
        server = self._get_server(daemon=True, ssl_only=0, idle_timeout=1)

        sock = FakeSocket('')

        def fake_select(rlist, wlist, xlist, timeout=None):
            return ([sock], [], [])

        self.stubs.Set(select, 'select', fake_select)
        self.assertRaises(
            websockifyserver.WebSockifyServer.EClose, server.do_handshake,
            sock, '127.0.0.1')

else:
                    if self.verify_client:
                        raise self.EClose("Client certificate verification requested, but this Python is too old.")
                    # new-style SSL wrapping is not needed, using to old style
                    retsock = ssl.wrap_socket(
                            sock,
                            server_side=True,
                            certfile=self.cert,
                            keyfile=self.key)
            except ssl.SSLError:
                _, x, _ = sys.exc_info()
                if x.args[0] == ssl.SSL_ERROR_EOF:
                    if len(x.args) > 1:
                        raise self.EClose(x.args[1])
                    else:
                        raise self.EClose("Got SSL_ERROR_EOF")
                else:
                    raise

        elif self.ssl_only:
            raise self.EClose("non-SSL connection received but disallowed")

        else:
            retsock = sock

        # If the address is like (host, port), we are extending it
        # with a flag indicating SSL. Not many other options
        # available...
        if len(address) == 2:
            address = (address[0], address[1], (retsock != sock))

        self.RequestHandlerClass(retsock, address, self)

ready = select.select([sock], [], [], 3)[0]

        if not ready:
            raise self.EClose("")
        # Peek, but do not read the data so that we have a opportunity
        # to SSL wrap the socket first
        handshake = sock.recv(1024, socket.MSG_PEEK)
        #self.msg("Handshake [%s]" % handshake)

        if not handshake:
            raise self.EClose("")

        elif handshake[0] in ("\x16", "\x80", 22, 128):
            # SSL wrap the connection
            if not ssl:
                raise self.EClose("SSL connection but no 'ssl' module")
            if not os.path.exists(self.cert):
                raise self.EClose("SSL connection but '%s' not found"
                                  % self.cert)
            retsock = None
            try:
                if (hasattr(ssl, 'create_default_context') 
                    and callable(ssl.create_default_context)):
                    # create new-style SSL wrapping for extended features
                    context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
                    if self.ssl_ciphers is not None:
                        context.set_ciphers(self.ssl_ciphers)
                    context.options = self.ssl_options
                    context.load_cert_chain(certfile=self.cert, keyfile=self.key, password=self.key_password)
                    if self.verify_client:
                        context.verify_mode = ssl.CERT_REQUIRED
                        if self.cafile:

sock,
                            server_side=True,
                            certfile=self.cert,
                            keyfile=self.key)
            except ssl.SSLError:
                _, x, _ = sys.exc_info()
                if x.args[0] == ssl.SSL_ERROR_EOF:
                    if len(x.args) > 1:
                        raise self.EClose(x.args[1])
                    else:
                        raise self.EClose("Got SSL_ERROR_EOF")
                else:
                    raise

        elif self.ssl_only:
            raise self.EClose("non-SSL connection received but disallowed")

        else:
            retsock = sock

        # If the address is like (host, port), we are extending it
        # with a flag indicating SSL. Not many other options
        # available...
        if len(address) == 2:
            address = (address[0], address[1], (retsock != sock))

        self.RequestHandlerClass(retsock, address, self)

        # Return the WebSockets socket which may be SSL wrapped
        return retsock

if self.ssl_ciphers is not None:
                        context.set_ciphers(self.ssl_ciphers)
                    context.options = self.ssl_options
                    context.load_cert_chain(certfile=self.cert, keyfile=self.key, password=self.key_password)
                    if self.verify_client:
                        context.verify_mode = ssl.CERT_REQUIRED
                        if self.cafile:
                            context.load_verify_locations(cafile=self.cafile)
                        else:
                            context.set_default_verify_paths()
                    retsock = context.wrap_socket(
                            sock,
                            server_side=True)
                else:
                    if self.verify_client:
                        raise self.EClose("Client certificate verification requested, but this Python is too old.")
                    # new-style SSL wrapping is not needed, using to old style
                    retsock = ssl.wrap_socket(
                            sock,
                            server_side=True,
                            certfile=self.cert,
                            keyfile=self.key)
            except ssl.SSLError:
                _, x, _ = sys.exc_info()
                if x.args[0] == ssl.SSL_ERROR_EOF:
                    if len(x.args) > 1:
                        raise self.EClose(x.args[1])
                    else:
                        raise self.EClose("Got SSL_ERROR_EOF")
                else:
                    raise

sock,
                            server_side=True)
                else:
                    if self.verify_client:
                        raise self.EClose("Client certificate verification requested, but this Python is too old.")
                    # new-style SSL wrapping is not needed, using to old style
                    retsock = ssl.wrap_socket(
                            sock,
                            server_side=True,
                            certfile=self.cert,
                            keyfile=self.key)
            except ssl.SSLError:
                _, x, _ = sys.exc_info()
                if x.args[0] == ssl.SSL_ERROR_EOF:
                    if len(x.args) > 1:
                        raise self.EClose(x.args[1])
                    else:
                        raise self.EClose("Got SSL_ERROR_EOF")
                else:
                    raise

        elif self.ssl_only:
            raise self.EClose("non-SSL connection received but disallowed")

        else:
            retsock = sock

        # If the address is like (host, port), we are extending it
        # with a flag indicating SSL. Not many other options
        # available...
        if len(address) == 2:
            address = (address[0], address[1], (retsock != sock))