Remove support for parallel processing on Windows.

Author: drvinceknight

axelrod/tests/integration/test_tournament.py

@@ -1,7 +1,7 @@
 import unittest
 import axelrod
-import tempfile
 import filecmp
+import sys
 
 from axelrod.strategy_transformers import FinalTransformer
 
@@ -34,9 +34,9 @@ def test_full_tournament(self):
         tournament = axelrod.Tournament(name='test', players=strategies,
                                         game=self.game, turns=2,
                                         repetitions=2)
-        tmp_file = tempfile.NamedTemporaryFile()
+        filename = "test_outputs/test_tournament.csv"
         self.assertIsNone(tournament.play(progress_bar=False,
-                                          filename=tmp_file.name,
+                                          filename=filename,
                                           build_results=False))
 
     def test_serial_play(self):
@@ -50,6 +50,8 @@ def test_serial_play(self):
         actual_outcome = sorted(zip(self.player_names, scores))
         self.assertEqual(actual_outcome, self.expected_outcome)
 
+    @unittest.skipIf(sys.platform.startswith("win"),
+                     "Parallel processing not supported on Windows")
     def test_parallel_play(self):
         tournament = axelrod.Tournament(
             name=self.test_name,
@@ -71,10 +73,10 @@ def test_repeat_tournament_deterministic(self):
                                             players=deterministic_players,
                                             game=self.game, turns=2,
                                             repetitions=2)
-            files.append(tempfile.NamedTemporaryFile())
-            tournament.play(progress_bar=False, filename=files[-1].name,
+            files.append("test_outputs/stochastic_tournament_{}.csv".format(_))
+            tournament.play(progress_bar=False, filename=files[-1],
                             build_results=False)
-        self.assertTrue(filecmp.cmp(files[0].name, files[1].name))
+        self.assertTrue(filecmp.cmp(files[0], files[1]))
 
     def test_repeat_tournament_stochastic(self):
         """
@@ -89,10 +91,10 @@ def test_repeat_tournament_stochastic(self):
                                             players=stochastic_players,
                                             game=self.game, turns=2,
                                             repetitions=2)
-            files.append(tempfile.NamedTemporaryFile())
-            tournament.play(progress_bar=False, filename=files[-1].name,
+            files.append("test_outputs/stochastic_tournament_{}.csv".format(_))
+            tournament.play(progress_bar=False, filename=files[-1],
                             build_results=False)
-        self.assertTrue(filecmp.cmp(files[0].name, files[1].name))
+        self.assertTrue(filecmp.cmp(files[0], files[1]))
 
 
 class TestNoisyTournament(unittest.TestCase):

axelrod/tests/unit/test_tournament.py

@@ -5,6 +5,7 @@
 from multiprocessing import Queue, cpu_count
 import unittest
 import warnings
+import sys
 
 from hypothesis import given, example, settings
 from hypothesis.strategies import integers, floats
@@ -189,6 +190,8 @@ def test_progress_bar_play(self):
         self.assertIsInstance(results, axelrod.ResultSet)
         self.assertEqual(tournament.progress_bar.total, 15)
 
+    @unittest.skipIf(sys.platform.startswith("win"),
+                     "Parallel processing not supported on Windows")
     def test_progress_bar_play_parallel(self):
         """Test that tournament plays when asking for progress bar for parallel
         tournament"""
@@ -234,6 +237,8 @@ def test_property_serial_play(self, tournament):
         self.assertEqual(results.nplayers, len(tournament.players))
         self.assertEqual(results.players, [str(p) for p in tournament.players])
 
+    @unittest.skipIf(sys.platform.startswith("win"),
+                     "Parallel processing not supported on Windows")
     def test_parallel_play(self):
         # Test that we get an instance of ResultSet
         tournament = axelrod.Tournament(
@@ -274,6 +279,8 @@ def test_run_serial(self):
         calls = tournament._write_interactions.call_args_list
         self.assertEqual(len(calls), 15)
 
+    @unittest.skipIf(sys.platform.startswith("win"),
+                     "Parallel processing not supported on Windows")
     def test_run_parallel(self):
         tournament = axelrod.Tournament(
             name=self.test_name,
@@ -289,6 +296,8 @@ def test_run_parallel(self):
         calls = tournament._write_interactions.call_args_list
         self.assertEqual(len(calls), 15)
 
+    @unittest.skipIf(sys.platform.startswith("win"),
+                     "Parallel processing not supported on Windows")
     def test_n_workers(self):
         max_processes = cpu_count()
 
@@ -309,6 +318,8 @@ def test_n_workers(self):
         self.assertEqual(tournament._n_workers(processes=max_processes+2),
                                                max_processes)
 
+    @unittest.skipIf(sys.platform.startswith("win"),
+                     "Parallel processing not supported on Windows")
     @unittest.skipIf(
         cpu_count() < 2,
         "not supported on single processor machines")
@@ -324,6 +335,8 @@ def test_2_workers(self):
             repetitions=self.test_repetitions,)
         self.assertEqual(tournament._n_workers(processes=2), 2)
 
+    @unittest.skipIf(sys.platform.startswith("win"),
+                     "Parallel processing not supported on Windows")
     def test_start_workers(self):
         workers = 2
         work_queue = Queue()
@@ -346,6 +359,8 @@ def test_start_workers(self):
                 stops += 1
         self.assertEqual(stops, workers)
 
+    @unittest.skipIf(sys.platform.startswith("win"),
+                     "Parallel processing not supported on Windows")
     def test_worker(self):
         tournament = axelrod.Tournament(
             name=self.test_name,

docs/index.rst

@@ -32,8 +32,8 @@ Here is quick overview of the current capabilities of the library:
     * The Moran process
     * An ecological model
 
-* Multi-processor support, caching for deterministic interactions, automatically
-  generate figures and statistics
+* Multi-processor support (not currently supported on Windows), caching for
+  deterministic interactions, automatically generate figures and statistics
 
 Every strategy is categorized on a number of dimensions, including: