From fecb8a8c8a0275b92149c0e9d54e377f93d9811c Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Fri, 1 Nov 2024 22:22:57 +0100 Subject: [PATCH] RDB tests for Python too --- src/pya/unit_tests/pyaTests.cc | 1 + testdata/python/rdbTest.py | 961 +++++++++++++++++++++++++++++++++ 2 files changed, 962 insertions(+) create mode 100644 testdata/python/rdbTest.py diff --git a/src/pya/unit_tests/pyaTests.cc b/src/pya/unit_tests/pyaTests.cc index 7420d1f69..19992cf95 100644 --- a/src/pya/unit_tests/pyaTests.cc +++ b/src/pya/unit_tests/pyaTests.cc @@ -108,6 +108,7 @@ PYTHONTEST (dbTransTest, "dbTransTest.py") PYTHONTEST (dbLayoutToNetlist, "dbLayoutToNetlist.py") PYTHONTEST (dbLayoutVsSchematic, "dbLayoutVsSchematic.py") PYTHONTEST (dbNetlistCrossReference, "dbNetlistCrossReference.py") +PYTHONTEST (rdbTest, "rdbTest.py") PYTHONTEST (layLayers, "layLayers.py") PYTHONTEST (layObjects, "layObjects.py") PYTHONTEST (layPixelBuffer, "layPixelBuffer.py") diff --git a/testdata/python/rdbTest.py b/testdata/python/rdbTest.py new file mode 100644 index 000000000..91a0f0867 --- /dev/null +++ b/testdata/python/rdbTest.py @@ -0,0 +1,961 @@ +# KLayout Layout Viewer +# Copyright (C) 2006-2024 Matthias Koefferlein +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +import pya +import unittest +import os +import sys + +def to_s_test(self): + r = self.name() + r += "[" + refs = [ self.database().cell_by_id(i.parent_cell_id).name() + "->" + str(i.trans) for i in self.each_reference() ] + r += ",".join(refs) + r += "]" + return r + +def to_s_items(self): + r = self.name() + r += "[" + ai = [] + for i in self.each_item(): + vv = [ str(v) for v in i.each_value() ] + ai.append("/".join(vv)) + r += ",".join(ai) + r += "]" + return r + +pya.RdbCell.to_s_items = to_s_items +pya.RdbCell.to_s_test = to_s_test + +class RDB_TestClass(unittest.TestCase): + + # RdbReference + def test_1(self): + + ref = pya.RdbReference(pya.DCplxTrans(), 0) + self.assertEqual(ref.trans.__str__(), "r0 *1 0,0") + ref.trans = pya.DCplxTrans(5.0) + self.assertEqual(ref.trans.__str__(), "r0 *5 0,0") + + self.assertEqual(ref.parent_cell_id, 0) + ref.parent_cell_id = 177 + self.assertEqual(ref.parent_cell_id, 177) + + # RdbCell, RdbCategory + def test_2(self): + + db = pya.ReportDatabase("name") + + cell = db.create_cell("cell_name") + self.assertEqual(cell.database().__repr__(), db.__repr__()) + self.assertEqual(cell.name(), "cell_name") + self.assertEqual(cell.rdb_id(), 1) + + cell2 = db.create_cell("new_cell", "var1") + self.assertEqual(cell2.name(), "new_cell") + self.assertEqual(cell2.layout_name(), "") + self.assertEqual(cell2.qname(), "new_cell:var1") + + cell2 = db.create_cell("cell_name", "var1", "cell_name$1") + self.assertEqual(cell.name(), "cell_name") + self.assertEqual(cell.qname(), "cell_name:1") + self.assertEqual(db.cell_by_qname("cell_name:1").rdb_id(), cell.rdb_id()) + self.assertEqual(db.cell_by_id(cell.rdb_id()).rdb_id(), cell.rdb_id()) + self.assertEqual(cell2.name(), "cell_name") + self.assertEqual(cell2.layout_name(), "cell_name$1") + self.assertEqual(cell2.qname(), "cell_name:var1") + self.assertEqual(db.cell_by_qname("cell_name:var1").rdb_id(), cell2.rdb_id()) + self.assertEqual(db.cell_by_id(cell2.rdb_id()).rdb_id(), cell2.rdb_id()) + self.assertEqual(cell2.rdb_id(), 3) + self.assertEqual(cell.num_items(), 0) + self.assertEqual(cell2.num_items(), 0) + self.assertEqual(cell.num_items_visited(), 0) + self.assertEqual(cell2.num_items_visited(), 0) + + cc = db.variants("cell_name") + self.assertEqual(len(cc), 2) + self.assertEqual(cc[0], cell.rdb_id()) + self.assertEqual(cc[1], cell2.rdb_id()) + + cc = [ c for c in db.each_cell() ] + self.assertEqual(len(cc), 3) + self.assertEqual(cc[0].rdb_id(), cell.rdb_id()) + self.assertEqual(cc[2].rdb_id(), cell2.rdb_id()) + + cat = db.create_category("cat") + self.assertEqual(cat.database().__repr__(), db.__repr__()) + self.assertEqual(cat.name(), "cat") + self.assertEqual(cat.rdb_id(), 4) + self.assertEqual(cat.path(), "cat") + + cats = db.create_category(cat, "subcat") + self.assertEqual(cats.name(), "subcat") + self.assertEqual(cats.rdb_id(), 5) + self.assertEqual(cats.path(), "cat.subcat") + self.assertEqual(cats.parent().rdb_id(), cat.rdb_id()) + + cat.description = "cat_desc" + self.assertEqual(cat.description, "cat_desc") + + x = [ c for c in cat.each_sub_category() ] + self.assertEqual(len(x), 1) + self.assertEqual(x[0].rdb_id(), cats.rdb_id()) + + item = db.create_item(cell.rdb_id(), cat.rdb_id()) + self.assertEqual(db.num_items(), 1) + self.assertEqual(db.num_items_visited(), 0) + self.assertEqual(db.num_items(cell.rdb_id(), cat.rdb_id()), 1) + self.assertEqual(db.num_items_visited(cell.rdb_id(), cat.rdb_id()), 0) + self.assertEqual(db.num_items(cell.rdb_id(), cats.rdb_id()), 0) + self.assertEqual(db.num_items_visited(cell.rdb_id(), cats.rdb_id()), 0) + self.assertEqual(cell.num_items(), 1) + self.assertEqual(cell2.num_items(), 0) + self.assertEqual(cat.num_items(), 1) + self.assertEqual(cats.num_items(), 0) + self.assertEqual(cell.num_items_visited(), 0) + self.assertEqual(cell2.num_items_visited(), 0) + self.assertEqual(cat.num_items_visited(), 0) + self.assertEqual(cats.num_items_visited(), 0) + + try: + item = db.create_item(1000, cat.rdb_id()) + self.assertEqual(False, True) + except Exception as ex: + self.assertEqual(ex.__str__(), "Not a valid cell ID: 1000 in ReportDatabase.create_item") + + try: + item = db.create_item(cell.rdb_id(), 1001) + self.assertEqual(False, True) + except Exception as ex: + self.assertEqual(ex.__str__(), "Not a valid category ID: 1001 in ReportDatabase.create_item") + + item2 = db.create_item(cell2, cats) + self.assertEqual(db.num_items(), 2) + self.assertEqual(db.num_items_visited(), 0) + self.assertEqual(db.num_items(cell2.rdb_id(), cats.rdb_id()), 1) + self.assertEqual(db.num_items_visited(cell2.rdb_id(), cats.rdb_id()), 0) + self.assertEqual(db.num_items(cell2.rdb_id(), cat.rdb_id()), 1) + self.assertEqual(db.num_items_visited(cell2.rdb_id(), cat.rdb_id()), 0) + self.assertEqual(cell.num_items(), 1) + self.assertEqual(cell2.num_items(), 1) + self.assertEqual(cat.num_items(), 2) + self.assertEqual(cats.num_items(), 1) + self.assertEqual(cell.num_items_visited(), 0) + self.assertEqual(cell2.num_items_visited(), 0) + self.assertEqual(cat.num_items_visited(), 0) + self.assertEqual(cats.num_items_visited(), 0) + + db.set_item_visited(item, True) + self.assertEqual(item.is_visited(), True) + self.assertEqual(cell.num_items_visited(), 1) + self.assertEqual(cell2.num_items_visited(), 0) + self.assertEqual(cat.num_items_visited(), 1) + self.assertEqual(cats.num_items_visited(), 0) + self.assertEqual(db.num_items(), 2) + self.assertEqual(db.num_items_visited(), 1) + self.assertEqual(db.num_items(cell.rdb_id(), cat.rdb_id()), 1) + self.assertEqual(db.num_items_visited(cell.rdb_id(), cat.rdb_id()), 1) + self.assertEqual(db.num_items(cell2.rdb_id(), cats.rdb_id()), 1) + self.assertEqual(db.num_items_visited(cell2.rdb_id(), cats.rdb_id()), 0) + self.assertEqual(db.num_items(cell.rdb_id(), cats.rdb_id()), 0) + self.assertEqual(db.num_items_visited(cell.rdb_id(), cats.rdb_id()), 0) + + db.set_item_visited(item2, True) + self.assertEqual(cell.num_items_visited(), 1) + self.assertEqual(cell2.num_items_visited(), 1) + self.assertEqual(cat.num_items_visited(), 2) + self.assertEqual(cats.num_items_visited(), 1) + self.assertEqual(db.num_items(), 2) + self.assertEqual(db.num_items_visited(), 2) + self.assertEqual(db.num_items(cell.rdb_id(), cat.rdb_id()), 1) + self.assertEqual(db.num_items_visited(cell.rdb_id(), cat.rdb_id()), 1) + self.assertEqual(db.num_items(cell2.rdb_id(), cats.rdb_id()), 1) + self.assertEqual(db.num_items_visited(cell2.rdb_id(), cats.rdb_id()), 1) + self.assertEqual(db.num_items(cell.rdb_id(), cats.rdb_id()), 0) + self.assertEqual(db.num_items_visited(cell.rdb_id(), cats.rdb_id()), 0) + + db.set_item_visited(item, False) + self.assertEqual(item.is_visited(), False) + self.assertEqual(cell.num_items_visited(), 0) + self.assertEqual(cell2.num_items_visited(), 1) + self.assertEqual(cat.num_items_visited(), 1) + self.assertEqual(cats.num_items_visited(), 1) + self.assertEqual(db.num_items(), 2) + self.assertEqual(db.num_items_visited(), 1) + self.assertEqual(db.num_items(cell.rdb_id(), cat.rdb_id()), 1) + self.assertEqual(db.num_items_visited(cell.rdb_id(), cat.rdb_id()), 0) + self.assertEqual(db.num_items(cell2.rdb_id(), cats.rdb_id()), 1) + self.assertEqual(db.num_items_visited(cell2.rdb_id(), cats.rdb_id()), 1) + self.assertEqual(db.num_items(cell.rdb_id(), cats.rdb_id()), 0) + self.assertEqual(db.num_items_visited(cell.rdb_id(), cats.rdb_id()), 0) + + ii = [ i for i in db.each_item() ] + self.assertEqual(len(ii), 2) + self.assertEqual(ii[0].cell_id(), item.cell_id()) + self.assertEqual(ii[0].category_id(), item.category_id()) + self.assertEqual(ii[1].cell_id(), item2.cell_id()) + self.assertEqual(ii[1].category_id(), item2.category_id()) + + ii = [ i for i in db.each_item_per_cell(cell.rdb_id()) ] + self.assertEqual(len(ii), 1) + self.assertEqual(ii[0].cell_id(), item.cell_id()) + self.assertEqual(ii[0].category_id(), item.category_id()) + + ii = [ i for i in cell.each_item() ] + self.assertEqual(len(ii), 1) + self.assertEqual(ii[0].cell_id(), item.cell_id()) + self.assertEqual(ii[0].category_id(), item.category_id()) + + ii = [ i for i in db.each_item_per_category(cats.rdb_id()) ] + self.assertEqual(len(ii), 1) + self.assertEqual(ii[0].cell_id(), item2.cell_id()) + self.assertEqual(ii[0].category_id(), item2.category_id()) + + ii = [ i for i in cats.each_item() ] + self.assertEqual(len(ii), 1) + self.assertEqual(ii[0].cell_id(), item2.cell_id()) + self.assertEqual(ii[0].category_id(), item2.category_id()) + + ii = [ i for i in db.each_item_per_cell_and_category(cell.rdb_id(), cats.rdb_id()) ] + self.assertEqual(len(ii), 0) + + ii = [ i for i in db.each_item_per_cell_and_category(cell2.rdb_id(), cats.rdb_id()) ] + self.assertEqual(len(ii), 1) + self.assertEqual(ii[0].cell_id(), item2.cell_id()) + self.assertEqual(ii[0].category_id(), item2.category_id()) + + refs = [ r for r in cell.each_reference() ] + self.assertEqual(len(refs), 0) + + cell.add_reference(pya.RdbReference(pya.DCplxTrans(2.5), 178)) + refs = [ r for r in cell.each_reference() ] + self.assertEqual(len(refs), 1) + self.assertEqual(refs[0].parent_cell_id, 178) + self.assertEqual(refs[0].database().__repr__(), db.__repr__()) + + cell.clear_references() + refs = [ r for r in cell.each_reference() ] + self.assertEqual(len(refs), 0) + + # RdbItemValue + def test_3(self): + + v = pya.RdbItemValue(1.0) + self.assertEqual(v.tag_id, 0) + v.tag_id = 15 + self.assertEqual(v.tag_id, 15) + + vf = pya.RdbItemValue(1.0) + vs = pya.RdbItemValue("a string") + vb = pya.RdbItemValue(pya.DBox(0, 10, 20, 30)) + vl = pya.RdbItemValue(pya.DText("abc", pya.DTrans())) + vp = pya.RdbItemValue(pya.DPolygon(pya.DBox(100, 101, 102, 103))) + ve = pya.RdbItemValue(pya.DEdge(pya.DPoint(0, 10), pya.DPoint(20, 30))) + vee = pya.RdbItemValue(pya.DEdgePair(pya.DEdge(0, 10, 5, 15), pya.DEdge(20, 30, 25, 35))) + + self.assertEqual(vf.__str__(), "float: 1") + self.assertEqual(vs.__str__(), "text: 'a string'") + self.assertEqual(vb.__str__(), "box: (0,10;20,30)") + self.assertEqual(vp.__str__(), "polygon: (100,101;100,103;102,103;102,101)") + self.assertEqual(vl.__str__(), "label: ('abc',r0 0,0)"); + self.assertEqual(ve.__str__(), "edge: (0,10;20,30)") + self.assertEqual(vee.__str__(), "edge-pair: (0,10;5,15)/(20,30;25,35)") + self.assertEqual(pya.RdbItemValue.from_s(vf.__str__()).__str__(), vf.__str__()) + self.assertEqual(pya.RdbItemValue.from_s(vs.__str__()).__str__(), vs.__str__()) + self.assertEqual(pya.RdbItemValue.from_s(vb.__str__()).__str__(), vb.__str__()) + self.assertEqual(pya.RdbItemValue.from_s(vp.__str__()).__str__(), vp.__str__()) + self.assertEqual(pya.RdbItemValue.from_s(vl.__str__()).__str__(), vl.__str__()) + self.assertEqual(pya.RdbItemValue.from_s(ve.__str__()).__str__(), ve.__str__()) + self.assertEqual(pya.RdbItemValue.from_s(vee.__str__()).__str__(), vee.__str__()) + + self.assertEqual(vf.is_float(), True) + self.assertEqual(vf.is_string(), False) + self.assertEqual(vf.is_polygon(), False) + self.assertEqual(vf.is_text(), False) + self.assertEqual(vf.is_edge(), False) + self.assertEqual(vf.is_box(), False) + self.assertEqual(vf.is_edge_pair(), False) + self.assertEqual(vf.float(), 1) + self.assertEqual(vf.string(), "1") + + self.assertEqual(vs.is_float(), False) + self.assertEqual(vs.is_string(), True) + self.assertEqual(vs.is_polygon(), False) + self.assertEqual(vs.is_text(), False) + self.assertEqual(vs.is_edge(), False) + self.assertEqual(vs.is_box(), False) + self.assertEqual(vs.is_edge_pair(), False) + self.assertEqual(vs.string(), "a string") + + self.assertEqual(vl.is_float(), False) + self.assertEqual(vl.is_string(), False) + self.assertEqual(vl.is_polygon(), False) + self.assertEqual(vl.is_text(), True) + self.assertEqual(vl.is_edge(), False) + self.assertEqual(vl.is_box(), False) + self.assertEqual(vl.is_edge_pair(), False) + self.assertEqual(vl.text().__str__(), "('abc',r0 0,0)") + self.assertEqual(vl.string(), "label: " + vl.text().__str__()) + + self.assertEqual(vp.is_float(), False) + self.assertEqual(vp.is_string(), False) + self.assertEqual(vp.is_polygon(), True) + self.assertEqual(vp.is_text(), False) + self.assertEqual(vp.is_edge(), False) + self.assertEqual(vp.is_box(), False) + self.assertEqual(vp.is_edge_pair(), False) + self.assertEqual(vp.polygon().__str__(), "(100,101;100,103;102,103;102,101)") + self.assertEqual(vp.string(), "polygon: " + vp.polygon().__str__()) + + self.assertEqual(ve.is_float(), False) + self.assertEqual(ve.is_string(), False) + self.assertEqual(ve.is_polygon(), False) + self.assertEqual(ve.is_text(), False) + self.assertEqual(ve.is_edge(), True) + self.assertEqual(ve.is_box(), False) + self.assertEqual(ve.is_edge_pair(), False) + self.assertEqual(ve.edge().__str__(), "(0,10;20,30)") + self.assertEqual(ve.string(), "edge: " + ve.edge().__str__()) + + self.assertEqual(vb.is_float(), False) + self.assertEqual(vb.is_string(), False) + self.assertEqual(vb.is_polygon(), False) + self.assertEqual(vb.is_text(), False) + self.assertEqual(vb.is_edge(), False) + self.assertEqual(vb.is_box(), True) + self.assertEqual(vb.is_edge_pair(), False) + self.assertEqual(vb.box().__str__(), "(0,10;20,30)") + self.assertEqual(vb.string(), "box: " + vb.box().__str__()) + + self.assertEqual(vee.is_float(), False) + self.assertEqual(vee.is_string(), False) + self.assertEqual(vee.is_polygon(), False) + self.assertEqual(vee.is_text(), False) + self.assertEqual(vee.is_edge(), False) + self.assertEqual(vee.is_box(), False) + self.assertEqual(vee.is_edge_pair(), True) + self.assertEqual(vee.edge_pair().__str__(), "(0,10;5,15)/(20,30;25,35)") + self.assertEqual(vee.string(), "edge-pair: " + vee.edge_pair().__str__()) + + # RdbItem + def test_4(self): + + db = pya.ReportDatabase("name") + + cell = db.create_cell("cell_name") + cat = db.create_category("cat") + + item = db.create_item(cell.rdb_id(), cat.rdb_id()) + self.assertEqual(item.database().__repr__(), db.__repr__()) + self.assertEqual(item.cell_id(), cell.rdb_id()) + self.assertEqual(item.category_id(), cat.rdb_id()) + + self.assertEqual(db.user_tag_id("x1") != 0, True) + self.assertEqual(db.tag_id("x1") != 0, True) + self.assertEqual(db.tag_id("x1") == db.user_tag_id("x1"), False) + db.set_tag_description(db.user_tag_id("x1"), "D") + self.assertEqual(db.tag_description(db.user_tag_id("x1")), "D") + self.assertEqual(db.tag_name(db.user_tag_id("x1")), "x1") + self.assertEqual(db.tag_description(db.tag_id("x1")), "") + self.assertEqual(db.tag_name(db.tag_id("x1")), "x1") + db.set_tag_description(db.tag_id("x1"), "U") + self.assertEqual(db.tag_description(db.user_tag_id("x1")), "D") + self.assertEqual(db.tag_description(db.tag_id("x1")), "U") + + item.add_tag(db.tag_id("x1")) + self.assertEqual(item.has_tag(db.tag_id("x2")), False) + self.assertEqual(item.has_tag(db.tag_id("x1")), True) + self.assertEqual(item.tags_str, "x1") + item.add_tag(db.tag_id("x2")) + self.assertEqual(item.has_tag(db.tag_id("x2")), True) + self.assertEqual(item.has_tag(db.tag_id("x1")), True) + self.assertEqual(item.tags_str, "x1,x2") + item.remove_tag(db.tag_id("x1")) + self.assertEqual(item.has_tag(db.tag_id("x2")), True) + self.assertEqual(item.has_tag(db.tag_id("x1")), False) + self.assertEqual(item.tags_str, "x2") + + item.tags_str="x2,x1" + self.assertEqual(item.has_tag(db.tag_id("x2")), True) + self.assertEqual(item.has_tag(db.tag_id("x1")), True) + self.assertEqual(item.tags_str, "x1,x2") + + item.tags_str="" + self.assertEqual(item.has_tag(db.tag_id("x2")), False) + self.assertEqual(item.has_tag(db.tag_id("x1")), False) + self.assertEqual(item.tags_str, "") + + self.assertEqual(item.image_str, "") + self.assertEqual(item.has_image(), False) + + self.assertEqual(item.comment, "") + item.comment = "abc" + self.assertEqual(item.comment, "abc") + + # can actually by any string, but only base64-encoded PNG images make sense + istr="iVBORw0KGgoAAAANSUhEUgAAACoAAAA0CAIAAABzfT3nAAAAA3NCSVQICAjb4U/gAAAACXBIWXMAAA0SAAANOgHo3ZneAAAA3UlEQVRYhe2WwQ3DIAxFoco8XaGZIaeO43FyYgZYgYXcQ6SWuDGgBhWq/qccIvGCEd9SbAwAAPSGaW2lFR2rfWDpXrPpSe2SP10fvnn/PZHZH9IwbKFVZZ/Z6wMtZcjW02Bn2FVpZYdWdkr2nvh23S2FyDNJuVITpwmRjTGbNr0v20U5byNtJuuJt/fO2f93+UlbEJl5UjVPr3Y71EQ/PoPPlU+lDJtWlCt3GwCMG33BuJGAcWMEMG6c1jBudCyf/nzV8nbZPRohclFLHdGbZ8eNSjN1fmf0AACA1jwA4hKxu4C6P7EAAAAASUVORK5CYII=" + item.image_str=istr + self.assertEqual(item.image_str, istr) + self.assertEqual(item.has_image(), True) + + if "image_pixels" in item.__dict__: + px=item.image_pixels + self.assertEqual(px.width, 42) + self.assertEqual(px.height, 52) + item.image = px + px2=item.image_pixels + self.assertEqual(px == px2, True) + + if "image" in item.__dict__: + px=item.image + self.assertEqual(px.width, 42) + self.assertEqual(px.height, 52) + item.image = px + px2=item.image + self.assertEqual(px2.width, 42) + self.assertEqual(px2.height, 52) + + vs = pya.RdbItemValue("a string") + vs2 = pya.RdbItemValue("a string (ii)") + item.add_value(vs) + item.add_value(vs2) + + vv=[ v for v in item.each_value() ] + self.assertEqual(len(vv), 2) + self.assertEqual(vv[0].__str__(), "text: 'a string'") + self.assertEqual(vv[1].__str__(), "text: 'a string (ii)'") + + item.clear_values() + vv=[ v for v in item.each_value() ] + self.assertEqual(len(vv), 0) + + item.clear_values() + item.add_value(1.0) + item.add_value("hello") + item.add_value(pya.DPolygon(pya.DBox(1, 2, 3, 4))) + item.add_value(pya.DBox(11, 12, 13, 14)) + item.add_value(pya.DEdge(21, 22, 23, 24)) + item.add_value(pya.DEdgePair(pya.DEdge(31, 32, 33, 34), pya.DEdge(41, 42, 43, 44))) + shapes = pya.Shapes() + pts = [ pya.Point(0, 0), pya.Point(50, 150) ] + shapes.insert(pya.Path(pts, 100)) + for s in shapes: + item.add_value(s, pya.CplxTrans(0.001)) + vv=[ v for v in item.each_value() ] + self.assertEqual(len(vv), 7) + self.assertEqual(vv[0].__str__(), "float: 1") + self.assertEqual(vv[1].__str__(), "text: hello") + self.assertEqual(vv[2].__str__(), "polygon: (1,2;1,4;3,4;3,2)") + self.assertEqual(vv[3].__str__(), "box: (11,12;13,14)") + self.assertEqual(vv[4].__str__(), "edge: (21,22;23,24)") + self.assertEqual(vv[5].__str__(), "edge-pair: (31,32;33,34)/(41,42;43,44)") + self.assertEqual(vv[6].__str__(), "path: (0,0;0.05,0.15) w=0.1 bx=0 ex=0 r=false") + + # Multiple items + def test_5(self): + + db = pya.ReportDatabase("name") + + cell = db.create_cell("cell_name") + cat = db.create_category("cat") + + r = pya.Region(pya.Box(0, 0, 100, 200)) + db.create_items(cell.rdb_id(), cat.rdb_id(), pya.CplxTrans(0.001), r) + a = [] + for item in db.each_item_per_category(cat.rdb_id()): + for v in item.each_value(): + a.append(str(v)) + self.assertEqual(";".join(a), "polygon: (0,0;0,0.2;0.1,0.2;0.1,0)") + + db = pya.ReportDatabase("name") + + cell = db.create_cell("cell_name") + cat = db.create_category("cat") + + p = pya.Polygon(pya.Box(0, 0, 100, 200)) + db.create_items(cell.rdb_id(), cat.rdb_id(), pya.CplxTrans(0.001), [p]) + a = [] + for item in db.each_item_per_category(cat.rdb_id()): + for v in item.each_value(): + a.append(str(v)) + self.assertEqual(";".join(a), "polygon: (0,0;0,0.2;0.1,0.2;0.1,0)") + + db = pya.ReportDatabase("name") + + cell = db.create_cell("cell_name") + cat = db.create_category("cat") + + r = pya.Edges(pya.Edge(0, 0, 100, 200)) + db.create_items(cell.rdb_id(), cat.rdb_id(), pya.CplxTrans(0.001), r) + a = [] + for item in db.each_item_per_category(cat.rdb_id()): + for v in item.each_value(): + a.append(str(v)) + self.assertEqual(";".join(a), "edge: (0,0;0.1,0.2)") + + db = pya.ReportDatabase("name") + + cell = db.create_cell("cell_name") + cat = db.create_category("cat") + + r = [ pya.Edge(0, 0, 100, 200) ] + db.create_items(cell.rdb_id(), cat.rdb_id(), pya.CplxTrans(0.001), r) + a = [] + for item in db.each_item_per_category(cat.rdb_id()): + for v in item.each_value(): + a.append(str(v)) + self.assertEqual(";".join(a), "edge: (0,0;0.1,0.2)") + + db = pya.ReportDatabase("name") + + cell = db.create_cell("cell_name") + cat = db.create_category("cat") + + r = pya.EdgePairs() + r.insert(pya.EdgePair(pya.Edge(0, 0, 100, 200), pya.Edge(10, 10, 50, 150))) + db.create_items(cell.rdb_id(), cat.rdb_id(), pya.CplxTrans(0.001), r) + a = [] + for item in db.each_item_per_category(cat.rdb_id()): + for v in item.each_value(): + a.append(str(v)) + self.assertEqual(";".join(a), "edge-pair: (0,0;0.1,0.2)/(0.01,0.01;0.05,0.15)") + + db = pya.ReportDatabase("name") + + cell = db.create_cell("cell_name") + cat = db.create_category("cat") + + r = [ pya.EdgePair(pya.Edge(0, 0, 100, 200), pya.Edge(10, 10, 50, 150)) ] + db.create_items(cell.rdb_id(), cat.rdb_id(), pya.CplxTrans(0.001), r) + a = [] + for item in db.each_item_per_category(cat.rdb_id()): + for v in item.each_value(): + a.append(str(v)) + self.assertEqual(";".join(a), "edge-pair: (0,0;0.1,0.2)/(0.01,0.01;0.05,0.15)") + + # ReportDatabase + def test_6(self): + + db = pya.ReportDatabase("name") + db.reset_modified() + self.assertEqual(db.is_modified(), False) + self.assertEqual(db.name(), "name") + db.description = "desc" + db.generator = "gg" + db.top_cell_name = "top" + db.original_file = "of" + self.assertEqual(db.description, "desc") + self.assertEqual(db.generator, "gg") + self.assertEqual(db.top_cell_name, "top") + self.assertEqual(db.original_file, "of") + + self.assertEqual(db.is_modified(), True) + db.reset_modified() + self.assertEqual(db.is_modified(), False) + + tag_id = db.tag_id("x") + self.assertEqual(tag_id, 1) + db.set_tag_description(tag_id, "xdesc") + self.assertEqual(db.tag_description(tag_id), "xdesc") + + cell = db.create_cell("cell_name") + cc = [ c for c in db.each_cell() ] + self.assertEqual(len(cc), 1) + self.assertEqual(cc[0].rdb_id(), cell.rdb_id()) + + cat = db.create_category("cat") + cc = [ c for c in db.each_category() ] + self.assertEqual(len(cc), 1) + self.assertEqual(cc[0].rdb_id(), cat.rdb_id()) + + cats = db.create_category(cat, "subcat") + c = db.category_by_path("x") + self.assertEqual(c, None) + c = db.category_by_path("cat") + self.assertEqual(c.rdb_id(), cat.rdb_id()) + c = db.category_by_path("cat.subcat") + self.assertEqual(c.rdb_id(), cats.rdb_id()) + + self.assertEqual(db.category_by_id(cat.rdb_id()).rdb_id(), cat.rdb_id()) + self.assertEqual(db.category_by_id(cats.rdb_id()).rdb_id(), cats.rdb_id()) + + item = db.create_item(cell.rdb_id(), cat.rdb_id()) + v = pya.RdbItemValue("a") + v.tag_id = db.user_tag_id("x2") + item.add_value(v) + v = pya.RdbItemValue("b") + v.tag_id = db.tag_id("x1") + item.add_value(v) + item.add_tag(db.tag_id("x1")) + item.add_tag(db.user_tag_id("x2")) + istr="iVBORw0KGgoAAAANSUhEUgAAACoAAAA0CAIAAABzfT3nAAAAA3NCSVQICAjb4U/gAAAACXBIWXMAAA0SAAANOgHo3ZneAAAA3UlEQVRYhe2WwQ3DIAxFoco8XaGZIaeO43FyYgZYgYXcQ6SWuDGgBhWq/qccIvGCEd9SbAwAAPSGaW2lFR2rfWDpXrPpSe2SP10fvnn/PZHZH9IwbKFVZZ/Z6wMtZcjW02Bn2FVpZYdWdkr2nvh23S2FyDNJuVITpwmRjTGbNr0v20U5byNtJuuJt/fO2f93+UlbEJl5UjVPr3Y71EQ/PoPPlU+lDJtWlCt3GwCMG33BuJGAcWMEMG6c1jBudCyf/nzV8nbZPRohclFLHdGbZ8eNSjN1fmf0AACA1jwA4hKxu4C6P7EAAAAASUVORK5CYII=" + if "image_str" in item.__dict__: + item.image_str=istr + + ut_testtmp = os.getenv("TESTTMP", ".") + tmp = os.path.join(ut_testtmp, "tmp.lyrdb") + + self.assertEqual(db.filename(), "") + db.save(tmp) + self.assertEqual(db.filename(), tmp) + + # load and save + db = None + + db2 = pya.ReportDatabase("neu") + db2.load(tmp) + self.assertEqual(os.path.basename(db2.filename()), os.path.basename(tmp)) + self.assertEqual(db2.name(), os.path.basename(tmp)) + + self.assertEqual(db2.description, "desc") + self.assertEqual(db2.generator, "gg") + self.assertEqual(db2.top_cell_name, "top") + self.assertEqual(db2.original_file, "of") + + c = db2.category_by_path("cat.subcat") + self.assertEqual(c.path(), "cat.subcat") + + cc = [ c for c in db2.each_category() ] + self.assertEqual(len(cc), 1) + + ii = [ i for i in db2.each_item() ] + self.assertEqual(len(ii), 1) + self.assertEqual(ii[0].tags_str, "x1,#x2") + self.assertEqual(ii[0].has_tag(db2.user_tag_id("x2")), True) + self.assertEqual(ii[0].has_tag(db2.tag_id("x1")), True) + self.assertEqual(ii[0].has_tag(db2.tag_id("x")), False) + # Only the first 30 bytes count ... the remaining part is too different for different versions of Qt + if "image_str" in ii[0].__dict__: + self.assertEqual(ii[0].image_str[range(0, 30)], istr[range(0, 30)]) + self.assertEqual(db2.cell_by_id(ii[0].cell_id()).qname(), "cell_name") + self.assertEqual(db2.category_by_id(ii[0].category_id()).path(), "cat") + vs = "" + for v in ii[0].each_value(): + vs += v.string() + self.assertEqual(vs, "ab") + vs = "" + for v in ii[0].each_value(): + if v.tag_id == db2.tag_id("x1"): + vs += v.string() + self.assertEqual(vs, "b") + vs = "" + for v in ii[0].each_value(): + if v.tag_id == db2.user_tag_id("x1"): + vs += v.string() + self.assertEqual(vs, "") + vs = "" + for v in ii[0].each_value(): + if v.tag_id == db2.user_tag_id("x2"): + vs += v.string() + self.assertEqual(vs, "a") + + # LayoutView + def test_10(self): + + if not "Application" in pya.__dict__: + return + + mw = pya.Application.instance().main_window() + mw.create_layout(1) + view = mw.current_view() + + self.ot = 0 + def on_changed(): + self.ot += 1 + view.on_rdb_list_changed += on_changed + + rdb_index = view.create_rdb("NEW_RDB") + self.assertEqual(view.num_rdbs(), 1) + self.assertEqual(self.ot, 1) + self.assertEqual(view.rdb(rdb_index).name(), "NEW_RDB") + view.remove_rdb(rdb_index) + self.assertEqual(view.num_rdbs(), 0) + self.assertEqual(self.ot, 2) + + view.on_rdb_list_changed -= on_changed + + self.ot = 0 + rdb_index = view.create_rdb("NEW_RDB2") + self.assertEqual(view.rdb(rdb_index).name(), "NEW_RDB2") + self.assertEqual(self.ot, 0) + self.assertEqual(view.num_rdbs(), 1) + rdb_index = view.create_rdb("NEW_RDB3") + self.assertEqual(view.rdb(rdb_index).name(), "NEW_RDB3") + self.assertEqual(view.num_rdbs(), 2) + self.assertEqual(self.ot, 0) + + mw.close_current_view() + + # scan_... methods + def test_11(self): + + ly = pya.Layout() + c0 = ly.create_cell("c0") + c1 = ly.create_cell("c1") + c2 = ly.create_cell("c2") + c3 = ly.create_cell("c3") + c1.insert(pya.CellInstArray(c2.cell_index(), pya.Trans(10, 20))) + c2.insert(pya.CellInstArray(c3.cell_index(), pya.Trans(11, 21))) + l1 = ly.insert_layer(pya.LayerInfo(1, 0)) + prop_id = ly.properties_id([[ "a", 17 ]]) + c0.shapes(l1).insert(pya.Box(0, 1, 2, 3), prop_id) + prop_id = ly.properties_id([[ "a", 21 ]]) + c1.shapes(l1).insert(pya.Box(0, 1, 20, 30), prop_id) + c2.shapes(l1).insert(pya.Box(0, 1, 21, 31)) + c3.shapes(l1).insert(pya.Box(0, 1, 22, 32)) + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + cat.scan_layer(ly, l1) + self.assertEqual(rdb.tag_name(1), "a") # from property + self.assertEqual(cat.num_items(), 4) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c0[];c1[];c2[];c3[]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c0[polygon: (0,0.001;0,0.003;0.002,0.003;0.002,0.001)/float: 17];c1[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)/float: 21];c2[polygon: (0,0.001;0,0.031;0.021,0.031;0.021,0.001)];c3[polygon: (0,0.001;0,0.032;0.022,0.032;0.022,0.001)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + cat.scan_layer(ly, l1, None, -1, False) + self.assertEqual(cat.num_items(), 4) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c0[];c1[];c2[];c3[]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c0[polygon: (0,0.001;0,0.003;0.002,0.003;0.002,0.001)];c1[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)];c2[polygon: (0,0.001;0,0.031;0.021,0.031;0.021,0.001)];c3[polygon: (0,0.001;0,0.032;0.022,0.032;0.022,0.001)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + cat.scan_layer(ly, l1, c1) + self.assertEqual(cat.num_items(), 3) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[];c2[c1->r0 *1 0.01,0.02];c3[c1->r0 *1 0.021,0.041]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)/float: 21];c2[polygon: (0,0.001;0,0.031;0.021,0.031;0.021,0.001)];c3[polygon: (0,0.001;0,0.032;0.022,0.032;0.022,0.001)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + cat.scan_layer(ly, l1, c1, 0) + self.assertEqual(cat.num_items(), 1) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)/float: 21]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + cat.scan_layer(ly, l1, c1, -1) + self.assertEqual(cat.num_items(), 3) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[];c2[c1->r0 *1 0.01,0.02];c3[c1->r0 *1 0.021,0.041]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)/float: 21];c2[polygon: (0,0.001;0,0.031;0.021,0.031;0.021,0.001)];c3[polygon: (0,0.001;0,0.032;0.022,0.032;0.022,0.001)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + cat.scan_layer(ly, l1, c1, 1) + self.assertEqual(cat.num_items(), 2) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[];c2[c1->r0 *1 0.01,0.02]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)/float: 21];c2[polygon: (0,0.001;0,0.031;0.021,0.031;0.021,0.001)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + cat.scan_shapes(c1.begin_shapes_rec(l1)) # hierarchical scan + self.assertEqual(cat.num_items(), 3) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[];c2[c1->r0 *1 0.01,0.02];c3[c1->r0 *1 0.021,0.041]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)/float: 21];c2[polygon: (0,0.001;0,0.031;0.021,0.031;0.021,0.001)];c3[polygon: (0,0.001;0,0.032;0.022,0.032;0.022,0.001)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + cat.scan_shapes(c1.begin_shapes_rec(l1), False, False) # hierarchical scan + self.assertEqual(cat.num_items(), 3) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[];c2[c1->r0 *1 0.01,0.02];c3[c1->r0 *1 0.021,0.041]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)];c2[polygon: (0,0.001;0,0.031;0.021,0.031;0.021,0.001)];c3[polygon: (0,0.001;0,0.032;0.022,0.032;0.022,0.001)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + cat.scan_shapes(c1.begin_shapes_rec(l1), True) # flat scan + self.assertEqual(cat.num_items(), 3) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)/float: 21,polygon: (0.01,0.021;0.01,0.051;0.031,0.051;0.031,0.021),polygon: (0.021,0.042;0.021,0.073;0.043,0.073;0.043,0.042)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + r = pya.Region(c1.begin_shapes_rec(l1)) + cat.scan_collection(rdb.create_cell("TOP"), pya.CplxTrans(0.001), r) # hierarchical scan + self.assertEqual(cat.num_items(), 3) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "TOP[];c1[TOP->r0 *1 0,0];c2[c1->r0 *1 0.01,0.02];c3[c1->r0 *1 0.021,0.041]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "TOP[];c1[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)/float: 21];c2[polygon: (0,0.001;0,0.031;0.021,0.031;0.021,0.001)];c3[polygon: (0,0.001;0,0.032;0.022,0.032;0.022,0.001)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + r = pya.Region(c1.begin_shapes_rec(l1)) + cat.scan_collection(rdb.create_cell("TOP"), pya.CplxTrans(0.001), r, True) # flat scan + self.assertEqual(cat.num_items(), 3) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "TOP[]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "TOP[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001)/float: 21,polygon: (0.01,0.021;0.01,0.051;0.031,0.051;0.031,0.021),polygon: (0.021,0.042;0.021,0.073;0.043,0.073;0.043,0.042)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + r = pya.Region(c1.begin_shapes_rec(l1)) + cat.scan_collection(rdb.create_cell("TOP"), pya.CplxTrans(0.001), r, True, False) # flat scan + self.assertEqual(cat.num_items(), 3) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "TOP[]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "TOP[polygon: (0,0.001;0,0.03;0.02,0.03;0.02,0.001),polygon: (0.01,0.021;0.01,0.051;0.031,0.051;0.031,0.021),polygon: (0.021,0.042;0.021,0.073;0.043,0.073;0.043,0.042)]") + + rdb = pya.ReportDatabase("neu") + cat = rdb.create_category("l1") + r = pya.Region(c1.begin_shapes_rec(l1)).merged() + cat.scan_collection(rdb.create_cell("TOP"), pya.CplxTrans(0.001), r, True) # flat scan + self.assertEqual(cat.num_items(), 1) + cn = [ c.to_s_test() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "TOP[]") + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "TOP[polygon: (0,0.001;0,0.03;0.01,0.03;0.01,0.051;0.021,0.051;0.021,0.073;0.043,0.073;0.043,0.042;0.031,0.042;0.031,0.021;0.02,0.021;0.02,0.001)]") + + # shape insertion from shape, shapes, recursive iterator + def test_12(self): + + ly = pya.Layout() + c0 = ly.create_cell("c0") + c1 = ly.create_cell("c1") + c2 = ly.create_cell("c2") + c3 = ly.create_cell("c3") + c1.insert(pya.CellInstArray(c2.cell_index(), pya.Trans(10, 20))) + c2.insert(pya.CellInstArray(c3.cell_index(), pya.Trans(11, 21))) + l1 = ly.insert_layer(pya.LayerInfo(1, 0)) + c0.shapes(l1).insert(pya.Box(0, 1, 2, 3)) + c1.shapes(l1).insert(pya.Text("Hello, world!", pya.Trans())) + c2.shapes(l1).insert(pya.Edge(0, 1, 21, 31)) + c3.shapes(l1).insert(pya.Polygon(pya.Box(0, 1, 22, 32))) + + rdb = pya.ReportDatabase("neu") + cat1 = rdb.create_category("l1") + cell1 = rdb.create_cell("c1") + for s in c0.shapes(l1).each(): + rdb.create_item(cell1.rdb_id(), cat1.rdb_id(), pya.CplxTrans(ly.dbu), s) + self.assertEqual(cat1.num_items(), 1) + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[polygon: (0,0.001;0,0.003;0.002,0.003;0.002,0.001)]") + + rdb = pya.ReportDatabase("neu") + cat1 = rdb.create_category("l1") + cell1 = rdb.create_cell("c1") + rdb.create_items(cell1.rdb_id(), cat1.rdb_id(), pya.CplxTrans(ly.dbu), c0.shapes(l1)) + self.assertEqual(cat1.num_items(), 1) + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[polygon: (0,0.001;0,0.003;0.002,0.003;0.002,0.001)]") + + rdb = pya.ReportDatabase("neu") + cat1 = rdb.create_category("l1") + cell1 = rdb.create_cell("c1") + rdb.create_items(cell1.rdb_id(), cat1.rdb_id(), c1.begin_shapes_rec(l1)) + self.assertEqual(cat1.num_items(), 3) + cn = [ c.to_s_items() for c in rdb.each_cell() ] + self.assertEqual(";".join(cn), "c1[label: ('Hello, world!',r0 0,0),edge: (0.01,0.021;0.031,0.051),polygon: (0.021,0.042;0.021,0.073;0.043,0.073;0.043,0.042)]") + + def test_13(self): + + # manipulations + rdb = pya.ReportDatabase("") + + _cell = rdb.create_cell("CELL") + _cat = rdb.create_category("cat") + _subcat = rdb.create_category(_cat, "subcat") + _subcat.description = "subcat_d" + _item1 = rdb.create_item(_cell.rdb_id(), _subcat.rdb_id()) + _item1.add_value(17.5) + _item1.add_value("string") + _item2 = rdb.create_item(_cell.rdb_id(), _subcat.rdb_id()) + _item2.add_value("b") + _subsubcat = rdb.create_category(_subcat, "subsubcat") + _cat2 = rdb.create_category("cat2") + + cell = rdb.cell_by_id(_cell.rdb_id()) + self.assertEqual(cell._is_const_object(), False) + self.assertEqual([ c for c in rdb.each_cell() ][0]._is_const_object(), False) + + cell = rdb.cell_by_qname("CELL") + self.assertEqual(cell._is_const_object(), False) + + cat = rdb.category_by_id(_cat.rdb_id()) + self.assertEqual(cat._is_const_object(), False) + + cat = rdb.category_by_path("cat") + self.assertEqual(cat._is_const_object(), False) + subcat = rdb.category_by_path("cat.subcat") + + self.assertEqual([ c for c in rdb.each_category() ][0]._is_const_object(), False) + self.assertEqual(",".join([ c.name() for c in rdb.each_category() ]), "cat,cat2") + self.assertEqual(subcat._is_const_object(), False) + self.assertEqual(subcat.database()._is_const_object(), False) + self.assertEqual(subcat.name(), "subcat") + self.assertEqual(subcat.parent().name(), "cat") + + self.assertEqual(subcat.description, "subcat_d") + subcat.description = "changed" + self.assertEqual(subcat.description, "changed") + + self.assertEqual(";".join([ "/".join([ str(v) for v in item.each_value() ]) for item in rdb.each_item_per_category(subcat.rdb_id())]), "float: 17.5/text: string;text: b") + + item1 = [ i for i in rdb.each_item_per_category(subcat.rdb_id())][0] + self.assertEqual(item1._is_const_object(), False) + item1.clear_values() + self.assertEqual(";".join([ "/".join([ str(v) for v in item.each_value() ]) for item in rdb.each_item_per_category(subcat.rdb_id())]), ";text: b") + item1.add_value("x") + self.assertEqual(";".join([ "/".join([ str(v) for v in item.each_value() ]) for item in rdb.each_item_per_category(subcat.rdb_id())]), "text: x;text: b") + item1.add_tag(17) + self.assertEqual(item1.has_tag(17), True) + self.assertEqual(item1.has_tag(16), False) + + item1 = [ i for i in rdb.each_item() ][0] + self.assertEqual(item1._is_const_object(), False) + self.assertEqual(item1.has_tag(17), True) + + item1 = [ i for i in rdb.each_item_per_cell(cell.rdb_id()) ][0] + self.assertEqual(item1._is_const_object(), False) + self.assertEqual(item1.has_tag(17), True) + + item1 = [ i for i in rdb.each_item_per_cell_and_category(cell.rdb_id(), subcat.rdb_id())][0] + self.assertEqual(item1._is_const_object(), False) + self.assertEqual(item1.has_tag(17), True) + + item1 = [ i for i in cell.each_item()][0] + self.assertEqual(item1._is_const_object(), False) + self.assertEqual(item1.has_tag(17), True) + +# run unit tests +if __name__ == '__main__': + suite = unittest.TestLoader().loadTestsFromTestCase(RDB_TestClass) + + if not unittest.TextTestRunner(verbosity = 1).run(suite).wasSuccessful(): + sys.exit(1) +