def test_query_raises_with_bad_range(self):
with self.assertRaisesRegexp(ValueError, 'Unknown reference_name'):
self.samples_reader.query(ranges.parse_literal('XXX:1-10'))
with self.assertRaisesRegexp(ValueError, 'Malformed region'):
self.samples_reader.query(ranges.parse_literal('chr1:0-5'))
with self.assertRaisesRegexp(ValueError, 'Malformed region'):
self.samples_reader.query(ranges.parse_literal('chr1:6-5'))
with self.assertRaisesRegexp(ValueError, 'Malformed region'):
self.samples_reader.query(ranges.parse_literal('chr1:10-5'))
def test_context_manager(self):
with vcf_reader.VcfReader.from_file(self.sites_vcf,
self.unindexed_options) as f:
self.assertEqual(expected_sites_contigs, list(f.header.contigs))
# Commented out because we in fact don't detect the malformed VCF yet. It is
# unclear if it's even possible to detect the issue with the API provided by
# htslib.
# def test_vcf_iterate_raises_on_malformed_record(self):
# malformed = test_utils.genomics_core_testdata('malformed.vcf')
# reader = vcf_reader.VcfReader.from_file(malformed, self.unindexed_options)
# iterable = iter(reader.iterate())
# self.assertIsNotNone(next(iterable))
# with self.assertRaises(ValueError):
# print(list(iterable))
if __name__ == '__main__':
absltest.main()
from evaluation.metrics import factor_vae
import numpy as np
class FactorVaeTest(absltest.TestCase):
def test_metric(self):
ground_truth_data = dummy_data.IdentityObservationsData()
representation_function = lambda x: x
random_state = np.random.RandomState(0)
scores = factor_vae.compute_factor_vae(ground_truth_data,
representation_function,
random_state, None, 5, 3000,
2000, 2500)
self.assertBetween(scores["train_accuracy"], 0.9, 1.0)
self.assertBetween(scores["eval_accuracy"], 0.9, 1.0)
def test_bad_metric(self):
ground_truth_data = dummy_data.IdentityObservationsData()
representation_function = np.zeros_like
random_state = np.random.RandomState(0)
scores = factor_vae.compute_factor_vae(ground_truth_data,
representation_function,
random_state, None, 5, 3000,
2000, 2500)
self.assertBetween(scores["train_accuracy"], 0.0, 0.2)
self.assertBetween(scores["eval_accuracy"], 0.0, 0.2)
if __name__ == "__main__":
absltest.main()
def main(argv=None): del argv # Unused. testing_startup.TestInit() absltest.main()
def test_xla_context_preserved_slice(self):
arr = np.arange(10, dtype=np.float32)
def f_jax(arr):
return lax.dynamic_slice(
arr, [100],
[1]) # out of bounds, should return the last element
self._compare_with_saved_model(f_jax, arr)
def test_xla_context_preserved_gather(self):
raise unittest.SkipTest(
"Disable in preparation for fixing b/153556869")
def f_jax(arr):
return arr[100] # out of bounds, should return the last element
arr = np.arange(10, dtype=np.float32)
if jtu.device_under_test() != "tpu":
# TODO(b/153556869): the compilation attributes are not saved in savedmodel
with self.assertRaisesRegex(
BaseException,
"Input 2 to .* XlaGather must be a compile-time constant"):
self._compare_with_saved_model(f_jax, arr)
else:
self._compare_with_saved_model(f_jax, arr)
if __name__ == "__main__":
absltest.main(testLoader=jtu.JaxTestLoader())
with self.subTest('07_start_test_client'):
test_client = self.startTestClient(test_servers[0])
with self.subTest('08_test_client_xds_config_exists'):
self.assertXdsConfigExists(test_client)
with self.subTest('09_test_server_received_rpcs_from_test_client'):
self.assertSuccessfulRpcs(test_client)
with self.subTest('10_round_robin'):
num_rpcs = 100
expected_rpcs_per_replica = num_rpcs / REPLICA_COUNT
rpcs_by_peer = self.getClientRpcStats(test_client,
num_rpcs).rpcs_by_peer
total_requests_received = sum(rpcs_by_peer[x]
for x in rpcs_by_peer)
self.assertEqual(total_requests_received, num_rpcs,
'Wrong number of RPCS')
for server in test_servers:
hostname = server.hostname
self.assertIn(hostname, rpcs_by_peer,
f'Server {hostname} did not receive RPCs')
self.assertLessEqual(
abs(rpcs_by_peer[hostname] - expected_rpcs_per_replica), 1,
f'Wrong number of RPCs for server {hostname}')
if __name__ == '__main__':
absltest.main(failfast=True)
self.tcli_obj.pipe = '/bin/grep boo | /bin/grep -v hoo'
self.assertEqual(b'boo\n', self.tcli_obj._Pipe('boo\nhoo'))
self.tcli_obj.pipe = '/bin/grep boo | /bin/grep -v boo'
self.assertEqual(b'', self.tcli_obj._Pipe('boo\nhoo'))
def testTildeExpandTargets(self):
"""Tests target expansion."""
with mock.patch.object(self.tcli_obj, '_PrintSystem') as mock_print:
self.tcli_obj.inventory.device_list = ['device_a', 'device_b']
self.tcli_obj.TildeCmd('expandtargets')
mock_print.assert_called_once_with('device_a,device_b')
def testAdvancedRegexpTargets(self):
"""b/2725704 tcli fails to parse regexes."""
# pylint: disable=anomalous-backslash-in-string
self.assertEqual(
('somecommand', [r'^br\d{2}.*'], False),
self.tcli_obj.cli_parser.ParseCommandLine(r"somecommand '^br\d{2}.*'"))
# Complex tilde commands targets/xtargets must be quoted.
# pylint: disable=anomalous-backslash-in-string
self.assertEqual(
('somecommand', [r'^brd{2}.*'], False),
self.tcli_obj.cli_parser.ParseCommandLine(r'somecommand ^br\d{2}.*'))
if __name__ == '__main__':
unittest.main()
def main(_):
absltest.main()
self.assertGreater(cmp_compat.cmp(b, a), 0)
elif outcome == Outcome.EQ:
self.assertEqual(cmp_compat.cmp(a, b), 0)
self.assertEqual(cmp_compat.cmp(b, a), 0)
elif outcome == Outcome.NE:
self.assertNotEqual(cmp_compat.cmp(a, b), 0)
self.assertNotEqual(cmp_compat.cmp(b, a), 0)
def testTotalOrderingFromCmp(self):
for a_val, b_val, outcome in test_cases:
a = IHaveACmp(a_val)
b = IHaveACmp(b_val)
if outcome == Outcome.LT:
self.assertLess(a, b)
self.assertGreater(b, a)
elif outcome == Outcome.EQ:
self.assertEqual(a, b)
self.assertEqual(b, a)
elif outcome == Outcome.NE:
self.assertNotEqual(a, b)
self.assertNotEqual(b, a)
def main(unused_argv):
absltest.main()
if __name__ == '__main__':
absltest.main(main)
def main(unused_argv): absltest.main()
def main(): """Simple wrapper to call absltest.main().""" return absltest.main()
def main():
absltest.main(*sys.argv)
def main(argv):
flow.env.init()
absltest.main()
self.assertLessEqual(agent.episodes, agent.reward)
self.assertEqual(agent.steps, self.steps)
def test_collect_mineral_shards(self):
with sc2_env.SC2Env(
map_name="CollectMineralShards",
step_mul=self.step_mul,
game_steps_per_episode=self.steps * self.step_mul) as env:
agent = scripted_agent.CollectMineralShards()
run_loop.run_loop([agent], env, self.steps)
# Get some points
self.assertLessEqual(agent.episodes, agent.reward)
self.assertEqual(agent.steps, self.steps)
def test_defeat_roaches(self):
with sc2_env.SC2Env(
map_name="DefeatRoaches",
step_mul=self.step_mul,
game_steps_per_episode=self.steps * self.step_mul) as env:
agent = scripted_agent.DefeatRoaches()
run_loop.run_loop([agent], env, self.steps)
# Get some points
self.assertLessEqual(agent.episodes, agent.reward)
self.assertEqual(agent.steps, self.steps)
if __name__ == "__main__":
basetest.main()
def main(*args, **kwargs):
"""Pass args and kwargs through to absltest main."""
return absltest.main(*args, **kwargs)
