qpid-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From acon...@apache.org
Subject [01/11] qpid-proton git commit: PROTON-1798: [c, cpp] self-contained test scripts.
Date Fri, 06 Jul 2018 16:59:13 GMT
Repository: qpid-proton
Updated Branches:
  refs/heads/master ea315ff04 -> 9778eda8e


PROTON-1798: [c,cpp] self-contained test scripts.

Simplify python test scripts for C and C++, get rid of the proctest.py common
library.  Each test script is now self-contained using only standard python 2.7.


Project: http://git-wip-us.apache.org/repos/asf/qpid-proton/repo
Commit: http://git-wip-us.apache.org/repos/asf/qpid-proton/commit/e2858e6a
Tree: http://git-wip-us.apache.org/repos/asf/qpid-proton/tree/e2858e6a
Diff: http://git-wip-us.apache.org/repos/asf/qpid-proton/diff/e2858e6a

Branch: refs/heads/master
Commit: e2858e6afd15581d8f8b029ce76a175bb5ea41da
Parents: ea315ff
Author: Alan Conway <aconway@redhat.com>
Authored: Wed Jul 4 15:43:16 2018 -0400
Committer: Alan Conway <aconway@redhat.com>
Committed: Fri Jul 6 12:16:32 2018 -0400

----------------------------------------------------------------------
 c/examples/CMakeLists.txt    |   6 +-
 c/examples/broker.c          |   4 +-
 c/examples/direct.c          |   4 +-
 c/examples/example_test.py   |  77 ++++++-------
 c/examples/receive.c         |   2 +-
 c/tests/CMakeLists.txt       |   2 -
 c/tests/fdlimit.py           |  44 +++-----
 cpp/examples/CMakeLists.txt  |   6 +-
 cpp/examples/broker.cpp      |  13 +--
 cpp/examples/example_test.py | 167 +++++++++++-----------------
 tools/python/proctest.py     | 227 --------------------------------------
 11 files changed, 121 insertions(+), 431 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/c/examples/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/c/examples/CMakeLists.txt b/c/examples/CMakeLists.txt
index 6f732a6..17438d0 100644
--- a/c/examples/CMakeLists.txt
+++ b/c/examples/CMakeLists.txt
@@ -53,12 +53,8 @@ macro(set_search_path result)
   file(TO_NATIVE_PATH "${${result}}" ${result}) # native slash separators
 endmacro()
 
