Changeset 1008 for branches

Timestamp:

11/18/11 17:41:12 (6 months ago)

Author:

apdavison

Message:

In neo_output branch, fixed most of the failing unit tests, removed no-longer-needed recording.files module and associated tests.

Location:

branches/neo_output

Files:

• src/common/populations.py (modified) (2 diffs)
• src/neuron/recording.py (modified) (2 diffs)
• src/recording/__init__.py (modified) (3 diffs)
• src/recording/files.py (deleted)
• test/unittests/test_basepopulation.py (modified) (3 diffs)
• test/unittests/test_files.py (deleted)
• test/unittests/test_neuron.py (modified) (6 diffs)
• test/unittests/test_population.py (modified) (2 diffs)
• test/unittests/test_recording.py (modified) (6 diffs)

branches/neo_output/src/common/populations.py

@@ -517 +517 @@
     @deprecated("get_data('v')")
     def get_v(self, gather=True, compatible_output=True):
-        return self.recorders['v'].get(gather, compatible_output, self.record_filter)
+        return self.get_data('v', gather)
 
     @deprecated("write_data(file, ['gsyn_exc', 'gsyn_inh'])")
@@ -525 +525 @@
     @deprecated("get_data(['gsyn_exc', 'gsyn_inh'])")
     def get_gsyn(self, gather=True, compatible_output=True):
-        return self.get_data(['gsyn_exc', 'gsyn_inh']), gather
+        return self.get_data(['gsyn_exc', 'gsyn_inh'], gather)
 
     def get_spike_counts(self, gather=True):

branches/neo_output/src/neuron/recording.py

@@ -88 +88 @@
     
     def _native_record(self, variable, id):
-        match = recordable_pattern.match(self.variable)
+        match = recordable_pattern.match(variable)
         if match:
             parts = match.groupdict()
@@ -126 +126 @@
         def trim_spikes(spikes):
             return spikes[spikes<=simulator.state.t+1e-9]
+        #import pdb; pdb.set_trace()
         for variable in variables_to_include:
             if variable == 'spikes':

branches/neo_output/src/recording/__init__.py

@@ -149 +149 @@
     
     def write(self, variables, file=None, gather=False, filter_ids=None):
-        """Write recorded data to file."""
-        file = file or self.file
+        """Write recorded data to a Neo IO"""
+        io = file or self.file
         if gather==False and self._simulator.state.num_processes > 1:
-            file.name += '.%d' % self._simulator.state.mpi_rank
+            io.filename += '.%d' % self._simulator.state.mpi_rank
         logger.debug("Recorder is writing '%s' to file '%s' with gather=%s" % (
-                                               variables, file.name, gather))
+                                               variables, io.filename, gather))
         data = self.get(variables, gather, filter_ids)
         if self._simulator.state.mpi_rank == 0 or gather == False:
@@ -163 +163 @@
     @property
     def metadata(self):
-        metadata = {}
-        if self.population is not None:
-            metadata.update({
+        metadata = {
                 'size': self.population.size,
                 'first_index': 0,
@@ -172 +170 @@
                 'last_id': self.population.last_id,
                 'label': self.population.label,
-            })
+            }
         metadata['dt'] = self._simulator.state.dt # note that this has to run on all nodes (at least for NEST)
         return metadata

branches/neo_output/test/unittests/test_basepopulation.py

@@ -320 +320 @@
     assert not p.can_record('foo')
     
-def test__record():
-    p = MockPopulation()
-    p.recorders = {'v': Mock()}
-    p._record('v')
-    meth, args, kwargs = p.recorders['v'].method_calls[0]
-    id_arr, = args
+def test_record_with_single_variable():
+    p = MockPopulation()
+    p.recorder = Mock()
+    p.record('v')
+    meth, args, kwargs = p.recorder.method_calls[0]
+    variables, id_arr = args
     assert_equal(meth, 'record')
+    assert_equal(variables, 'v')
     assert_arrays_equal(id_arr, p.all_cells)
 
