def setUp(self): self.nchildren = 2 self.seed1 = 0 self.seed2 = 10000 self.chx1 = fake_neo(ChannelIndex, seed=self.seed1, n=self.nchildren) self.chx2 = fake_neo(ChannelIndex, seed=self.seed2, n=self.nchildren) self.targobj = self.chx1 self.units1 = self.chx1.units self.units2 = self.chx2.units self.sigarrs1 = self.chx1.analogsignals self.sigarrs2 = self.chx2.analogsignals self.irrsig1 = self.chx1.irregularlysampledsignals self.irrsig2 = self.chx2.irregularlysampledsignals self.units1a = clone_object(self.units1) self.sigarrs1a = clone_object(self.sigarrs1, n=2) self.irrsig1a = clone_object(self.irrsig1, n=2) self.trains1 = [[train for train in unit.spiketrains] for unit in self.units1] self.trains2 = [[train for train in unit.spiketrains] for unit in self.units2] self.trains1 = sum(self.trains1, []) self.trains2 = sum(self.trains2, [])
def setUp(self): self.nchildren = 2 self.seed1 = 0 self.seed2 = 10000 self.blk1 = fake_neo(Block, seed=self.seed1, n=self.nchildren) self.blk2 = fake_neo(Block, seed=self.seed2, n=self.nchildren) self.targobj = self.blk1 self.segs1 = self.blk1.segments self.segs2 = self.blk2.segments self.chxs1 = self.blk1.channel_indexes self.chxs2 = self.blk2.channel_indexes self.units1 = [[unit for unit in chx.units] for chx in self.chxs1] self.units2 = [[unit for unit in chx.units] for chx in self.chxs2] self.units1 = sum(self.units1, []) self.units2 = sum(self.units2, []) self.sigarrs1 = [[sigarr for sigarr in chx.analogsignals] for chx in self.chxs1] self.sigarrs2 = [[sigarr for sigarr in chx.analogsignals] for chx in self.chxs2] self.trains1 = [[train for train in unit.spiketrains] for unit in self.units1] self.trains2 = [[train for train in unit.spiketrains] for unit in self.units2] self.irsigs1 = [[irsig for irsig in chx.irregularlysampledsignals] for chx in self.chxs1] self.irsigs2 = [[irsig for irsig in chx.irregularlysampledsignals] for chx in self.chxs2] self.epcs1 = [[epc for epc in seg.epochs] for seg in self.segs1] self.epcs2 = [[epc for epc in seg.epochs] for seg in self.segs2] self.evts1 = [[evt for evt in seg.events] for seg in self.segs1] self.evts2 = [[evt for evt in seg.events] for seg in self.segs2] self.sigarrs1 = sum(self.sigarrs1, []) self.sigarrs2 = sum(self.sigarrs2, []) self.trains1 = sum(self.trains1, []) self.trains2 = sum(self.trains2, []) self.irsigs1 = sum(self.irsigs1, []) self.irsigs2 = sum(self.irsigs2, []) self.epcs1 = sum(self.epcs1, []) self.epcs2 = sum(self.epcs2, []) self.evts1 = sum(self.evts1, []) self.evts2 = sum(self.evts2, [])
def setUp(self): self.nchildren = 2 self.seed1 = 0 self.seed2 = 10000 self.unit1 = fake_neo(Unit, seed=self.seed1, n=self.nchildren) self.unit2 = fake_neo(Unit, seed=self.seed2, n=self.nchildren) self.targobj = self.unit1 self.trains1 = self.unit1.spiketrains self.trains2 = self.unit2.spiketrains self.trains1a = clone_object(self.trains1)
def subcheck__generate_datasets(self, cls, cascade, seed=None): self.annotations['seed'] = seed if seed is None: res = fake_neo(obj_type=cls, cascade=cascade) else: res = fake_neo(obj_type=cls, cascade=cascade, seed=seed) if not hasattr(cls, 'lower'): self.assertTrue(isinstance(res, cls)) else: self.assertEqual(res.__class__.__name__, cls) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) resattr = get_fake_values(cls, annotate=False, seed=0) if seed is not None: for name, value in resattr.items(): if name in ['channel_names', 'channel_indexes', 'channel_index']: continue try: try: resvalue = getattr(res, name) except AttributeError: if name == 'signal': continue raise try: self.assertEqual(resvalue, value) except ValueError: assert_arrays_equal(resvalue, value) except BaseException as exc: exc.args += ('from %s' % name,) raise if not getattr(res, '_child_objects', ()): pass elif not cascade: self.assertEqual(res.children, ()) else: self.assertNotEqual(res.children, ()) if cls in ['RecordingChannelGroup', RecordingChannelGroup]: for i, rchan in enumerate(res.recordingchannels): self.assertEqual(rchan.name, res.channel_names[i].astype(str)) self.assertEqual(rchan.index, res.channel_indexes[i]) for i, unit in enumerate(res.units): for sigarr in res.analogsignalarrays: self.assertEqual(unit.channel_indexes[0], sigarr.channel_index[i])
def subcheck__generate_datasets(self, cls, cascade, seed=None): self.annotations['seed'] = seed if seed is None: res = fake_neo(obj_type=cls, cascade=cascade) else: res = fake_neo(obj_type=cls, cascade=cascade, seed=seed) if not hasattr(cls, 'lower'): self.assertTrue(isinstance(res, cls)) else: self.assertEqual(res.__class__.__name__, cls) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) resattr = get_fake_values(cls, annotate=False, seed=0) if seed is not None: for name, value in resattr.items(): if name in [ 'channel_names', 'channel_indexes', 'channel_index', 'coordinates' ]: continue try: try: resvalue = getattr(res, name) except AttributeError: if name == 'signal': continue raise try: self.assertEqual(resvalue, value) except ValueError: assert_arrays_equal(resvalue, value) except BaseException as exc: exc.args += ('from %s' % name, ) raise if not getattr(res, '_child_objects', ()): pass elif not cascade: self.assertEqual(res.children, ()) else: self.assertNotEqual(res.children, ()) if cls in ['ChannelIndex', ChannelIndex]: for i, unit in enumerate(res.units): for sigarr in res.analogsignals: self.assertEqual(unit.get_channel_indexes()[0], sigarr.get_channel_index()[i])
def setUp(self): self.nchildren = 2 self.seed1 = 0 self.seed2 = 10000 self.unit1 = fake_neo(Unit, seed=self.seed1, n=self.nchildren) self.unit2 = fake_neo(Unit, seed=self.seed2, n=self.nchildren) self.targobj = self.unit1 self.spikes1 = self.unit1.spikes self.spikes2 = self.unit2.spikes self.trains1 = self.unit1.spiketrains self.trains2 = self.unit2.spiketrains self.spikes1a = clone_object(self.spikes1) self.trains1a = clone_object(self.trains1)
def setUp(self): self.nchildren = 2 self.seed1 = 0 self.seed2 = 10000 self.rcg1 = fake_neo(RecordingChannelGroup, seed=self.seed1, n=self.nchildren) self.rcg2 = fake_neo(RecordingChannelGroup, seed=self.seed2, n=self.nchildren) self.targobj = self.rcg1 self.rchans1 = self.rcg1.recordingchannels self.rchans2 = self.rcg2.recordingchannels self.units1 = self.rcg1.units self.units2 = self.rcg2.units self.sigarrs1 = self.rcg1.analogsignalarrays self.sigarrs2 = self.rcg2.analogsignalarrays self.rchans1a = clone_object(self.rchans1) self.units1a = clone_object(self.units1) self.sigarrs1a = clone_object(self.sigarrs1, n=2) self.spikes1 = [[spike for spike in unit.spikes] for unit in self.units1] self.spikes2 = [[spike for spike in unit.spikes] for unit in self.units2] self.trains1 = [[train for train in unit.spiketrains] for unit in self.units1] self.trains2 = [[train for train in unit.spiketrains] for unit in self.units2] self.sigs1 = [[sig for sig in rchan.analogsignals] for rchan in self.rchans1] self.sigs2 = [[sig for sig in rchan.analogsignals] for rchan in self.rchans2] self.irsigs1 = [[irsig for irsig in rchan.irregularlysampledsignals] for rchan in self.rchans1] self.irsigs2 = [[irsig for irsig in rchan.irregularlysampledsignals] for rchan in self.rchans2] self.spikes1 = sum(self.spikes1, []) self.spikes2 = sum(self.spikes2, []) self.trains1 = sum(self.trains1, []) self.trains2 = sum(self.trains2, []) self.sigs1 = sum(self.sigs1, []) self.sigs2 = sum(self.sigs2, []) self.irsigs1 = sum(self.irsigs1, []) self.irsigs2 = sum(self.irsigs2, [])
def test__fake_neo__cascade(self): self.annotations['seed'] = None obj_type = Segment cascade = True res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, Segment)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) self.assertEqual(len(res.analogsignals), 1) self.assertEqual(len(res.irregularlysampledsignals), 1) self.assertEqual(len(res.spiketrains), 1) self.assertEqual(len(res.events), 1) self.assertEqual(len(res.epochs), 1) for child in res.children: del child.annotations['i'] del child.annotations['j'] self.assertEqual(res.analogsignals[0].annotations, self.annotations) self.assertEqual(res.irregularlysampledsignals[0].annotations, self.annotations) self.assertEqual(res.spiketrains[0].annotations, self.annotations) self.assertEqual(res.events[0].annotations, self.annotations) self.assertEqual(res.epochs[0].annotations, self.annotations)
def test__fake_neo__cascade(self): self.annotations['seed'] = None obj_type = 'ChannelIndex' cascade = True res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, ChannelIndex)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) for child in res.children_recur: del child.annotations['i'] del child.annotations['j'] self.assertEqual(len(res.units), 1) unit = res.units[0] self.assertEqual(unit.annotations, self.annotations) self.assertEqual(len(res.analogsignals), 1) self.assertEqual(res.analogsignals[0].annotations, self.annotations) self.assertEqual(len(unit.spiketrains), 1) self.assertEqual(unit.spiketrains[0].annotations, self.annotations)
def setUp(self): self.nchildren = 2 blk = fake_neo(Block, seed=0, n=self.nchildren) self.unit1, self.unit2, self.unit3, self.unit4 = blk.list_units self.seg1, self.seg2 = blk.segments self.targobj = self.seg1 self.seed1 = self.seg1.annotations['seed'] self.seed2 = self.seg2.annotations['seed'] del self.seg1.annotations['i'] del self.seg2.annotations['i'] del self.seg1.annotations['j'] del self.seg2.annotations['j'] self.sigarrs1 = self.seg1.analogsignals self.sigarrs2 = self.seg2.analogsignals self.irsigs1 = self.seg1.irregularlysampledsignals self.irsigs2 = self.seg2.irregularlysampledsignals self.trains1 = self.seg1.spiketrains self.trains2 = self.seg2.spiketrains self.epcs1 = self.seg1.epochs self.epcs2 = self.seg2.epochs self.evts1 = self.seg1.events self.evts2 = self.seg2.events self.sigarrs1a = clone_object(self.sigarrs1, n=2) self.irsigs1a = clone_object(self.irsigs1) self.trains1a = clone_object(self.trains1) self.epcs1a = clone_object(self.epcs1) self.evts1a = clone_object(self.evts1)
def setUp(self): self.nchildren = 2 self.seed1 = 0 self.seed2 = 10000 self.rchan1 = fake_neo(RecordingChannel, seed=self.seed1, n=self.nchildren) self.rchan2 = fake_neo(RecordingChannel, seed=self.seed2, n=self.nchildren) self.targobj = self.rchan1 self.sigs1 = self.rchan1.analogsignals self.sigs2 = self.rchan2.analogsignals self.irsigs1 = self.rchan1.irregularlysampledsignals self.irsigs2 = self.rchan2.irregularlysampledsignals self.sigs1a = clone_object(self.sigs1) self.irsigs1a = clone_object(self.irsigs1)
def test__merge(self): unit1a = fake_neo(Unit, seed=self.seed1, n=self.nchildren) assert_same_sub_schema(self.unit1, unit1a) unit1a.annotate(seed=self.seed2) unit1a.spiketrains.append(self.trains2[0]) unit1a.merge(self.unit2) assert_same_sub_schema(self.trains1a + self.trains2, unit1a.spiketrains)
def test__fake_neo__cascade(self): self.annotations["seed"] = None obj_type = "Event" cascade = True res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, Event)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations)
def test__fake_neo__nocascade(self): self.annotations['seed'] = None obj_type = 'AnalogSignal' cascade = False res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, AnalogSignal)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations)
def test__fake_neo__cascade(self): self.annotations['seed'] = None obj_type = AnalogSignal cascade = True res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, AnalogSignal)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations)
def test__fake_neo__cascade(self): self.annotations['seed'] = None obj_type = Epoch cascade = True res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, Epoch)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations)
def test__fake_neo__nocascade(self): self.annotations['seed'] = None obj_type = 'IrregularlySampledSignal' cascade = False res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, IrregularlySampledSignal)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations)
def test__fake_neo__cascade(self): self.annotations['seed'] = None obj_type = IrregularlySampledSignal cascade = True res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, IrregularlySampledSignal)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations)
def test__fake_neo__nocascade(self): self.annotations['seed'] = None obj_type = 'Epoch' cascade = False res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, Epoch)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations)
def test_property_change(self): """ Make sure all attributes are saved properly after the change, including quantities, units, types etc.""" iom = NeoHdf5IO(filename=self.test_file) for obj_type in objectnames: obj = fake_neo(obj_type, cascade=False) iom.save(obj) self.assertTrue(hasattr(obj, "hdf5_path")) replica = iom.get(obj.hdf5_path, cascade=False) assert_objects_equivalent(obj, replica)
def test__merge(self): unit1a = fake_neo(Unit, seed=self.seed1, n=self.nchildren) assert_same_sub_schema(self.unit1, unit1a) unit1a.annotate(seed=self.seed2) unit1a.spiketrains.append(self.trains2[0]) unit1a.merge(self.unit2) self.check_creation(self.unit2) assert_same_sub_schema(self.trains1a + self.trains2, unit1a.spiketrains)
def test__fake_neo__nocascade(self): self.annotations['seed'] = None obj_type = Unit cascade = False res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, Unit)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) self.assertEqual(len(res.spiketrains), 0)
def test__merge(self): chx1a = fake_neo(ChannelIndex, seed=self.seed1, n=self.nchildren) assert_same_sub_schema(self.chx1, chx1a) chx1a.annotate(seed=self.seed2) chx1a.analogsignals.append(self.sigarrs2[0]) chx1a.merge(self.chx2) assert_same_sub_schema(self.sigarrs1a + self.sigarrs2, chx1a.analogsignals, exclude=['channel_index']) assert_same_sub_schema(self.units1a + self.units2, chx1a.units)
def test__merge(self): rchan1a = fake_neo(RecordingChannel, seed=self.seed1, n=self.nchildren) assert_same_sub_schema(self.rchan1, rchan1a) rchan1a.annotate(seed=self.seed2) rchan1a.analogsignals.append(self.sigs2[0]) rchan1a.merge(self.rchan2) self.check_creation(self.rchan2) assert_same_sub_schema(self.sigs1a + self.sigs2, rchan1a.analogsignals) assert_same_sub_schema(self.irsigs1a + self.irsigs2, rchan1a.irregularlysampledsignals)
def test__fake_neo__cascade(self): self.annotations['seed'] = None obj_type = 'Block' cascade = True res = fake_neo(obj_type=obj_type, cascade=cascade) for child in res.children_recur: del child.annotations['i'] del child.annotations['j'] self.assertTrue(isinstance(res, Block)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) self.assertEqual(len(res.segments), 1) seg = res.segments[0] self.assertEqual(seg.annotations, self.annotations) self.assertEqual(len(res.channel_indexes), 1) chx = res.channel_indexes[0] self.assertEqual(chx.annotations, self.annotations) self.assertEqual(len(seg.analogsignals), 1) self.assertEqual(len(seg.analogsignals), 1) self.assertEqual(len(seg.irregularlysampledsignals), 1) self.assertEqual(len(seg.spiketrains), 1) self.assertEqual(len(seg.events), 1) self.assertEqual(len(seg.epochs), 1) self.assertEqual(seg.analogsignals[0].annotations, self.annotations) self.assertEqual(seg.analogsignals[0].annotations, self.annotations) self.assertEqual(seg.irregularlysampledsignals[0].annotations, self.annotations) self.assertEqual(seg.spiketrains[0].annotations, self.annotations) self.assertEqual(seg.events[0].annotations, self.annotations) self.assertEqual(seg.epochs[0].annotations, self.annotations) self.assertEqual(len(chx.units), 1) unit = chx.units[0] self.assertEqual(unit.annotations, self.annotations) self.assertEqual(len(chx.analogsignals), 1) self.assertEqual(chx.analogsignals[0].annotations, self.annotations) self.assertEqual(len(unit.spiketrains), 1) self.assertEqual(unit.spiketrains[0].annotations, self.annotations)
def test__fake_neo__nocascade(self): self.annotations['seed'] = None obj_type = Block cascade = False res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, Block)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) self.assertEqual(len(res.segments), 0) self.assertEqual(len(res.channel_indexes), 0)
def test__fake_neo__nocascade(self): self.annotations['seed'] = None obj_type = 'RecordingChannel' cascade = False res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, RecordingChannel)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) self.assertEqual(len(res.analogsignals), 0) self.assertEqual(len(res.irregularlysampledsignals), 0)
def test__fake_neo__nocascade(self): self.annotations['seed'] = None obj_type = ChannelIndex cascade = False res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, ChannelIndex)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) self.assertEqual(len(res.units), 0) self.assertEqual(len(res.analogsignals), 0)
def test__merge(self): blk1a = fake_neo(Block, seed=self.seed1, n=self.nchildren) assert_same_sub_schema(self.blk1, blk1a) blk1a.annotate(seed=self.seed2) blk1a.segments.append(self.segs2[0]) blk1a.merge(self.blk2) segs1a = clone_object(self.blk1).segments chxs1a = clone_object(self.chxs1) assert_same_sub_schema(chxs1a + self.chxs2, blk1a.channel_indexes) assert_same_sub_schema(segs1a + self.segs2, blk1a.segments)
def test__fake_neo__nocascade(self): self.annotations['seed'] = None obj_type = RecordingChannelGroup cascade = False res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, RecordingChannelGroup)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) self.assertEqual(len(res.recordingchannels), 0) self.assertEqual(len(res.units), 0) self.assertEqual(len(res.analogsignalarrays), 0)
def test__merge(self): blk1a = fake_neo(Block, seed=self.seed1, n=self.nchildren) assert_same_sub_schema(self.blk1, blk1a) blk1a.annotate(seed=self.seed2) blk1a.segments.append(self.segs2[0]) blk1a.merge(self.blk2) segs1a = clone_object(self.blk1).segments rcgs1a = clone_object(self.rcgs1) assert_same_sub_schema(rcgs1a + self.rcgs2, blk1a.recordingchannelgroups) assert_same_sub_schema(segs1a + self.segs2, blk1a.segments)
def test_attr_changes(self): """ gets an object, changes its attributes, saves it, then compares how good the changes were saved. """ iom = NeoHdf5IO(filename=self.test_file) for obj_type in objectnames: obj = fake_neo(obj_type=obj_type, cascade=False) iom.save(obj) orig_obj = iom.get(obj.hdf5_path) for attr in obj._all_attrs: if hasattr(orig_obj, attr[0]): setattr(obj, attr[0], get_fake_value(*attr)) iom.save(orig_obj) test_obj = iom.get(orig_obj.hdf5_path) assert_objects_equivalent(orig_obj, test_obj)
def test__merge(self): chx1a = fake_neo(ChannelIndex, seed=self.seed1, n=self.nchildren) assert_same_sub_schema(self.chx1, chx1a) chx1a.annotate(seed=self.seed2) chx1a.analogsignals.append(self.sigarrs2[0]) chx1a.merge(self.chx2) self.check_creation(self.chx2) assert_same_sub_schema(self.sigarrs1a + self.sigarrs2, chx1a.analogsignals, exclude=['channel_index']) assert_same_sub_schema(self.units1a + self.units2, chx1a.units)
def test_create(self): """ Create test file with signals, segments, blocks etc. """ iom = NeoHdf5IO(filename=self.test_file) b1 = fake_neo() # creating a structure iom.save(b1) # saving # must be assigned after save self.assertTrue(hasattr(b1, "hdf5_path")) iom.close() iom.connect(filename=self.test_file) b2 = iom.get(b1.hdf5_path) # new object assert_neo_object_is_compliant(b2) assert_same_sub_schema(b1, b2)
def test__merge(self): seg1a = fake_neo(Block, seed=self.seed1, n=self.nchildren).segments[0] assert_same_sub_schema(self.seg1, seg1a) seg1a.epochs.append(self.epcs2[0]) seg1a.merge(self.seg2) assert_same_sub_schema(self.sigarrs1a + self.sigarrs2, seg1a.analogsignals) assert_same_sub_schema(self.irsigs1a + self.irsigs2, seg1a.irregularlysampledsignals) assert_same_sub_schema(self.epcs1 + self.epcs2, seg1a.epochs) assert_same_sub_schema(self.evts1 + self.evts2, seg1a.events) assert_same_sub_schema(self.trains1 + self.trains2, seg1a.spiketrains)
def test__fake_neo__nocascade(self): self.annotations['seed'] = None obj_type = 'Segment' cascade = False res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, Segment)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) self.assertEqual(len(res.analogsignals), 0) self.assertEqual(len(res.irregularlysampledsignals), 0) self.assertEqual(len(res.spiketrains), 0) self.assertEqual(len(res.events), 0) self.assertEqual(len(res.epochs), 0)
def test__fake_neo__cascade(self): self.annotations['seed'] = None obj_type = 'Unit' cascade = True res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, Unit)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) self.assertEqual(len(res.spiketrains), 1) for child in res.children_recur: del child.annotations['i'] del child.annotations['j'] self.assertEqual(res.spiketrains[0].annotations, self.annotations)
def test__merge(self): rcg1a = fake_neo(RecordingChannelGroup, seed=self.seed1, n=self.nchildren) assert_same_sub_schema(self.rcg1, rcg1a) rcg1a.annotate(seed=self.seed2) rcg1a.analogsignalarrays.append(self.sigarrs2[0]) rcg1a.merge(self.rcg2) self.check_creation(self.rcg2) assert_same_sub_schema(self.sigarrs1a + self.sigarrs2, rcg1a.analogsignalarrays, exclude=['channel_index']) assert_same_sub_schema(self.units1a + self.units2, rcg1a.units) assert_same_sub_schema(self.rchans1a + self.rchans2, rcg1a.recordingchannels, exclude=['channel_index'])
def test__fake_neo__cascade(self): self.annotations['seed'] = None obj_type = RecordingChannel cascade = True res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, RecordingChannel)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) self.assertEqual(len(res.analogsignals), 1) self.assertEqual(len(res.irregularlysampledsignals), 1) for child in res.children_recur: del child.annotations['i'] del child.annotations['j'] self.assertEqual(res.analogsignals[0].annotations, self.annotations) self.assertEqual(res.irregularlysampledsignals[0].annotations, self.annotations)
def test__fake_neo__cascade(self): self.annotations['seed'] = None obj_type = 'RecordingChannelGroup' cascade = True res = fake_neo(obj_type=obj_type, cascade=cascade) self.assertTrue(isinstance(res, RecordingChannelGroup)) assert_neo_object_is_compliant(res) self.assertEqual(res.annotations, self.annotations) for child in res.children_recur: del child.annotations['i'] del child.annotations['j'] self.assertEqual(len(res.recordingchannels), 1) rchan = res.recordingchannels[0] self.assertEqual(rchan.annotations, self.annotations) self.assertEqual(len(res.units), 1) unit = res.units[0] self.assertEqual(unit.annotations, self.annotations) self.assertEqual(len(res.analogsignalarrays), 1) self.assertEqual(res.analogsignalarrays[0].annotations, self.annotations) self.assertEqual(len(rchan.analogsignals), 1) self.assertEqual(len(rchan.irregularlysampledsignals), 1) self.assertEqual(rchan.analogsignals[0].annotations, self.annotations) self.assertEqual(rchan.irregularlysampledsignals[0].annotations, self.annotations) self.assertEqual(len(unit.spiketrains), 1) self.assertEqual(len(unit.spikes), 1) self.assertEqual(unit.spiketrains[0].annotations, self.annotations) self.assertEqual(unit.spikes[0].annotations, self.annotations)