-# Add the tools directory for the 'proctest' module
-set_search_path(EXAMPLE_PYTHONPATH "${CMAKE_SOURCE_DIR}/tools/python" "$ENV{PYTHON_PATH}")
-set(EXAMPLE_ENV "PYTHONPATH=${EXAMPLE_PYTHONPATH}")
-
 add_test(
   NAME c-example-tests
-  COMMAND ${PN_ENV_SCRIPT} ${EXAMPLE_ENV} "PATH=${test_path}" ${VALGRIND_ENV} --
+  COMMAND ${PN_ENV_SCRIPT} "PATH=${test_path}" ${VALGRIND_ENV} --
           ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/example_test.py -v
   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/c/examples/broker.c
----------------------------------------------------------------------
diff --git a/c/examples/broker.c b/c/examples/broker.c
index dcb0158..d2591df 100644
--- a/c/examples/broker.c
+++ b/c/examples/broker.c
@@ -364,8 +364,8 @@ static void handle(broker_t* b, pn_event_t* e) {
        m->start = (char*)realloc(m->start, m->size);
        recv = pn_link_recv(l, m->start, m->size);
        if (recv == PN_ABORTED) { /*  */
-         fprintf(stderr, "Message aborted\n");
-         fflush(stderr);
+         printf("Message aborted\n");
+         fflush(stdout);
          m->size = 0;           /* Forget the data we accumulated */
          pn_delivery_settle(d); /* Free the delivery so we can receive the next message */
          pn_link_flow(l, WINDOW - pn_link_credit(l)); /* Replace credit for the aborted message
*/

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/c/examples/direct.c
----------------------------------------------------------------------
diff --git a/c/examples/direct.c b/c/examples/direct.c
index fd0c3a4..a990663 100644
--- a/c/examples/direct.c
+++ b/c/examples/direct.c
@@ -132,8 +132,8 @@ static void handle_receive(app_data_t *app, pn_event_t* event) {
        m->start = (char*)realloc(m->start, m->size);
        recv = pn_link_recv(l, m->start, m->size);
        if (recv == PN_ABORTED) {
-         fprintf(stderr, "Message aborted\n");
-         fflush(stderr);
+         printf("Message aborted\n");
+         fflush(stdout);
          m->size = 0;           /* Forget the data we accumulated */
          pn_delivery_settle(d); /* Free the delivery so we can receive the next message */
          pn_link_flow(l, 1);    /* Replace credit for aborted message */

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/c/examples/example_test.py
----------------------------------------------------------------------
diff --git a/c/examples/example_test.py b/c/examples/example_test.py
index 25a089b..f7aa911 100644
--- a/c/examples/example_test.py
+++ b/c/examples/example_test.py
@@ -17,112 +17,99 @@
 # under the License
 #
 
-# This is a test script to run the examples and verify that they behave as expected.
+# Run the C examples and verify that they behave as expected.
+# Example executables must be in PATH
 
-import unittest, sys, time
-from proctest import *
-
-def python_cmd(name):
-    dir = os.path.dirname(__file__)
-    return [sys.executable, os.path.join(dir, "..", "..", "python", name)]
+import unittest, sys, time, re
+from subprocess import Popen, PIPE, check_output, CalledProcessError, STDOUT
 
 MESSAGES=10
 
 def receive_expect_messages(n=MESSAGES): return ''.join(['{"sequence"=%s}\n'%i for i in range(1,
n+1)])
 def receive_expect_total(n=MESSAGES): return "%s messages received\n"%n
 def receive_expect(n=MESSAGES): return receive_expect_messages(n)+receive_expect_total(n)
-
 def send_expect(n=MESSAGES): return "%s messages sent and acknowledged\n" % n
 def send_abort_expect(n=MESSAGES): return "%s messages started and aborted\n" % n
 
-def wait_listening(proc):
-    m = proc.wait_re("listening on ([0-9]+)$")
-    return m.group(1), m.group(0)+"\n" # Return (port, line)
+def wait_listening(p):
+    return re.search("listening on ([0-9]+)$", p.stdout.readline()).group(1)
 
-class Broker(object):
-    def __init__(self, test):
-        self.test = test
+class Broker(Popen):
+    def __init__(self):
+        super(Broker, self).__init__(["broker", "", "0"], stdout=PIPE)
 
     def __enter__(self):
-        self.proc = self.test.proc(["broker", "", "0"])
-        self.port, _ = wait_listening(self.proc)
+        self.port = wait_listening(self)
         return self
 
     def __exit__(self, *args):
-        b = getattr(self, "proc")
-        if b:
-            if b.poll() !=  None: # Broker crashed
-                raise ProcError(b, "broker crash")
-            b.kill()
+        self.kill()
 
-class CExampleTest(ProcTestCase):
+class ExampleTest(unittest.TestCase):
 
     def runex(self, name, port, messages=MESSAGES):
         """Run an example with standard arguments, return output"""
-        return self.proc([name, "", str(port), "xtest", str(messages)]).wait_exit()
+        return check_output([name, "", str(port), "xtest", str(messages)], stderr=STDOUT)
 
     def test_send_receive(self):
         """Send first then receive"""
-        with Broker(self) as b:
+        with Broker() as b:
             self.assertEqual(send_expect(), self.runex("send", b.port))
             self.assertMultiLineEqual(receive_expect(), self.runex("receive", b.port))
 
     def test_receive_send(self):
         """Start receiving  first, then send."""
-        with Broker(self) as b:
+        with Broker() as b:
             self.assertEqual(send_expect(), self.runex("send", b.port))
             self.assertMultiLineEqual(receive_expect(), self.runex("receive", b.port))
 
     def test_send_direct(self):
         """Send to direct server"""
-        d = self.proc(["direct", "", "0"])
-        port, line = wait_listening(d)
+        d = Popen(["direct", "", "0"], stdout=PIPE)
+        port = wait_listening(d)
         self.assertEqual(send_expect(), self.runex("send", port))
-        self.assertMultiLineEqual(line+receive_expect(), d.wait_exit())
+        self.assertMultiLineEqual(receive_expect(), d.communicate()[0])
 
     def test_receive_direct(self):
         """Receive from direct server"""
-        d = self.proc(["direct", "", "0"])
-        port, line = wait_listening(d)
+        d = Popen(["direct", "", "0"], stdout=PIPE)
+        port = wait_listening(d)
         self.assertMultiLineEqual(receive_expect(), self.runex("receive", port))
-        self.assertEqual(line+"10 messages sent and acknowledged\n", d.wait_exit())
+        self.assertEqual("10 messages sent and acknowledged\n", d.communicate()[0])
 
     def test_send_abort_broker(self):
         """Sending aborted messages to a broker"""
-        with Broker(self) as b:
+        with Broker() as b:
             self.assertEqual(send_expect(), self.runex("send", b.port))
             self.assertEqual(send_abort_expect(), self.runex("send-abort", b.port))
-            b.proc.wait_re("Message aborted\n"*MESSAGES)
+            for i in xrange(MESSAGES):
+                self.assertEqual("Message aborted\n", b.stdout.readline())
             self.assertEqual(send_expect(), self.runex("send", b.port))
             expect = receive_expect_messages(MESSAGES)+receive_expect_messages(MESSAGES)+receive_expect_total(20)
             self.assertMultiLineEqual(expect, self.runex("receive", b.port, "20"))
 
     def test_send_abort_direct(self):
         """Send aborted messages to the direct server"""
-        d = self.proc(["direct", "", "0", "examples", "20"])
-        port, line = wait_listening(d)
-        expect = line
+        d = Popen(["direct", "", "0", "examples", "20"], stdout=PIPE)
+        port = wait_listening(d)
         self.assertEqual(send_expect(), self.runex("send", port))
-        expect += receive_expect_messages()
-        d.wait_re(expect)
         self.assertEqual(send_abort_expect(), self.runex("send-abort", port))
-        expect += "Message aborted\n"*MESSAGES
-        d.wait_re(expect)
         self.assertEqual(send_expect(), self.runex("send", port))
-        expect += receive_expect_messages()+receive_expect_total(20)
+        expect = receive_expect_messages() + "Message aborted\n"*MESSAGES + receive_expect_messages()+receive_expect_total(20)
         self.maxDiff = None
-        self.assertMultiLineEqual(expect, d.wait_exit())
+        self.assertMultiLineEqual(expect, d.communicate()[0])
 
     def test_send_ssl_receive(self):
         """Send with SSL, then receive"""
         try:
-            with Broker(self) as b:
+            with Broker() as b:
                 got = self.runex("send-ssl", b.port)
                 self.assertIn("secure connection:", got)
                 self.assertIn(send_expect(), got)
                 self.assertMultiLineEqual(receive_expect(), self.runex("receive", b.port))
-        except ProcError as e:
-            if e.out.startswith("error initializing SSL"):
+        except CalledProcessError as e:
+            print "FIXME", e.output
+            if e.output.startswith("error initializing SSL"):
                 print("Skipping %s: SSL not available" % self.id())
             else:
                 raise

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/c/examples/receive.c
----------------------------------------------------------------------
diff --git a/c/examples/receive.c b/c/examples/receive.c
index 8280345..c70e0d8 100644
--- a/c/examples/receive.c
+++ b/c/examples/receive.c
@@ -105,7 +105,7 @@ static bool handle(app_data_t* app, pn_event_t* event) {
        m->start = (char*)realloc(m->start, m->size);
        recv = pn_link_recv(l, m->start + oldsize, m->size);
        if (recv == PN_ABORTED) {
-         fprintf(stderr, "Message aborted\n");
+         printf("Message aborted\n");
          m->size = 0;           /* Forget the data we accumulated */
          pn_delivery_settle(d); /* Free the delivery so we can receive the next message */
          pn_link_flow(l, 1);    /* Replace credit for aborted message */

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/c/tests/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/c/tests/CMakeLists.txt b/c/tests/CMakeLists.txt
index 7283c87..c79cda4 100644
--- a/c/tests/CMakeLists.txt
+++ b/c/tests/CMakeLists.txt
@@ -78,8 +78,6 @@ if(HAS_PROACTOR)
   else(WIN32)
     set(path "$<TARGET_FILE_DIR:c-broker>:$ENV{PATH}")
   endif(WIN32)
-  # Add the tools directory for the 'proctest' module
-  set_search_path(pypath "${CMAKE_SOURCE_DIR}/tools/python" "$ENV{PYTHON_PATH}")
 
   add_test(NAME c-fdlimit-tests COMMAND ${PN_ENV_SCRIPT} -- "PATH=${path}" "PYTHONPATH=${pypath}"
${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/fdlimit.py)
 endif(HAS_PROACTOR)

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/c/tests/fdlimit.py
----------------------------------------------------------------------
diff --git a/c/tests/fdlimit.py b/c/tests/fdlimit.py
index 57faef8..4836140 100644
--- a/c/tests/fdlimit.py
+++ b/c/tests/fdlimit.py
@@ -18,28 +18,23 @@
 #
 from __future__ import print_function
 
-from proctest import *
+import os, sys
+from subprocess import Popen, PIPE
 
-def wait_listening(proc):
-    m = proc.wait_re("listening on ([0-9]+)$")
-    return m.group(1), m.group(0)+"\n" # Return (port, line)
+def wait_listening(p):
+    return re.search("listening on ([0-9]+)$", p.stdout.readline()).group(1)
 
-class LimitedBroker(object):
-    def __init__(self, test, fdlimit):
-        self.test = test
+class LimitedBroker(Popen):
+    def __init__(self, fdlimit):
+        super(LimitedBroker, self).__init__(["broker", "", "0"], stdout=PIPE, stderr=open(os.devnull))
         self.fdlimit = fdlimit
 
     def __enter__(self):
-        self.proc = self.test.proc(["broker", "", "0"])
-        self.port, _ = wait_listening(self.proc)
+        self.port = wait_listening(self)
         return self
 
     def __exit__(self, *args):
-        b = getattr(self, "proc")
-        if b:
-            if b.poll() not in [1, None]: # Broker crashed or got expected connection error
-                raise ProcError(b, "broker crash")
-            b.kill()
+        self.kill()
 
 # Check if we can run prlimit to control resources
 try:
@@ -50,36 +45,27 @@ except:
 
 class FdLimitTest(ProcTestCase):
 
-    def proc(self, *args, **kwargs):
-        """Skip valgrind for all processes started by this test"""
-        return super(FdLimitTest, self).proc(*args, valgrind=False, **kwargs)
-
     def test_fd_limit_broker(self):
         """Check behaviour when running out of file descriptors on accept"""
         # Not too many FDs but not too few either, some are used for system purposes.
         fdlimit = 256
-        with LimitedBroker(self, fdlimit) as b:
+        with LimitedBroker(fdlimit) as b:
             receivers = []
             # Start enough receivers to use all FDs, make sure the broker logs an error
             for i in range(fdlimit+1):
-                receivers.append(self.proc(["receive", "", b.port, str(i)]))
-
-            # Note: libuv silently swallows EMFILE/ENFILE errors so there is no error reporting.
-            # The epoll proactor will close the users connection with the EMFILE/ENFILE error
-            if "TRANSPORT_CLOSED" in b.proc.out:
-                self.assertIn("open files", b.proc.out)
+                receivers.append(Popen(["receive", "", b.port, str(i)], stdout=PIPE))
 
             # All FDs are now in use, send attempt should fail or hang
-            self.assertIn(self.proc(["send", "", b.port, "x"]).poll(), [1, None])
+            self.assertIn(Popen(["send", "", b.port, "x"], stdout=PIPE, stderr=STDOUT).poll(),
[1, None])
 
             # Kill receivers to free up FDs
             for r in receivers:
                 r.kill()
             for r in receivers:
-                r.wait_exit(expect=None)
+                r.wait()
             # send/receive should succeed now
-            self.assertIn("10 messages sent", self.proc(["send", "", b.port]).wait_exit())
-            self.assertIn("10 messages received", self.proc(["receive", "", b.port]).wait_exit())
+            self.assertIn("10 messages sent", check_output(["send", "", b.port]))
+            self.assertIn("10 messages received", check_output(["receive", "", b.port]))
 
 if __name__ == "__main__":
     main()

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/cpp/examples/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/cpp/examples/CMakeLists.txt b/cpp/examples/CMakeLists.txt
index a9bde0a..8487a6b 100644
--- a/cpp/examples/CMakeLists.txt
+++ b/cpp/examples/CMakeLists.txt
@@ -113,10 +113,6 @@ macro(set_search_path result)
   file(TO_NATIVE_PATH "${${result}}" ${result}) # native slash separators
 endmacro()
 
-# Add the tools directory for the 'proctest' module
-set_search_path(EXAMPLE_PYTHONPATH "${CMAKE_SOURCE_DIR}/tools/python" "$ENV{PYTHON_PATH}")
-set(EXAMPLE_ENV "PYTHONPATH=${EXAMPLE_PYTHONPATH}")
-
 # Add a test with the correct environment to find test executables and valgrind.
 macro(add_cpp_test name)
   if(WIN32)
@@ -126,7 +122,7 @@ macro(add_cpp_test name)
   endif(WIN32)
   add_test(
     NAME ${name}
-    COMMAND ${PN_ENV_SCRIPT} ${EXAMPLE_ENV} "PATH=${test_path}" ${VALGRIND_ENV}
+    COMMAND ${PN_ENV_SCRIPT} "PATH=${test_path}" ${VALGRIND_ENV}
             "HAS_CPP11=$<$<BOOL:${HAS_ENOUGH_CPP11}>:1>" -- ${ARGN}
     )
 endmacro()

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/cpp/examples/broker.cpp
----------------------------------------------------------------------
diff --git a/cpp/examples/broker.cpp b/cpp/examples/broker.cpp
index 47d6109..479ec01 100644
--- a/cpp/examples/broker.cpp
+++ b/cpp/examples/broker.cpp
@@ -44,10 +44,6 @@
 
 #if PN_CPP_HAS_STD_THREAD
 #include <thread>
-
-int hardware_concurrency() {return std::thread::hardware_concurrency();}
-#else
-int hardware_concurrency() {return 1;}
 #endif
 
 #include "fake_cpp11.hpp"
@@ -396,14 +392,9 @@ class broker {
     }
 
     void run() {
-#if PN_CPP_SUPPORTS_THREADS
-        int threads = hardware_concurrency();
-        std::cout << "starting " << threads << " listening threads\n";
-        std::cout.flush();
-        container_.run(threads);
+#if PN_CPP_HAS_STD_THREAD
+        container_.run(std::thread::hardware_concurrency());
 #else
-        std::cout << "no thread support - starting 1 listening thread\n";
-        std::cout.flush();
         container_.run();
 #endif
     }

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/cpp/examples/example_test.py
----------------------------------------------------------------------
diff --git a/cpp/examples/example_test.py b/cpp/examples/example_test.py
index b9f0621..b83540f 100644
--- a/cpp/examples/example_test.py
+++ b/cpp/examples/example_test.py
@@ -17,20 +17,13 @@
 # under the License
 #
 
-# This is a test script to run the examples and verify that they behave as expected.
-
-import unittest
-import os, sys, socket, time, re, inspect
-from proctest import *
-from random import randrange
-from subprocess import Popen, PIPE, STDOUT, call
-from copy import copy
-import platform
-from os.path import dirname as dirname
-from threading import Thread, Event
-from string import Template
+# Run the C++ examples and verify that they behave as expected.
+# Example executables must be in PATH
 
-createdSASLDb = False
+import unittest, sys, time, re, shutil, os
+from subprocess import Popen, PIPE, STDOUT, check_output, check_call
+from os.path import dirname
+from string import Template
 
 def _cyrusSetup(conf_dir):
   """Write out simple SASL config.tests
@@ -41,52 +34,31 @@ def _cyrusSetup(conf_dir):
 mech_list: EXTERNAL DIGEST-MD5 SCRAM-SHA-1 CRAM-MD5 PLAIN ANONYMOUS
 """)
     abs_conf_dir = os.path.abspath(conf_dir)
-    call(args=['rm','-rf',abs_conf_dir])
+    shutil.rmtree(abs_conf_dir, True)
     os.mkdir(abs_conf_dir)
     db = os.path.join(abs_conf_dir,'proton.sasldb')
     conf = os.path.join(abs_conf_dir,'proton-server.conf')
-    f = open(conf, 'w')
-    f.write(t.substitute(db=db))
-    f.close()
-
+    with open(conf, 'w') as f:
+        f.write(t.substitute(db=db))
     cmd_template = Template("echo password | ${saslpasswd} -c -p -f ${db} -u proton user")
     cmd = cmd_template.substitute(db=db, saslpasswd=saslpasswd)
-    call(args=cmd, shell=True)
-
+    check_call(args=cmd, shell=True)
     os.environ['PN_SASL_CONFIG_PATH'] = abs_conf_dir
-    global createdSASLDb
-    createdSASLDb = True
 
 # Globally initialize Cyrus SASL configuration
 _cyrusSetup('sasl-conf')
 
-def wait_listening(proc):
-    m = proc.wait_re(".*listening on ([0-9]+)$")
-    return m.group(1), m.group(0)+"\n" # Return (port, line)
-
-class BrokerTestCase(ProcTestCase):
-    """
-    ExampleTest that starts a broker in setUpClass and kills it in tearDownClass.
-    Subclasses must set `broker_exe` class variable with the name of the broker executable.
-    """
-    @classmethod
-    def setUpClass(cls):
-        cls.broker = None       # In case Proc throws, create the attribute.
-        cls.broker = Proc([cls.broker_exe, "-a", "//:0"])
-        cls.port, line = wait_listening(cls.broker)
-        cls.addr = "//:%s/example" % cls.port
-
-    @classmethod
-    def tearDownClass(cls):
-        if cls.broker:
-            cls.broker.kill()
-
-    def tearDown(self):
-        b = type(self).broker
-        if b and b.poll() !=  None: # Broker crashed
-            type(self).setUpClass() # Start another for the next test.
-            raise ProcError(b, "broker crash")
-        super(BrokerTestCase, self).tearDown()
+def wait_listening(p):
+    return re.search("listening on ([0-9]+)$", p.stdout.readline()).group(1)
+
+class Broker(Popen):
+    port = None
+    def __init__(self):
+        super(Broker, self).__init__(["broker", "-a", "//:0"], stdout=PIPE, stderr=open(os.devnull))
+        Broker.port = wait_listening(self)
+        Broker.addr = "amqp://:%s/example" % self.port
+    def __enter__(self): return self
+    def __exit__(self, *args): self.kill()
 
 
 CLIENT_EXPECT="""Twas brillig, and the slithy toves => TWAS BRILLIG, AND THE SLITHY TOVES
@@ -98,51 +70,52 @@ And the mome raths outgrabe. => AND THE MOME RATHS OUTGRABE.
 def recv_expect():
     return "".join(['{"sequence"=%s}\n' % (i+1) for i in range(100)])
 
-class ContainerExampleTest(BrokerTestCase):
+class ContainerExampleTest(unittest.TestCase):
     """Run the container examples, verify they behave as expected."""
 
     broker_exe = "broker"
 
     def test_helloworld(self):
-        self.assertMultiLineEqual('Hello World!\n', self.proc(["helloworld", self.addr]).wait_exit())
+        self.assertMultiLineEqual('Hello World!\n', check_output(["helloworld", Broker.addr]))
 
     def test_simple_send_recv(self):
-        self.assertMultiLineEqual("all messages confirmed\n", self.proc(["simple_send", "-a",
self.addr]).wait_exit())
-        self.assertMultiLineEqual(recv_expect(), self.proc(["simple_recv", "-a", self.addr]).wait_exit())
+        self.assertMultiLineEqual("all messages confirmed\n", check_output(["simple_send",
"-a", Broker.addr]))
+        self.assertMultiLineEqual(recv_expect(), check_output(["simple_recv", "-a", Broker.addr]))
 
     def test_simple_recv_send(self):
-        # Start receiver first, then run sender"""
-        recv = self.proc(["simple_recv", "-a", self.addr])
-        self.assertMultiLineEqual("all messages confirmed\n", self.proc(["simple_send", "-a",
self.addr]).wait_exit())
-        self.assertMultiLineEqual(recv_expect(), recv.wait_exit())
+        recv = Popen(["simple_recv", "-a", Broker.addr], stdout=PIPE)
+        self.assertMultiLineEqual("all messages confirmed\n", check_output(["simple_send",
"-a", Broker.addr]))
+        self.assertMultiLineEqual(recv_expect(), recv.communicate()[0])
 
 
     def test_simple_send_direct_recv(self):
-        recv = self.proc(["direct_recv", "-a", "//:0"])
-        port, line = wait_listening(recv)
-        addr = "//:%s/examples" % port
-        self.assertMultiLineEqual("all messages confirmed\n",
-                                  self.proc(["simple_send", "-a", addr]).wait_exit())
-        self.assertMultiLineEqual(line+recv_expect(), recv.wait_exit())
+        recv = Popen(["direct_recv", "-a", "//:0"], stdout=PIPE)
+        addr = "//:%s/examples" % wait_listening(recv)
+        self.assertMultiLineEqual("all messages confirmed\n", check_output(["simple_send",
"-a", addr]))
+        self.assertMultiLineEqual(recv_expect(), recv.communicate()[0])
+
 
     def test_simple_recv_direct_send(self):
-        send = self.proc(["direct_send", "-a", "//:0"])
-        port, line = wait_listening(send)
-        addr = "//:%s/examples" % port
-        self.assertMultiLineEqual(recv_expect(), self.proc(["simple_recv", "-a", addr]).wait_exit())
-        self.assertMultiLineEqual(line+"all messages confirmed\n", send.wait_exit())
+        send = Popen(["direct_send", "-a", "//:0"], stdout=PIPE)
+        addr = "//:%s/examples" % wait_listening(send)
+        self.assertMultiLineEqual(recv_expect(), check_output(["simple_recv", "-a", addr]))
+        self.assertMultiLineEqual("all messages confirmed\n", send.communicate()[0])
 
     def test_request_response(self):
-        server = self.proc(["server", self.addr, "example"]) # self.addr has the connection
info
-        server.wait_re("connected")
-        self.assertMultiLineEqual(CLIENT_EXPECT,
-                         self.proc(["client", "-a", self.addr]).wait_exit())
+        server = Popen(["server", Broker.addr, "example"], stdout=PIPE)
+        self.assertIn("connected to", server.stdout.readline())
+        try:
+            self.assertMultiLineEqual(CLIENT_EXPECT, check_output(["client", "-a", Broker.addr]))
+        finally:
+            server.kill()
 
     def test_request_response_direct(self):
-        server = self.proc(["server_direct", "-a", "//:0"])
-        port, line = wait_listening(server);
-        addr = "//:%s/examples" % port
-        self.assertMultiLineEqual(CLIENT_EXPECT, self.proc(["client", "-a", addr]).wait_exit())
+        server = Popen(["server_direct", "-a", "//:0"], stdout=PIPE)
+        addr = "//:%s/examples" % wait_listening(server);
+        try:
+            self.assertMultiLineEqual(CLIENT_EXPECT, check_output(["client", "-a", addr]))
+        finally:
+            server.kill()
 
     def test_flow_control(self):
         want="""success: Example 1: simple credit
@@ -150,7 +123,7 @@ success: Example 2: basic drain
 success: Example 3: drain without credit
 success: Example 4: high/low watermark
 """
-        self.assertMultiLineEqual(want, self.proc(["flow_control", "--quiet"]).wait_exit())
+        self.assertMultiLineEqual(want, check_output(["flow_control", "--quiet"]))
 
     def test_encode_decode(self):
         want="""
@@ -177,17 +150,17 @@ list[int(42), boolean(0), symbol(x)]
 map{string(k1):int(42), symbol(k2):boolean(0)}
 """
         self.maxDiff = None
-        self.assertMultiLineEqual(want, self.proc(["encode_decode"]).wait_exit())
+        self.assertMultiLineEqual(want, check_output(["encode_decode"]))
 
     def test_scheduled_send_03(self):
         # Output should be a bunch of "send" lines but can't guarantee exactly how many.
-        out = self.proc(["scheduled_send_03", "-a", self.addr+"scheduled_send", "-t", "0.1",
"-i", "0.001"]).wait_exit().split()
+        out = check_output(["scheduled_send_03", "-a", Broker.addr+"scheduled_send", "-t",
"0.1", "-i", "0.001"]).split()
         self.assertTrue(len(out) > 0);
         self.assertEqual(["send"]*len(out), out)
 
     @unittest.skipUnless(os.getenv('HAS_CPP11'), "not a  C++11 build")
     def test_scheduled_send(self):
-        out = self.proc(["scheduled_send", "-a", self.addr+"scheduled_send", "-t", "0.1",
"-i", "0.001"]).wait_exit().split()
+        out = check_output(["scheduled_send", "-a", Broker.addr+"scheduled_send", "-t", "0.1",
"-i", "0.001"]).split()
         self.assertTrue(len(out) > 0);
         self.assertEqual(["send"]*len(out), out)
 
@@ -201,32 +174,25 @@ short=42 string=bar
 expected conversion_error: "unexpected type, want: uint got: int"
 expected conversion_error: "unexpected type, want: uint got: string"
 """
-        self.assertMultiLineEqual(expect, self.proc(["message_properties"]).wait_exit())
+        self.assertMultiLineEqual(expect, check_output(["message_properties"]))
 
     @unittest.skipUnless(os.getenv('HAS_CPP11'), "not a  C++11 build")
     def test_multithreaded_client(self):
-        got = self.proc(["multithreaded_client", self.addr, "examples", "10"], helgrind=True).wait_exit()
+        got = check_output(["multithreaded_client", Broker.addr, "examples", "10"])
         self.maxDiff = None
-        self.assertRegexpMatches(got, "10 messages sent and received");
+        self.assertIn("10 messages sent and received", got);
 
 #    @unittest.skipUnless(os.getenv('HAS_CPP11'), "not a  C++11 build")
     @unittest.skip("Test is unstable, will enable when fixed")
     def test_multithreaded_client_flow_control(self):
-        got = self.proc(["multithreaded_client_flow_control", self.addr, "examples", "10",
"2"], helgrind=True).wait_exit()
+        got = check_output(["multithreaded_client_flow_control", Broker.addr, "examples",
"10", "2"])
         self.maxDiff = None
-        self.assertRegexpMatches(got, "20 messages sent and received");
+        self.assertIn("20 messages sent and received", got);
 
-class ContainerExampleSSLTest(BrokerTestCase):
+class ContainerExampleSSLTest(unittest.TestCase):
     """Run the SSL container examples, verify they behave as expected."""
 
     broker_exe = "broker"
-    valgrind = False            # Disable for all tests, including inherited
-
-    def setUp(self):
-        super(ContainerExampleSSLTest, self).setUp()
-
-    def tearDown(self):
-        super(ContainerExampleSSLTest, self).tearDown()
 
     def ssl_certs_dir(self):
         """Absolute path to the test SSL certificates"""
@@ -234,21 +200,18 @@ class ContainerExampleSSLTest(BrokerTestCase):
 
     def test_ssl(self):
         # SSL without SASL, VERIFY_PEER_NAME
-        # Disable valgrind when using OpenSSL
-        out = self.proc(["ssl", "-c", self.ssl_certs_dir()]).wait_exit()
+        out = check_output(["ssl", "-c", self.ssl_certs_dir()])
         expect = "Server certificate identity CN=test_server\nHello World!"
         self.assertIn(expect, out)
 
     def test_ssl_no_name(self):
-        # VERIFY_PEER
-        # Disable valgrind when using OpenSSL
-        out = self.proc(["ssl", "-c", self.ssl_certs_dir(), "-v", "noname"], valgrind=False).wait_exit()
+        out = check_output(["ssl", "-c", self.ssl_certs_dir(), "-v", "noname"])
         expect = "Outgoing client connection connected via SSL.  Server certificate identity
CN=test_server\nHello World!"
         self.assertIn(expect, out)
 
     def test_ssl_bad_name(self):
         # VERIFY_PEER
-        out = self.proc(["ssl", "-c", self.ssl_certs_dir(), "-v", "fail"]).wait_exit()
+        out = check_output(["ssl", "-c", self.ssl_certs_dir(), "-v", "fail"])
         expect = "Expected failure of connection with wrong peer name"
         self.assertIn(expect, out)
 
@@ -258,9 +221,9 @@ class ContainerExampleSSLTest(BrokerTestCase):
 Outgoing client connection connected via SSL.  Server certificate identity CN=test_server
 Hello World!
 """
-        # Disable valgrind when using OpenSSL
-        out = self.proc(["ssl_client_cert", self.ssl_certs_dir()]).wait_exit()
+        out = check_output(["ssl_client_cert", self.ssl_certs_dir()])
         self.assertIn(expect, out)
 
 if __name__ == "__main__":
-    unittest.main()
+    with Broker():
+        unittest.main()

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/e2858e6a/tools/python/proctest.py
----------------------------------------------------------------------
diff --git a/tools/python/proctest.py b/tools/python/proctest.py
deleted file mode 100644
index 6445f95..0000000
--- a/tools/python/proctest.py
+++ /dev/null
@@ -1,227 +0,0 @@
-
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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
-#
-
-"""Unit test library to simplify tests that start, monitor, check and report
-output from sub-processes. Provides safe port allocation for processes that
-listen on a port. Allows executables to be run under a debugging tool like
-valgrind.
-"""
-
-import unittest
-import os, sys, socket, time, re, inspect, errno, threading, tempfile
-from  random import randrange
-from subprocess import Popen, PIPE, STDOUT
-from copy import copy
-import platform
-from os.path import dirname as dirname
-
-DEFAULT_TIMEOUT=30              # Valgrind can be very slow.
-
-class ProcError(Exception):
-    """An exception that displays failed process output"""
-    def __init__(self, proc, what="bad exit status"):
-        self.out = proc.out.strip()
-        returncode = getattr(proc, 'returncode') # Can be missing in some cases
-        msg = "%s (exit=%s) command:\n%s" % (what, returncode, " ".join(proc.args))
-        if self.out:
-            msg += "\nvvvvvvvvvvvvvvvv\n%s\n^^^^^^^^^^^^^^^^" % self.out
-        else:
-            msg += "\n<<no output>>"
-        super(ProcError, self, ).__init__(msg)
-
-class NotFoundError(ProcError):
-    pass
-
-class Proc(Popen):
-    """Subclass of suprocess.Popen that stores its output and can scan it for a
-    'ready' pattern' Use self.out to access output (combined stdout and stderr).
-    You can't set the Popen stdout and stderr arguments, they will be overwritten.
-    """
-
-    @property
-    def out(self):
-        self._out.seek(0)
-        return self._out.read()
-
-    def __init__(self, args, valgrind=True, helgrind=False, **kwargs):
-        """Start an example process"""
-        self.args = list(args)
-        self.kwargs = kwargs
-        self._out = tempfile.TemporaryFile(mode='w+')
-        valgrind_exe = valgrind and os.getenv("VALGRIND")
-        if valgrind_exe:
-            # run valgrind for speed, not for detailed information
-            vg = [valgrind_exe]
-            if helgrind:
-                vg += ["--tool=helgrind", "--quiet", "--error-exitcode=42"]
-            else:
-                vg += ["--tool=memcheck"] + os.getenv("VALGRIND_ARGS").split(' ')
-            self.args = vg + self.args
-        if os.getenv("PROCTEST_VERBOSE"):
-            sys.stderr.write("\n== running == "+" ".join(self.args)+"\n")
-        try:
-            Popen.__init__(self, self.args, stdout=self._out, stderr=STDOUT, **kwargs)
-        except OSError as e:
-            if e.errno == errno.ENOENT:
-                raise NotFoundError(self, str(e))
-            raise ProcError(self, str(e))
-        except Exception as e:
-            raise ProcError(self, str(e))
-
-    def __del__(self):
-        self._out.close()
-
-    def kill(self):
-        try:
-            if self.poll() is None:
-                Popen.kill(self)
-        except:
-            pass                # Already exited.
-        return self.out
-
-    def wait_exit(self, timeout=DEFAULT_TIMEOUT, expect=0):
-        """Wait for process to exit, return output. Raise ProcError  on failure."""
-        t = threading.Thread(target=self.wait)
-        t.start()
-        t.join(timeout)
-        if self.poll() is None:      # Still running
-            self.kill()
-            raise ProcError(self, "still running after %ss" % timeout)
-        if expect is not None and self.poll() != expect:
-            raise ProcError(self)
-        return self.out
-
-    def wait_re(self, regexp, timeout=DEFAULT_TIMEOUT):
-        """
-        Wait for regexp to appear in the output, returns the re.search match result.
-        The target process should flush() important output to ensure it appears.
-        """
-        if timeout:
-            deadline = time.time() + timeout
-        while timeout is None or time.time() < deadline:
-            match = re.search(regexp, self.out)
-            if match:
-                return match
-            if self.poll() is not None:
-                raise ProcError(self, "process exited while waiting for '%s'" % (regexp))
-            time.sleep(0.01)    # Not very efficient
-        raise ProcError(self, "gave up waiting for '%s' after %ss" % (regexp, timeout))
-
-def _tc_missing(attr):
-    return not hasattr(unittest.TestCase, attr)
-
-class ProcTestCase(unittest.TestCase):
-    """TestCase that manages started processes
-
-    Also roughly provides setUpClass() and tearDownClass() and other features
-    missing in python 2.6. If subclasses override setUp() or tearDown() they
-    *must* call the superclass.
-    """
-
-    def setUp(self):
-        super(ProcTestCase, self).setUp()
-        self.procs = []
-
-    def tearDown(self):
-        for p in self.procs:
-            p.kill()
-        super(ProcTestCase, self).tearDown()
-
-    # Default value for valgrind= in proc() function if not explicitly set.
-    # Override by setting a "valgrind" member in subclass or instance.
-    valgrind=True
-
-    def proc(self, *args, **kwargs):
-        """Return a Proc() that will be automatically killed on teardown"""
-        if 'valgrind' in kwargs:
-            p = Proc(*args, **kwargs)
-        else:
-            p = Proc(*args, valgrind=self.valgrind, **kwargs)
-        self.procs.append(p)
-        return p
-
-    if _tc_missing('setUpClass') and _tc_missing('tearDownClass'):
-
-        @classmethod
-        def setUpClass(cls):
-            pass
-
-        @classmethod
-        def tearDownClass(cls):
-            pass
-
-        def setUp(self):
-            super(ProcTestCase, self).setUp()
-            cls = type(self)
-            if not hasattr(cls, '_setup_class_count'): # First time
-                def is_test(m):
-                    return inspect.ismethod(m) and m.__name__.startswith('test_')
-                cls._setup_class_count = len(inspect.getmembers(cls, predicate=is_test))
-                cls.setUpClass()
-            self.procs = []
-
-        def tearDown(self):
-            self.assertTrue(self._setup_class_count > 0)
-            self._setup_class_count -=  1
-            if self._setup_class_count == 0:
-                type(self).tearDownClass()
-            for p in self.procs:
-                p.kill()
-            super(ProcTestCase, self).tearDown()
-
-    if _tc_missing('assertIn'):
-        def assertIn(self, a, b):
-            self.assertTrue(a in b, "%r not in %r" % (a, b))
-
-    if _tc_missing('assertMultiLineEqual'):
-        def assertMultiLineEqual(self, a, b):
-            self.assertEqual(a, b)
-
-from functools import reduce
-
-#### Skip decorators missing in python 2.6
-
-def _id(obj):
-    return obj
-
-from functools import wraps
-
-def skip(reason):
-    def decorator(test):
-       @wraps(test)
-       def skipper(*args, **kwargs):
-           print("skipped %s: %s" % (test.__name__, reason))
-       return skipper
-    return decorator
-
-def skipIf(cond, reason):
-    if cond: return skip(reason)
-    else: return _id
-
-def skipUnless(cond, reason):
-    if not cond: return skip(reason)
-    else: return _id
-
-if not hasattr(unittest, 'skip'): unittest.skip = skip
-if not hasattr(unittest, 'skipIf'): unittest.skipIf = skipIf
-if not hasattr(unittest, 'skipUnless'): unittest.skipUnless = skipUnless
-
-from unittest import main
-if __name__ == "__main__":
-    main()


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org


Mime
View raw message