def setup_method(self, method):
"""Creates empty DataArray"""
self.data_array = DataArray((100, 100, 100), Settings())
def setup_method(self, method):
"""Creates empty DataArray"""
self.data_array = DataArray((100, 100, 100))
class TestDataArray(object):
"""Unit tests for DataArray"""
def setup_method(self, method):
"""Creates empty DataArray"""
self.data_array = DataArray((100, 100, 100), Settings())
def test_iter(self):
"""Unit test for __iter__"""
assert list(iter(self.data_array)) == []
self.data_array[(1, 2, 3)] = "12"
self.data_array[(1, 2, 4)] = "13"
assert sorted(list(iter(self.data_array))) == [(1, 2, 3), (1, 2, 4)]
def test_keys(self):
"""Unit test for keys"""
assert list(self.data_array.keys()) == []
self.data_array[(1, 2, 3)] = "12"
self.data_array[(1, 2, 4)] = "13"
assert sorted(self.data_array.keys()) == [(1, 2, 3), (1, 2, 4)]
def test_pop(self):
"""Unit test for pop"""
self.data_array[(1, 2, 3)] = "12"
self.data_array[(1, 2, 4)] = "13"
assert self.data_array.pop((1, 2, 3)) == "12"
assert sorted(self.data_array.keys()) == [(1, 2, 4)]
def test_get_shape(self):
"""Unit test for _get_shape"""
assert self.data_array.shape == (100, 100, 100)
def test_set_shape(self):
"""Unit test for _set_shape"""
self.data_array.shape = (10000, 100, 100)
assert self.data_array.shape == (10000, 100, 100)
param_get_last_filled_cell = [
({(0, 0, 0): "2"}, 0, (0, 0)),
({(2, 0, 2): "2"}, 0, (0, 0)),
({(2, 0, 2): "2"}, None, (2, 0)),
({(2, 0, 2): "2"}, 2, (2, 0)),
({(32, 30, 0): "432"}, 0, (32, 30)),
]
@pytest.mark.parametrize("content,table,res", param_get_last_filled_cell)
def test_get_last_filled_cell(self, content, table, res):
"""Unit test for get_last_filled_cellet_end"""
for key in content:
self.data_array[key] = content[key]
assert self.data_array.get_last_filled_cell(table)[:2] == res
def test_getstate(self):
"""Unit test for __getstate__ (pickle support)"""
assert "dict_grid" in self.data_array.__getstate__()
def test_slicing(self):
"""Unit test for __getitem__ and __setitem__"""
self.data_array[0, 0, 0] = "'Test'"
self.data_array[0, 0, 0] = "'Tes'"
assert self.data_array[0, 0, 0] == "'Tes'"
def test_cell_array_generator(self):
"""Unit test for cell_array_generator"""
cell_array = self.data_array[:5, 0, 0]
assert list(cell_array) == [None] * 5
cell_array = self.data_array[:5, :5, 0]
assert [list(c) for c in cell_array] == [[None] * 5] * 5
cell_array = self.data_array[:5, :5, :5]
assert [[list(e) for e in c] for c in cell_array] == \
[[[None] * 5] * 5] * 5
def test_set_cell_attributes(self):
"""Unit test for _set_cell_attributes"""
cell_attributes = self.data_array.cell_attributes
attr = CellAttribute(Selection([], [], [], [], []), 0,
AttrDict([("Test", None)]))
cell_attributes.clear()
cell_attributes.append(attr)
assert self.data_array.cell_attributes == cell_attributes
param_adjust_cell_attributes = [
(0, 5, 0, (4, 3, 0), (9, 3, 0)),
(34, 5, 0, (4, 3, 0), (4, 3, 0)),
(0, 0, 0, (4, 3, 0), (4, 3, 0)),
(1, 5, 1, (4, 3, 0), (4, 8, 0)),
(1, 5, 1, (4, 3, 1), (4, 8, 1)),
(0, -1, 2, (4, 3, 1), None),
(0, -1, 2, (4, 3, 2), (4, 3, 1)),
]
@pytest.mark.parametrize("inspoint, noins, axis, src, target",
param_adjust_cell_attributes)
def test_adjust_cell_attributes(self, inspoint, noins, axis, src, target):
"""Unit test for _adjust_cell_attributes"""
row, col, tab = src
cell_attributes = self.data_array.cell_attributes
attr_dict = AttrDict([("angle", 0.2)])
attr = CellAttribute(Selection([], [], [], [], [(row, col)]), tab,
attr_dict)
cell_attributes.clear()
cell_attributes.append(attr)
self.data_array._adjust_cell_attributes(inspoint, noins, axis)
if target is None:
for key in attr_dict:
# Should be at default value
default_ca = DefaultCellAttributeDict()[key]
assert cell_attributes[src][key] == default_ca
else:
for key in attr_dict:
assert cell_attributes[target][key] == attr_dict[key]
param_test_insert = [
({(2, 3, 0): "42"}, 1, 1, 0, None,
{(2, 3, 0): None, (3, 3, 0): "42"}),
({(0, 0, 0): "0", (0, 0, 2): "2"}, 1, 1, 2, None,
{(0, 0, 3): "2", (0, 0, 4): None}),
]
@pytest.mark.parametrize("data, inspoint, notoins, axis, tab, res",
param_test_insert)
def test_insert(self, data, inspoint, notoins, axis, tab, res):
"""Unit test for insert operation"""
self.data_array.dict_grid.update(data)
self.data_array.insert(inspoint, notoins, axis, tab)
for key in res:
assert self.data_array[key] == res[key]
param_test_delete = [
({(2, 3, 4): "42"}, 1, 1, 0, None, {(1, 3, 4): "42"}),
({(0, 0, 0): "1"}, 0, 1, 0, 0, {(0, 0, 0): None}),
({(0, 0, 1): "1"}, 0, 1, 2, None, {(0, 0, 0): "1"}),
({(3, 3, 2): "3"}, 0, 2, 2, None, {(3, 3, 0): "3"}),
({(4, 2, 1): "3"}, 2, 1, 1, 1, {(4, 2, 1): None}),
({(10, 0, 0): "1"}, 0, 10, 0, 0, {(0, 0, 0): "1"}),
]
@pytest.mark.parametrize("data, delpoint, notodel, axis, tab, res",
param_test_delete)
def test_delete(self, data, delpoint, notodel, axis, tab, res):
"""Tests delete operation"""
self.data_array.dict_grid.update(data)
self.data_array.delete(delpoint, notodel, axis, tab)
for key in res:
assert self.data_array[key] == res[key]
def test_delete_error(self):
"""Tests delete operation error"""
self.data_array[2, 3, 4] = "42"
try:
self.data_array.delete(1, 1, 20)
assert False
except ValueError:
pass
def test_set_row_height(self):
"""Unit test for set_row_height"""
self.data_array.set_row_height(7, 1, 22.345)
assert self.data_array.row_heights[7, 1] == 22.345
def test_set_col_width(self):
"""Unit test for set_col_width"""
self.data_array.set_col_width(7, 1, 22.345)
assert self.data_array.col_widths[7, 1] == 22.345
class TestDataArray(object):
"""Unit test for DataArray"""
def setup_method(self, method):
"""Creates empty DataArray"""
self.data_array = DataArray((100, 100, 100))
def test_row_heights(self):
pass
def test_col_widths(self):
pass
def test_cell_attributes(self):
pass
def test_keys(self):
pass
def test_pop(self):
pass
def test_get_shape(self):
"""Test shape attribute"""
assert self.data_array.shape == (100, 100, 100)
def test_set_shape(self):
"""Test shape attribute"""
self.data_array.shape = (10000, 100, 100)
assert self.data_array.shape == (10000, 100, 100)
def test_getstate(self):
"""Test pickle support"""
assert "dict_grid" in self.data_array.__getstate__()
def test_getitem(self):
"""Test shape attribute"""
pass
def test_setitem(self):
"""Single and multiple item assignment test"""
self.data_array[0, 0, 0] = "'Test'"
##assert len(self.grid.unredo.undolist) == 1
self.data_array[0, 0, 0] = "'Tes'"
##assert len(self.grid.unredo.undolist) == 2
assert self.data_array[0, 0, 0] == "'Tes'"
for teststring in v.getstrings(number=100, maxlength=1000):
x, y, z = [gmpy.rand('next', maxdim) \
for maxdim in self.data_array.shape]
self.data_array[x, y, z] = "".join(["'", teststring, "'"])
assert self.data_array[x, y, z] == "".join(["'", teststring, "'"])
def test_cell_array_generator(self):
""""""
pass
def test_insert(self):
"""Tests insert operation"""
self.data_array[2, 3, 4] = 42
self.data_array.insert(1, 100, 0)
assert self.data_array.shape == (200, 100, 100)
assert self.data_array[2, 3, 4] is None
assert self.data_array[102, 3, 4] == 42
def test_delete(self):
"""Tests delete operation"""
self.data_array[2, 3, 4] = "42"
self.data_array.delete(1, 1, 0)
assert self.data_array[2, 3, 4] is None
assert self.data_array[1, 3, 4] == "42"
print self.data_array.shape
assert self.data_array.shape == (99, 100, 100)
def test_set_row_height(self):
pass
def test_set_col_width(self):
pass