-def test__record_invalid_variable():
-    p = MockPopulation()
-    assert_raises(errors.RecordingError, p._record, 'foo')
-
-#def test__record_int():
-    #p = MockPopulation()
-    #p.recorders = {'spikes': Mock()}
-    #p._record('spikes', 5)
-    #meth, args, kwargs = p.recorders['spikes'].method_calls[0]
-    #id_arr, = args
-    #assert_equal(meth, 'record')
-    #assert_equal(id_arr.size, 5)
-
-#def test__record_with_RNG():
-    #p = MockPopulation()
-    #p.recorders = {'v': Mock()}
-    #rng = Mock()
-    #rng.permutation = Mock(return_value=numpy.arange(p.size))
-    #p._record('v', 5, rng)
-    #meth, args, kwargs = p.recorders['v'].method_calls[0]
-    #id_arr, = args
-    #assert_equal(meth, 'record')
-    #assert_equal(id_arr.size, 5)
-    #rng.permutation.assert_called_with(p.all_cells)
-
-#def test__record_list():
-    #record_list = ['curly', 'larry', 'moe'] # should really check that record_list contains IDs
-    #p = MockPopulation()
-    #p.recorders = {'v': Mock()}
-    #p._record('v', record_list)
-    #meth, args, kwargs = p.recorders['v'].method_calls[0]
-    #id_list, = args
-    #assert_equal(meth, 'record')
-    #assert_equal(id_list, record_list)
-    
-def test_invalid_record_from():
-    p = MockPopulation()
-    assert_raises(Exception, p._record, 'v', 4.2)
-    
-def test_spike_recording():
-    p = MockPopulation()
-    p._record = Mock()
-    p.record("arg1")
-    p._record.assert_called_with('spikes', "arg1")
+def test_record_with_multiple_variables():
+    p = MockPopulation()
+    p.recorder = Mock()
+    p.record(['v', 'gsyn_exc', 'spikes'])
+    meth, args, kwargs = p.recorder.method_calls[0]
+    variables, id_arr = args
+    assert_equal(meth, 'record')
+    assert_equal(variables, ['v', 'gsyn_exc', 'spikes'])
+    assert_arrays_equal(id_arr, p.all_cells)
     
 def test_record_v():
     p = MockPopulation()
-    p._record = Mock()
+    p.record = Mock()
     p.record_v("arg1")
-    p._record.assert_called_with('v', "arg1")
+    p.record.assert_called_with('v', "arg1")
 
 def test_record_gsyn():
     p = MockPopulation()
-    p._record = Mock()
+    p.record = Mock()
     p.record_gsyn("arg1")
-    p._record.assert_called_with('gsyn', "arg1")
+    p.record.assert_called_with(['gsyn_exc', 'gsyn_inh'], "arg1")
 
 def test_printSpikes():
     p = MockPopulation()
-    p.recorders = {'spikes': Mock()}
-    p.record_filter = "arg4"
-    p.printSpikes("arg1", "arg2", "arg3")
-    meth, args, kwargs = p.recorders['spikes'].method_calls[0]
+    p.recorder = Mock()
+    p.record_filter = "filter"
+    p.printSpikes("file", "gather", "compatible_output")
+    meth, args, kwargs = p.recorder.method_calls[0]
     assert_equal(meth, 'write')
-    assert_equal(args, ("arg1", "arg2", "arg3", "arg4"))
+    assert_equal(args, ("spikes", "file", "gather", "filter"))
     
 def test_getSpikes():
     p = MockPopulation()
-    p.recorders = {'spikes': Mock()}
-    p.record_filter = "arg3"
-    p.getSpikes("arg1", "arg2")
-    meth, args, kwargs = p.recorders['spikes'].method_calls[0]
+    p.recorder = Mock()
+    p.record_filter = "filter"
+    p.getSpikes("gather", "compatible_output")
+    meth, args, kwargs = p.recorder.method_calls[0]
     assert_equal(meth, 'get')
-    assert_equal(args, ("arg1", "arg2", "arg3"))
+    assert_equal(args, ("spikes", "gather", "filter"))
 
 def test_print_v():
     p = MockPopulation()
-    p.recorders = {'v': Mock()}
-    p.record_filter = "arg4"
-    p.print_v("arg1", "arg2", "arg3")
-    meth, args, kwargs = p.recorders['v'].method_calls[0]
+    p.recorder = Mock()
+    p.record_filter = "filter"
+    p.print_v("file", "gather", "compatible_output")
+    meth, args, kwargs = p.recorder.method_calls[0]
     assert_equal(meth, 'write')
