Now has script to run doctests

Author: geraintpalmer

ciw/tests/doctests.py

@@ -0,0 +1,16 @@
+import doctest
+import os
+import unittest
+
+
+def load_tests(loader, tests, ignore):
+    for root, dirs, files in os.walk("./docs"):
+        for f in files:
+            if f.endswith(".rst"):
+                 tests.addTests(doctest.DocFileSuite(os.path.join(root, f)))
+
+    return tests
+
+
+if __name__ == '__main__':
+    unittest.main()

docs/Basics/further_shell.rst

@@ -7,48 +7,48 @@ First, set up a parameters file as described in :ref:`parameters-file`.
 Now importing Ciw and the parameters file as a dictionary is simple::
 
     >>> import ciw
-    >>> params = ciw.load_parameters(<path_to_file>)
-    >>> params["Number_of_servers"]
-    [2, 1, 1]
+    >>> params = ciw.load_parameters(<path_to_file>) # doctest:+SKIP
+    >>> params["Number_of_servers"] # doctest:+SKIP
+    [2, 1, 1] # doctest:+SKIP
 
 Set up a Simulation object, from which all parameters can also be accessed::
 
-    >>> Q = ciw.Simulation(params)
-    >>> Q.number_of_nodes
-    3
-    >>> Q.queue_capacities
-    ['Inf', 'Inf', 10]
-    >>> Q.lmbda    # The arrival rates of the system
-    [[1.0, 1.8, 7.25], [6.0, 4.5, 2.0]]
-    >>> Q.lmbda[0]    # Arrival rates of the 0th class
-    [1.0, 1.8, 7.2]
+    >>> Q = ciw.Simulation(params) # doctest:+SKIP
+    >>> Q.number_of_nodes # doctest:+SKIP
+    3 # doctest:+SKIP
+    >>> Q.queue_capacities # doctest:+SKIP
+    ['Inf', 'Inf', 10] # doctest:+SKIP
+    >>> Q.lmbda    # The arrival rates of the system # doctest:+SKIP
+    [[1.0, 1.8, 7.25], [6.0, 4.5, 2.0]] # doctest:+SKIP
+    >>> Q.lmbda[0]    # Arrival rates of the 0th class # doctest:+SKIP
+    [1.0, 1.8, 7.2] # doctest:+SKIP
 
 A full list of Ciw's objects and attributes can be found here: :ref:`objects-attributes`
 Now to run a simulation simply run the following method::
 
-    >>> Q.simulate_until_max_time()
+    >>> Q.simulate_until_max_time() # doctest:+SKIP
 
 Individuals' data records can be accessed directly using the following methods::
 
-    >>> all_individuals = Q.get_all_individuals()    # Creates a list of all individuals in the system
-    >>> all_individuals[0]
-    Individual 13
-    >>> all_individuals[0].data_records.values()[0][0].wait    # Time Individual 13 was waiting for this instance of service
-    0.39586652218275364
-    >>> all_individuals[0].data_records.values()[0][0].arrival_date # Time Individual 13 arrived for this instance of service
-    0.5736475797750542
+    >>> all_individuals = Q.get_all_individuals()    # Creates a list of all individuals in the system # doctest:+SKIP
+    >>> all_individuals[0] # doctest:+SKIP
+    Individual 13 # doctest:+SKIP
+    >>> all_individuals[0].data_records.values()[0][0].wait    # Time Individual 13 was waiting for this instance of service # doctest:+SKIP
+    0.39586652218275364 # doctest:+SKIP
+    >>> all_individuals[0].data_records.values()[0][0].arrival_date # Time Individual 13 arrived for this instance of service # doctest:+SKIP
+    0.5736475797750542 # doctest:+SKIP
 
 A full list of data records can be obtained, with or without headers::
     
-    >>> records = Q.get_all_records(headers=True)
-    >>> records[:3]
-    [['I.D. Number', 'Customer Class', 'Node', 'Arrival Date', 'Waiting Time', 'Service Start Date', 'Service Time', 'Service End Date', 'Time Blocked', 'Exit Date'],
-    [1, 0, 1, 0.16207509531905792, 0.0, 0.16207509531905792, 0.014861757967438763, 0.1769368532864967, 0.0, 0.1769368532864967],
-    [2, 0, 1, 0.4628182409609607, 0.0, 0.4628182409609607, 0.13420139243827206, 0.5970196333992328, 0.0, 0.5970196333992328]]
+    >>> records = Q.get_all_records(headers=True) # doctest:+SKIP
+    >>> records[:3] # doctest:+SKIP
+    [['I.D. Number', 'Customer Class', 'Node', 'Arrival Date', 'Waiting Time', 'Service Start Date', 'Service Time', 'Service End Date', 'Time Blocked', 'Exit Date'], # doctest:+SKIP
+    [1, 0, 1, 0.16207509531905792, 0.0, 0.16207509531905792, 0.014861757967438763, 0.1769368532864967, 0.0, 0.1769368532864967], # doctest:+SKIP
+    [2, 0, 1, 0.4628182409609607, 0.0, 0.4628182409609607, 0.13420139243827206, 0.5970196333992328, 0.0, 0.5970196333992328]] # doctest:+SKIP
 
 
 The full list data records can be written to a csv file::
 
-    >>> Q.write_records_to_file(<path_to_file>)
+    >>> Q.write_records_to_file(<path_to_file>) # doctest:+SKIP
 
 Please see :ref:`output-file` for an explanation of the data contained here.

docs/Basics/getting_started.rst

@@ -49,4 +49,4 @@ Ciw can then use this parameters dictionary to run the simulation::
 
 Once this simulation has been run, :ref:`output-file` can be written to file through::
 
