class TestRowColumnInfoAccess(unittest.TestCase):
def setUp(self):
self.table = Table(xmlnode=etree.XML(SQUAREMATRIX))
def test_get_row_info(self):
row_info = self.table.row_info(0)
self.assertEqual(row_info.style_name, 'r0')
def test_get_row_info_by_address(self):
row_info = self.table.row_info('C2')
self.assertEqual(row_info.style_name, 'r1')
def test_get_row_info_neg_index(self):
row_info = self.table.row_info(-1)
self.assertEqual(row_info.style_name, 'r3')
def test_get_row_info_index_error(self):
with self.assertRaises(IndexError):
self.table.row_info(4)
def test_get_column_info(self):
column_info = self.table.column_info(0)
self.assertEqual(column_info.style_name, 'c0')
def test_get_column_info_by_address(self):
column_info = self.table.column_info('B3')
self.assertEqual(column_info.style_name, 'c1')
def test_get_column_info_neg_index(self):
column_info = self.table.column_info(-1)
self.assertEqual(column_info.style_name, 'c3')
def test_get_column_info_index_error(self):
with self.assertRaises(IndexError):
self.table.column_info(4)
class TestRowColumnInfoAccess(unittest.TestCase):
def setUp(self):
self.table = Table(xmlnode=etree.XML(SQUAREMATRIX))
def test_get_row_info(self):
row_info = self.table.row_info(0)
self.assertEqual(row_info.style_name, 'r0')
def test_get_row_info_by_address(self):
row_info = self.table.row_info('C2')
self.assertEqual(row_info.style_name, 'r1')
def test_get_row_info_neg_index(self):
row_info = self.table.row_info(-1)
self.assertEqual(row_info.style_name, 'r3')
def test_get_row_info_index_error(self):
with self.assertRaises(IndexError):
self.table.row_info(4)
def test_get_column_info(self):
column_info = self.table.column_info(0)
self.assertEqual(column_info.style_name, 'c0')
def test_get_column_info_by_address(self):
column_info = self.table.column_info('B3')
self.assertEqual(column_info.style_name, 'c1')
def test_get_column_info_neg_index(self):
column_info = self.table.column_info(-1)
self.assertEqual(column_info.style_name, 'c3')
def test_get_column_info_index_error(self):
with self.assertRaises(IndexError):
self.table.column_info(4)
def test_set_table_by_name(self):
self.sheets += Table(name='Sheet1')
self.sheets['Sheet1'] = Table(name='Sheet2')
self.assertEqual(len(self.sheets), 1)
self.assertEqual(self.sheets[0].name, 'Sheet2')
class TestTableContentAccess(unittest.TestCase):
def setUp(self):
self.table = Table(xmlnode=etree.XML(SQUAREMATRIX))
def test_metrics(self):
self.assertEqual(self.table.name, 'RowColAccess')
self.assertEqual(self.table.ncols(), 4)
self.assertEqual(self.table.nrows(), 4)
def test_row_neg_index(self):
cell = self.table[-1, 0]
self.assertEqual(cell.value, 13.)
def test_col_index_error(self):
with self.assertRaises(IndexError):
self.table[0, 4]
def test_access_cell_by_index(self):
cell = self.table[0, 0]
self.assertEqual(cell.value, 1.)
def test_access_cell_by_reference(self):
cell = self.table['B1']
self.assertEqual(cell.value, 2.)
def test_setting_cell_by_index(self):
self.table[0, 0] = Cell('Textcell')
cell = self.table['A1']
self.assertEqual(cell.plaintext(), "Textcell")
def test_setting_cell_by_address(self):
self.table['A1'] = Cell('Textcell')
cell = self.table[0, 0]
self.assertEqual(cell.plaintext(), "Textcell")
def test_set_cell_row_index_error(self):
with self.assertRaises(IndexError):
self.table[10, 0] = Cell()
def test_set_cell_column_index_error(self):
with self.assertRaises(IndexError):
self.table[0, 10] = Cell()
def test_set_cell_neg_row_index(self):
self.table[-1, 0] = Cell('Textcell')
cell = self.table[3, 0]
self.assertEqual(cell.plaintext(), "Textcell")
def test_set_cell_neg_column_index(self):
self.table[0, -1] = Cell('Textcell')
cell = self.table[0, 3]
self.assertEqual(cell.plaintext(), "Textcell")
def test_if_rows_generates_lists(self):
nrows = self.table.nrows()
ncols = self.table.ncols()
for row in self.table.rows():
cells = row
self.assertEqual(len(cells), ncols)
class TestTableContentAccess(unittest.TestCase):
def setUp(self):
self.table = Table(xmlnode=etree.XML(SQUAREMATRIX))
def test_metrics(self):
self.assertEqual(self.table.name, 'RowColAccess')
self.assertEqual(self.table.ncols(), 4)
self.assertEqual(self.table.nrows(), 4)
def test_row_neg_index(self):
cell = self.table[-1, 0]
self.assertEqual(cell.value, 13.)
def test_col_index_error(self):
with self.assertRaises(IndexError):
self.table[0, 4]
def test_access_cell_by_index(self):
cell = self.table[0, 0]
self.assertEqual(cell.value, 1.)
def test_access_cell_by_reference(self):
cell = self.table['B1']
self.assertEqual(cell.value, 2.)
def test_setting_cell_by_index(self):
self.table[0, 0] = Cell('Textcell')
cell = self.table['A1']
self.assertEqual(cell.plaintext(), "Textcell")
def test_setting_cell_by_address(self):
self.table['A1'] = Cell('Textcell')
cell = self.table[0, 0]
self.assertEqual(cell.plaintext(), "Textcell")
def test_set_cell_row_index_error(self):
with self.assertRaises(IndexError):
self.table[10, 0] = Cell()
def test_set_cell_column_index_error(self):
with self.assertRaises(IndexError):
self.table[0, 10] = Cell()
def test_set_cell_neg_row_index(self):
self.table[-1, 0] = Cell('Textcell')
cell = self.table[3, 0]
self.assertEqual(cell.plaintext(), "Textcell")
def test_set_cell_neg_column_index(self):
self.table[0, -1] = Cell('Textcell')
cell = self.table[0, 3]
self.assertEqual(cell.plaintext(), "Textcell")
def test_if_rows_generates_lists(self):
nrows = self.table.nrows()
ncols = self.table.ncols()
for row in self.table.rows():
cells = row
self.assertEqual(len(cells), ncols)
def test_copy_table_with_new_name(self):
table1 = Table(name='Test')
table1['A1'].set_value('marker')
table2 = table1.copy(newname='Copy of '+table1.name)
self.assertEqual('Copy of Test', table2.name, "table2 has wrong name.")
self.assertEqual('marker', table2['A1'].value, "marker not found in table2")
def test_remove_table_by_index(self):
self.sheets += Table(name='Sheet1')
self.sheets += Table(name='Sheet2')
del self.sheets['Sheet1']
self.assertEqual(len(self.sheets), 1)
self.assertEqual(self.sheets[0].name, 'Sheet2')
def test_sheet_insert(self):
self.sheets += Table(name='Sheet1')
self.sheets += Table(name='Sheet2')
self.sheets.insert(1, Table(name='Sheet3'))
self.assertEqual(self.sheets[1].name, 'Sheet3')
self.assertEqual(len(self.sheets), 3)
def test_copy_table_with_new_name(self):
table1 = Table(name='Test')
table1['A1'].set_value('marker')
table2 = table1.copy(newname='Copy of ' + table1.name)
self.assertEqual('Copy of Test', table2.name, "table2 has wrong name.")
self.assertEqual('marker', table2['A1'].value,
"marker not found in table2")
def setUp(self):
self.table = Table('TEST', size=(10, 10))
add_table_prelude_content(self.table)
for col in range(self.table.nrows()):
self.table[0, col].set_value('checkmark%d' % col )
invoke_cache = self.cellvalue(0, col)
for col in range(self.table.ncols()):
column_info = self.table.column_info(col)
column_info.style_name = 'c%d' % col
class TestTableContent(unittest.TestCase):
def setUp(self):
self.table = Table(xmlnode=etree.XML(TABLE_COMP))
def test_metrics(self):
self.assertEqual(self.table.ncols(), 7)
self.assertEqual(self.table.nrows(), 7)
def test_set_get_different_values(self):
ncols = self.table.ncols()
for row in range(self.table.nrows()):
for col in range(ncols):
cell = self.table[row, col]
cell.set_value(row * ncols + col, 'float')
for row in range(self.table.nrows()):
for col in range(ncols):
cell = self.table[row, col]
self.assertEqual(row * ncols + col, int(cell.value))
class TestTableContent(unittest.TestCase):
def setUp(self):
self.table = Table(xmlnode=etree.XML(TABLE_COMP))
def test_metrics(self):
self.assertEqual(self.table.ncols(), 7)
self.assertEqual(self.table.nrows(), 7)
def test_set_get_different_values(self):
ncols = self.table.ncols()
for row in range(self.table.nrows()):
for col in range(ncols):
cell = self.table[row, col]
cell.set_value(row*ncols + col, 'float')
for row in range(self.table.nrows()):
for col in range(ncols):
cell = self.table[row, col]
self.assertEqual(row*ncols + col, int(cell.value))
class TestCellSpan(unittest.TestCase):
# this test-case tests only, if cell spanning is available
# for extensive cell span testing see: test_cell_span_controller.py
def setUp(self):
self.table = Table(name="TEST", size=(10, 10))
def test_set_cell_span(self):
self.table.set_cell_span('A1', (3, 3))
self.assertEqual((3, 3), self.table['A1'].span, "Span values for cell 'A1' not set.")
self.assertTrue(self.table['B2'].covered, "cell 'B1' is not covered")
def test_remove_cell_span(self):
self.table.set_cell_span('A1', (3, 3))
self.table.remove_cell_span('A1')
self.assertEqual((1, 1), self.table['A1'].span, "Span values for cell 'A1' should be (1, 1).")
self.assertFalse(self.table['B2'].covered, "cell 'B1' is covered")
class TestCellSpan(unittest.TestCase):
# this test-case tests only, if cell spanning is available
# for extensive cell span testing see: test_cell_span_controller.py
def setUp(self):
self.table = Table(name="TEST", size=(10, 10))
def test_set_cell_span(self):
self.table.set_cell_span('A1', (3, 3))
self.assertEqual((3, 3), self.table['A1'].span,
"Span values for cell 'A1' not set.")
self.assertTrue(self.table['B2'].covered, "cell 'B1' is not covered")
def test_remove_cell_span(self):
self.table.set_cell_span('A1', (3, 3))
self.table.remove_cell_span('A1')
self.assertEqual((1, 1), self.table['A1'].span,
"Span values for cell 'A1' should be (1, 1).")
self.assertFalse(self.table['B2'].covered, "cell 'B1' is covered")
def test_name_with_cr_and_tabs(self):
table = Table('table\tname\r ')
self.assertEqual(table.name, 'table name', "table name not normalized")
def test_get_name(self):
table = Table()
name = table.name
self.assertTrue(is_string(name))
def test_clear_table(self):
table = Table(name="TEST")
table[0, 0].set_value("marker")
table.clear()
self.assertIsNone(table[0, 0].value, "cell value should be None")
def test_protection_key_is_set(self):
table = Table()
table.protected = True
key = table.get_attr(CN('table:protection-key'))
self.assertIsNotNone(key, "protection-key not set")
self.assertGreater(len(key), 8, "protection-key is too short")
def test_set_print(self):
table = Table()
table.print_ = True
self.assertTrue(table.print_)
self.assertEqual(table.get_attr(CN('table:print')), 'true', 'table:print should be true')
def test_set_protected(self):
table = Table()
table.protected = True
self.assertTrue(table.protected)
self.assertEqual(table.get_attr(CN('table:protected')), 'true', 'wrong tag name')
def test_protection_key_not_set(self):
table = Table()
key = table.get_attr(CN('table:protection-key'))
self.assertIsNone(key)
def test_set_style_name(self):
table = Table()
table.style_name = 'STYLE'
self.assertEqual(table.style_name, 'STYLE')
self.assertEqual(table.get_attr(CN('table:style-name')), 'STYLE', 'wrong tag name')
def test_set_name(self):
table = Table()
table.name = 'TABLE'
self.assertEqual(table.name, 'TABLE')
self.assertEqual(table.get_attr(CN('table:name')), 'TABLE', 'wrong tag name')
def setUp(self):
self.table = Table(name="TEST", size=(10, 10))
def test_get_style_name(self):
table = Table()
self.assertIsNone(table.style_name)
class TestTableColumnManagement(unittest.TestCase):
def colinfo(self, index):
return self.table.column_info(index).style_name
def cellvalue(self, row, col):
return self.table[row, col].value
def setUp(self):
self.table = Table('TEST', size=(10, 10))
add_table_prelude_content(self.table)
for col in range(self.table.nrows()):
self.table[0, col].set_value('checkmark%d' % col )
invoke_cache = self.cellvalue(0, col)
for col in range(self.table.ncols()):
column_info = self.table.column_info(col)
column_info.style_name = 'c%d' % col
def test_append_one_column(self):
self.table.append_columns(1)
self.assertEqual(11, self.table.ncols(), "expected 11 columns")
column_info = self.table.column_info(10)
self.assertEqual(column_info.kind, "TableColumn")
def test_append_two_columns(self):
self.table.append_columns(2)
self.assertEqual(12, self.table.ncols(), "expected 12 columns")
column_info = self.table.column_info(11)
self.assertEqual(column_info.kind, "TableColumn")
def test_append_count_zero_error(self):
with self.assertRaises(ValueError):
self.table.append_columns(0)
def test_append_negative_count_error(self):
with self.assertRaises(ValueError):
self.table.append_columns(-1)
def test_insert_one_column(self):
self.table.insert_columns(5, count=1)
self.chk_insert_one_column()
def test_insert_one_column_neg_index(self):
self.table.insert_columns(-5, count=1)
self.chk_insert_one_column()
def chk_insert_one_column(self):
self.assertEqual(11, self.table.ncols(), "expected 11 columns")
self.assertEqual('checkmark4', self.cellvalue(0, 4), "expected checkmark4 in col 4")
self.assertIsNone(self.cellvalue(0, 5), "expected None in col 5")
self.assertEqual('checkmark5', self.cellvalue(0, 6), "expected checkmark5 in col 6")
self.assertEqual('c4', self.colinfo(4), "expected 'c4' as colinfo 4")
self.assertEqual('c5', self.colinfo(6), "expected 'c5' as colinfo 6")
def test_insert_two_columns(self):
self.table.insert_columns(5, count=2)
self.assertEqual(12, self.table.ncols(), "expected 12 columns")
self.assertEqual('checkmark4', self.cellvalue(0, 4), "expected checkmark4 in col 4")
self.assertIsNone(self.cellvalue(0, 5), "expected None in col 5")
self.assertIsNone(self.cellvalue(0, 6), "expected None in col 6")
self.assertEqual('checkmark5', self.cellvalue(0, 7), "expected checkmark5 in col 7")
self.assertEqual(self.colinfo(4), 'c4', "expected 'c4' as colinfo 4")
self.assertEqual(self.colinfo(7), 'c5', "expected 'c5' as colinfo 7")
def test_insert_zero_cols_value_error(self):
with self.assertRaises(ValueError):
self.table.insert_columns(0, count=0)
def test_insert_negative_cols_value_error(self):
with self.assertRaises(ValueError):
self.table.insert_columns(0, count=-1)
def test_delete_one_column(self):
self.table.delete_columns(5, count=1)
self.chk_delete_one_column()
def test_delete_one_column_neg_index(self):
self.table.delete_columns(-5, count=1)
self.chk_delete_one_column()
def chk_delete_one_column(self):
self.assertEqual(9, self.table.ncols(), "expected 9 columns")
self.assertEqual('checkmark4', self.cellvalue(0, 4), "expected checkmark4 in col 4")
self.assertEqual('checkmark6', self.cellvalue(0, 5), "expected checkmark6 in col 5")
self.assertEqual(self.colinfo(4), 'c4', "expected 'c4' as colinfo 4")
self.assertEqual(self.colinfo(5), 'c6', "expected 'c6' as colinfo 5")
def test_delete_two_columns(self):
self.table.delete_columns(5, count=2)
self.chk_delete_two_columns()
def test_delete_two_columns_neg_index(self):
self.table.delete_columns(-5, count=2)
self.chk_delete_two_columns()
def chk_delete_two_columns(self):
self.assertEqual(8, self.table.ncols(), "expected 8 columns")
self.assertEqual('checkmark4', self.cellvalue(0, 4), "expected checkmark4 in col 4")
self.assertEqual('checkmark7', self.cellvalue(0, 5), "expected checkmark7 in col 5")
self.assertEqual('c4', self.colinfo(4), "expected 'c4' as colinfo 4")
self.assertEqual('c7', self.colinfo(5), "expected 'c7' as colinfo 5")
def test_delete_last_column(self):
self.table.delete_columns(index=9)
self.assertEqual(9, self.table.ncols(), "expected 9 columns")
def test_delete_zero_cols_value_error(self):
with self.assertRaises(ValueError):
self.table.delete_columns(0, count=0)
def test_delete_negative_cols_value_error(self):
with self.assertRaises(ValueError):
self.table.delete_columns(0, count=-1)
def test_delete_cols_index_out_of_range_error(self):
with self.assertRaises(IndexError):
self.table.delete_columns(10, count=1)
def test_delete_cols_index_and_count_out_of_range_error(self):
with self.assertRaises(IndexError):
self.table.delete_columns(9, count=2)
class TestRowColumnAccess(unittest.TestCase):
def setUp(self):
self.table = Table(xmlnode=etree.XML(SQUAREMATRIX))
def test_get_row_1_by_index(self):
values = [cell.value for cell in self.table.row(1)]
self.assertEqual(values, [5., 6., 7., 8.])
def test_get_row_1_by_address(self):
self.assertEqual(tofloats(self.table.row('A2')), [5., 6., 7., 8.])
def test_row_slice(self):
self.assertEqual(tofloats(self.table.row(1)[1:3]), [6., 7.])
def test_row_index_error(self):
with self.assertRaises(IndexError):
self.table.row(4)
def test_row_neg_index(self):
self.assertEqual(tofloats(self.table.row(-1)), [13., 14., 15., 16.])
def test_get_column_1_by_index(self):
self.assertEqual(tofloats(self.table.column(1)), [2., 6., 10., 14.])
def test_get_column_1_by_address(self):
self.assertEqual(tofloats(self.table.column('B2')), [2., 6., 10., 14.])
def test_column_slice(self):
self.assertEqual(tofloats(self.table.column(1)[1:3]), [6., 10.])
def test_column_index_error(self):
with self.assertRaises(IndexError):
self.table.column(4)
def test_column_neg_index(self):
self.assertEqual(tofloats(self.table.column(-1)), [4., 8., 12., 16.])
def test_rows(self):
values = tofloats(chain(*self.table.rows()))
expected = [float(x) for x in range(1, 17)]
self.assertEqual(expected, values)
def test_columns(self):
values = tofloats(chain(*self.table.columns()))
expected = [1., 5., 9., 13., 2., 6., 10., 14., 3., 7., 11., 15., 4., 8., 12., 16.]
self.assertEqual(expected, values)
def test_copy_table_without_new_name(self):
table1 = Table(name='Test')
table2 = table1.copy()
self.assertEqual('CopyOfTest', table2.name, "table2 has wrong name.")
def test_setup_error(self):
with self.assertRaises(ValueError):
Table(size=(1, 0))
with self.assertRaises(ValueError):
Table(size=(0, 1))
def test_has_TAG(self):
table = Table()
self.assertEqual(table.TAG, CN('table:table'))
def test_copy_table_without_new_name(self):
table1 = Table(name='Test')
table2 = table1.copy()
self.assertEqual('CopyOfTest', table2.name, "table2 has wrong name.")
def setUp(self):
self.table = Table(xmlnode=etree.XML(SQUAREMATRIX))
def setUp(self):
self.table = Table(xmlnode=etree.XML(TABLE_COMP))
def setUp(self):
self.table = Table(xmlnode=etree.XML(SQUAREMATRIX))
class TestRowColumnAccess(unittest.TestCase):
def setUp(self):
self.table = Table(xmlnode=etree.XML(SQUAREMATRIX))
def test_get_row_1_by_index(self):
values = [cell.value for cell in self.table.row(1)]
self.assertEqual(values, [5., 6., 7., 8.])
def test_get_row_1_by_address(self):
self.assertEqual(tofloats(self.table.row('A2')), [5., 6., 7., 8.])
def test_row_slice(self):
self.assertEqual(tofloats(self.table.row(1)[1:3]), [6., 7.])
def test_row_index_error(self):
with self.assertRaises(IndexError):
self.table.row(4)
def test_row_neg_index(self):
self.assertEqual(tofloats(self.table.row(-1)), [13., 14., 15., 16.])
def test_get_column_1_by_index(self):
self.assertEqual(tofloats(self.table.column(1)), [2., 6., 10., 14.])
def test_get_column_1_by_address(self):
self.assertEqual(tofloats(self.table.column('B2')), [2., 6., 10., 14.])
def test_column_slice(self):
self.assertEqual(tofloats(self.table.column(1)[1:3]), [6., 10.])
def test_column_index_error(self):
with self.assertRaises(IndexError):
self.table.column(4)
def test_column_neg_index(self):
self.assertEqual(tofloats(self.table.column(-1)), [4., 8., 12., 16.])
def test_rows(self):
values = tofloats(chain(*self.table.rows()))
expected = [float(x) for x in range(1, 17)]
self.assertEqual(expected, values)
def test_columns(self):
values = tofloats(chain(*self.table.columns()))
expected = [
1., 5., 9., 13., 2., 6., 10., 14., 3., 7., 11., 15., 4., 8., 12.,
16.
]
self.assertEqual(expected, values)
class TestTableRowManagement(unittest.TestCase):
def cellvalue(self, row, col):
return self.table[row, col].value
def setUp(self):
self.table = Table('TEST', size=(10, 10))
add_table_prelude_content(self.table)
for row in range(10):
self.table[row,0].set_value('checkmark%d' % row )
invoke_cache = self.cellvalue(row, 0)
def test_metrics(self):
self.assertEqual(10, self.table.nrows(), "expected 10 rows")
self.assertEqual(10, self.table.ncols(), "expected 10 columns")
def test_append_one_row(self):
self.table.append_rows(1)
self.assertEqual(11, self.table.nrows(), "expected 11 rows")
def test_append_two_rows(self):
self.table.append_rows(2)
self.assertEqual(12, self.table.nrows(), "expected 12 rows")
def test_append_zero_rows_value_error(self):
with self.assertRaises(ValueError):
self.table.append_rows(0)
def test_append_negative_rows_value_error(self):
with self.assertRaises(ValueError):
self.table.append_rows(-1)
def test_insert_one_row(self):
self.table.insert_rows(index=5, count=1)
self.chk_insert_one_row()
def test_insert_one_row_neg_index(self):
self.table.insert_rows(index=-5, count=1)
self.chk_insert_one_row()
def chk_insert_one_row(self):
self.assertEqual(11, self.table.nrows(), "expected 11 rows")
self.assertEqual('checkmark4', self.cellvalue(4, 0), "expected checkmark4 in row 4")
self.assertIsNone(self.cellvalue(5, 0), "expected None in row 5")
self.assertEqual('checkmark5', self.cellvalue(6, 0), "expected checkmark5 in row 6")
def test_insert_two_rows(self):
self.table.insert_rows(index=5, count=2)
self.chk_insert_two_rows()
def test_insert_two_rows_neg_index(self):
self.table.insert_rows(index=-5, count=2)
self.chk_insert_two_rows()
def chk_insert_two_rows(self):
self.assertEqual(12, self.table.nrows(), "expected 12 rows")
self.assertEqual('checkmark4', self.cellvalue(4, 0), "expected checkmark4 in row 4")
self.assertIsNone(self.cellvalue(5, 0))
self.assertIsNone(self.cellvalue(6, 0))
self.assertEqual('checkmark5', self.cellvalue(7, 0), "expected checkmark5 in row 7")
def test_insert_zero_rows_value_error(self):
with self.assertRaises(ValueError):
self.table.insert_rows(0, count=0)
def test_insert_negative_rows_value_error(self):
with self.assertRaises(ValueError):
self.table.insert_rows(0, count=-1)
def test_insert_rows_out_of_range_index_error(self):
with self.assertRaises(IndexError):
self.table.insert_rows(10, count=1)
def test_delete_one_row(self):
self.table.delete_rows(index=5, count=1)
self.chk_delete_one_row()
def test_delete_one_row_neg_index(self):
self.table.delete_rows(index=-5, count=1)
self.chk_delete_one_row()
def chk_delete_one_row(self):
self.assertEqual(9, self.table.nrows(), "expected 9 rows")
self.assertEqual('checkmark4', self.cellvalue(4, 0), "expected checkmark4 in row 4")
self.assertEqual('checkmark6', self.cellvalue(5, 0), "expected checkmark6 in row 5")
def test_delete_two_rows(self):
self.table.delete_rows(index=5, count=2)
self.chk_delete_two_rows()
def test_delete_two_rows_neg_index(self):
self.table.delete_rows(index=-5, count=2)
self.chk_delete_two_rows()
def chk_delete_two_rows(self):
self.assertEqual(8, self.table.nrows(), "expected 8 rows")
self.assertEqual('checkmark4', self.cellvalue(4, 0), "expected checkmark4 in row 4")
self.assertEqual('checkmark7', self.cellvalue(5, 0), "expected checkmark7 in row 5")
def test_delete_last_row(self):
self.table.delete_rows(index=9)
self.assertEqual(9, self.table.nrows(), "expected 9 rows")
def test_delete_zero_rows_value_error(self):
with self.assertRaises(ValueError):
self.table.delete_rows(0, count=0)
def test_delete_negative_rows_value_error(self):
with self.assertRaises(ValueError):
self.table.delete_rows(0, count=-1)
def test_delete_rows_index_out_of_range_error(self):
with self.assertRaises(IndexError):
self.table.delete_rows(10, count=1)
def test_delete_rows_index_and_count_out_of_range_error(self):
self.table.xmlnode.append(etree.Element('FakeNode'))
with self.assertRaises(IndexError):
self.table.delete_rows(9, count=2)
def test_clear_table(self):
table = Table(name="TEST")
table[0,0].set_value("marker")
table.clear()
self.assertIsNone(table[0,0].value, "cell value should be None")
def setUp(self):
self.table = Table('TEST', size=(10, 10))
add_table_prelude_content(self.table)
for row in range(10):
self.table[row,0].set_value('checkmark%d' % row )
invoke_cache = self.cellvalue(row, 0)
def test_has_xmlnode(self):
table = Table()
self.assertIsNotNone(table.xmlnode)
def test_get_protected(self):
table = Table()
self.assertFalse(table.protected)
def setUp(self):
self.table = Table(name="TEST", size=(10, 10))
def test_protection_key_not_set(self):
table = Table()
key = table.get_attr(CN('table:protection-key'))
self.assertIsNone(key)
def test_set_name(self):
table = Table()
table.name = 'TABLE'
self.assertEqual(table.name, 'TABLE')
self.assertEqual(table.get_attr(CN('table:name')), 'TABLE',
'wrong tag name')
def test_reset(self):
table = Table(name="TEST", size=(7, 5))
table.reset(size=(8, 10))
self.assertEqual("TEST", table.name, "name attribute is deleted")
self.assertEqual(table.ncols(), 10)
self.assertEqual(table.nrows(), 8)
def test_name_with_apostroph2(self):
table = Table(" table'name")
self.assertEqual(table.name, 'table name', "table name not normalized")
def test_reset(self):
table = Table(name="TEST", size=(7, 5))
table.reset(size=(8, 10))
self.assertEqual("TEST", table.name, "name attribute is deleted")
self.assertEqual(table.ncols(), 10)
self.assertEqual(table.nrows(), 8)
def test_set_style_name(self):
table = Table()
table.style_name = 'STYLE'
self.assertEqual(table.style_name, 'STYLE')
self.assertEqual(table.get_attr(CN('table:style-name')), 'STYLE',
'wrong tag name')
def setUp(self):
self.table = Table(xmlnode=etree.XML(TABLE_COMP))
def test_set_protected(self):
table = Table()
table.protected = True
self.assertTrue(table.protected)
self.assertEqual(table.get_attr(CN('table:protected')), 'true',
'wrong tag name')
def test_init_row_cols(self):
table = Table(name="TEST", size=(7, 5))
self.assertEqual(table.nrows(), 7)
self.assertEqual(table.ncols(), 5)
def test_protection_key_is_set(self):
table = Table()
table.protected = True
key = table.get_attr(CN('table:protection-key'))
self.assertIsNotNone(key, "protection-key not set")
self.assertGreater(len(key), 8, "protection-key is too short")
def test_init_row_cols(self):
table = Table(name="TEST", size=(7, 5))
self.assertEqual(table.nrows(), 7)
self.assertEqual(table.ncols(), 5)