-    assert_equal(args, ("arg1", "arg2", "arg3", "arg4"))
+    assert_equal(args, ("v", "file", "gather", "filter"))
     
 def test_get_v():
     p = MockPopulation()
-    p.recorders = {'v': Mock()}
-    p.record_filter = "arg3"
-    p.get_v("arg1", "arg2")
-    meth, args, kwargs = p.recorders['v'].method_calls[0]
+    p.recorder = Mock()
+    p.record_filter = "filter"
+    p.get_v("gather", "compatible_output")
+    meth, args, kwargs = p.recorder.method_calls[0]
     assert_equal(meth, 'get')
-    assert_equal(args, ("arg1", "arg2", "arg3"))
+    assert_equal(args, ("v", "gather", "filter"))
     
 def test_print_gsyn():
     p = MockPopulation()
-    p.recorders = {'gsyn': Mock()}
-    p.record_filter = "arg4"
-    p.print_gsyn("arg1", "arg2", "arg3")
-    meth, args, kwargs = p.recorders['gsyn'].method_calls[0]
+    p.recorder = Mock()
+    p.record_filter = "filter"
+    p.print_gsyn("file", "gather", "compatible_output")
+    meth, args, kwargs = p.recorder.method_calls[0]
     assert_equal(meth, 'write')
-    assert_equal(args, ("arg1", "arg2", "arg3", "arg4"))
+    assert_equal(args, (["gsyn_exc", "gsyn_inh"], "file", "gather", "filter"))
     
 def test_get_gsyn():
     p = MockPopulation()
-    p.recorders = {'gsyn': Mock()}
-    p.record_filter = "arg3"
-    p.get_gsyn("arg1", "arg2")
-    meth, args, kwargs = p.recorders['gsyn'].method_calls[0]
+    p.recorder = Mock()
+    p.record_filter = "filter"
+    p.get_gsyn("gather", "compatible_output")
+    meth, args, kwargs = p.recorder.method_calls[0]
     assert_equal(meth, 'get')
-    assert_equal(args, ("arg1", "arg2", "arg3"))
+    assert_equal(args, (["gsyn_exc", "gsyn_inh"], "gather", "filter"))
     
 def test_get_spike_counts():
     p = MockPopulation()
-    p.recorders = {'spikes': Mock()}
-    p.get_spike_counts("arg1")
-    meth, args, kwargs = p.recorders['spikes'].method_calls[0]
+    p.recorder = Mock()
+    p.get_spike_counts("gather")
+    meth, args, kwargs = p.recorder.method_calls[0]
     assert_equal(meth, 'count')
-    assert_equal(args, ("arg1", None))
+    assert_equal(args, ("spikes", "gather", None))
     
 def test_meanSpikeCount():
@@ -452 +418 @@
     MockPopulation._simulator.state.mpi_rank = 0
     p = MockPopulation()
-    p.recorders = {'spikes': Mock()}
-    p.recorders['spikes'].count = Mock(return_value={0: 2, 1: 5})
+    p.recorder = Mock()
+    p.recorder.count = Mock(return_value={0: 2, 1: 5})
     assert_equal(p.meanSpikeCount(), 3.5)
     MockPopulation._simulator.state.mpi_rank = orig_rank
@@ -461 +427 @@
     MockPopulation._simulator.state.mpi_rank = 1
     p = MockPopulation()
-    p.recorders = {'spikes': Mock()}
-    p.recorders['spikes'].count = Mock(return_value={0: 2, 1: 5})
+    p.recorder = Mock()
+    p.recorder.count = Mock(return_value={0: 2, 1: 5})
     assert p.meanSpikeCount() is numpy.NaN
     MockPopulation._simulator.state.mpi_rank = orig_rank

branches/neo_output/test/unittests/test_neuron.py

@@ -5 +5 @@
 from nose.tools import assert_equal, assert_raises, assert_almost_equal
 import numpy
+from pyNN.utility import assert_arrays_equal
 
 class MockCellClass(object):
-    recordable = ['v']
+    recordable = ['v', 'spikes', 'gsyn_exc', 'gsyn_inh', 'spam']
     parameters = ['romans', 'judeans']
     injectable = True
@@ -29 +30 @@
         self.judeans = judeans
         self.foo_init = -99.9
+        self.traces = {}
 
 class MockID(int):
