def test_write(self):
mocker = Mocker()
db = mocker.mock()
insert_book ='''
insert into book (title, isbn, publisher, list_price,
publish_date, class, sheet_numbers, folio, print_type,
author, barcode, comments) values
('a', '1234', 'aph', '30', '2012', 'I.',
18, '4', 'mono', 'sb', 'a', 'blahblahblah')
'''
db.query(insert_book)
insert_tags = '''
'''
db.query(insert_tags)
db.commit()
mocker.replay()
writer = CatalogMySQLWriter(db)
item = CatalogItem(
'a', '1234', 'aph', '30', '2012', 'I.', 18, '4', 'mono', 'sb',
'a', 'blahblahblah', { 'audience': 'ms', 'awards': 'annual' })
writer.write(item)
mocker.restore()
mocker.verify()
def setUpZope(self, app, configurationContext):
# Mock postmonkey
mocker = Mocker()
postmonkey = mocker.replace("postmonkey")
mailchimp = postmonkey.PostMonkey(ANY)
mocker.count(0, 1000)
# Lists
mailchimp.lists()
mocker.count(0, 1000)
mocker.result({
u'total': 2,
u'data': [{
u'id': 625,
u'web_id': 625,
u'name': u'ACME Newsletter',
u'default_from_name': u'*****@*****.**',
},
{
u'id': 626,
u'web_id': 626,
u'name': u'ACME Newsletter 2',
u'default_from_name': u'*****@*****.**',
},
]})
mocker.replay()
# Load ZCML
import example.tdd
xmlconfig.file(
'configure.zcml',
example.tdd,
context=configurationContext
)
def test_offset(self):
"""
Test that, if the server's BEGIN_CONTENT message specifies an offset,
the file to be uploaded is seek'ed to the right position.
"""
offset = 23
mocker = Mocker()
transport = mocker.mock()
transport.registerProducer(ANY, streaming=True)
transport.write(ANY)
mocker.count(1, None) # I don't really care how many times
fd = mocker.mock()
fd.seek(offset) # this is really all I care about
fd.read(ANY)
mocker.result('')
mocker.replay()
protocol = StorageClient()
protocol.transport = transport
pc = PutContent(protocol, 'share', 'node', '', '', 0, 0, 0, fd)
message = protocol_pb2.Message()
message.type = protocol_pb2.Message.BEGIN_CONTENT
message.begin_content.offset = offset
pc.start()
pc.processMessage(message)
def test_result_is_cached(self):
viewlet = self.get_viewlet()
viewlet.update()
self.assertNotIn('purple', viewlet.generate_css(),
'Unexpectedly found "purple" in the CSS')
# Setting a custom style automatically invalidates the cache.
# For testing that things are cached, we stub the cache invalidation,
# so that the cache persists.
mocker = Mocker()
invalidate_cache_mock = mocker.replace(invalidate_cache)
expect(invalidate_cache_mock()).count(1, None)
mocker.replay()
ICustomStyles(self.layer['portal']).set('css.body-background', 'purple')
self.assertNotIn('purple', viewlet.generate_css(),
'The result was not cached.')
# Removing the stub and invalidating the cache should update the result.
mocker.restore()
mocker.verify()
invalidate_cache()
self.assertIn('purple', viewlet.generate_css(),
'Expected "purple" in CSS - does the style'
' css.body-background no longer work?')
def test_find_match_not_matched(self):
key1 = 'chr1:154000-230000'
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result([key1])
container1[key1]
mocker.result(junction)
container2[key1]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [])
self.assertEqual(self.diff.keys(), [key1])
mocker.restore()
mocker.verify()
def test_without_when(self):
mocker = Mocker()
mock_time = mocker.replace('time.time')
mock_time()
mocker.result(1.0)
mock_time()
mocker.result(2.0)
mock_time()
mocker.result(3.0)
mock_time()
mocker.result(4.0)
mock_time()
mocker.result(5.0)
mocker.replay()
controller = pid.PID(P = 0.5, I = 0.5, D = 0.5,
setpoint = 0, initial = 12)
self.assertEqual(controller.calculate_response(6), -3)
self.assertEqual(controller.calculate_response(3), -4.5)
self.assertEqual(controller.calculate_response(-1.5), -0.75)
self.assertEqual(controller.calculate_response(-2.25), -1.125)
mocker.restore()
mocker.verify()
def test_find_match_matched(self):
key = 'chr1:154000-230000'
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
mocker.count(1, None)
container = mocker.mock()
container.keys()
mocker.result([key])
container[key]
mocker.result(junction)
mocker.count(1, None)
mocker.replay()
self.common, self.diff = jc.findMatch(container, container)
self.assertEqual(self.common.keys(), ['chr1:154000-230000'])
self.assertEqual(self.diff.keys(), [])
mocker.restore()
mocker.verify()
def test_read_tags(self):
mocker = Mocker()
csv_reader = mocker.mock()
headers = [
'title', 'isbn', 'publisher', 'list_price', 'publish_date',
'class_', 'sheet_numbers', 'folio', 'print_type', 'author',
'barcode', 'comments', 'audience', 'awards']
first_line = [
'a', '1234', 'aph', '30', '2012', 'I.', 18, '4', 'mono', 'sb', 'a',
'blahblahblah', 'ms', 'annual']
field_map = {'title': 0, 'isbn': 1, 'publisher': 2, 'list_price': 3,
'publish_date': 4, 'class_': 5, 'sheet_numbers': 6, 'folio': 7,
'print_type': 8, 'author': 9, 'barcode': 10, 'comments': 11 }
csv_reader.next() # read headers
mocker.result(headers)
csv_reader.next() # read first line
mocker.result(first_line)
mocker.replay()
reader = CatalogReader(csv_reader, field_map)
item = reader.read()
self.assertIsInstance(item, CatalogItem)
self.assertEquals(2, len(item.tags))
self.assertEquals('ms', item.tags['audience'])
self.assertEquals('annual', item.tags['awards'])
mocker.restore()
mocker.verify()
def test_required_field_missing(self):
mocker = Mocker()
csv_reader = mocker.mock()
headers = [
'title', 'isbn', 'publisher', 'list_price', 'publish_date',
'class_', 'sheet_numbers', 'folio', 'print_type', 'author',
'barcode']
first_line = [
'a', '1234', 'aph', '30', '2012', 'I.', 18, '4', 'mono', 'sb', 'a']
field_map = {
'title': 0, 'isbn': 1, 'publisher': 2, 'list_price': 3,
'publish_date': 4, 'class_': 5, 'sheet_numbers': 6, 'folio': 7,
'print_type': 8, 'author': 9, 'barcode': 10, 'comments': 11 }
csv_reader.next() # read headers
mocker.result(headers)
csv_reader.next() # read first line
mocker.result(first_line)
mocker.replay()
reader = CatalogReader(csv_reader, field_map)
item = reader.read()
self.assertIsNone(item.comments)
mocker.restore()
mocker.verify()
def test_log_changes_with_valid_params(self):
mocker = Mocker()
databroker = mocker.mock()
document_types = ['article', 'journal']
events = ['add', 'update', 'delete']
# db "insert" must be called len(document_types) * len(events) times
for document_type in document_types:
for event in events:
databroker['historychanges_%s' % document_type].insert(ANY)
mocker.result(123457890)
mocker.replay()
db = DataBroker(databroker)
for document_type in document_types:
for event in events:
log_data = {
'document_type': document_type,
'code': '123',
'collection': 'test_collection',
'event': event,
'date': datetime.now().isoformat(),
}
log_id = db._log_changes(**log_data)
self.assertEqual(log_id, 123457890)
def test_historylogs_without_filters(self):
for document_type in ['article', 'journal']:
historylogs = json.loads(
open(
os.path.dirname(__file__) +
'/fixtures/historylogs_%s.json' % document_type).read())
mocker = Mocker()
databroker = mocker.mock()
databroker['historychanges_%s' % document_type].find(ANY).count()
mocker.result(historylogs['meta']['total'])
databroker['historychanges_%s' % document_type].find(ANY).skip(
ANY).limit(ANY).sort("date")
mocker.result(historylogs['objects'])
mocker.replay()
db = DataBroker(databroker)
result = db.historychanges(document_type)
# assert date filters are correct in meta
self.assertIn('meta', result.keys())
self.assertIn('filter', result['meta'].keys())
self.assertIn('date', result['meta']['filter'].keys())
self.assertEqual(['$lte', '$gt'],
result['meta']['filter']['date'].keys())
self.assertEqual(historylogs['meta']['total'],
result['meta']['total'])
self.assertIn('objects', result.keys())
self.assertEqual(historylogs['objects'], result['objects'])
self.assertEqual(result['objects'][0].keys(),
['date', 'code', 'event', 'collection'])
def test_find_match_not_matched(self):
key1 = "chr1:154000-230000"
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result([key1])
container1[key1]
mocker.result(junction)
container2[key1]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [])
self.assertEqual(self.diff.keys(), [key1])
mocker.restore()
mocker.verify()
def test_historylogs_without_filters(self):
for document_type in ['article', 'journal']:
historylogs = json.loads(
open(os.path.dirname(__file__) +
'/fixtures/historylogs_%s.json' % document_type).read()
)
mocker = Mocker()
databroker = mocker.mock()
databroker['historychanges_%s' % document_type].find(ANY).count()
mocker.result(historylogs['meta']['total'])
databroker['historychanges_%s' % document_type].find(ANY).skip(ANY).limit(ANY).sort("date")
mocker.result(historylogs['objects'])
mocker.replay()
db = DataBroker(databroker)
result = db.historychanges(document_type)
# assert date filters are correct in meta
self.assertIn('meta', result.keys())
self.assertIn('filter', result['meta'].keys())
self.assertIn('date', result['meta']['filter'].keys())
self.assertEqual(['$lte', '$gt'], result['meta']['filter']['date'].keys())
self.assertEqual(
historylogs['meta']['total'],
result['meta']['total']
)
self.assertIn('objects', result.keys())
self.assertEqual(historylogs['objects'], result['objects'])
self.assertEqual(
result['objects'][0].keys(),
['date', 'code', 'event', 'collection']
)
def test_find_match_matched(self):
key = "chr1:154000-230000"
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
mocker.count(1, None)
container = mocker.mock()
container.keys()
mocker.result([key])
container[key]
mocker.result(junction)
mocker.count(1, None)
mocker.replay()
self.common, self.diff = jc.findMatch(container, container)
self.assertEqual(self.common.keys(), ["chr1:154000-230000"])
self.assertEqual(self.diff.keys(), [])
mocker.restore()
mocker.verify()
def test_result_is_cached(self):
view = self.get_view()
self.assertNotIn('purple', view.generate_css(),
'Unexpectedly found "purple" in the CSS')
# Setting a custom style automatically invalidates the cache.
# For testing that things are cached, we stub the cache invalidation,
# so that the cache persists.
mocker = Mocker()
invalidate_cache_mock = mocker.replace(invalidate_cache)
expect(invalidate_cache_mock()).count(1, None)
mocker.replay()
ICustomStyles(self.layer['portal']).set('css.body-background',
'purple')
self.assertNotIn('purple', view.generate_css(),
'The result was not cached.')
# Removing the stub and invalidating the cache should update the result.
mocker.restore()
mocker.verify()
invalidate_cache()
self.assertIn(
'purple', view.generate_css(),
'Expected "purple" in CSS - does the style'
' css.body-background no longer work?')
def test_log_changes_with_valid_params(self):
mocker = Mocker()
databroker = mocker.mock()
document_types = ['article', 'journal']
events = ['add', 'update', 'delete']
# db "insert" must be called len(document_types) * len(events) times
for document_type in document_types:
for event in events:
databroker['historychanges_%s' % document_type].insert(ANY)
mocker.result(123457890)
mocker.replay()
db = DataBroker(databroker)
for document_type in document_types:
for event in events:
log_data = {
'document_type': document_type,
'code': '123',
'collection': 'test_collection',
'event': event,
'date': datetime.now().isoformat(),
}
log_id = db._log_changes(**log_data)
self.assertEqual(log_id, 123457890)
def test_read_basic_fields(self):
mocker = Mocker()
csv_reader = mocker.mock()
csv_reader.next()
header_line = [
'title', 'isbn', 'publisher', 'list_price', 'publish_date',
'class_', 'sheet_numbers', 'folio', 'print_type', 'author',
'barcode', 'comments']
mocker.result(header_line)
csv_reader.next()
first_line = [
'a', '1234', 'aph', '30', '2012', 'I.', 18, '4', 'mono', 'sb', 'a',
'blahblahblah' ]
mocker.result(first_line)
mocker.replay()
field_map = {'title': 0, 'isbn': 1, 'publisher': 2, 'list_price': 3,
'publish_date': 4, 'class_': 5, 'sheet_numbers': 6, 'folio': 7,
'print_type': 8, 'author': 9, 'barcode': 10, 'comments': 11 }
reader = CatalogReader(csv_reader, field_map)
item = reader.read()
self.assertIsInstance(item, CatalogItem)
mocker.restore()
mocker.verify()
def test_is_up_shold_return_true_when_instance_is_running_and_db_is_up(self):
mocker = Mocker()
obj = mocker.replace("mysqlapi.api.models.DatabaseManager.is_up")
obj()
mocker.result(True)
mocker.replay()
instance = Instance(name="foo", state="running")
manager = DatabaseManager("foo", "127.0.0.1")
self.assertTrue(instance.is_up(manager))
def test_default_variant_label_empty(self):
mocker = Mocker()
data = mocker.mock()
data.context.objectValues()
mocker.result(())
mocker.replay()
self.assertEquals(shopitem.default_variant_label(data), '')
def test_str(self):
mocker = Mocker()
junc = mocker.mock()
junc.getCoord()
mocker.result("chr1:154000-230000")
junc.name
mocker.result("JUNC00001")
mocker.replay()
self.assertEqual(jc.Junction.__str__.im_func(junc), "chr1:154000-230000, JUNC00001")
def test_is_up_should_return_false_when_instance_is_not_running(self):
mocker = Mocker()
obj = mocker.replace("mysqlapi.api.models.DatabaseManager.is_up")
obj()
mocker.result(False)
mocker.replay()
instance = Instance(name="foo", state="running")
manager = DatabaseManager("foo", "127.0.0.1")
self.assertFalse(instance.is_up(manager))
def test_default_opener(self):
mocker = Mocker()
DeliciousAPI = mocker.replace("deliciousapi.DeliciousAPI")
dapi = DeliciousAPI()
dapi.get_user("test_user", "test_pass")
mocker.result(OPENER_RESULT)
mocker.replay()
default_opener("test_user", "test_pass")
mocker.verify()
def test_str(self):
mocker = Mocker()
junc = mocker.mock()
junc.getCoord()
mocker.result('chr1:154000-230000')
junc.name
mocker.result('JUNC00001')
mocker.replay()
self.assertEqual(jc.Junction.__str__.im_func(junc),
'chr1:154000-230000, JUNC00001')
def test_get_coord(self):
mocker = Mocker()
junc = mocker.mock()
junc.chrom
mocker.result("chr1")
junc.start
mocker.result(154000)
junc.end
mocker.result(230000)
mocker.replay()
self.assertEqual(jc.Junction.getCoord.im_func(junc), "chr1:154000-230000")
def test_get_article_available_code(self):
mocker = Mocker()
databroker = mocker.mock()
databroker['articles'].find_one(ANY)
mocker.result(self._raw_json)
mocker.replay()
db = DataBroker(databroker)
self.assertEqual(db.get_article('xx')['code'], 'S0034-89102010000400007')
def test_get_article_unavailable_code(self):
mocker = Mocker()
databroker = mocker.mock()
databroker['articles'].find_one(ANY)
mocker.result(None)
mocker.replay()
db = DataBroker(databroker)
self.assertEqual(db.get_article('xx'), None)
def test_exists_article_False(self):
mocker = Mocker()
databroker = mocker.mock()
databroker['articles'].find(ANY).count()
mocker.result(None)
mocker.replay()
db = DataBroker(databroker)
self.assertEqual(db.exists_article('xx'), False)
def test_exists_article_False(self):
mocker = Mocker()
databroker = mocker.mock()
databroker['articles'].find(ANY).count()
mocker.result(None)
mocker.replay()
db = DataBroker(databroker)
self.assertEqual(db.exists_article('xx'), False)
def test_fill_order():
order = Order("item #1", 50)
mocker = Mocker()
inventory = mocker.mock()
inventory.remove("item #1", 50)
mocker.replay()
order.fill(inventory)
mocker.verify()
assert order.filled
def test_get_coord(self):
mocker = Mocker()
junc = mocker.mock()
junc.chrom
mocker.result('chr1')
junc.start
mocker.result(154000)
junc.end
mocker.result(230000)
mocker.replay()
self.assertEqual(jc.Junction.getCoord.im_func(junc),
'chr1:154000-230000')
def test_converte2opl(self):
linhas_arquivo_entrada = [['4','3'],['0','1','2','4'],['0','2','4','8'],['1','3','6','12'],['0','3']]
linhas_arquivo_saida_esperada = ['s = "0";','d = "3";',
'A = {<"0","1",[2,4]>,\n<"0","2",[4,8]>,\n<"1","3",[6,12]>};']
converte2opl = Converte2OPL('arquivo.txt','arquivo_saida.txt')
mocker = Mocker()
obj = mocker.patch(converte2opl)
obj.le_arquivo_entrada()
mocker.result(linhas_arquivo_entrada)
mocker.replay()
obj.converte()
self.assertListEqual(linhas_arquivo_saida_esperada,obj.linhas_arquivo_saida)
def test_healthcheck_returns_500_if_the_mysql_server_is_off(self):
mocker = Mocker()
obj = mocker.replace("mysqlapi.api.models.DatabaseManager.is_up")
obj()
mocker.result(False)
mocker.replay()
request = RequestFactory().get("/resources/g8mysql/status/")
view = Healthcheck()
fake = mocks.FakeEC2Client()
view._client = fake
response = view.get(request, "g8mysql")
self.assertEqual(500, response.status_code)
mocker.verify()
def test_import_urls_from_delicious(self):
mocker = Mocker()
opener = mocker.mock()
opener("test_user", "test_pass")
mocker.result(OPENER_RESULT)
mocker.replay()
urls = import_urls_from_delicious("test_user", "test_pass", opener)
self.assertEquals("http://example.com/", urls[0].url)
self.assertEquals("http://google.com/", urls[1].url)
self.assertEquals("http://yahoo.com/", urls[2].url)
mocker.verify()
def test_order_not_filled():
order = Order("item #1", 1)
mocker = Mocker()
inventory = mocker.mock()
inventory.remove("item #1", 1)
mocker.throw(QuantityError)
mocker.replay()
order.fill(inventory)
mocker.verify()
assert not order.filled
class FreezedClock(object):
def __init__(self, new_now):
self.new_now = new_now
def forward(self, **kwargs):
self.new_now = datetime.now() + timedelta(**kwargs)
self.__exit__(None, None, None)
self.__enter__()
def backward(self, **kwargs):
self.new_now = datetime.now() - timedelta(**kwargs)
self.__exit__(None, None, None)
self.__enter__()
def __enter__(self):
if type(self.new_now) != datetime:
raise ValueError(
'The freeze_date argument must be a datetime.datetime'
' instance, got %s' % type(self.new_now).__name__)
self.mocker = Mocker()
# Replace "datetime.datetime.now" classmethod
self._previous_datetime_now = datetime.now
@classmethod
def freezed_now(klass, tz=None):
if not tz:
return self.new_now.replace(tzinfo=None)
elif self.new_now.tzinfo != tz:
return tz.normalize(self.new_now.astimezone(tz))
else:
return self.new_now
curse(datetime, 'now', freezed_now)
# Replace "time.time" function
new_time = (calendar.timegm(self.new_now.timetuple()) +
(self.new_now.timetuple().tm_isdst * 60 * 60) +
(self.new_now.microsecond * 0.000001))
time_class = self.mocker.replace('time.time')
expect(time_class()).call(lambda: new_time).count(0, None)
self.mocker.replay()
return self
def __exit__(self, exc_type, exc_value, traceback):
self.mocker.restore()
self.mocker.verify()
curse(datetime, 'now', self._previous_datetime_now)
class BundleDeserializationTests(TestCaseWithScenarios):
scenarios = [
('dummy_import_failure', {
'pathname': '/public/personal/admin/',
'is_public': 'true',
'content': 'bogus',
'content_filename': 'test1.json',
}),
]
def setUp(self):
super(BundleDeserializationTests, self).setUp()
self.bundle = fixtures.create_bundle(
self.pathname, self.content, self.content_filename)
self.mocker = Mocker()
def tearDown(self):
self.bundle.delete_files()
self.mocker.restore()
self.mocker.verify()
super(BundleDeserializationTests, self).tearDown()
def test_deserialize_failure_leaves_trace(self):
mock = self.mocker.patch(self.bundle)
expect(mock._do_deserialize(False)).throw(Exception("boom"))
self.mocker.replay()
self.bundle.deserialize(False)
self.assertFalse(self.bundle.is_deserialized)
self.assertEqual(self.bundle.deserialization_error.error_message, "boom")
def test_deserialize_ignores_deserialized_bundles(self):
# just reply as we're not using mocker in this test case
self.mocker.replay()
self.bundle.is_deserialized = True
self.bundle.deserialize(False)
self.assertTrue(self.bundle.is_deserialized)
def test_deserialize_sets_is_serialized_on_success(self):
mock = self.mocker.patch(self.bundle)
expect(mock._do_deserialize(False))
self.mocker.replay()
self.bundle.deserialize(False)
self.assertTrue(self.bundle.is_deserialized)
def test_deserialize_clears_old_error_on_success(self):
BundleDeserializationError.objects.create(
bundle=self.bundle,
error_message="not important").save()
mock = self.mocker.patch(self.bundle)
expect(mock._do_deserialize(False))
self.mocker.replay()
self.bundle.deserialize(False)
# note we cannot check for self.bundle.deserialization_error
# directly due to the way django handles operations that affect
# existing instances (it does not touch them like storm would
# IIRC).
self.assertRaises(
BundleDeserializationError.DoesNotExist,
BundleDeserializationError.objects.get, bundle=self.bundle)
class BundleDeserializationTests(TestCaseWithScenarios):
scenarios = [
('dummy_import_failure', {
'pathname': '/public/personal/admin/',
'is_public': 'true',
'content': 'bogus',
'content_filename': 'test1.json',
}),
]
def setUp(self):
super(BundleDeserializationTests, self).setUp()
self.bundle = fixtures.create_bundle(self.pathname, self.content,
self.content_filename)
self.mocker = Mocker()
def tearDown(self):
self.bundle.delete_files()
self.mocker.restore()
self.mocker.verify()
super(BundleDeserializationTests, self).tearDown()
def test_deserialize_failure_leaves_trace(self):
mock = self.mocker.patch(self.bundle)
expect(mock._do_deserialize(False)).throw(Exception("boom"))
self.mocker.replay()
self.bundle.deserialize(False)
self.assertFalse(self.bundle.is_deserialized)
self.assertEqual(self.bundle.deserialization_error.error_message,
"boom")
def test_deserialize_ignores_deserialized_bundles(self):
# just reply as we're not using mocker in this test case
self.mocker.replay()
self.bundle.is_deserialized = True
self.bundle.deserialize(False)
self.assertTrue(self.bundle.is_deserialized)
def test_deserialize_sets_is_serialized_on_success(self):
mock = self.mocker.patch(self.bundle)
expect(mock._do_deserialize(False))
self.mocker.replay()
self.bundle.deserialize(False)
self.assertTrue(self.bundle.is_deserialized)
def test_deserialize_clears_old_error_on_success(self):
BundleDeserializationError.objects.create(
bundle=self.bundle, error_message="not important").save()
mock = self.mocker.patch(self.bundle)
expect(mock._do_deserialize(False))
self.mocker.replay()
self.bundle.deserialize(False)
# note we cannot check for self.bundle.deserialization_error
# directly due to the way django handles operations that affect
# existing instances (it does not touch them like storm would
# IIRC).
self.assertRaises(BundleDeserializationError.DoesNotExist,
BundleDeserializationError.objects.get,
bundle=self.bundle)
def test_iatc_cellSize():
cell = ImageAndTextCell.alloc().init()
assert cell.image() is None
size = cell.cellSize()
m = Mocker()
image = m.mock(NSImage)
image.size().width >> 10
m.replay()
cell.setImage_(image)
assert cell.image() is image
print size.width
size2 = cell.cellSize()
assert size2.width == size.width + 10, "%s != %s" % (size2.width, size.width + 10)
assert size2.height == size.height
class MockEnvironment(object):
def __init__(self):
self.mocker = Mocker()
_setup_fileio(self.mocker)
_setup_mysqlclient(self.mocker)
_setup_subprocess(self.mocker)
def replace_environment(self):
self.mocker.replay()
def restore_environment(self):
# restore MySQLClient
# restore normal file io
# restore normal subprocess
self.mocker.restore()
class MockEnvironment(object):
def __init__(self):
self.mocker = Mocker()
_setup_fileio(self.mocker)
_setup_mysqlclient(self.mocker)
_setup_subprocess(self.mocker)
def replace_environment(self):
self.mocker.replay()
def restore_environment(self):
# restore MySQLClient
# restore normal file io
# restore normal subprocess
self.mocker.restore()
def test_iatc_cellSize():
cell = mod.ImageAndTextCell.alloc().init()
assert cell.image() is None
size = cell.cellSize()
m = Mocker()
image = m.mock(ak.NSImage)
image.size().width >> 10
m.replay()
cell.setImage_(image)
assert cell.image() is image
print(size.width)
size2 = cell.cellSize()
assert size2.width == size.width + 10, "%s != %s" % (size2.width,
size.width + 10)
assert size2.height == size.height
def test_shared_exon(self):
mocker = Mocker()
self.model = mocker.mock()
self.model.blockStarts
mocker.result([100, 400, 700])
mocker.count(2, None)
self.model.blockSizes
mocker.result([100, 100, 100])
mocker.count(1, None)
self.model.chrom
mocker.result('chr1')
mocker.count(2, None)
self.model.start
mocker.result(0)
mocker.count(1, None)
self.junctions1 = mocker.mock()
self.junctions2 = mocker.mock()
self.junc1 = [400]
self.junc2 = [700]
juncKey = 'chr1:200'
self.junctions1[juncKey]
mocker.result(self.junc1)
self.junctions2[juncKey]
mocker.result(self.junc2)
juncKey = 'chr1:500'
self.junctions1[juncKey]
mocker.throw(KeyError)
juncKey = 'chr1:800'
self.junctions1[juncKey]
mocker.throw(KeyError)
mocker.replay()
self.sharedExons = {}
jc.scanJunctions(self.model, self.junctions1, self.junctions2,
self.sharedExons)
for j in self.sharedExons:
self.assertEqual(self.sharedExons[j], [400])
self.assertEqual(j, 'chr1:200')
def test_without_when(self):
mocker = Mocker()
mock_time = mocker.replace('time.time')
mock_time()
mocker.result(1.0)
mocker.replay()
controller = pid.PID(P = 0.5, I = 0.5, D = 0.5,
setpoint = 0, initial = 12)
mocker.restore()
mocker.verify()
self.assertEqual(controller.gains, (0.5, 0.5, 0.5))
self.assertAlmostEqual(controller.setpoint[0], 0.0)
self.assertEqual(len(controller.setpoint), 1)
self.assertAlmostEqual(controller.previous_time, 1.0)
self.assertAlmostEqual(controller.previous_error, -12.0)
self.assertAlmostEqual(controller.integrated_error, 0)
def test_authorized_when_plugin_returns_True(self):
clientmanager = getUtility(IClientManager)
client = clientmanager.get_client_by_id('foo')
mocker = Mocker()
request = DummyRequest(headers={'X-BRIDGE-ORIGIN': 'foo'})
plugin = mocker.mock()
expect(plugin(request)).result(plugin)
expect(plugin.is_authorized(client)).result(True)
sm = get_current_registry()
sm.registerAdapter(plugin, [Interface],
IAuthorizationPlugin,
name='foo',
event=False)
mocker.replay()
manager = queryAdapter(request, IAuthorizationManager)
self.assertTrue(manager.authorize())
mocker.restore()
mocker.verify()
def test_find_match_match_not_match(self):
key1 = ['chr1:154000-230000', 'chr1:155000-230000']
key2 = ['chr1:154000-230000']
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
mocker.count(1, None)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result(key1)
container1[key1[0]]
mocker.result(junction)
mocker.count(1, None)
container1[key1[1]]
mocker.result(junction)
mocker.count(1, None)
container2[key1[0]]
mocker.result(junction)
mocker.count(1, None)
container2[key1[1]]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [key1[0]])
self.assertEqual(self.diff.keys(), [key1[1]])
mocker.restore()
mocker.verify()
class Test_sascalc_Prop_calcpmi(MockerTestCase):
def setUp(self):
self.centertmp = sasop.Move.center
self.m = Mocker()
sasop.Move.center = self.m.mock()
sasop.Move.center(ARGS)
self.m.result(None)
self.m.count(0, None)
self.m.replay()
self.o = sasmol.SasMol(0)
def assert_list_almost_equal_flip_sign_allowed(self, a, b, places=5):
if (len(a) != len(b)):
raise TypeError
else:
sign = 1
for i in range(len(a)):
if isinstance(a[i], (int, float)):
if (numpy.isnan(a[i]) and numpy.isnan(b[i])): continue
if (a[i] * b[i] < 0.0): sign = -1
self.assertAlmostEqual(a[i], sign * b[i], places)
else:
self.assert_list_almost_equal_flip_sign_allowed(
a[i], b[i], places)
def reorder_eigens(self, result_eigenvalues, result_eigenvectors):
idx = result_eigenvalues.argsort()
idx = idx[::-1]
result_eigenvalues = result_eigenvalues[idx]
result_eigenvectors = result_eigenvectors[idx]
result_eigenvectors[2] *= -1
return result_eigenvalues, result_eigenvectors
def test_one_atom(self):
return
'''
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.0]]],floattype))
self.o.setElement(['C'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(result_eigenvalues, result_eigenvectors)
print list(result_I), '\n',list(result_eigenvalues), '\n', list(result_eigenvectors)
expected_I = numpy.array([[156.14, 24.022, 36.032], [24.022, 120.108, -72.065], [36.032, -72.065, 60.054]], floattype)
expected_eigenvalues = numpy.array([168.151, 168.151, -5.329e-15], floattype)
expected_eigenvectors = numpy.array([[0.103, -0.812, 0.575], [0.964, 0.148, 0.222], [-0.267, 0.535, 0.802]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(expected_I, result_I, 3)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvalues, result_eigenvalues,3)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvectors, result_eigenvectors,3)
'''
def test_two_centered_atoms(self):
return
'''
self.o.setCoor(numpy.array([[[-1.0, -2.0, -3.0],[1.0, 2.0, 3.0]]],floattype))
self.o.setElement(['C','C'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(result_eigenvalues, result_eigenvectors)
print list(result_eigenvalues), '\n', list(result_eigenvectors)
expected_I = numpy.array([[26., -4., -6.], [-4., 20., -12.], [-6., -12., 10.]], floattype)
expected_eigenvalues = numpy.array([336.302, 336.302, -7.105e-15], floattype)
expected_eigenvectors = numpy.array([[-0.103, -0.812, 0.575], [0.964, -0.148, -0.222], [0.267, 0.535, 0.802]],floattype)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvalues, result_eigenvalues,3)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvectors, result_eigenvectors,3)
'''
def test_two_uncentered_atoms(self):
self.o.setCoor(
numpy.array([[[-2.0, -2.0, -3.0], [1.0, 2.0, 3.0]]], floattype))
self.o.setElement(['C', 'N'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(
result_eigenvalues, result_eigenvectors)
print result_I, '\n', result_eigenvalues, '\n', result_eigenvectors
expected_eigenvalues = numpy.array([400.277, 394.737, 5.54], floattype)
expected_eigenvectors = numpy.array(
[[-6.274e-15, -8.321e-01, 5.547e-01],
[9.246e-01, -2.114e-01, -3.170e-01],
[3.810e-01, 5.129e-01, 7.693e-01]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvalues, result_eigenvalues, 3)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvectors, result_eigenvectors, 3)
def test_six_uncentered_atoms(self):
self.o.setCoor(
numpy.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setElement(['C', 'N', 'O', 'C', 'N', 'O'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(
result_eigenvalues, result_eigenvectors)
print result_I, '\n', result_eigenvalues, '\n', result_eigenvectors
expected_eigenvalues = numpy.array([5761.418, 5625.53, 139.66],
floattype)
expected_eigenvectors = numpy.array(
[[0.351, -0.821, 0.451], [-0.837, -0.059, 0.544],
[0.42, 0.568, 0.708]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvalues, result_eigenvalues, 2)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvectors, result_eigenvectors, 3)
def test_six_uncentered_atoms_inf1(self):
self.o.setCoor(
numpy.array(
[[[util.HUGE, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setMass([1.0, 2.0, 3.2, 3.6, 5.2, 2.8])
self.o.setNatoms(len(self.o.mass()))
with self.assertRaises(Exception):
result = self.o.calcpmi(0)
def test_six_uncentered_atoms_inf2(self):
self.o.setCoor(
numpy.array(
[[[util.INF, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setMass([1.0, 2.0, 3.2, 3.6, 5.2, 2.8])
self.o.setNatoms(len(self.o.mass()))
with self.assertRaises(Exception):
result = self.o.calcpmi(0)
def test_six_uncentered_atoms_nan(self):
self.o.setCoor(
numpy.array(
[[[util.NAN, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setMass([1.0, 2.0, 3.2, 3.6, 5.2, 2.8])
self.o.setNatoms(len(self.o.mass()))
with self.assertRaises(Exception):
result = self.o.calcpmi(0)
def test_six_uncentered_atoms_tiny(self):
self.o.setCoor(
numpy.array(
[[[util.TINY, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setElement(['C', 'N', 'O', 'C', 'N', 'O'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(
result_eigenvalues, result_eigenvectors)
print list(result_I), '\n', list(result_eigenvalues), '\n', list(
result_eigenvectors)
expected_I = numpy.array(
[[4675.176, -1324.189, -1572.26], [-1324.189, 3932.916, -2256.545],
[-1572.26, -2256.545, 2894.494]], floattype)
expected_eigenvalues = numpy.array([5748.699, 5591.441, 162.447],
floattype)
expected_eigenvectors = numpy.array(
[[0.321, -0.821, 0.472], [-0.852, -0.032, 0.523],
[0.414, 0.57, 0.709]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(
expected_I, result_I, 3)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvalues, result_eigenvalues, 2)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvectors, result_eigenvectors, 3)
def test_six_uncentered_atoms_ZERO(self):
self.o.setCoor(
numpy.array(
[[[util.ZERO, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setElement(['C', 'N', 'O', 'C', 'N', 'O'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(
result_eigenvalues, result_eigenvectors)
print list(result_I), '\n', list(result_eigenvalues), '\n', list(
result_eigenvectors)
expected_I = numpy.array(
[[4675.176, -1324.189, -1572.26], [-1324.189, 3932.916, -2256.545],
[-1572.26, -2256.545, 2894.494]], floattype)
expected_eigenvalues = numpy.array([5748.699, 5591.441, 162.447],
floattype)
expected_eigenvectors = numpy.array(
[[0.321, -0.821, 0.472], [-0.852, -0.032, 0.523],
[0.414, 0.57, 0.709]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(
expected_I, result_I, 3)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvalues, result_eigenvalues, 2)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvectors, result_eigenvectors, 3)
def tearDown(self):
self.m.restore()
self.m.verify()
sasop.Move.center = self.centertmp
class Test_unit_operate_Move_translate(MockerTestCase):
def setUp(self):
self.m = Mocker()
self.back_mass_check = operate.Move.mass_check
operate.Move.mass_check = self.m.mock()
operate.Move.mass_check()
self.m.result(None)
self.m.count(0,None)
self.m.replay()
self.o=system.Molecule(0)
def assert_list_almost_equal(self,a,b,places=5):
if (len(a)!=len(b)):
raise TypeError
else:
for i in range(len(a)):
if isinstance(a[i],(int,float,numpy.generic)):
if (numpy.isnan(a[i]) and numpy.isnan(b[i])): continue
self.assertAlmostEqual(a[i],b[i],places)
else:
self.assert_list_almost_equal(a[i],b[i],places)
def test_one_atom_about_X_axis(self):
'''
test one atom rotating about the z axis
'''
self.o.setCoor(numpy.array([[[1.0, 1.0, 1.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(90.0*numpy.pi/180.0, floattype)
frame = 0
#
expected_coor = numpy.array([[[1.0, -1.0, 1.0]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_one_atom_about_Y_axis(self):
'''
test one atom rotating about the z axis
'''
self.o.setCoor(numpy.array([[[1.0, 1.0, 1.0]]],floattype))
axis = 'y'
theta = util.num_to_floattype(90.0*numpy.pi/180.0, floattype)
frame = 0
#
expected_coor = numpy.array([[[1.0, 1.0, -1.0]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_one_atom_about_Z_axis(self):
'''
test one atom rotating about the z axis
'''
self.o.setCoor(numpy.array([[[1.0, 1.0, 1.0]]],floattype))
axis = 'z'
theta = util.num_to_floattype(90.0*numpy.pi/180.0, floattype)
frame = 0
#
expected_coor = numpy.array([[[-1.0, 1.0, 1.0]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_two_atoms_about_X_axis(self):
'''
test two atoms rotating about the x axis
'''
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.87],[-5.0, 3.2, 6.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(90.0*numpy.pi/180.0, floattype)
frame = 0
#
expected_coor = numpy.array([[[-1.0, -3.87, 2.0],[-5.0, -6.0, 3.2]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_two_atoms_about_Y_axis(self):
#test two atoms rotating about the x axis
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.87],[-5.0, 3.2, 6.0]]],floattype))
axis = 'y'
theta = util.num_to_floattype(90.0*numpy.pi/180.0, floattype)
frame = 0
#
expected_coor = numpy.array([[[3.87, 2.0, 1.0],[6.0, 3.2, 5.0]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_two_atoms_about_Z_axis(self):
'''
test two atoms rotating about the x axis
'''
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.87],[-5.0, 3.2, 6.0]]],floattype))
axis = 'z'
theta = util.num_to_floattype(280.0*numpy.pi/180.0, floattype)
frame = 0
#
#expected_coor = numpy.array([[[-2.0, -1.0, 3.87],[-3.2, -5.0, 6.0]]], floattype)[frame]
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[-1.0*cs-2.0*si, -1.0*si+2.0*cs, 3.87],[-5.0*cs-3.2*si, -5.0*si+3.2*cs, 6.0]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_about_X_axis(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(128.0*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, 2.0*cs-3.0*si, 2.0*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_about_X_axis_inf1(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(util.HUGE*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, 2.0*cs-3.0*si, 2.0*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
#the first element becomes nan after 1.2+inf*0(nan)
def test_six_atoms_about_X_axis_inf2(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(util.INF*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, 2.0*cs-3.0*si, 2.0*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
#the first row of elements becomes all nan due to operation between the regular number with nan*0
def test_six_atoms_about_X_axis_nan(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(util.NAN*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, util.NAN*cs-3.0*si, util.NAN*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_about_X_axis_tiny(self):
self.o.setCoor(numpy.array([[[1.2, util.TINY, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(128.0*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, util.TINY*cs-3.0*si, util.TINY*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_about_X_axis_zero(self):
self.o.setCoor(numpy.array([[[1.2, util.ZERO, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(128.0*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, util.ZERO*cs-3.0*si, util.ZERO*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def tearDown(self):
self.m.verify()
operate.Move.mass_check =self.back_mass_check
class TestIdentifyJunctions(TestCase):
def setUp(self):
self.mocker = Mocker()
self.exon1 = self.mocker.mock()
self.exon2 = self.mocker.mock()
self.exon3 = self.mocker.mock()
self.exon4 = self.mocker.mock()
self.exon5 = self.mocker.mock()
self.exon6 = self.mocker.mock()
self.exon7 = self.mocker.mock()
self.exon8 = self.mocker.mock()
self.exon9 = self.mocker.mock()
self.exon10 = self.mocker.mock()
self.exon1.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon1.start
self.mocker.result(1100)
self.mocker.count(1, None)
self.exon1.end
self.mocker.result(1200)
self.mocker.count(1, None)
self.exon1.prevExons
self.mocker.result(set([]))
self.mocker.count(1, None)
self.exon1.nextExons
self.mocker.result([
'chr1:1300-1400',
'chr1:1250-1400',
'chr1:1300-1350',
'chr1:1500-1600',
])
self.mocker.count(1, None)
self.exon2.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon2.start
self.mocker.result(1300)
self.mocker.count(1, None)
self.exon2.end
self.mocker.result(1400)
self.mocker.count(1, None)
self.exon2.nextExons
self.mocker.result(set(['chr1:1500-1600']))
self.mocker.count(1, None)
self.exon2.prevExons
self.mocker.result(set(['chr1:1100-1200']))
self.mocker.count(1, None)
self.exon3.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon3.start
self.mocker.result(1250)
self.mocker.count(1, None)
self.exon3.end
self.mocker.result(1400)
self.mocker.count(1, None)
self.exon3.nextExons
self.mocker.result(set(['chr1:1500-1600', 'chr1:1900-2000']))
self.mocker.count(1, None)
self.exon3.prevExons
self.mocker.result(set(['chr1:1100-1200']))
self.mocker.count(1, None)
self.exon4.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon4.start
self.mocker.result(1300)
self.mocker.count(1, None)
self.exon4.end
self.mocker.result(1350)
self.mocker.count(1, None)
self.exon4.nextExons
self.mocker.result(set(['chr1:1500-1600']))
self.mocker.count(1, None)
self.exon4.prevExons
self.mocker.result(set(['chr1:1100-1200']))
self.mocker.count(1, None)
self.exon5.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon5.start
self.mocker.result(1500)
self.mocker.count(1, None)
self.exon5.end
self.mocker.result(1600)
self.mocker.count(1, None)
self.exon5.nextExons
self.mocker.result(set(['chr1:1700-1800']))
self.mocker.count(1, None)
self.exon5.prevExons
self.mocker.result(
set([
'chr1:1100-1200',
'chr1:1300-1400',
'chr1:1250-1400',
'chr1:1300-1350',
'chr1:1220-1320',
]))
self.mocker.count(1, None)
self.exon6.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon6.start
self.mocker.result(1700)
self.mocker.count(1, None)
self.exon6.end
self.mocker.result(1800)
self.mocker.count(1, None)
self.exon6.nextExons
self.mocker.result(set(['chr1:1900-2000', 'chr1:1930-2300']))
self.mocker.count(1, None)
self.exon6.prevExons
self.mocker.result(set(['chr1:1500-1600']))
self.mocker.count(1, None)
self.exon7.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon7.start
self.mocker.result(1900)
self.mocker.count(1, None)
self.exon7.end
self.mocker.result(2000)
self.mocker.count(1, None)
self.exon7.nextExons
self.mocker.result(set([]))
self.mocker.count(1, None)
self.exon7.prevExons
self.mocker.result(set(['chr1:1250-1400', 'chr1:1700-1800']))
self.mocker.count(1, None)
self.exon8.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon8.start
self.mocker.result(1220)
self.mocker.count(1, None)
self.exon8.end
self.mocker.result(1320)
self.mocker.count(1, None)
self.exon8.nextExons
self.mocker.result(['chr1:1500-1600'])
self.mocker.count(1, None)
self.exon8.prevExons
self.mocker.result(set([]))
self.mocker.count(1, None)
self.exon9.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon9.start
self.mocker.result(1900)
self.mocker.count(1, None)
self.exon9.end
self.mocker.result(2300)
self.mocker.count(1, None)
self.exon9.nextExons
self.mocker.result([])
self.mocker.count(1, None)
self.exon9.prevExons
self.mocker.result(set(['chr1:1700-1800']))
self.mocker.count(1, None)
self.exon10.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon10.start
self.mocker.result(1930)
self.mocker.count(1, None)
self.exon10.end
self.mocker.result(2300)
self.mocker.count(1, None)
self.exon10.nextExons
self.mocker.result([])
self.mocker.count(1, None)
self.exon10.prevExons
self.mocker.result(set(['chr1:1700-1800']))
self.mocker.count(1, None)
self.mocker.replay()
def test_alternative_splice_site(self):
self.genes = {
'chr1:gene1': [
'chr1:1100-1200',
'chr1:1300-1400',
'chr1:1250-1400',
'chr1:1300-1350',
'chr1:1500-1600',
'chr1:1700-1800',
'chr1:1900-2000',
'chr1:1220-1320',
'chr1:1900-2300',
'chr1:1930-2300',
]
}
self.exons = {}
self.exons['chr1:1100-1200'] = self.exon1
self.exons['chr1:1300-1400'] = self.exon2
self.exons['chr1:1250-1400'] = self.exon3
self.exons['chr1:1300-1350'] = self.exon4
self.exons['chr1:1500-1600'] = self.exon5
self.exons['chr1:1700-1800'] = self.exon6
self.exons['chr1:1900-2000'] = self.exon7
self.exons['chr1:1220-1320'] = self.exon8
self.exons['chr1:1900-2300'] = self.exon9
self.exons['chr1:1930-2300'] = self.exon10
self.junctions = jc.identifyJunctions(self.genes, self.exons)
self.assertEqual(len(self.junctions), 10)
altSplicing = [k for k in self.junctions.keys() \
if self.junctions[k].event == 'alternativeSplicing']
print >> sys.stderr, 'alter splicing', altSplicing
altSS = [k for k in self.junctions.keys() \
if self.junctions[k].event == 'alternativeSpliceSite']
#print >> sys.stderr, 'alter splice site', altSS
skipped = [k for k in self.junctions.keys() \
if self.junctions[k].event == 'skippedExon']
#print >> sys.stderr, 'skipped exon', skipped
noAlt = [
k for k in self.junctions.keys() if not self.junctions[k].event
]
self.assertEqual(len(altSplicing), 2)
self.assertEqual(len(altSS), 4)
self.assertEqual('chr1:1200-1300' in altSS, True)
self.assertEqual(len(skipped), 2)
self.assertEqual('chr1:1200-1500' in skipped, True)
self.assertEqual(len(noAlt), 2)
class TestCreatePath(TestCase):
def setUp(self):
self.mocker = Mocker()
self.isoform1 = self.mocker.mock()
self.isoform2 = self.mocker.mock()
self.isoform3 = self.mocker.mock()
self.isoform1.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.isoform1.chromStart
self.mocker.result(1000)
self.mocker.count(1, None)
self.isoform1.end
self.mocker.result(2000)
self.isoform1.name
self.mocker.result('chr1:gene1.1')
self.isoform1.startCodon
self.mocker.result(1000)
self.isoform1.stopCodon
self.mocker.result(2000)
self.isoform1.blockSizes
self.mocker.result([100, 100, 100, 100, 100])
self.mocker.count(1, None)
self.isoform1.blockStarts
self.mocker.result([100, 300, 500, 700, 900])
self.mocker.count(1, None)
self.isoform2.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.isoform2.chromStart
self.mocker.result(1000)
self.mocker.count(1, None)
self.isoform2.end
self.mocker.result(2000)
self.isoform2.name
self.mocker.result('chr1:gene1.2')
self.isoform2.startCodon
self.mocker.result(1000)
self.isoform2.stopCodon
self.mocker.result(2000)
self.isoform2.blockSizes
self.mocker.result([100, 150, 100, 100, 100])
self.mocker.count(1, None)
self.isoform2.blockStarts
self.mocker.result([100, 250, 500, 700, 900])
self.mocker.count(1, None)
self.isoform3.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.isoform3.chromStart
self.mocker.result(1000)
self.mocker.count(1, None)
self.isoform3.end
self.mocker.result(2000)
self.isoform3.name
self.mocker.result('chr1:gene1.3')
self.isoform3.startCodon
self.mocker.result(1000)
self.isoform3.stopCodon
self.mocker.result(2000)
self.isoform3.blockSizes
self.mocker.result([100, 50, 100, 100, 100])
self.mocker.count(1, None)
self.isoform3.blockStarts
self.mocker.result([100, 300, 500, 700, 900])
self.mocker.count(1, None)
self.mocker.replay()
def test_grouping(self):
self.group = {}
self.exons = {}
jc.groupExons(self.group, self.exons, self.isoform1)
jc.groupExons(self.group, self.exons, self.isoform2)
jc.groupExons(self.group, self.exons, self.isoform3)
self.assertEqual(len(self.group), 1)
self.assertEqual(self.group.keys()[0], 'chr1:gene1')
self.assertEqual(len(self.exons), 7)
self.assertEqual(len(self.exons['chr1:1100-1200'].nextExons), 3)
self.assertEqual(len(self.exons['chr1:1100-1200'].prevExons), 0)
self.assertEqual(len(self.exons['chr1:1500-1600'].prevExons), 3)
self.assertEqual(len(self.exons['chr1:1700-1800'].prevExons), 1)
self.assertEqual(len(self.exons['chr1:1900-2000'].nextExons), 0)
class TestBuildJunctionDict(TestCase):
def setUp(self):
self.mocker = Mocker()
self.junctions = self.mocker.mock()
self.junction1 = self.mocker.mock()
self.junction2 = self.mocker.mock()
self.junction3 = self.mocker.mock()
self.junction1.start
self.mocker.result(100)
self.mocker.count(0, None)
self.junction1.end
self.mocker.result(200)
self.mocker.count(0, None)
self.junction1.chrom
self.mocker.result('chr1')
self.mocker.count(0, None)
self.junction2.start
self.mocker.result(100)
self.mocker.count(0, None)
self.junction2.end
self.mocker.result(300)
self.mocker.count(0, None)
self.junction2.chrom
self.mocker.result('chr1')
self.mocker.count(0, None)
self.junction3.start
self.mocker.result(200)
self.mocker.count(0, None)
self.junction3.end
self.mocker.result(300)
self.mocker.count(0, None)
self.junction3.chrom
self.mocker.result('chr1')
self.mocker.count(0, None)
def test_no_overlaps(self):
self.junctions.iteritems()
self.mocker.generate([('chr1:100-200', self.junction1)])
self.mocker.replay()
self.container = jc.buildJunctionDict(self.junctions)
self.assertEqual(self.container['chr1:100'], [200])
self.assertEqual(len(self.container), 1)
self.mocker.restore()
self.mocker.verify()
def test_overlaps(self):
self.junctions.iteritems()
self.mocker.generate([('chr1:100-200', self.junction1),
('chr1:100-300', self.junction2)])
self.mocker.replay()
self.container = jc.buildJunctionDict(self.junctions)
self.assertEqual(self.container['chr1:100'], [200, 300])
self.assertEqual(len(self.container), 1)
self.mocker.restore()
self.mocker.verify()
def test_multiple_junctions_with_overlaps(self):
self.junctions.iteritems()
self.mocker.generate([('chr1:100-200', self.junction1),
('chr1:100-300', self.junction2),
('chr1:200-300', self.junction3)], )
self.mocker.replay()
self.container = jc.buildJunctionDict(self.junctions)
self.assertEqual(self.container['chr1:100'], [200, 300])
self.assertEqual(self.container['chr1:200'], [300])
self.assertEqual(len(self.container), 2)
self.mocker.restore()
self.mocker.verify()
class Test_unit_operate_Move_translate(MockerTestCase):
def setUp(self):
self.back_mass_check = operate.Move.mass_check
self.back_calccom = calculate.Calculate.calculate_center_of_mass
self.m = Mocker()
calculate.Calculate.calculate_center_of_mass = self.m.mock()
calculate.Calculate.calculate_center_of_mass(ARGS)
self.m.result(None)
self.m.count(0,None)
operate.Move.mass_check = self.m.mock()
operate.Move.mass_check()
self.m.result(None)
self.m.count(0,None)
self.m.replay()
self.o=system.Molecule(0)
def assert_list_almost_equal(self,a,b,places=5):
if (len(a)!=len(b)):
raise TypeError
else:
for i in range(len(a)):
if isinstance(a[i],(int,float,numpy.generic)):
if (numpy.isnan(a[i]) and numpy.isnan(b[i])): continue
self.assertAlmostEqual(a[i],b[i],places)
else:
self.assert_list_almost_equal(a[i],b[i],places)
def test_one_atom(self):
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.0]]],floattype))
value = numpy.array([1.0, 3.0, 6.0],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[0.0, 5.0, 9.0]]], floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_two_atoms(self):
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.87],[-5.0, 3.2, 6.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-4.0, 2.0, 9.97],[-8.0, 3.2, 12.1]]], floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, 9.1],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_inf1(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.HUGE],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, util.HUGE],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_inf2(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.INF],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, util.INF],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_nan(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.NAN],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, util.NAN],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_tiny(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.TINY],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, util.TINY+6.1],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_zero(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.ZERO],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, 6.1],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def tearDown(self):
self.m.verify()
calculate.Calculate.calculate_center_of_mass=self.back_calccom
operate.Move.mass_check =self.back_mass_check
class Test_linear_algebra(MockerTestCase):
def setUp(self):
self.m = Mocker()
"""
linear_algebra.Math.__init__ = self.m.mock()
linear_algebra.Math.__init__(ARGS)
self.m.result(None)
self.m.count(0,None)
"""
self.m.replay()
#self.o=linear_algebra.Math()
def assert_list_almost_equal(self,a,b):
if (len(a)!=len(b)):
raise "LengthError"
else:
for i in range(len(a)):
if (numpy.isnan(a[i]) and numpy.isnan(b[i])): continue
self.assertAlmostEqual(a[i],b[i],places=2)
def test_against_mathematica_two_unit_atoms_one_origin(self):
x=numpy.array([[0.0, 0.0, 0.0],[1.0, 0.0, 0.0]], floattype)
y=numpy.array([[0.0, 0.0, 0.0],[0.0, 1.0, 0.0]], floattype)
result_u = linear_algebra.find_u(x,y)
expected_u = [[0.0, 1.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]];
for i in range(len(result_u)):
self.assert_list_almost_equal(list(result_u[i]),expected_u[i])
def test_against_mathematica_two_unit_atoms(self):
x=numpy.array([[1.0, 1.0, 1.0], [2.0, 1.0, 1.0]], floattype)
y=numpy.array([[1.0, 1.0, 1.0], [1.0, 2.0, 1.0]], floattype)
result_u = linear_algebra.find_u(x,y); print result_u
expected_u = [[0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]];
for i in range(len(result_u)):
self.assert_list_almost_equal(list(result_u[i]),expected_u[i])
def test_against_mathematica_two_overlap_unit_atoms(self):
x=numpy.array([[1.0, 1.0, 1.0], [1.0, 2.0, 1.0]], floattype)
y=numpy.array([[1.0, 1.0, 1.0], [1.0, 2.0, 1.0]], floattype)
result_u = linear_algebra.find_u(x,y); print result_u
print result_u
expected_u = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
for i in range(len(result_u)):
self.assert_list_almost_equal(list(result_u[i]),expected_u[i])
def test_against_mathematica_two_overlap_atoms(self):
x=numpy.array([[2.920, -2.367, 1.693], [-0.770, -0.827, -0.417]], floattype)
y=numpy.array([[2.920, -2.367, 1.693], [-0.770, -0.827, -0.417]], floattype)
result_u = linear_algebra.find_u(x,y)
expected_u = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
for i in range(len(result_u)):
self.assert_list_almost_equal(list(result_u[i]),expected_u[i])
def test_against_mathematica_three_arbitary_atoms(self):
x=numpy.array([[2.920, -2.367, 1.693], [-0.770, -0.827, -0.417], [-2.150, 3.193, -1.277]], floattype)
y=numpy.array([[1.663, -1.170, 3.567], [-1.197, -1.460, -0.523], [-0.467, 2.630, -3.043]], floattype)
result_u = linear_algebra.find_u(x,y)
expected_u = [[0.902737, -0.0539463, 0.426797], [0.23798, 0.8891, -0.390981], [-0.358373, 0.454522, 0.815462]]
for i in range(len(result_u)):
self.assert_list_almost_equal(list(result_u[i]),expected_u[i])
def test_against_mathematica_six_arbitary_atoms(self):
x=numpy.array([[0.357, -12.123, 2.098], [1.209, 10.209, -50.082], [-1.098, 3.572, 2.982], \
[1.231, -1.230, 0.589], [12.398, -30.289, 19.482], [12.123, 0.980, 19.309]], floattype)
y=numpy.array([[90.380, 12.987, 0.392], [3.219, 83.390, 0.028], [0.002, 10.298, -18.820], \
[12.879, -10.298, 0.987], [0.986, 12.984, 0.367], [12.359, -12.402, 1.298]], floattype)
result_u = linear_algebra.find_u(x,y)
expected_u = [[0.121253, 0.025345, 0.992298], [-0.992602, 0.00937959, 0.12105], [-0.00623933, -0.999635, 0.0262948]]
for i in range(len(result_u)):
self.assert_list_almost_equal(list(result_u[i]),expected_u[i])
def test_find_u_zero(self):
x=numpy.array([[0,0,0],[0,0,0]], floattype)
y=numpy.array([[0,0,0],[0,0,0]], floattype)
rmx = linear_algebra.find_u(x,y)
result = numpy.dot(rmx,y.T)
result = result.T
self.assertEqual(len(result),len(x))
for i in range(len(x)):
self.assert_list_almost_equal(list(result[i]),x[i])
def test_find_u_unit(self):
x=numpy.array([[0,0,0],[1,0,0]], floattype)
y=numpy.array([[0,0,0],[0,1,0]], floattype)
rmx = linear_algebra.find_u(x,y)
result = numpy.dot(rmx,y.T)
result = result.T
self.assertEqual(len(result),len(x))
for i in range(len(x)):
self.assert_list_almost_equal(list(result[i]),x[i])
def test_find_u_arb(self):
x=numpy.array([[2.920, -2.367, 1.693], [-0.770, -0.827, -0.417], [-2.150, 3.193, -1.277]], floattype)
y=numpy.array([[1.663, -1.170, 3.567], [-1.197, -1.460, -0.523], [-0.467, 2.630, -3.043]], floattype)
result_u = linear_algebra.find_u(x,y)
expected_u = [[0.902737, -0.0539463, 0.426797], [0.23798, 0.8891, -0.390981], [-0.358373, 0.454522, 0.815462]]
for i in range(len(result_u)):
self.assert_list_almost_equal(list(result_u[i]),expected_u[i])
def test_find_u_rotate_pdb(self):
m1 = system.Molecule(0)
m2 = system.Molecule(1)
m1.read_pdb(PdbPath+"1CRN.pdb")
m2.read_pdb(modulePdbPath+"1CRN-rot.pdb")
coor_sub_m1 = m1.coor()[0]
coor_sub_m2 = m2.coor()[0]
u = linear_algebra.find_u(coor_sub_m1, coor_sub_m2)
result = numpy.array((numpy.matrix(u)*(numpy.matrix(coor_sub_m2).T)).T, numpy.float)
#print numpy.dot(result.reshape(1,-1)[0],coor_sub_m1.reshape(1,-1)[0])/numpy.sqrt(numpy.dot(coor_sub_m1.reshape(1,-1)[0],coor_sub_m1.reshape(1,-1)[0])*numpy.dot(result.reshape(1,-1)[0],result.reshape(1,-1)[0]))
#m3 = system.Molecule(2)
#m3.read_pdb('1CRN.pdb')
#m3._coor[0,:]=result
#m3.writepdb('1CRN-result.pdb',0,'w')
self.assertEqual(len(result),len(coor_sub_m1))
for i in range(len(coor_sub_m1)):
self.assert_list_almost_equal(list(result[i]),coor_sub_m1[i])
def tearDown(self):
self.m.verify()
