def test_init(): bio = BytesIO() shape = [2, 3, 4] dtype = np.int32 arr = np.arange(24, dtype=dtype).reshape(shape) bio.seek(16) bio.write(arr.tostring(order='F')) hdr = FunkyHeader(shape) ap = ArrayProxy(bio, hdr) assert_true(ap.file_like is bio) assert_equal(ap.shape, shape) # shape should be read only assert_raises(AttributeError, setattr, ap, 'shape', shape) # Get the data assert_array_equal(np.asarray(ap), arr) # Check we can modify the original header without changing the ap version hdr.shape[0] = 6 assert_not_equal(ap.shape, shape) # Data stays the same, also assert_array_equal(np.asarray(ap), arr) # C order also possible bio = BytesIO() bio.seek(16) bio.write(arr.tostring(order='C')) ap = CArrayProxy(bio, FunkyHeader((2, 3, 4))) assert_array_equal(np.asarray(ap), arr) # Illegal init assert_raises(TypeError, ArrayProxy, bio, object())
def test_TimeArray_bool(): time1 = ts.TimeArray([1, 2, 3], time_unit="s") time2 = ts.TimeArray([1000, 2000, 3000], time_unit="ms") bool_arr = np.ones(time1.shape, dtype=bool) npt.assert_equal(time1, time2) npt.assert_equal(bool_arr, time1 == time2) nt.assert_not_equal(type(time1 == time2), ts.TimeArray)
def test_if_select_with_namedplace_city_province_country_is_ok(self): query = "SELECT cdb_geocode_namedplace_point(city,province,country) " \ "as geometry FROM {0} LIMIT 1&api_key={1}".format( self.env_variables['table_name'], self.env_variables['api_key']) geometry = IntegrationTestHelper.execute_query(self.sql_api_url, query) assert_not_equal(geometry['geometry'], None)
def test_posterior_transitions_w_training(): sequences = [ list(x) for x in ( 'A', 'ACT', 'GGCA', 'TACCTGT' ) ] indices = { state.name: i for i, state in enumerate( model.states ) } transitions = model.dense_transition_matrix() i0, i1, i2 = indices['I0'], indices['I1'], indices['I2'] d1, d2, d3 = indices['D1'], indices['D2'], indices['D3'] m1, m2, m3 = indices['M1'], indices['M2'], indices['M3'] assert_equal( transitions[d1, i1], transitions[d2, i2] ) assert_equal( transitions[i0, i0], transitions[i1, i1] ) assert_equal( transitions[i0, i0], transitions[i2, i2] ) assert_equal( transitions[i0, m1], transitions[i1, m2] ) assert_equal( transitions[d1, d2], transitions[d2, d3] ) assert_equal( transitions[i0, d1], transitions[i1, d2] ) assert_equal( transitions[i0, d1], transitions[i2, d3] ) model.train( sequences ) transitions = model.dense_transition_matrix() assert_not_equal( transitions[d1, i1], transitions[d2, i2] ) assert_not_equal( transitions[i0, m1], transitions[i1, m2] ) assert_not_equal( transitions[d1, d2], transitions[d2, d3] ) assert_not_equal( transitions[i0, d1], transitions[i1, d2] ) assert_not_equal( transitions[i0, d1], transitions[i2, d3] )
def test_customer_bank_accounts_create_new_idempotency_key_for_each_call(): fixture = helpers.load_fixture('customer_bank_accounts')['create'] helpers.stub_response(fixture) helpers.client.customer_bank_accounts.create(*fixture['url_params']) helpers.client.customer_bank_accounts.create(*fixture['url_params']) assert_not_equal(responses.calls[0].request.headers.get('Idempotency-Key'), responses.calls[1].request.headers.get('Idempotency-Key'))
def test_fetch_atlas_schaefer_2018(): valid_n_rois = [100, 200, 300, 400, 500, 600, 800, 1000] valid_yeo_networks = [7, 17] valid_resolution_mm = [1, 2] assert_raises(ValueError, atlas.fetch_atlas_schaefer_2018, n_rois=44) assert_raises(ValueError, atlas.fetch_atlas_schaefer_2018, yeo_networks=10) assert_raises(ValueError, atlas.fetch_atlas_schaefer_2018, resolution_mm=3) for n_rois, yeo_networks, resolution_mm in \ itertools.product(valid_n_rois, valid_yeo_networks, valid_resolution_mm): data = atlas.fetch_atlas_schaefer_2018(n_rois=n_rois, yeo_networks=yeo_networks, resolution_mm=resolution_mm, data_dir=tst.tmpdir, verbose=0) assert_not_equal(data.description, '') assert_true(isinstance(data.maps, _basestring)) assert_true(isinstance(data.labels, np.ndarray)) assert_equal(len(data.labels), n_rois) assert_true(data.labels[0].astype(str).startswith("{}Networks". format(yeo_networks))) img = nibabel.load(data.maps) assert_equal(img.header.get_zooms()[0], resolution_mm) assert_true(np.array_equal(np.unique(img.dataobj), np.arange(n_rois+1)))
def test_mx_lookup(ld, cmx): # has MX, has MX server ld.return_value = ['mx1.fake.mailgun.com', 'mx2.fake.mailgun.com'] cmx.return_value = 'mx1.fake.mailgun.com' addr = address.validate_address('*****@*****.**') assert_not_equal(addr, None) # has fallback A, has MX server ld.return_value = ['domain.com'] cmx.return_value = 'domain.com' addr = address.validate_address('*****@*****.**') assert_not_equal(addr, None) # has MX, no server answers ld.return_value = ['mx.example.com'] cmx.return_value = None addr = address.validate_address('*****@*****.**') assert_equal(addr, None) # no MX ld.return_value = [] cmx.return_value = None addr = address.validate_address('*****@*****.**') assert_equal(addr, None)
def test_fetch_localizer_calculation_task(): local_url = "file://" + tst.datadir ids = np.asarray(['S%2d' % i for i in range(94)]) ids = ids.view(dtype=[('subject_id', 'S3')]) tst.mock_fetch_files.add_csv('cubicwebexport.csv', ids) tst.mock_fetch_files.add_csv('cubicwebexport2.csv', ids) # Disabled: cannot be tested without actually fetching covariates CSV file # All subjects dataset = func.fetch_localizer_calculation_task(data_dir=tst.tmpdir, url=local_url, verbose=0) assert_true(isinstance(dataset.ext_vars, np.recarray)) assert_true(isinstance(dataset.cmaps[0], _basestring)) assert_equal(dataset.ext_vars.size, 1) assert_equal(len(dataset.cmaps), 1) # 20 subjects dataset = func.fetch_localizer_calculation_task(n_subjects=20, data_dir=tst.tmpdir, url=local_url, verbose=0) assert_true(isinstance(dataset.ext_vars, np.recarray)) assert_true(isinstance(dataset.cmaps[0], _basestring)) assert_equal(dataset.ext_vars.size, 20) assert_equal(len(dataset.cmaps), 20) assert_not_equal(dataset.description, '')
def test_get_collections(self): resp = self.db.list_sentry_roles_by_group() # Non Sentry Admin can do that assert_not_equal(0, resp.status.value, resp) assert_true('denied' in resp.status.message, resp) resp = self.db.list_sentry_roles_by_group(groupName='*') assert_equal(0, resp.status.value, resp)
def test_calculate_scale(): # Test for special cases in scale calculation npa = np.array SIAW = SlopeInterArrayWriter SAW = SlopeArrayWriter # Offset handles scaling when it can aw = SIAW(npa([-2, -1], dtype=np.int8), np.uint8) assert_equal(get_slope_inter(aw), (1.0, -2.0)) # Sign flip handles these cases aw = SAW(npa([-2, -1], dtype=np.int8), np.uint8) assert_equal(get_slope_inter(aw), (-1.0, 0.0)) aw = SAW(npa([-2, 0], dtype=np.int8), np.uint8) assert_equal(get_slope_inter(aw), (-1.0, 0.0)) # But not when min magnitude is too large (scaling mechanism kicks in) aw = SAW(npa([-510, 0], dtype=np.int16), np.uint8) assert_equal(get_slope_inter(aw), (-2.0, 0.0)) # Or for floats (attempts to expand across range) aw = SAW(npa([-2, 0], dtype=np.float32), np.uint8) assert_not_equal(get_slope_inter(aw), (-1.0, 0.0)) # Case where offset handles scaling aw = SIAW(npa([-1, 1], dtype=np.int8), np.uint8) assert_equal(get_slope_inter(aw), (1.0, -1.0)) # Can't work for no offset case assert_raises(WriterError, SAW, npa([-1, 1], dtype=np.int8), np.uint8) # Offset trick can't work when max is out of range aw = SIAW(npa([-1, 255], dtype=np.int16), np.uint8) slope_inter = get_slope_inter(aw) assert_not_equal(slope_inter, (1.0, -1.0))
def test_fetch_adhd(): local_url = "file://" + tst.datadir sub1 = [3902469, 7774305, 3699991] sub2 = [2014113, 4275075, 1019436, 3154996, 3884955, 27034, 4134561, 27018, 6115230, 27037, 8409791, 27011] sub3 = [3007585, 8697774, 9750701, 10064, 21019, 10042, 10128, 2497695, 4164316, 1552181, 4046678, 23012] sub4 = [1679142, 1206380, 23008, 4016887, 1418396, 2950754, 3994098, 3520880, 1517058, 9744150, 1562298, 3205761, 3624598] subs = np.array(sub1 + sub2 + sub3 + sub4, dtype='i8') subs = subs.view(dtype=[('Subject', 'i8')]) tst.mock_fetch_files.add_csv( 'ADHD200_40subs_motion_parameters_and_phenotypics.csv', subs) adhd = func.fetch_adhd(data_dir=tst.tmpdir, url=local_url, n_subjects=12, verbose=0) assert_equal(len(adhd.func), 12) assert_equal(len(adhd.confounds), 12) assert_equal(len(tst.mock_url_request.urls), 13) # Subjects + phenotypic assert_not_equal(adhd.description, '')
def test_limit_documents(self): c = self.conn.collection c.test.create() c.test.docs.create({"doc": 1}) c.test.docs.create({"doc": 2}) assert_not_equal( self.conn.collection.test.documents().count, 1 ) assert_equal( len(self.conn.collection.test.documents()), self.conn.collection.test.documents().count ) assert_equal( len(self.conn.collection.test.documents().limit(1)), 1 ) assert_equal( len(self.conn.collection.test .documents() .offset(2) .limit(1)), 0)
def test_group(module, EXAMPLE): assert_hasattr(module, 'Group') assert_is_instance(module.Group, type) shared = module.Shared.from_dict(EXAMPLE['shared']) values = EXAMPLE['values'] for value in values: shared.add_value(value) group1 = module.Group() group1.init(shared) for value in values: group1.add_value(shared, value) group2 = module.Group.from_values(shared, values) assert_close(group1.dump(), group2.dump()) group = module.Group.from_values(shared, values) dumped = group.dump() group.init(shared) group.load(dumped) assert_close(group.dump(), dumped) for value in values: group2.remove_value(shared, value) assert_not_equal(group1, group2) group2.merge(shared, group1) for value in values: group1.score_value(shared, value) for _ in xrange(10): value = group1.sample_value(shared) group1.score_value(shared, value) module.sample_group(shared, 10) group1.score_data(shared) group2.score_data(shared)
def test_gaussian_random_seed(): genson.set_global_seed(42) gson = \ """ { "gaussian_random_seed" : gaussian(0, 1, draws=2) } """ gen = genson.loads(gson) vals = [val['gaussian_random_seed'] for val in gen] assert_equal(vals[0], 0.4967141530112327) assert_equal(vals[1], -0.13826430117118466) genson.set_global_seed(None) gen.reset() vals = [val['gaussian_random_seed'] for val in gen] assert_not_equal(vals[0], 0.4967141530112327) assert_not_equal(vals[1], -0.13826430117118466) genson.set_global_seed(42) gen.reset() gen = genson.loads(gson) vals = [val['gaussian_random_seed'] for val in gen] assert_equal(vals[0], 0.4967141530112327) assert_equal(vals[1], -0.13826430117118466)
def test_001_is_runnable(self): """ Still running after we launch it. As authauth is a persistent server it should be still be running!""" time.sleep(1) assert_not_equal(self.process, None) assert_equal(self.process.poll(), None)
def test_Opener_various(): # Check we can do all sorts of files here message = b"Oh what a giveaway" bz2_fileno = hasattr(BZ2File, 'fileno') with InTemporaryDirectory(): sobj = BytesIO() for input in ('test.txt', 'test.txt.gz', 'test.txt.bz2', sobj): with Opener(input, 'wb') as fobj: fobj.write(message) assert_equal(fobj.tell(), len(message)) if input == sobj: input.seek(0) with Opener(input, 'rb') as fobj: message_back = fobj.read() assert_equal(message, message_back) if input == sobj: # Fileno is unsupported for BytesIO assert_raises(UnsupportedOperation, fobj.fileno) elif input.endswith('.bz2') and not bz2_fileno: assert_raises(AttributeError, fobj.fileno) else: # Just check there is a fileno assert_not_equal(fobj.fileno(), 0)
def test2(): datafile = resource_filename('sknano', 'data/nanotubes/1010_1cell.data') atoms = DATAData(fpath=datafile).atoms atoms.assign_unique_ids() atoms.update_attrs() assert_not_equal(atoms.Natoms, 20) assert_equal(atoms.Natoms, 40)
def test_complete(): fig = plt.figure('Figure with a label?', figsize=(10, 6)) plt.suptitle('Can you fit any more in a figure?') # make some arbitrary data x, y = np.arange(8), np.arange(10) data = u = v = np.linspace(0, 10, 80).reshape(10, 8) v = np.sin(v * -0.6) plt.subplot(3, 3, 1) plt.plot(list(xrange(10))) plt.subplot(3, 3, 2) plt.contourf(data, hatches=['//', 'ooo']) plt.colorbar() plt.subplot(3, 3, 3) plt.pcolormesh(data) plt.subplot(3, 3, 4) plt.imshow(data) plt.subplot(3, 3, 5) plt.pcolor(data) plt.subplot(3, 3, 6) plt.streamplot(x, y, u, v) plt.subplot(3, 3, 7) plt.quiver(x, y, u, v) plt.subplot(3, 3, 8) plt.scatter(x, x**2, label='$x^2$') plt.legend(loc='upper left') plt.subplot(3, 3, 9) plt.errorbar(x, x * -0.5, xerr=0.2, yerr=0.4) ###### plotting is done, now test its pickle-ability ######### # Uncomment to debug any unpicklable objects. This is slow (~200 seconds). # recursive_pickle(fig) result_fh = BytesIO() pickle.dump(fig, result_fh, pickle.HIGHEST_PROTOCOL) plt.close('all') # make doubly sure that there are no figures left assert_equal(plt._pylab_helpers.Gcf.figs, {}) # wind back the fh and load in the figure result_fh.seek(0) fig = pickle.load(result_fh) # make sure there is now a figure manager assert_not_equal(plt._pylab_helpers.Gcf.figs, {}) assert_equal(fig.get_label(), 'Figure with a label?')
def test_delete_cohort_with_tags(self): # add a tag to the cohort unparsed_tag = "test-tag" response = self.app.post('/cohorts/{0}/tag/add/{1}' .format(self.cohort.id, unparsed_tag)) assert_true(response.data.find('"tags":') >= 0) assert_true(response.data.find('"name": "test-tag"') >= 0) self.session.commit() t = self.session.query(TagStore.id) \ .filter(TagStore.name == 'test-tag') \ .first() assert_not_equal(t, None) ct = self.session.query(CohortTagStore) \ .filter(CohortTagStore.cohort_id == self.cohort.id) \ .filter(CohortTagStore.tag_id == t[0]) \ .first() assert_not_equal(ct, None) # delete the cohort cohort_id = self.cohort.id response = self.app.post('/cohorts/delete/{0}'.format(self.cohort.id)) assert_true(response.data.find('isRedirect') >= 0) assert_true(response.data.find('/cohorts') >= 0) self.session.commit() c = self.session.query(CohortStore).get(cohort_id) assert_equal(c, None)
def step_impl(context, data): if data == 'new': assert_not_equal(context.page_data, context.page.get_all_page_data()) elif data == 'previous': assert_equal(context.old_page_data, context.page.get_all_page_data()) else: raise Exception('Unknown data')
def test_yahoo_pass(): with patch.object(address, 'mail_exchanger_lookup') as mock_method: mock_method.side_effect = mock_exchanger_lookup # valid length range for i in range(4, 33): localpart = ''.join(random.choice(string.ascii_letters) for x in range(i)) addr = address.validate_address(localpart + DOMAIN) assert_not_equal(addr, None) # start must be letter for i in string.ascii_letters: localpart = str(i) + 'aaa' addr = address.validate_address(localpart + DOMAIN) assert_not_equal(addr, None) # end must be letter or number for i in string.ascii_letters + string.digits: localpart = 'aaa' + str(i) addr = address.validate_address(localpart + DOMAIN) assert_not_equal(addr, None) # must be letter, num, and underscore for i in string.ascii_letters + string.digits + '_': localpart = 'aa' + str(i) + '00' addr = address.validate_address(localpart + DOMAIN) assert_not_equal(addr, None) # only zero or one dot (.) allowed for i in range(0, 2): localpart = 'aa' + '.'*i + '00' addr = address.validate_address(localpart + DOMAIN) assert_not_equal(addr, None)
def test_configure_get(self): response = self.app.get('/metrics/configure/BytesAdded') assert_not_equal( response.data.find('name="positive_only_sum"'), -1, 'A form to configure a BytesAdded metric was not rendered' )
def test_info(): "Check that Inspector.info fills out various fields as expected." i = inspector.info(Call, oname='Call') nt.assert_equal(i['type_name'], 'type') expted_class = str(type(type)) # <class 'type'> (Python 3) or <type 'type'> nt.assert_equal(i['base_class'], expted_class) nt.assert_regex(i['string_form'], "<class 'IPython.core.tests.test_oinspect.Call'( at 0x[0-9a-f]{1,9})?>") fname = __file__ if fname.endswith(".pyc"): fname = fname[:-1] # case-insensitive comparison needed on some filesystems # e.g. Windows: nt.assert_equal(i['file'].lower(), compress_user(fname).lower()) nt.assert_equal(i['definition'], None) nt.assert_equal(i['docstring'], Call.__doc__) nt.assert_equal(i['source'], None) nt.assert_true(i['isclass']) nt.assert_equal(i['init_definition'], "Call(x, y=1)") nt.assert_equal(i['init_docstring'], Call.__init__.__doc__) i = inspector.info(Call, detail_level=1) nt.assert_not_equal(i['source'], None) nt.assert_equal(i['docstring'], None) c = Call(1) c.__doc__ = "Modified instance docstring" i = inspector.info(c) nt.assert_equal(i['type_name'], 'Call') nt.assert_equal(i['docstring'], "Modified instance docstring") nt.assert_equal(i['class_docstring'], Call.__doc__) nt.assert_equal(i['init_docstring'], Call.__init__.__doc__) nt.assert_equal(i['call_docstring'], Call.__call__.__doc__)
def test_outgoing_url(): redirect_url = settings.REDIRECT_URL secretkey = settings.REDIRECT_SECRET_KEY exceptions = settings.REDIRECT_URL_WHITELIST settings.REDIRECT_URL = 'http://example.net' settings.REDIRECT_SECRET_KEY = 'sekrit' settings.REDIRECT_URL_WHITELIST = ['nicedomain.com'] try: myurl = 'http://example.com' s = urlresolvers.get_outgoing_url(myurl) # Regular URLs must be escaped. eq_(s, 'http://example.net/bc7d4bb262c9f0b0f6d3412ede7d3252c2e311bb1d55f6' '2315f636cb8a70913b/' 'http%3A//example.com') # No double-escaping of outgoing URLs. s2 = urlresolvers.get_outgoing_url(s) eq_(s, s2) evil = settings.REDIRECT_URL.rstrip('/') + '.evildomain.com' s = urlresolvers.get_outgoing_url(evil) assert_not_equal(s, evil, 'No subdomain abuse of double-escaping protection.') nice = 'http://nicedomain.com/lets/go/go/go' eq_(nice, urlresolvers.get_outgoing_url(nice)) finally: settings.REDIRECT_URL = redirect_url settings.REDIRECT_SECRET_KEY = secretkey settings.REDIRECT_URL_WHITELIST = exceptions
def test_allocate(self): self.block.from_list([0] * 100) assert_raises(InvalidArgumentError, self.block.allocate) assert_raises(InvalidArgumentError, self.block.allocate, None, 0) assert_raises(InvalidArgumentError, self.block.allocate, None, -1) assert_raises(InvalidArgumentError, self.block.allocate, None, -10) assert_raises(InvalidArgumentError, self.block.allocate, [], None) assert_raises(InvalidArgumentError, self.block.allocate, [1], 2) # Allocate an entire range self.block.deallocate((0, 49)) assert_raises(NotEnoughUnallocatedSpaceError, self.block.allocate, None, 51) offset = self.block.allocate(size=50) assert_equal(offset, 0) assert_equal(self.block.unallocated_ranges, []) # Allocate the beginning of a range self.block.deallocate((10, 39)) offset = self.block.allocate(data=[0x12, 0x34, 0xef]) assert_equal(offset, 10) assert_equal(self.block.unallocated_ranges, [(13, 39)]) assert_equal(self.block[offset:offset + 3].to_list(), [0x12, 0x34, 0xef]) assert_not_equal(self.block.to_list(), [0] * 100) self.block[offset:offset + 3] = [0] * 3 assert_equal(self.block.to_list(), [0] * 100)
def test_farsi_correction(): """Verify that a Farsi sentence is corrected""" wrong = u"ابن یک جملهٔ آرمایسی است" right = u"این یک جملهٔ آزمایشی است" corrected = d.suggest(wrong) new = u" ".join([word.new for word in corrected]) assert_not_equal(wrong, new)
def test_write_uncor(self): """ Testcase main """ assert_equal(self.nvme_read(), 0) assert_equal(self.write_uncor(), 0) assert_not_equal(self.nvme_read(), 0) assert_equal(self.nvme_write(), 0) assert_equal(self.nvme_read(), 0)
def test_rev(self): doc = self.create_document({}) doc._rev = None assert_not_equal(doc._id, None) assert_equal(doc._rev, None)
def test_select(self): for db in settings.DATABASES: people = Employee.objects.db_manager(db).select() assert_not_equal(people.count(), 0) for p in people: ok_(p.first_name) ok_(p.last_name)
def test_simple_stochastic_synapse(sim, plot_figure=False): # in this test we connect sim.setup(min_delay=0.5) t_stop = 1000.0 spike_times = np.arange(2.5, t_stop, 5.0) source = sim.Population(1, sim.SpikeSourceArray(spike_times=spike_times)) neurons = sim.Population(4, sim.IF_cond_exp(tau_syn_E=1.0)) synapse_type = sim.SimpleStochasticSynapse(weight=0.5, p=np.array([[0.0, 0.5, 0.5, 1.0]])) connections = sim.Projection(source, neurons, sim.AllToAllConnector(), synapse_type=synapse_type) source.record('spikes') neurons.record('gsyn_exc') sim.run(t_stop) data = neurons.get_data().segments[0] gsyn = data.analogsignals[0].rescale('uS') if plot_figure: import matplotlib.pyplot as plt for i in range(neurons.size): plt.subplot(neurons.size, 1, i+1) plt.plot(gsyn.times, gsyn[:, i]) plt.savefig("test_simple_stochastic_synapse_%s.png" % sim.__name__) print(data.analogsignals[0].units) crossings = [] for i in range(neurons.size): crossings.append( gsyn.times[:-1][np.logical_and(gsyn.magnitude[:-1, i] < 0.4, 0.4 < gsyn.magnitude[1:, i])]) assert_equal(crossings[0].size, 0) assert_less(crossings[1].size, 0.6*spike_times.size) assert_greater(crossings[1].size, 0.4*spike_times.size) assert_equal(crossings[3].size, spike_times.size) assert_not_equal(crossings[1], crossings[2]) print(crossings[1].size / spike_times.size) return data
def test_locks_for_meta_tiles(self): assert_not_equal( self.tile_mgr.lock(Tile((0, 0, 2))).lock_file, self.tile_mgr.lock(Tile((2, 0, 2))).lock_file)
def test_simple(): load_builtins() with chdir(PARENT): assert_not_equal(os.getcwd(), HERE) dirstack.cd(["tests"]) assert_equal(os.getcwd(), HERE)
def test_version(): argv = ['anorack', '--version'] (actual_stdout, actual_stderr) = run_main(argv, None) assert_not_equal('', actual_stdout) assert_equal('', actual_stderr)
def test_copy_files(): cluster = pseudo_hdfs4.shared_cluster() try: c = make_logged_in_client() user = User.objects.get(username='******') prefix = '/tmp/test_copy_files' if cluster.fs.exists(prefix): cluster.fs.rmtree(prefix) # Jars in various locations deployment_dir = '%s/workspace' % prefix external_deployment_dir = '%s/deployment' % prefix jar_1 = '%s/udf1.jar' % prefix jar_2 = '%s/lib/udf2.jar' % prefix jar_3 = '%s/udf3.jar' % deployment_dir jar_4 = '%s/lib/udf4.jar' % deployment_dir # Never move cluster.fs.mkdir(prefix) cluster.fs.create(jar_1) cluster.fs.create(jar_2) cluster.fs.create(jar_3) cluster.fs.create(jar_4) class MockNode(): def __init__(self, jar_path): self.jar_path = jar_path class MockJob(): def __init__(self): self.node_list = [ MockNode(jar_1), MockNode(jar_2), MockNode(jar_3), MockNode(jar_4), ] def get_application_filename(self): return 'workflow.xml' submission = Submission(user, job=MockJob(), fs=cluster.fs, jt=cluster.jt) submission._copy_files(deployment_dir, "<xml>My XML</xml>") submission._copy_files(external_deployment_dir, "<xml>My XML</xml>") # All sources still there assert_true(cluster.fs.exists(jar_1)) assert_true(cluster.fs.exists(jar_2)) assert_true(cluster.fs.exists(jar_3)) assert_true(cluster.fs.exists(jar_4)) deployment_dir = deployment_dir + '/lib' external_deployment_dir = external_deployment_dir + '/lib' list_dir_workspace = cluster.fs.listdir(deployment_dir) list_dir_deployement = cluster.fs.listdir(external_deployment_dir) # All destinations there assert_true(cluster.fs.exists(deployment_dir + '/udf1.jar'), list_dir_workspace) assert_true(cluster.fs.exists(deployment_dir + '/udf2.jar'), list_dir_workspace) assert_true(cluster.fs.exists(deployment_dir + '/udf3.jar'), list_dir_workspace) assert_true(cluster.fs.exists(deployment_dir + '/udf4.jar'), list_dir_workspace) assert_true(cluster.fs.exists(external_deployment_dir + '/udf1.jar'), list_dir_deployement) assert_true(cluster.fs.exists(external_deployment_dir + '/udf2.jar'), list_dir_deployement) assert_true(cluster.fs.exists(external_deployment_dir + '/udf3.jar'), list_dir_deployement) assert_true(cluster.fs.exists(external_deployment_dir + '/udf4.jar'), list_dir_deployement) stats_udf1 = cluster.fs.stats(deployment_dir + '/udf1.jar') stats_udf2 = cluster.fs.stats(deployment_dir + '/udf2.jar') stats_udf3 = cluster.fs.stats(deployment_dir + '/udf3.jar') stats_udf4 = cluster.fs.stats(deployment_dir + '/udf4.jar') submission._copy_files('%s/workspace' % prefix, "<xml>My XML</xml>") assert_not_equal( stats_udf1['fileId'], cluster.fs.stats(deployment_dir + '/udf1.jar')['fileId']) assert_not_equal( stats_udf2['fileId'], cluster.fs.stats(deployment_dir + '/udf2.jar')['fileId']) assert_not_equal( stats_udf3['fileId'], cluster.fs.stats(deployment_dir + '/udf3.jar')['fileId']) assert_equal(stats_udf4['fileId'], cluster.fs.stats(deployment_dir + '/udf4.jar')['fileId']) finally: try: cluster.fs.rmtree(prefix) except: LOG.exception('failed to remove %s' % prefix)
def test_equality(): """ Test featureset equality """ # create a featureset fs1, _ = make_classification_data(num_examples=100, num_features=4, num_labels=3, train_test_ratio=1.0) # create a featureset with a different set but same number # of features and everything else the same fs2, _ = make_classification_data(num_examples=100, num_features=4, num_labels=3, train_test_ratio=1.0) fs2.features *= 2 # create a featureset with different feature names # and everything else the same fs3, _ = make_classification_data(num_examples=100, num_features=4, num_labels=3, feature_prefix='g', train_test_ratio=1.0) # create a featureset with a different set of labels # and everything else the same fs4, _ = make_classification_data(num_examples=100, num_features=4, num_labels=2, train_test_ratio=1.0) # create a featureset with a different set but same number # of IDs and everything else the same fs5, _ = make_classification_data(num_examples=100, num_features=4, num_labels=3, train_test_ratio=1.0) fs5.ids = np.array(['A' + i for i in fs2.ids]) # create a featureset with a different vectorizer # and everything else the same fs6, _ = make_classification_data(num_examples=100, num_features=4, num_labels=3, train_test_ratio=1.0, use_feature_hashing=True, feature_bins=2) # create a featureset with a different number of features # and everything else the same fs7, _ = make_classification_data(num_examples=100, num_features=5, num_labels=3, train_test_ratio=1.0) # create a featureset with a different number of examples # and everything else the same fs8, _ = make_classification_data(num_examples=200, num_features=4, num_labels=3, train_test_ratio=1.0) # create a featureset with a different vectorizer instance # and everything else the same fs9, _ = make_classification_data(num_examples=100, num_features=4, num_labels=3, train_test_ratio=1.0) # now check for the expected equalities assert_not_equal(fs1, fs2) assert_not_equal(fs1, fs3) assert_not_equal(fs1, fs4) assert_not_equal(fs1, fs5) assert_not_equal(fs1, fs6) assert_not_equal(fs1, fs7) assert_not_equal(fs1, fs8) assert_not_equal(id(fs1.vectorizer), id(fs9.vectorizer)) eq_(fs1, fs9)
def test_addOrdersToFleetsForTurn(self): NORTH_OFFSET = (0, 50, 0) EAST_OFFSET = (50, 0, 0) SOUTH_OFFSET = (0, -50, 0) WEST_OFFSET = (-50, 0, 0) #OFFSET_LIST = [NORTH_OFFSET, EAST_OFFSET, SOUTH_OFFSET, WEST_OFFSET ] fc_0 = self.player0.fleetCommand hw_0_xy = self.p0_colonyHW_obj.planet.xy # ---------- setup and test ----------- startingShipCount = startingShipDesignsCount() assert_equal(len(fc_0.fleets), startingShipCount) for key, obj in fc_0.fleets.items(): assert_true(isinstance(obj.fleetOrders, list)) # fleet has list of orders assert_equal(len(obj.fleetOrders), 0) # fleet orders is empty assert_equal(obj.xy, hw_0_xy) # fleet is at HW (x,y) # ----------- give orders and test ------- print("hw_0_xy: %s; n_order: %s; e_order:%s" % (hw_0_xy, TestFleets._update_xy_orders(hw_0_xy, NORTH_OFFSET), TestFleets._update_xy_orders(hw_0_xy, EAST_OFFSET))) #assert_false(True) # ------ orders for fleet ----- testCommands = { 0: { "orders": [{ "coordinates": TestFleets._update_xy_orders( hw_0_xy, NORTH_OFFSET), # or at currentLocation "velocity_command": "speed_levels_from_list", "waypoint_action": "action_from_list" }] }, 1: { "orders": [{ "coordinates": TestFleets._update_xy_orders( hw_0_xy, EAST_OFFSET), # or at currentLocation "velocity_command": "speed_levels_from_list", "waypoint_action": "action_from_list" }] }, 2: { "orders": [{ "coordinates": TestFleets._update_xy_orders( hw_0_xy, SOUTH_OFFSET), # or at currentLocation "velocity_command": "speed_levels_from_list", "waypoint_action": "action_from_list" }] }, 3: { "orders": [{ "coordinates": TestFleets._update_xy_orders( hw_0_xy, WEST_OFFSET), # or at currentLocation "velocity_command": "speed_levels_from_list", "waypoint_action": "action_from_list" }] } } # ---- send orders to fleet ----- fc_0.addOrdersToFleetsForTurn(testCommands) # ----- test fleet location ----- for key, obj in fc_0.fleets.items(): assert_true(isinstance(obj.fleetOrders, list)) # fleet has list of orders assert_equal(len(obj.fleetOrders), 1) # fleet orders is empty print("xy{} destinationxy{}".format( obj.xy, obj.fleetOrders[0]["coordinates"])) assert_equal(obj.xy, hw_0_xy) assert_not_equal(obj.xy, obj.fleetOrders[0]["coordinates"]) assert_equal(obj.destinationXY, obj.fleetOrders[0]["coordinates"])
def check_desktop_links(self, links): """Desktop links should have the correct firefox version""" key = 'firefox-%s' % self.latest_version() for link in links: assert_not_equal(pq(link).attr('href').find(key), -1)
def test_repaired_neuron(): result = CutPlane.find(DATA / 'bio_neuron-000.h5', bin_width=10).to_json() assert_not_equal(result['status'], 'ok')
def test_versioned_graph_save_and_restore(workdir): path = os.path.join(workdir, 'my-graph.json') static = dag({"unchanging": "eternal"}, {}) graph_s0 = dag({ "name": "graph", "version": 0 }, { "static": static, "changing": dag({"a": "A"}, {}), "removed": dag({"bleep": "blorp"}, {}), }) graph_s1 = dag({ "name": "graph", "version": 1 }, { "static": static, "changing": dag({"b": "B"}, {}), }) version_map = tokendict.TokenDict({ "v0": graph_s0, "v1": graph_s0, "v2": graph_s1, "v3": graph_s1 }) transformer = merky.AnnotationTransformer() writer = structure.JSONFileWriteStructure(path) writer.populate(transformer.transform(version_map)) writer.close() reader = structure.JSONFileReadStructure(path) tokens = tokendict.TokenDict.from_token(reader.head, reader.get) tools.assert_equal(["v0", "v1", "v2", "v3"], list(tokens.keys())) # Same states get same tokens. tools.assert_equal(tokens.dict_["v0"], tokens.dict_["v1"]) tools.assert_equal(tokens.dict_["v2"], tokens.dict_["v3"]) tools.assert_equal(getpath(reader, "v0", 1, "static"), getpath(reader, "v2", 1, "static")) # Different states, different tokens. tools.assert_not_equal(tokens.dict_["v1"], tokens.dict_["v2"]) tools.assert_not_equal(getpath(reader, "v0", 1, "changing"), getpath(reader, "v2", 1, "changing")) restored = tokendict.TokenDict.from_token( reader.head, reader.get, attrgraph.AttributeGraph.from_token) tools.assert_equal(["v0", "v1", "v2", "v3"], list(restored.keys())) tools.assert_equal(dict(graph_s0.attrs), dict(restored["v0"].attrs)) tools.assert_equal(dict(graph_s1.attrs), dict(restored["v2"].attrs)) tools.assert_equal(["changing", "removed", "static"], list(sorted(restored["v0"].members.keys()))) tools.assert_equal(["changing", "static"], list(sorted(restored["v2"].members.keys()))) tools.assert_equal(dict(graph_s0.members["changing"].attrs), dict(restored["v1"].members["changing"].attrs)) tools.assert_equal(dict(graph_s1.members["changing"].attrs), dict(restored["v3"].members["changing"].attrs)) tools.assert_equal(dict(restored["v0"].members["static"].attrs), dict(restored["v3"].members["static"].attrs))
def test_independent(): d = IndependentComponentsDistribution( [NormalDistribution(5, 2), ExponentialDistribution(2)]) assert_equal(round(d.log_probability((4, 1)), 4), -3.0439) assert_equal(round(d.log_probability((100, 0.001)), 4), -1129.0459) d = IndependentComponentsDistribution([NormalDistribution(5, 2), ExponentialDistribution(2)], weights=[18., 1.]) assert_equal(round(d.log_probability((4, 1)), 4), -32.5744) assert_equal(round(d.log_probability((100, 0.001)), 4), -20334.5764) d.fit([(5, 1), (5.2, 1.7), (4.7, 1.9), (4.9, 2.4), (4.5, 1.2)]) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.86) assert_equal(round(d.parameters[0][0].parameters[1], 4), 0.2417) assert_equal(round(d.parameters[0][1].parameters[0], 4), 0.6098) d = IndependentComponentsDistribution([NormalDistribution(5, 2), UniformDistribution(0, 10)]) d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0), (2, 20)], inertia=0.5) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) d.fit([(0, 0), (5, 0), (3, 0), (5, -5), (7, 0), (3, 0), (4, 0), (5, 0), (2, 20)], inertia=0.75) assert_not_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_not_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_not_equal(d.parameters[0][1].parameters[0], -2.5) assert_not_equal(d.parameters[0][1].parameters[1], 15) d = IndependentComponentsDistribution([NormalDistribution(5, 2), UniformDistribution(0, 10)]) d.summarize([(0, 0), (5, 0), (3, 0)]) d.summarize([(5, -5), (7, 0)]) d.summarize([(3, 0), (4, 0), (5, 0), (2, 20)]) d.from_summaries(inertia=0.5) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) d.freeze() d.fit([(1, 7), (7, 2), (2, 4), (2, 4), (1, 4)]) assert_equal(round(d.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(d.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(d.parameters[0][1].parameters[0], -2.5) assert_equal(d.parameters[0][1].parameters[1], 15) e = Distribution.from_json(d.to_json()) assert_equal(e.name, "IndependentComponentsDistribution") assert_equal(round(e.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(e.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(e.parameters[0][1].parameters[0], -2.5) assert_equal(e.parameters[0][1].parameters[1], 15) f = pickle.loads(pickle.dumps(e)) assert_equal(e.name, "IndependentComponentsDistribution") assert_equal(round(f.parameters[0][0].parameters[0], 4), 4.3889) assert_equal(round(f.parameters[0][0].parameters[1], 4), 1.9655) assert_equal(f.parameters[0][1].parameters[0], -2.5) assert_equal(f.parameters[0][1].parameters[1], 15) X = numpy.array([[0.5, 0.2, 0.7], [0.3, 0.1, 0.9], [0.4, 0.3, 0.8], [0.3, 0.3, 0.9], [0.3, 0.2, 0.6], [0.5, 0.2, 0.8]]) d = IndependentComponentsDistribution.from_samples(X, distributions=NormalDistribution) assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4) assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4) assert_almost_equal(d.parameters[0][1].parameters[0], 0.21666, 4) assert_almost_equal(d.parameters[0][1].parameters[1], 0.06872, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 0.78333, 4) assert_almost_equal(d.parameters[0][2].parameters[1], 0.10672, 4) d = IndependentComponentsDistribution.from_samples(X, distributions=ExponentialDistribution) assert_almost_equal(d.parameters[0][0].parameters[0], 2.6087, 4) assert_almost_equal(d.parameters[0][1].parameters[0], 4.6154, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 1.2766, 4) d = IndependentComponentsDistribution.from_samples(X, distributions=[NormalDistribution, NormalDistribution, NormalDistribution]) assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4) assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4) assert_almost_equal(d.parameters[0][1].parameters[0], 0.21666, 4) assert_almost_equal(d.parameters[0][1].parameters[1], 0.06872, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 0.78333, 4) assert_almost_equal(d.parameters[0][2].parameters[1], 0.10672, 4) d = IndependentComponentsDistribution.from_samples(X, distributions=[NormalDistribution, LogNormalDistribution, ExponentialDistribution]) assert_almost_equal(d.parameters[0][0].parameters[0], 0.38333, 4) assert_almost_equal(d.parameters[0][0].parameters[1], 0.08975, 4) assert_almost_equal(d.parameters[0][1].parameters[0], -1.5898, 4) assert_almost_equal(d.parameters[0][1].parameters[1], 0.36673, 4) assert_almost_equal(d.parameters[0][2].parameters[0], 1.27660, 4)
def test_all_swagger_preserved_in_spec(self): """Builder should store the swagger documented cell.""" expected = ''' { "swagger": "2.0", "info" : {"version" : "0.0.0", "title" : "Default Title"}, "paths": { "/some/resource": { "get": { "summary": "Get some resource", "description": "Get some kind of resource?", "operationId": "getSomeResource", "produces": [ "application/json" ], "responses": { "200": { "description": "a resource", "schema": { "type": "object", "required": ["name"], "properties": { "name": { "type": "string" } } } }, "400": { "description": "Error retrieving resources", "schema": { "$ref": "#/definitions/error" } } } } } } } ''' builder = SwaggerSpecBuilder( SwaggerCellParser(kernelspec='some_spec', notebook_cells=[{ "source": expected }])) builder.add_cell(expected) result = builder.build() self.maxDiff = None self.assertEqual( result['paths']['/some/resource']['get']['description'], json.loads(expected)['paths']['/some/resource']['get'] ['description'], 'description was not preserved') self.assertTrue('info' in result, 'info was not preserved') self.assertTrue('title' in result['info'], 'title was not present') self.assertEqual(result['info']['title'], json.loads(expected)['info']['title'], 'title was not preserved') self.assertEqual( json.dumps(result['paths']['/some/resource'], sort_keys=True), json.dumps(json.loads(expected)['paths']['/some/resource'], sort_keys=True), 'operations were not as expected') new_title = 'new title. same contents.' builder.set_default_title(new_title) result = builder.build() assert_not_equal(result['info']['title'], new_title, 'title should not have been changed')
def assert_not_equal(self, *args, **kwds): assert_not_equal(*args, **kwds)
def deepcopy_edge_attr(self, H, G): assert_equal(G[1][2]['foo'], H[1][2]['foo']) G[1][2]['foo'].append(1) assert_not_equal(G[1][2]['foo'], H[1][2]['foo'])
def test_find_file_magic(): run = ip.find_line_magic('run') nt.assert_not_equal(oinspect.find_file(run), None)
def deepcopy_graph_attr(self, H, G): assert_equal(G.graph['foo'], H.graph['foo']) G.graph['foo'].append(1) assert_not_equal(G.graph['foo'], H.graph['foo'])
def check_upload(_step, file_name): index = get_index(file_name) assert_not_equal(index, -1)
def test_osx(): nt.assert_not_equal(sys.platform, 'darwin', "This test can't run under osx")
def deepcopy_node_attr(self, H, G): assert_equal(G.nodes[0]['foo'], H.nodes[0]['foo']) G.nodes[0]['foo'].append(1) assert_not_equal(G.nodes[0]['foo'], H.nodes[0]['foo'])
def test_decimal_rescale(): # Test that we don't get back a data array with dtype np.object when our # rescale slope is a decimal dw = didw.wrapper_from_file(DATA_FILE_DEC_RSCL) assert_not_equal(dw.get_data().dtype, np.object)
def test_with_multiedges_self_loops(self): G = cycle_graph(10) XG = nx.Graph() XG.add_nodes_from(G) XG.add_weighted_edges_from((u, v, u) for u, v in G.edges()) XGM = nx.MultiGraph() XGM.add_nodes_from(G) XGM.add_weighted_edges_from((u, v, u) for u, v in G.edges()) XGM.add_edge(0, 1, weight=2) # multiedge XGS = nx.Graph() XGS.add_nodes_from(G) XGS.add_weighted_edges_from((u, v, u) for u, v in G.edges()) XGS.add_edge(0, 0, weight=100) # self loop # Dict of dicts # with self loops, OK dod = to_dict_of_dicts(XGS) GG = from_dict_of_dicts(dod, create_using=nx.Graph) assert_nodes_equal(XGS.nodes(), GG.nodes()) assert_edges_equal(XGS.edges(), GG.edges()) GW = to_networkx_graph(dod, create_using=nx.Graph) assert_nodes_equal(XGS.nodes(), GW.nodes()) assert_edges_equal(XGS.edges(), GW.edges()) GI = nx.Graph(dod) assert_nodes_equal(XGS.nodes(), GI.nodes()) assert_edges_equal(XGS.edges(), GI.edges()) # Dict of lists # with self loops, OK dol = to_dict_of_lists(XGS) GG = from_dict_of_lists(dol, create_using=nx.Graph) # dict of lists throws away edge data so set it to none enone = [(u, v, {}) for (u, v, d) in XGS.edges(data=True)] assert_nodes_equal(sorted(XGS.nodes()), sorted(GG.nodes())) assert_edges_equal(enone, sorted(GG.edges(data=True))) GW = to_networkx_graph(dol, create_using=nx.Graph) assert_nodes_equal(sorted(XGS.nodes()), sorted(GW.nodes())) assert_edges_equal(enone, sorted(GW.edges(data=True))) GI = nx.Graph(dol) assert_nodes_equal(sorted(XGS.nodes()), sorted(GI.nodes())) assert_edges_equal(enone, sorted(GI.edges(data=True))) # Dict of dicts # with multiedges, OK dod = to_dict_of_dicts(XGM) GG = from_dict_of_dicts(dod, create_using=nx.MultiGraph, multigraph_input=True) assert_nodes_equal(sorted(XGM.nodes()), sorted(GG.nodes())) assert_edges_equal(sorted(XGM.edges()), sorted(GG.edges())) GW = to_networkx_graph(dod, create_using=nx.MultiGraph, multigraph_input=True) assert_nodes_equal(sorted(XGM.nodes()), sorted(GW.nodes())) assert_edges_equal(sorted(XGM.edges()), sorted(GW.edges())) GI = nx.MultiGraph( dod) # convert can't tell whether to duplicate edges! assert_nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes())) #assert_not_equal(sorted(XGM.edges()), sorted(GI.edges())) assert_false(sorted(XGM.edges()) == sorted(GI.edges())) GE = from_dict_of_dicts(dod, create_using=nx.MultiGraph, multigraph_input=False) assert_nodes_equal(sorted(XGM.nodes()), sorted(GE.nodes())) assert_not_equal(sorted(XGM.edges()), sorted(GE.edges())) GI = nx.MultiGraph(XGM) assert_nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes())) assert_edges_equal(sorted(XGM.edges()), sorted(GI.edges())) GM = nx.MultiGraph(G) assert_nodes_equal(sorted(GM.nodes()), sorted(G.nodes())) assert_edges_equal(sorted(GM.edges()), sorted(G.edges())) # Dict of lists # with multiedges, OK, but better write as DiGraph else you'll # get double edges dol = to_dict_of_lists(G) GG = from_dict_of_lists(dol, create_using=nx.MultiGraph) assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes())) assert_edges_equal(sorted(G.edges()), sorted(GG.edges())) GW = to_networkx_graph(dol, create_using=nx.MultiGraph) assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes())) assert_edges_equal(sorted(G.edges()), sorted(GW.edges())) GI = nx.MultiGraph(dol) assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes())) assert_edges_equal(sorted(G.edges()), sorted(GI.edges()))
def test_fasta__hash(): assert_equal(hash(FASTA("A", "B", "C")), hash(FASTA("A", "B", "C"))) assert_not_equal(hash(FASTA("A", "B", "C")), hash(FASTA("B", "B", "C"))) assert_not_equal(hash(FASTA("A", "B", "C")), hash(FASTA("A", "C", "C"))) assert_not_equal(hash(FASTA("A", "B", "C")), hash(FASTA("A", "B", "D")))
def test_win32(): nt.assert_not_equal(sys.platform, 'win32', "This test can't run under windows")
def iter2backoff_batches(cls, iter, batch_chunksize_list, buffer_size): logger = FoxylibLogger.func_level2logger(cls.iter2backoff_batches, logging.DEBUG) n = buffer_size m = len(batch_chunksize_list) queue_list = [[] for _ in range(m)] h_i2j = {} h_i2out = {} buffer_in = [None] * (n + 1) # f_batch_list = lmap(ig(0), batch_chunksize_list) # chunksize_list = lmap(ig(1), batch_chunksize_list) def i2next(i): return (i + 1) % (n + 1) def append2j(i, j): h_i2j[i] = j queue_list[j].append(i) def iy2out(i, y): h_i2out[i] = y h_i2j.pop(i) def i2j_new(i, j_old): j_new = j_old + 1 h_i2j[i] = j_new queue_list[j_new].append(i) def j2batch(j): if not queue_list[j]: return f_batch, chunksize = batch_chunksize_list[j] i_list = queue_list[j][:chunksize] queue_list[j] = queue_list[j][chunksize:] x_list = [buffer_in[i] for i in i_list] by_list = f_batch(x_list) if j == m - 1: ix_list = [(i, buffer_in[i]) for i, (b, y) in zip_strict(i_list, by_list) if not b] assert_false(ix_list) for i, (b, y) in zip_strict(i_list, by_list): if b: iy2out(i, y) else: i2j_new(i, j) logger.debug({ "step": "j2batch", "j": j, "h_i2out": h_i2out, "h_i2j": h_i2j, }) def i2yield(i): assert_in(i, h_i2out) assert_not_in(i, h_i2j) y = h_i2out.pop(i) logger.debug({"step": "i2yield", "i": i, "y": y}) return y i_head = -1 i_tail = -1 for x in iter: i_head = i2next(i_head) logger.debug({"i_head": i_head}) assert_not_in(i_head, h_i2j) buffer_in[i_head] = x append2j(i_head, 0) if len(h_i2j) + len(h_i2out) < n: continue i_tail = i2next(i_tail) logger.debug({ "i_tail": i_tail, "h_i2j": h_i2j, "h_i2out": h_i2out, }) assert_not_equal(i_tail in h_i2j, i_tail in h_i2out) if i_tail in h_i2out: yield i2yield(i_tail) continue j_tail = h_i2j[i_tail] for j in range(j_tail, m): j2batch(j) if i_tail not in h_i2out: # not done continue yield i2yield(i_tail) break for j in range(m): while queue_list[j]: j2batch(j) assert_false(h_i2j) while h_i2out: i_tail = i2next(i_tail) yield i2yield(i_tail)
def test_fetch_coords_power_2011(): bunch = atlas.fetch_coords_power_2011() assert_equal(len(bunch.rois), 264) assert_not_equal(bunch.description, '')
def test_get_ssdeep(self): try: import pydeep assert_not_equal(None, self.file.get_ssdeep()) except ImportError: assert_equal(None, self.file.get_ssdeep())
def test_fasta__inequality(): assert_not_equal(FASTA("A", "B", "C"), FASTA("A", "B", "D")) assert_not_equal(FASTA("A", "B", "C"), FASTA("A", None, "C")) assert_not_equal(FASTA("A", "B", "C"), FASTA("D", "B", "C"))
def test_collection_neq(): elements = ["a", "b", "c"] c1 = Collection(elements) c2 = Collection(elements[:2]) assert_not_equal(c1, c2)
def test_eternity(self): dt = d(2001, 1, 1) assert_less(dt, eternity) assert_less_equal(dt, eternity) assert_greater(eternity, dt) assert_greater_equal(eternity, dt) assert_less(-eternity, dt) assert_less_equal(-eternity, dt) assert_greater(dt, -eternity) assert_greater_equal(dt, -eternity) assert_less(-eternity, eternity) assert_less_equal(-eternity, eternity) assert_greater(eternity, -eternity) assert_greater_equal(eternity, -eternity) assert_equal(eternity, eternity) assert_equal(-eternity, -eternity) assert_not_equal(dt, eternity) assert_not_equal(eternity, dt) assert_not_equal(dt, -eternity) assert_not_equal(-eternity, dt) assert_not_equal(-eternity, eternity) assert_not_equal(eternity, -eternity) assert_equal([-eternity, dt, eternity], sorted([dt, eternity, -eternity])) assert_equal(eternity, --eternity) assert_equal(-eternity, ---eternity)
def test_undertaker(self): """ UNDERTAKER (CORE): Test the undertaker. """ tmp_scope = 'mock' nbdatasets = 5 nbfiles = 5 set_account_limit('jdoe', get_rse_id('MOCK'), -1) dsns1 = [{ 'name': 'dsn_%s' % generate_uuid(), 'scope': tmp_scope, 'type': 'DATASET', 'lifetime': -1 } for i in range(nbdatasets)] dsns2 = [{ 'name': 'dsn_%s' % generate_uuid(), 'scope': tmp_scope, 'type': 'DATASET', 'lifetime': -1, 'rules': [{ 'account': 'jdoe', 'copies': 1, 'rse_expression': 'MOCK', 'grouping': 'DATASET' }] } for i in range(nbdatasets)] add_dids(dids=dsns1 + dsns2, account='root') replicas = list() for dsn in dsns1 + dsns2: files = [{ 'scope': tmp_scope, 'name': 'file_%s' % generate_uuid(), 'bytes': 1, 'adler32': '0cc737eb', 'tombstone': datetime.utcnow() + timedelta(weeks=2), 'meta': { 'events': 10 } } for i in range(nbfiles)] attach_dids(scope=tmp_scope, name=dsn['name'], rse='MOCK', dids=files, account='root') replicas += files add_rules(dids=dsns1, rules=[{ 'account': 'jdoe', 'copies': 1, 'rse_expression': 'MOCK', 'grouping': 'DATASET' }]) undertaker(worker_number=1, total_workers=1, once=True) undertaker(worker_number=1, total_workers=1, once=True) for replica in replicas: assert_not_equal( get_replica(scope=replica['scope'], name=replica['name'], rse='MOCK')['tombstone'], None)
def test_get_sample_data(cls): data = cls.indexer.get_sample_data({}, database='hue', table='desktop_document2', column='id') assert_equal(0, data['status'], data) assert_not_equal('', data['rows'], data)