@@ -40 +42 @@
     celltype = MockCellClass()
     local_cells = [MockID(44), MockID(33)]
+    label = "mock population"
+    def describe(self):
+        return "mock population"
 
 # simulator
@@ -238 +243 @@
     
     def setup(self):
-        if "foo" not in recording.Recorder.formats:
-            recording.Recorder.formats['foo'] = "bar"
-        self.rv = recording.Recorder('v')
-        self.rg = recording.Recorder('gsyn')
-        self.rs = recording.Recorder('spikes')
-        self.rf = recording.Recorder('foo')
+        p = MockPopulation()
+        self.rv = recording.Recorder(p)
+        self.rg = recording.Recorder(p)
+        self.rs = recording.Recorder(p)
+        self.rf = recording.Recorder(p)
         self.cells = [MockID(22), MockID(29)]
     
     def teardown(self):
-        recording.Recorder.formats.pop("foo")
+        pass
     
     def test__record(self):
-        self.rv._record(self.cells)
-        self.rg._record(self.cells)
-        self.rs._record(self.cells)
+        self.rv._record('v', self.cells)
+        self.rg._record('gsyn_inh', self.cells)
+        self.rs._record('spikes', self.cells)
         for cell in self.cells:
             cell._cell.record.assert_called_with(1)
@@ -260 +264 @@
         
     def test__get_v(self):
-        self.rv.recorded = self.cells
+        self.rv.recorded['v'] = self.cells
         self.cells[0]._cell.vtrace = numpy.arange(-65.0, -64.0, 0.1)
         self.cells[1]._cell.vtrace = numpy.arange(-64.0, -65.0, -0.1)
         self.cells[0]._cell.record_times = self.cells[1]._cell.record_times = numpy.arange(0.0, 1.0, 0.1)
-        vdata = self.rv._get(gather=False, compatible_output=True, filter=None)
-        assert_equal(vdata.shape, (20,3))
+        vdata = self.rv._get(['v'], gather=False, filter_ids=None)
+        assert_equal(len(vdata.segments[0].analogsignals), 2)
+        assert_arrays_equal(numpy.array(vdata.segments[0].analogsignals[0]), self.cells[0]._cell.vtrace)
         
     def test__get_spikes(self):
-        self.rs.recorded = self.cells
+        self.rs.recorded['spikes'] = self.cells
         self.cells[0]._cell.spike_times = numpy.arange(101.0, 111.0)
         self.cells[1]._cell.spike_times = numpy.arange(13.0, 23.0)
         simulator.state.t = 111.0
-        sdata = self.rs._get(gather=False, compatible_output=True, filter=None)
-        assert_equal(sdata.shape, (20,2))
+        sdata = self.rs._get(['spikes'], gather=False, filter_ids=None)
+        assert_equal(len(sdata.segments[0].spiketrains), 2)
+        assert_arrays_equal(numpy.array(sdata.segments[0].spiketrains[0]), self.cells[0]._cell.spike_times)
         
     def test__get_gsyn(self):
-        self.rg.recorded = self.cells
+        self.rg.recorded['gsyn_inh'] = self.cells
         for cell in self.cells:
             cell._cell.gsyn_trace = {}
@@ -284 +290 @@
             cell._cell.gsyn_trace['inhibitory_TM'] = numpy.arange(4.01, 4.0199, 0.001)
             cell._cell.record_times = self.cells[1]._cell.record_times = numpy.arange(0.0, 1.0, 0.1)
-        gdata = self.rg._get(gather=False, compatible_output=True, filter=None)
+        gdata = self.rg._get(['gsyn_inh'], gather=False, filter_ids=None)
         assert_equal(gdata.shape, (20,4))
     
     def test__local_count(self):
-        self.rs.recorded = self.cells
+        self.rs.recorded['spikes'] = self.cells
         self.cells[0]._cell.spike_times = h.Vector(numpy.arange(101.0, 111.0))
         self.cells[1]._cell.spike_times = h.Vector(numpy.arange(13.0, 33.0))
-        assert_equal(self.rs._local_count(filter=None), {22: 10, 29: 20})
-    
+        assert_equal(self.rs._local_count('spikes', filter_ids=None), {22: 10, 29: 20})
+    

branches/neo_output/test/unittests/test_population.py