-	>>> Q.write_records_to_file(<path_to_file>)
+	>>> Q.write_records_to_file(<path_to_file>)  # doctest:+SKIP

docs/Basics/output_file.rst

@@ -6,7 +6,7 @@ The Output Data
 
 Once a simulation has been run, the following method may be called to write a data file::
 
-    >>> Q.write_records_to_file('data/file/location.csv')
+    >>> Q.write_records_to_file(<path_to_file>) # doctest:+SKIP
 
 This file contains does not contain summary statistics, but all the information that happened during the simulation in raw format.
 Each time an individual completes service at a service station, a data record of that service is kept.
@@ -28,4 +28,4 @@ The following table summarises the columns:
 
 The :code:`write_records_to_file` method writes a header as default. To disable this feature, input :code:`headers=False`::
 
-    >>> Q.write_records_to_file(<path_to_file>, header=False)
+    >>> Q.write_records_to_file(<path_to_file>, header=False) # doctest:+SKIP

docs/Basics/parameters_dict.rst

@@ -26,16 +26,16 @@ And then each customer class requires:
 
 A full example of the parameters dictionary for a three node network with two classes of customer is shown below::
 
-    >>> {'Arrival_rates': {'Class 1': [1.0, 1.8, 7.25],
-                           'Class 0': [6.0, 4.5, 2.0]},
-    ...  'Number_of_nodes': 3,
-    ...  'detect_deadlock': False,
-    ...  'Simulation_time': 2500,
-    ...  'Number_of_servers': [2, 1, 1],
-    ...  'Queue_capacities': ['Inf', 'Inf', 10],
-    ...  'Number_of_classes': 2,
-    ...  'Service_distributions': {'Class 1': [['Exponential', 8.5], ['Triangular', 0.1, 0.8, 0.95], ['Exponential', 3.0]],
-    ...                    'Class 0': [['Exponential', 7.0], ['Exponential', 5.0], ['Gamma', 0.4, 0.6]]},
+    >>> params = {'Arrival_rates': {'Class 1': [1.0, 1.8, 7.25],
+    ...                             'Class 0': [6.0, 4.5, 2.0]},
+    ...           'Number_of_nodes': 3,
+    ...           'detect_deadlock': False,
+    ...           'Simulation_time': 2500,
+    ...           'Number_of_servers': [2, 1, 1],
+    ...           'Queue_capacities': ['Inf', 'Inf', 10],
+    ...           'Number_of_classes': 2,
+    ...           'Service_distributions': {'Class 1': [['Exponential', 8.5], ['Triangular', 0.1, 0.8, 0.95], ['Exponential', 3.0]],
+    ...                                     'Class 0': [['Exponential', 7.0], ['Exponential', 5.0], ['Gamma', 0.4, 0.6]]},
     ...  'Transition_matrices': {'Class 1': [[0.7, 0.05, 0.05], [0.5, 0.1, 0.4], [0.2, 0.2, 0.2]],
     ...                          'Class 0': [[0.1, 0.6, 0.2], [0.0, 0.5, 0.5], [0.3, 0.1, 0.1]]}}
 

docs/Examples/mm1.rst

@@ -12,14 +12,17 @@ Standard queueing theory gives the expected wait in an M/M/1 queue as :math:`\ma
 We set up the parameters in ASQ::
 
     >>> params_dict = {'Arrival_rates': {'Class 0': [3.0]},
-    ...                'Service_distributions':{'Class 0': [['Exponential', 5.0]]},
+    ...                'Service_distributions': {'Class 0': [['Exponential', 5.0]]},
     ...                'Simulation_time': 250,
-    ...                'Transition_matrices': {'Class 0': [[0.0]]}
+    ...                'Transition_matrices': {'Class 0': [[0.0]]},
+    ...                'Number_of_servers': [1]
     ...                }
 
 The following code repeats the experiment 100 times, only recording waits for those that arrived after a warm-up time of 50.
 It then returns the average wait in the system::
-
+    
+    >>> import ciw
+    >>> from random import seed
     >>> def iteration(warmup):
     ...     Q = ciw.Simulation(params_dict)
     ...     Q.simulate_until_max_time()

docs/Features/deadlock.rst

@@ -13,8 +13,8 @@ In order to take advantage of this feature, set deadlock detection option to Tru
 Then use the :code:`simulate_until_deadlock` method to return the times to deadlock from each state::
 
    >>> import ciw
-   >>> Q = ciw.Simulation(deadlock_params)
-   >>> times = Q.simulate_until_deadlock()
+   >>> Q = ciw.Simulation(deadlock_params) # doctest:+SKIP
+   >>> times = Q.simulate_until_deadlock() # doctest:+SKIP
 
 where :code:`times` is a dictionary with states as keys and times to deadlock as values. Note that :code:`Simulation_time` is ingnored in this case.
 
@@ -41,6 +41,7 @@ Parameters::
 Running until deadlock::
 
     >>> import ciw
+    >>> from random import seed
     >>> seed(99)
     >>> Q = ciw.Simulation(params)
     >>> times = Q.simulate_until_deadlock()

doctests.py

@@ -0,0 +1,16 @@
+import doctest
+import os
+import unittest
+
+
+def load_tests(loader, tests, ignore):
+    for root, dirs, files in os.walk("./docs"):
+        for f in files:
+            if f.endswith(".rst"):
+                 tests.addTests(doctest.DocFileSuite(os.path.join(root, f)))
+
+    return tests
+
+
+if __name__ == '__main__':
+    unittest.main()