# KLayout Layout Viewer
# Copyright (C) 2006-2025 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)

  def test_14(self):

    # same names do not generate a new category
    rdb = pya.ReportDatabase("")

    _cell = rdb.create_cell("CELL")

    _cat = rdb.create_category("cat")
    _cat_same = rdb.create_category("cat")
    self.assertEqual(_cat.rdb_id(), _cat_same.rdb_id())

    _subcat = rdb.create_category(_cat, "subcat")
    _subcat_same = rdb.create_category(_cat_same, "subcat")
    self.assertEqual(_subcat.rdb_id(), _subcat_same.rdb_id())

    # testing whether decrementing the reference count would do harm
    _cat = None
    _cat_same = None
    self.assertEqual(_subcat.rdb_id(), _subcat_same.rdb_id())

# run unit tests
if __name__ == '__main__':
  suite = unittest.TestLoader().loadTestsFromTestCase(RDB_TestClass)

  if not unittest.TextTestRunner(verbosity = 1).run(suite).wasSuccessful():
    sys.exit(1)