@@ -1 @@
-from pyNN import errors, random, standardmodels, space
+from pyNN import errors, random, standardmodels, space, recording
 from pyNN.common import populations
 from nose.tools import assert_equal, assert_raises
@@ -57 +57 @@
     assert_equal(p.celltype.parameters, {'A': 20.0, 'B': -34.9})
     assert_equal(p.initial_values, {})
-    assert isinstance(p.recorders, dict)
     p.initialize.assert_called_with('m', -1.23)
     

branches/neo_output/test/unittests/test_recording.py

@@ -1 @@
-from pyNN import recording
+from pyNN import recording, errors
 from nose.tools import assert_equal, assert_raises
 from mock import Mock
 import numpy
 import os
+from collections import defaultdict
 from pyNN.utility import assert_arrays_equal
 
@@ -10 +11 @@
     mpi_comm = recording.mpi_comm
 
-def setup():
-    recording.Recorder._simulator = MockSimulator(mpi_rank=0)
-    
-def teardown():
-    del recording.Recorder._simulator
 
 #def test_rename_existing():
@@ -44 +40 @@
     last_id = first_id + size
     label = "mock population"
+    celltype = Mock()
     def __len__(self):
         return self.size
     def can_record(self, variable):
-        if variable in ["spikes", "v", "gsyn"]:
+        if variable in ["spikes", "v", "gsyn_exc", "gsyn_inh", "spam"]:
             return True
         else:
@@ -53 +50 @@
     def id_to_index(self, id):
         return id
+    def describe(self):
+        return "mock population"
 
+class MockNeoBlock(object):
+    def __init__(self):
+        self.name = None
+        self.description = None
+        self.segments = [Mock()]
+    def annotate(self, **annotations):
+        pass
 
 def test_Recorder_create():
-    r = recording.Recorder('spikes')
-    assert_equal(r.variable, 'spikes')
-    assert_equal(r.population, None)
+    p = MockPopulation()
+    r = recording.Recorder(p)
+    assert_equal(r.population, p)
     assert_equal(r.file, None)
-    assert_equal(r.recorded, set([]))
+    assert_equal(r.recorded, defaultdict(set))
     
 def test_Recorder_invalid_variable():
-    assert_raises(AssertionError,
-                  recording.Recorder, 'foo', population=MockPopulation())
+    p = MockPopulation()
+    r = recording.Recorder(p)
+    all_ids = (MockID(0, True), MockID(1, False), MockID(2, True), MockID(3, True), MockID(4, False))
+    assert_raises(errors.RecordingError,
+                  r.record, 'foo', all_ids)
 
 class MockID(object):
@@ -72 +81 @@
 
 def test_record():
-    r = recording.Recorder('spikes')
+    p = MockPopulation()
+    r = recording.Recorder(p)
     r._record = Mock()
-    assert_equal(r.recorded, set([]))
+    assert_equal(r.recorded, defaultdict(set))
     
     all_ids = (MockID(0, True), MockID(1, False), MockID(2, True), MockID(3, True), MockID(4, False))
     first_ids = all_ids[0:3]
-    r.record(first_ids)
-    assert_equal(r.recorded, set(id for id in first_ids if id.local))
-    assert_equal(len(r.recorded), 2)
-    r._record.assert_called_with(r.recorded)
+    r.record('spam', first_ids)
+    assert_equal(r.recorded['spam'], set(id for id in first_ids if id.local))
+    assert_equal(len(r.recorded['spam']), 2)
+    r._record.assert_called_with('spam', r.recorded['spam'])
     
     more_ids = all_ids[2:5]
-    r.record(more_ids)
-    assert_equal(r.recorded, set(id for id in all_ids if id.local))
-    assert_equal(len(r.recorded), 3)
-    r._record.assert_called_with(set(all_ids[3:4]))
+    r.record('spam', more_ids)
+    assert_equal(r.recorded['spam'], set(id for id in all_ids if id.local))
+    assert_equal(len(r.recorded['spam']), 3)
+    r._record.assert_called_with('spam', set(all_ids[3:4]))
 
 def test_filter_recorded():
-    r = recording.Recorder('spikes')
+    p = MockPopulation()
+    r = recording.Recorder(p)
     r._record = Mock()
     all_ids = (MockID(0, True), MockID(1, False), MockID(2, True), MockID(3, True), MockID(4, False))
