@@ -0,0 +1,36 @@
+from unittest import TestCase, main
+import tempfile
+from csp.csp import process
+
+class BaseCspTest(TestCase):
+    """Provides an output mechanism for asserting the output of
+    parallel running processes or threads. Python's builtin datatypes
+    will be copied for each process. Instead we use a file here."""
+
+    def setUp(self):
+        self.outpipe = tempfile.TemporaryFile(mode='wt+')
+
+    def proc(self, x):
+        def tester():
+            self.outpipe.write(str(x))
+            self.outpipe.flush()
+        return process(tester)()
+
+    def source(self, data, channel_out):
+        def tester(cout):
+            for x in data:
+                cout.write(x)
+        return process(tester)(channel_out)
+
+    def sink(self, length, channel_in):
+        def tester(length, cin):
+            for ii in range(length):
+                x = cin.read()
+                self.outpipe.write(str(x))
+            self.outpipe.flush()
+        return process(tester)(length, channel_in)
+
+    def output(self):
+        self.outpipe.seek(0)
+        return self.outpipe.read()
+
@@ -0,0 +1,53 @@
+from base import BaseCspTest, main
+from csp.csp import Channel, Par
+
+class TestChannels(BaseCspTest):
+
+    def test_single_source_sink_channel(self):
+        chan = Channel()
+        self.source('012345', chan) // (self.sink(6, chan), )
+        self.assertEquals(self.output(), '012345')
+
+    def test_multiple_source_sink_channel_triples(self):
+        chans = [Channel() for x in range(5)]
+        srces = Par(*[self.source(str(ii), ch) for ii, ch in enumerate(chans)])
+        sinks = Par(*[self.sink(1, ch) for ch in chans])
+        Par(srces, sinks).start()
+        self.assertEquals(''.join(sorted(self.output())), '01234')
+
+    def test_multiple_source_sink_tuples_one_channel(self):
+        channel = Channel()
+        srces = Par(*[self.source(str(ii), channel) for ii in range(5)])
+        sinks = Par(*[self.sink(1, channel) for ii in range(5)])
+        Par(srces, sinks).start()
+        self.assertEquals(''.join(sorted(self.output())), '01234')
+
+
+class TestPoison(BaseCspTest):
+
+    def test_poison_aborts_channel(self):
+        channel = Channel()
+        channel.poison()
+        Par(self.source('012345', channel),
+            self.sink(6, channel)).start()
+        self.assertEquals(self.output(), '')
+
+    def test_poison_does_not_abort_other_channels(self):
+        poisoned_channel = Channel()
+        clean_channel = Channel()
+        poisoned_channel.poison()
+        Par(self.source('012345', clean_channel),
+            self.sink(6, clean_channel)).start()
+        self.assertEquals(self.output(), '012345')
+
+
+class TestOverread(BaseCspTest):
+
+    def do_not_test_overread(self): # as it will hang
+        channel = Channel()
+        self.source('012345', channel) // (self.sink(12, channel), )
+        self.assertEquals(self.output(), '012345')
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,39 @@
+from base import BaseCspTest, main
+from csp.csp import Par
+
+class TestPar(BaseCspTest):
+
+    def test_process_object(self):
+        Par(*[self.proc(x) for x in range(5)]).start()
+        self.assertEqual(''.join(sorted(self.output())), '01234')
+
+    def test_supports_nesting(self):
+        _ = self.proc
+        Par(_(0), Par(_(1), _(2)), Par(_(3), Par(_(4), _(5)))).start()
+        self.assertEqual(''.join(sorted(self.output())), '012345')
+
+
+class TestMixinFloordivOperator(BaseCspTest):
+
+    def test_floordiv_runs_parallel(self):
+        _ = self.proc
+        _(0) // (_(1), _(2), _(3), _(4))
+        self.assertEqual(''.join(sorted(self.output())), '01234')
+
+    def does_not_work_with_non_tuple(self):
+        # Why not?
+        _ = self.proc
+        _(0) // _(1)
+        self.assertEqual(''.join(sorted(self.output())), '01')
+
+
+class TestMixParObjectAndFloordivOperator(BaseCspTest):
+
+    def test_mixed_syntax(self):
+        _ = self.proc
+        _(0) // (Par(_(1), _(2)), _(3))
+        self.assertEqual(''.join(sorted(self.output())), '0123')
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,44 @@
+from unittest import TestCase, main
+from csp.csp import process, Channel, Par
+import tempfile
+
+@process
+def sender(message, channel):
+    channel.write(message)
+
+@process
+def receiver(channel, temp_file):
+    temp_file.write(channel.read())
+    temp_file.flush()
+
+
+class TestUnbound(TestCase):
+
+    def test_works(self):
+        channel = Channel()
+        temp_file = tempfile.TemporaryFile()
+        Par(sender('123', channel), receiver(channel, temp_file)).start()
+        temp_file.seek(0)
+        self.assertEqual(temp_file.read(), '123')
+
+
+class TestBound(TestCase):
+
+    def setUp(self):
+        self.channel = Channel()
+
+    @process
+    def sender(self, message):
+        self.channel.write(message)
+
+    @process
+    def receiver(self):
+        self.result = self.channel.read()
+
+    def test_workd(self):
+        Par(self.sender('123'), self.receiver()).start()
+        self.assertEqual(self.result, '123')
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,41 @@
+from base import BaseCspTest, main
+from csp.csp import Seq
+
+class TestSeq(BaseCspTest):
+
+    def test_process_object(self):
+        Seq(*[self.proc(x) for x in range(5)]).start()
+        self.assertEqual(self.output(), '01234')
+
+    def test_supports_nesting(self):
+        _ = self.proc
+        Seq(_(0), Seq(_(1), _(2)), Seq(_(3), Seq(_(4), _(5)))).start()
+        self.assertEqual(self.output(), '012345')
+
+
+class TestMixinGtOperator(BaseCspTest):
+
+    def test_greater_operator_starts_sequence(self):
+        _ = self.proc
+        _(0) > _(1) > _(2) > _(3) > _(4)
+        self.assertEqual(self.output(), '01234')
+
+
+    def does_not_supports_nesting(self):
+        # As the resulting Seq object is immediately started, the syntax
+        # does not make sense, when nested
+        _ = self.proc
+        _(0) > (_(1) > _(2)) > (_(3) > (_(4) > _(5)))
+        self.assertEqual(self.output(), '012345')
+
+
+class TestMixSeqObjectAndGtOperator(BaseCspTest):
+
+    def test_mixed_syntax(self):
+        _ = self.proc
+        _(0) > Seq(_(1), _(2)) > _(3)
+        self.assertEqual(self.output(), '0123')
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+"""
+This is mainly only a test finder, but adds the feature of running
+tests that start with "csptest_" twice for the os_thread and os_process
+backend.
+"""
+
+import sys
+import os
+import unittest
+import re
+
+os.chdir(os.path.dirname(__file__))
+sys.path.insert(0, '..')
+test_suite_re = re.compile('((csp)?test_(.*))\.py$')
+
+BACKENDS = []
+try:
+    import csp.os_thread
+    BACKENDS.append(sys.modules['csp.os_thread'])
+except: pass
+#try:
+#    import csp.os_process
+#    BACKENDS.append(sys.modules['csp.os_process'])
+#except: pass
+import csp.csp
+
+if len(BACKENDS) < 2:
+    from warnings import warn
+    warn('This platform supports only backend {0}, '
+         'the other one is thus UNTESTED!'.format(csp.csp.CSP_IMPLEMENTATION))
+
+
+runner = unittest.TextTestRunner(verbosity=1)
+def load_and_run(test_module):
+    sys.stdout.flush()
+    suite = unittest.defaultTestLoader.loadTestsFromName(test_module)
+    return runner.run(suite).wasSuccessful()
+
+for testcase in [os.path.basename(x) for x in sys.argv[1:]] or os.listdir('.'):
+    assert os.path.exists(testcase)
+    testname = test_suite_re.match(os.path.basename(testcase))
+    if testname is None:
+        continue
+    test_module, csptest, titlename = testname.groups()
+    title = 'Testing ' + titlename
+    if csptest:
+        for backend in BACKENDS:
+            if test_module in sys.modules:
+                del sys.modules[test_module]
+            sys.modules['csp.csp'] = backend
+            sys.stdout.write('{0} ({1}): '.format(title,
+                                                  backend.CSP_IMPLEMENTATION))
+            if not load_and_run(test_module):
+                sys.exit(2)
+    else:
+        sys.stdout.write(title + ': ')
+        if not load_and_run(test_module):
+            sys.exit(2)
+    print