def message(m)
  $stdout.puts(m)
  $stdout.flush
end

def run_testsuite(dm, ic, tiled = false)

  lb = 100
  
  a = input(RBA::LayerInfo::new(1, 0))
  b = input(2)
  c = input(3)
  x = input(10)
  y = input(11)
  empty = input(1000)

  h = {}
  layers.each { |l| h[l] = true }
  h[RBA::LayerInfo::new(1, 0)] || raise("missing layer 1/0 in layers list")
  
  c.is_merged? == false || raise("unexpected value")
  
  message "--- general #{lb}"
  
  l1 = a&b
  l1.output(lb, dm)
  l1.is_empty? && raise("must not be empty")
  
  a.and(b).xor(l1).is_empty? || raise("xor not empty")
  tiled || (a.and(b).is_merged? == true || raise("unexpected value"))
  
  a.xor(b).output(RBA::LayerInfo::new(lb + 1, dm))
  a.xor(b).xor(a ^ b).is_empty? || raise("xor not empty")
  a.not(b).output(lb + 2, dm)
  a.not(b).xor(a - b).is_empty? || raise("xor not empty")
  a.or(b).output(lb + 3, dm)
  a.or(b).xor(a | b).is_empty? || raise("xor not empty")
  
  a.join(b).output(lb + 4, dm)
  a.join(b).xor(a + b).is_empty? || raise("xor not empty")

  if !tiled
    a.join(b).data.size == 16 * ic || raise("unexpected shape count")
  end
  
  c.raw.is_clean? == false || raise("unexpected value")
  # c.raw switched the semantics
  c.is_clean? == false || raise("unexpected value")
  (c.area / ic).to_s == "10.0" || raise("unexpected value")
  (c.edges.length / ic).to_s == "18.0" || raise("unexpected value")
  (c.perimeter / ic).to_s == "18.0" || raise("unexpected value")
  c.clean
  c.is_clean? == true || raise("unexpected value")
  (c.area / ic).to_s == "9.0" || raise("unexpected value")
  (c.edges.length / ic).to_s == "14.0" || raise("unexpected value")
  (c.perimeter / ic).to_s == "14.0" || raise("unexpected value")
  (c.dup.area / ic).to_s == "9.0" || raise("unexpected value")
  (c.raw.clean.area / ic).to_s == "9.0" || raise("unexpected value")
  (c.area / ic).to_s == "9.0" || raise("unexpected value")
  (c.raw.area / ic).to_s == "10.0" || raise("unexpected value")
  c.clean

  if ic == 1    
    c.bbox.to_s == "(-4,-5;0,-2)" || raise("unexpected value")
  end
  
  lb += 10
  message "--- centers, start_segments, end_segments #{lb}"
  
  a.edges.centers(0.1).extended_out(0.01).output(lb, dm)
  a.edges.centers(0, 0.5).extended_out(0.01).output(lb + 1, dm)
  a.edges.centers(0.5, 0.5).extended_out(0.01).output(lb + 2, dm)
  a.edges.start_segments(0.1).extended_out(0.01).output(lb + 3, dm)
  a.edges.start_segments(0, 0.5).extended_out(0.01).output(lb + 4, dm)
  a.edges.start_segments(0.5, 0.5).extended_out(0.01).output(lb + 5, dm)
  a.edges.end_segments(0.1).extended_out(0.01).output(lb + 6, dm)
  a.edges.end_segments(0, 0.5).extended_out(0.01).output(lb + 7, dm)
  a.edges.end_segments(0.5, 0.5).extended_out(0.01).output(lb + 8, dm)
  
  a.polygons? == true || raise("unexpected value")
  a.edges? == false || raise("unexpected value")
  a.edge_pairs? == false || raise("unexpected value")
  a.edges.edge_pairs? == false || raise("unexpected value")
  a.edges.polygons? == false || raise("unexpected value")
  a.edges.edges? == true || raise("unexpected value")
  a.space(0.5).edge_pairs? == true || raise("unexpected value")
  a.space(0.5).polygons? == false || raise("unexpected value")
  a.space(0.5).edges? == false || raise("unexpected value")
  
  lb += 10
  message "--- extended #{lb}"
  
  a.edges.with_length(0.6).extended(begin: 0.1, end: 0.15, out: 0.1, in: -0.05).output(lb, dm)
  a.edges.with_length(0.6).extended(out: 0.1, in: -0.05).output(lb + 1, dm)
  a.edges.with_length(0..0.7).extended(out: 0.1, in: -0.05).output(lb + 2, dm)
  a.edges.with_length(0..0.7).extended(out: 0.1, in: -0.05, joined: true).output(lb + 3, dm)
  a.edges.with_length(0..0.7).extended(begin: 0.1, end: 0.15, out: 0.1, in: 0.05, joined: true).output(lb + 4, dm)
  a.edges.with_length(0..0.7).extended(0.1, 0.15, 0.1, 0.05).output(lb + 5, dm)
  a.edges.with_length(0..0.7).extended(0.1, 0.15, 0.1, 0.05, true).output(lb + 6, dm)
  a.edges.with_length(0..0.7).extended_out(0.1).output(lb + 7, dm)
  a.edges.with_length(0..0.7).extended_in(0.1).output(lb + 8, dm)
  
  lb += 10
  message "--- extents #{lb}"
  
  b.extents.output(lb, dm)
  
  lb += 10
  message "--- first_edges, second_edges, edges #{lb}"
  
  a.enclosing(b, 0.5, whole_edges).first_edges.extended_out(0.01).output(lb, dm)
  a.enclosing(b, 0.5, whole_edges).second_edges.extended_out(0.01).output(lb + 1, dm)
  a.enclosing(b, 0.5, whole_edges).edges.extended_out(0.01).output(lb + 2, dm)
  
  lb += 10
  message "--- hulls, holes #{lb}"
  
  c.xor(b).holes.output(lb, dm)
  c.xor(b).hulls.output(lb + 1, dm)
  c.xor(b).xor(c.xor(b).hulls - c.xor(b).holes).is_empty? || raise("xor not empty")
  
  lb += 10
  message "--- interacting, in, not_in #{lb}"
  
  b.interacting(a).output(lb, dm)
  b.not_interacting(a).output(lb, dm + 1)
  b.interacting(empty).output(lb, dm + 2)
  b.not_interacting(empty).output(lb, dm + 3)
  b.interacting(a).in(b).output(lb + 1, dm)
  (b|a).not_in(b).output(lb + 2, dm)
  x.in(b).output(lb + 3, dm)
  b.sized(0.1).in(b).is_empty? == true || raise("unexpected value")
  
  lb += 10
  message "--- inside, outside, overlapping, interacting #{lb}"
  
  b.inside(c).output(lb, dm)
  b.not_inside(c).output(lb, dm + 1)
  b.inside(empty).output(lb, dm + 2)
  b.not_inside(empty).output(lb, dm + 3)
  b.outside(c).output(lb + 1, dm)
  b.not_outside(c).output(lb + 1, dm + 1)
  b.outside(empty).output(lb + 1, dm + 2)
  b.not_outside(empty).output(lb + 1, dm + 3)
  b.overlapping(c).output(lb + 2, dm)
  b.not_overlapping(c).output(lb + 2, dm + 1)
  b.overlapping(empty).output(lb + 2, dm + 2)
  b.not_overlapping(empty).output(lb + 2, dm + 3)
  b.interacting(c).output(lb + 3, dm)
  b.not_interacting(c).output(lb + 3, dm + 1)
  b.interacting(empty).output(lb + 3, dm + 2)
  b.not_interacting(empty).output(lb + 3, dm + 3)
  bdup = b.dup
  bdup.select_inside(c)
  bdup.xor(b.inside(c)).output(lb + 4, dm)
  bdup = b.dup
  bdup.select_not_inside(c)
  bdup.output(lb + 4, dm + 1)
  bdup = b.dup
  bdup.select_inside(empty)
  bdup.output(lb + 4, dm + 2)
  bdup = b.dup
  bdup.select_not_inside(empty)
  bdup.output(lb + 4, dm + 3)
  bdup = b.dup
  bdup.select_outside(c)
  bdup.xor(b.outside(c)).output(lb + 5, dm)
  bdup = b.dup
  bdup.select_not_outside(c)
  bdup.output(lb + 5, dm + 1)
  bdup = b.dup
  bdup.select_outside(empty)
  bdup.output(lb + 5, dm + 2)
  bdup = b.dup
  bdup.select_not_outside(empty)
  bdup.output(lb + 5, dm + 3)
  bdup = b.dup
  bdup.select_overlapping(c)
  bdup.xor(b.overlapping(c)).output(lb + 6, dm)
  bdup = b.dup
  bdup.select_not_overlapping(c)
  bdup.output(lb + 6, dm + 1)
  bdup = b.dup
  bdup.select_overlapping(empty)
  bdup.output(lb + 6, dm + 2)
  bdup = b.dup
  bdup.select_not_overlapping(empty)
  bdup.output(lb + 6, dm + 3)
  bdup = b.dup
  bdup.select_interacting(c)
  bdup.xor(b.interacting(c)).output(lb + 7, dm)
  bdup = b.dup
  bdup.select_not_interacting(c)
  bdup.output(lb + 7, dm + 1)
  bdup = b.dup
  bdup.select_interacting(empty)
  bdup.output(lb + 7, dm + 2)
  bdup = b.dup
  bdup.select_not_interacting(empty)
  bdup.output(lb + 7, dm + 3)
  b.inside(empty).output(lb + 8, dm)
  b.not_inside(empty).output(lb + 8, dm + 1)
  b.outside(empty).output(lb + 9, dm)
  b.not_outside(empty).output(lb + 9, dm + 1)
  
  lb += 10
  message "--- merge #{lb}"
  
  c.raw
  if !tiled
    c.merged.is_merged? == true || raise("unexpected value")
  end
  c.merged.output(lb, dm)
  c.merged(2).output(lb + 1, dm)
  c.merged(3).output(lb + 2, dm)
  c.clean
  cdup = c.dup
  cdup.merge.xor(c.merged).output(lb + 3, dm)
  cdup.xor(c.merged).output(lb + 4, dm)
  cdup = c.dup
  cdup.merge(2).xor(c.merged(2)).output(lb + 5, dm)
  cdup.xor(c.merged(2)).output(lb + 6, dm)
  
  lb += 10
  message "--- move, transform, rotate, scale #{lb}"
  
  c.moved(0.2, -0.1).output(lb, dm)
  cdup = c.dup
  cdup.move(0.2, -0.1)
  cdup.xor(c.moved(0.2, -0.1)).is_empty? == true || raise("xor not empty")
  t = RBA::DCplxTrans::new(0.5)
  c.transformed(t).output(lb + 1, dm)
  cdup = c.dup
  cdup.transform(t)
  cdup.xor(c.transformed(t)).is_empty? == true || raise("xor not empty")
  c.scaled(0.5).output(lb + 2, dm)
  cdup = c.dup
  cdup.scale(0.5)
  cdup.xor(c.scaled(0.5)).is_empty? == true || raise("xor not empty")
  c.rotated(45).output(lb + 3, dm)
  cdup = c.dup
  cdup.rotate(45)
  cdup.xor(c.rotated(45)).is_empty? == true || raise("xor not empty")
  
  lb += 10
  message "--- rectangles, rectilinear #{lb}"
  
  a.rectangles.output(lb, dm)
  a.non_rectangles.output(lb + 1, dm)
  a.rectilinear.output(lb + 2, dm)
  a.non_rectilinear.output(lb + 3, dm)
  c.raw
  c.non_rectangles.output(lb + 4, dm)
  c.clean
  c.rectangles.output(lb + 5, dm)
  
  lb += 10
  message "--- enclosing #{lb}"
  
  a.enclosing(b, 0.5).polygons.output(lb, dm)
  a.enclosing(b, 0.5).polygons.xor(a.enc(b, 0.5).polygons).is_empty? == true || raise("xor not empty")
  a.enclosing(b, 0.5, euclidian).polygons.output(lb + 1, dm)
  a.enclosing(b, 0.5, square).polygons.output(lb + 2, dm)
  a.enclosing(b, 0.5, projection).polygons.output(lb + 3, dm)
  a.enclosing(b, 0.5, euclidian, whole_edges).polygons.output(lb + 4, dm)
  a.enclosing(b, 0.5, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  a.enclosing(b, 0.5, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  a.enclosing(b, 0.5, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- enclosing (edges) #{lb}"
  
  ae = a.edges
  be = b.edges
  ae.enclosing(be, 0.5).polygons.output(lb, dm)
  ae.enclosing(be, 0.5).polygons.xor(ae.enc(be, 0.5).polygons).is_empty? == true || raise("xor not empty")
  ae.enclosing(be, 0.5, euclidian).polygons.output(lb + 1, dm)
  ae.enclosing(be, 0.5, square).polygons.output(lb + 2, dm)
  ae.enclosing(be, 0.5, projection).polygons.output(lb + 3, dm)
  ae.enclosing(be, 0.5, euclidian, whole_edges).polygons.output(lb + 4, dm)
  ae.enclosing(be, 0.5, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  ae.enclosing(be, 0.5, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  ae.enclosing(be, 0.5, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- isolated #{lb}"
  
  b.isolated(0.4).polygons.output(lb, dm)
  b.isolated(0.4).polygons.xor(b.iso(0.4).polygons).is_empty? == true || raise("xor not empty")
  b.isolated(0.4, euclidian).polygons.output(lb + 1, dm)
  b.isolated(0.4, square).polygons.output(lb + 2, dm)
  b.isolated(0.4, projection).polygons.output(lb + 3, dm)
  b.isolated(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
  b.isolated(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  b.isolated(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  b.isolated(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- notch #{lb}"
  
  b.notch(0.4).polygons.output(lb, dm)
  b.notch(0.4, euclidian).polygons.output(lb + 1, dm)
  b.notch(0.4, square).polygons.output(lb + 2, dm)
  b.notch(0.4, projection).polygons.output(lb + 3, dm)
  b.notch(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
  b.notch(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  b.notch(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  b.notch(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- overlap #{lb}"
  
  a.overlap(b, 0.5).polygons.output(lb, dm)
  a.overlap(b, 0.5, euclidian).polygons.output(lb + 1, dm)
  a.overlap(b, 0.5, square).polygons.output(lb + 2, dm)
  a.overlap(b, 0.5, projection).polygons.output(lb + 3, dm)
  a.overlap(b, 0.5, euclidian, whole_edges).polygons.output(lb + 4, dm)
  a.overlap(b, 0.5, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  a.overlap(b, 0.5, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  a.overlap(b, 0.5, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- overlap (edges) #{lb}"
  
  ae = a.edges
  be = b.edges
  ae.overlap(be, 0.5).polygons.output(lb, dm)
  ae.overlap(be, 0.5, euclidian).polygons.output(lb + 1, dm)
  ae.overlap(be, 0.5, square).polygons.output(lb + 2, dm)
  ae.overlap(be, 0.5, projection).polygons.output(lb + 3, dm)
  ae.overlap(be, 0.5, euclidian, whole_edges).polygons.output(lb + 4, dm)
  ae.overlap(be, 0.5, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  ae.overlap(be, 0.5, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  ae.overlap(be, 0.5, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- separation #{lb}"
  
  a.separation(b, 0.4).polygons.output(lb, dm)
  a.separation(b, 0.4).polygons.xor(a.sep(b, 0.4).polygons).is_empty? == true || raise("xor not empty")
  a.separation(b, 0.4, euclidian).polygons.output(lb + 1, dm)
  a.separation(b, 0.4, square).polygons.output(lb + 2, dm)
  a.separation(b, 0.4, projection).polygons.output(lb + 3, dm)
  a.separation(b, 0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
  a.separation(b, 0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  a.separation(b, 0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  a.separation(b, 0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- sized #{lb}"
  
  x.sized(0.1).output(lb, dm)
  x.sized(0.1, 0).output(lb + 1, dm)
  x.sized(0.1, diamond_limit).output(lb + 2, dm)
  x.sized(0.1, octagon_limit).output(lb + 3, dm)
  x.sized(0.1, square_limit).output(lb + 4, dm)
  x.sized(0.1, acute_limit).output(lb + 5, dm)
  x.sized(0.1, no_limit).output(lb + 6, dm)
  xdup = x.dup
  xdup.size(0.1, 0)
  xdup.xor(x.sized(0.1, 0)).is_empty? == true || raise("xor not empty")
  a.sized(4.0, no_limit).output(lb + 7, dm)
  
  lb += 10
  message "--- space #{lb}"
  
  b.space(0.4).polygons.output(lb, dm)
  b.space(0.4, euclidian).polygons.output(lb + 1, dm)
  b.space(0.4, square).polygons.output(lb + 2, dm)
  b.space(0.4, projection).polygons.output(lb + 3, dm)
  b.space(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
  b.space(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  b.space(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  b.space(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- space (edges) #{lb}"
  
  be = b.edges
  be.space(0.4).polygons.output(lb, dm)
  be.space(0.4, euclidian).polygons.output(lb + 1, dm)
  be.space(0.4, square).polygons.output(lb + 2, dm)
  be.space(0.4, projection).polygons.output(lb + 3, dm)
  be.space(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
  be.space(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  be.space(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  be.space(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- width #{lb}"
  
  b.width(0.4).polygons.output(lb, dm)
  b.width(0.4, euclidian).polygons.output(lb + 1, dm)
  b.width(0.4, square).polygons.output(lb + 2, dm)
  b.width(0.4, projection).polygons.output(lb + 3, dm)
  b.width(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
  b.width(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  b.width(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  b.width(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- width (edges) #{lb}"
  
  be = b.edges
  be.width(0.4).polygons.output(lb, dm)
  be.width(0.4, euclidian).polygons.output(lb + 1, dm)
  be.width(0.4, square).polygons.output(lb + 2, dm)
  be.width(0.4, projection).polygons.output(lb + 3, dm)
  be.width(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
  be.width(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
  be.width(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
  be.width(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
  
  lb += 10
  message "--- with_angle #{lb}"
  
  a.edges.with_angle(90.degree).extended_out(0.01).output(lb, dm)
  a.edges.with_angle(45 .. 90.1).extended_out(0.01).output(lb + 1, dm)
  a.edges.with_angle(0, 45.1).extended_out(0.01).output(lb + 2, dm)
  a.edges.without_angle(90.degree).extended_out(0.01).output(lb + 3, dm)
  a.edges.without_angle(45 .. 90.1).extended_out(0.01).output(lb + 4, dm)
  a.edges.without_angle(0, 45.1).extended_out(0.01).output(lb + 5, dm)
  a.with_angle(135).polygons.output(lb + 6, dm)
  
  lb += 10
  message "--- with_area #{lb}"
  
  b.with_area(0.49.um2).output(lb, dm)
  b.with_area(0 .. 0.5).output(lb + 1, dm)
  b.with_area(0.5, nil).output(lb + 2, dm)
  b.without_area(0.49.um2).output(lb + 3, dm)
  b.without_area(nil, 0.5).output(lb + 4, dm)
  b.without_area(0.5, nil).output(lb + 5, dm)
  
  lb += 10
  message "--- with_perimeter #{lb}"
  
  b.with_perimeter(2.8.um).output(lb, dm)
  b.with_perimeter(0 .. 3.um).output(lb + 1, dm)
  b.with_perimeter(3.um, nil).output(lb + 2, dm)
  b.without_perimeter(2.8.um).output(lb + 3, dm)
  b.without_perimeter(nil, 3.um).output(lb + 4, dm)
  b.without_perimeter(3.um, nil).output(lb + 5, dm)
  
  lb += 10
  message "--- with_bbox_height #{lb}"
  
  b.with_bbox_height(0.7.um).output(lb, dm)
  b.with_bbox_height(0 .. 0.7.um+1.dbu).output(lb + 1, dm)
  b.with_bbox_height(0.7.um, nil).output(lb + 2, dm)
  b.without_bbox_height(0.7.um).output(lb + 3, dm)
  b.without_bbox_height(nil, 0.7.um+1.dbu).output(lb + 4, dm)
  b.without_bbox_height(0.7.um, nil).output(lb + 5, dm)
  
  lb += 10
  message "--- with_bbox_width #{lb}"
  
  b.with_bbox_width(0.7.um).output(lb, dm)
  b.with_bbox_width(0 .. 0.7.um+1.dbu).output(lb + 1, dm)
  b.with_bbox_width(0.7.um, nil).output(lb + 2, dm)
  b.without_bbox_width(0.7.um).output(lb + 3, dm)
  b.without_bbox_width(nil, 0.7.um+1.dbu).output(lb + 4, dm)
  b.without_bbox_width(0.7.um, nil).output(lb + 5, dm)
  
  lb += 10
  message "--- with_bbox_min #{lb}"
  
  b.with_bbox_min(0.7.um).output(lb, dm)
  b.with_bbox_min(0 .. 0.7.um+1.dbu).output(lb + 1, dm)
  b.with_bbox_min(0.7.um, nil).output(lb + 2, dm)
  b.without_bbox_min(0.7.um).output(lb + 3, dm)
  b.without_bbox_min(nil, 0.7.um+1.dbu).output(lb + 4, dm)
  b.without_bbox_min(0.7.um, nil).output(lb + 5, dm)
  
  lb += 10
  message "--- with_bbox_max #{lb}"
  
  b.with_bbox_max(0.7.um).output(lb, dm)
  b.with_bbox_max(0 .. 0.7.um+1.dbu).output(lb + 1, dm)
  b.with_bbox_max(0.7.um, nil).output(lb + 2, dm)
  b.without_bbox_max(0.7.um).output(lb + 3, dm)
  b.without_bbox_max(nil, 0.7.um+1.dbu).output(lb + 4, dm)
  b.without_bbox_max(0.7.um, nil).output(lb + 5, dm)
  
  lb += 10
  message "--- with_length #{lb}"
  
  a.edges.with_length(0.6.um).extended_out(0.01).output(lb, dm)
  a.edges.with_length(0 .. 0.6.um+1.dbu).extended_out(0.01).output(lb + 1, dm)
  a.edges.with_length(0.6, nil).extended_out(0.01).output(lb + 2, dm)
  a.edges.without_length(0.6.um).extended_out(0.01).output(lb + 3, dm)
  a.edges.without_length(0 .. 0.6.um+1.dbu).extended_out(0.01).output(lb + 4, dm)
  a.edges.without_length(0.6, nil).extended_out(0.01).output(lb + 5, dm)
  
  lb += 10
  message "--- ongrid, snap #{lb}"
  
  a.ongrid(0.2).polygons(1.dbu).output(lb, dm)
  a.ongrid(0, 0.1).polygons(1.dbu).output(lb + 1, dm)
  a.snapped(0.2).output(lb + 2, dm)
  a.snapped(0, 0.1).output(lb + 3, dm)
  adup = a.dup
  adup.snap(0.2)
  adup.xor(a.snapped(0.2)).output(lb + 4, dm)
  
  lb += 10
  message "--- odd polygon check #{lb}"
  
  y.odd_polygons.output(lb, dm)
  
end

if $drc_test_mode == 1

  source($drc_test_source, "TOP")
  target($drc_test_target, "TOP")
  run_testsuite(0, 1)

elsif $drc_test_mode == 2

  target($drc_test_target, "TOPTOP")
  source($drc_test_source, "TOPTOP")
  run_testsuite(0, 900)

elsif $drc_test_mode == 3

  target($drc_test_target, "TOPTOP")
  source($drc_test_source, "TOPTOP")

  tiles(4.1, 5.2)
  # must be that big ...
  tile_borders(1.um, 1.um)
  threads(4)

  run_testsuite(0, 900, true)

elsif $drc_test_mode == 4

  target($drc_test_target, "TOPTOP")
  source($drc_test_source, "TOPTOP")

  tiles(10000.0, 10000.0)
  tile_borders(0, 0)
  threads(4)

  run_testsuite(0, 900, true)

end