-    r.record(all_ids)
-    assert_equal(r.recorded, set(id for id in all_ids if id.local))
+    r.record(['spikes', 'spam'], all_ids)
+    assert_equal(r.recorded['spikes'], set(id for id in all_ids if id.local))
+    assert_equal(r.recorded['spam'], set(id for id in all_ids if id.local))
 
     filter = all_ids[::2]
-    filtered_ids = r.filter_recorded(filter)
+    filtered_ids = r.filter_recorded('spam', filter)
     assert_equal(filtered_ids, set(id for id in filter if id.local))
     
-    assert_equal(r.filter_recorded(None), r.recorded)
+    assert_equal(r.filter_recorded('spikes', None), r.recorded['spikes'])
 
-def test_get__zero_offset():
-    r = recording.Recorder('spikes')
-    fake_data = numpy.array([
-                    (3, 12.3),
-                    (4, 14.5),
-                    (7, 19.8)
-                ])
+def test_get():
+    p = MockPopulation()
+    r = recording.Recorder(p)
+    r._simulator = MockSimulator(mpi_rank=0)
+    fake_data = MockNeoBlock()
     r._get = Mock(return_value=fake_data)
-    assert_arrays_equal(r.get(), fake_data)
+    r.get('spikes')
+    assert_equal(fake_data.name, p.label)
+    assert_equal(fake_data.description, p.describe())
 
 
@@ -121 +133 @@
         self.state = MockState(mpi_rank)
 
+class MockNeoIO(object):
+    filename = "fake_file"
+    write = Mock()
+
 def test_write__with_filename__compatible_output__gather__onroot():
     orig_metadata = recording.Recorder.metadata
     recording.Recorder.metadata = {'a': 2, 'b':3}
-    r = recording.Recorder('spikes')
-    fake_data = numpy.array([
-                    (3, 12.3),
-                    (4, 14.5),
-                    (7, 19.8)
-                ])
+    p = MockPopulation()
+    r = recording.Recorder(p)
+    r._simulator = MockSimulator(mpi_rank=0)
+    fake_data = MockNeoBlock()
     r._get = Mock(return_value=fake_data)
-    r._make_compatible = Mock(return_value=fake_data)
-    r.write(file="tmp.spikes", gather=True, compatible_output=True)
-
-    os.remove("tmp.spikes")
+    output_io = MockNeoIO()
+    r.write("spikes", file=output_io, gather=True)
     recording.Recorder.metadata = orig_metadata
+    output_io.write.assert_called_with(fake_data)
 
 def test_metadata_property():
-    r = recording.Recorder('spikes', population=None)
-    r._get = Mock(return_value=numpy.random.uniform(size=(6,2)))
+    p = MockPopulation()
+    r = recording.Recorder(population=p)
+    r._simulator = MockSimulator(mpi_rank=0)
     assert_equal(r.metadata,
-                 {'variable': 'spikes', 'dt': 0.123, 'n': 6})
-    
-    r = recording.Recorder('v', population=MockPopulation())
-    r._get = Mock(return_value=numpy.random.uniform(size=(6,2)))
-    assert_equal(r.metadata,
-                 {'first_id': 2454, 'label': 'mock population', 'n': 6,
-                  'variable': 'v', 'dt': 0.123, 'last_id': 2465, 'size': 11,
+                 {'first_id': 2454, 'label': 'mock population',
+                  'dt': 0.123, 'last_id': 2465, 'size': 11,
                   'first_index': 0, 'last_index': 11})
-    
-def test__make_compatible_spikes():
-    r = recording.Recorder('spikes')
-    input_data = numpy.array([[0, 12.3], [1, 45.2], [0, 46.3],
-                              [4, 49.4], [0, 78.3]])
-    output_data = r._make_compatible(input_data) # time id
-    assert_arrays_equal(input_data[:,(1,0)], output_data)
 
-def test__make_compatible_v():
-    r = recording.Recorder('v')
-    input_data = numpy.array([[0, 0.0, -65.0], [3, 0.0, -65.0],
-                              [0, 0.1, -64.3], [3, 0.1, -65.1],
-                              [0, 0.2, -63.7], [3, 0.2, -65.5]])
-    output_data = r._make_compatible(input_data) # voltage id
-    assert_arrays_equal(input_data[:,(2,0)], output_data) 
 
 #def test_count__spikes_gather():