jfreeze-ruby-gdsii 1.0.1

data/test/h_write.rb

@@ -0,0 +1,117 @@
+##############################################################################
+#
+# == write.rb
+#
+# Tests the capabilities of writing GDSII using the high-level group objects.
+# This test should cover most of the capabilities of the high-level GDSII
+# methods.
+#
+# === Author
+#
+# James D. Masters (james.d.masters@gmail.com)
+#
+##############################################################################
+
+require 'time'
+require 'gdsii'
+
+include Gdsii
+
+
+# Get arguments / show usage...
+unless (out_file = ARGV[0])
+  abort "
+Uses high-level GDSII methods to write out a number of GDSII records using
+many of the available method calls.  This can be useful to verify that the
+GDSII library is working and the output file can be compared against the
+file found in ./test/baseline/h_write.gds to ensure that the platform is
+reading and writing GDSII properly.
+
+Usage: h_write.rb <out-file>
+
+"
+end
+
+
+# Get a standard time (epoch; 12/31/1969) so we have the same time stamp for
+# comparing GDSII output
+time = Time.utc(2000, 1, 1, 0, 0, 0)
+
+# Create a new GDSII library
+lib = Library.new('MYLIB.DB')
+lib.modify_time = time
+lib.access_time = time
+
+# Create a top level structure
+top = Structure.new('top')
+top.create_time = time
+top.modify_time = time
+
+# Create a box 5u square on layer 1:0 with the center at the origin
+Boundary.new(1, 0, [-2500,-2500, -2500,2500, 2500,2500, 2500,-2500, -2500,-2500]) do |bnd|
+  bnd.add Property.new(1, 'testprop1')
+  bnd.add Property.new(1, 'testprop2')
+  bnd.add Property.new(2, 'testprop3')
+  top.add bnd
+end
+
+# Create text labels around the 5u box using different text label origins
+top.add Text.new(1, 0, [0,0],         'c',  0, :c )
+top.add Text.new(1, 0, [0,2500],      'n',  0, :n )
+top.add Text.new(1, 0, [2500,2500],   'ne', 0, :ne)
+top.add Text.new(1, 0, [2500,0],      'e',  0, :e )
+top.add Text.new(1, 0, [2500,-2500],  'se', 0, :se)
+top.add Text.new(1, 0, [0,-2500],     's',  0, :s )
+top.add Text.new(1, 0, [-2500,-2500], 'sw', 0, :sw)
+top.add Text.new(1, 0, [-2500,0],     'w',  0, :w )
+top.add Text.new(1, 0, [-2500,2500],  'nw', 0, :nw)
+
+# Test different fonts
+0.upto(3) do |font|
+  top.add Text.new(1, 0, [0, -500*font-3000], "font#{font}", font)
+end
+
+# Create a via/contact structure
+via = Structure.new('via')
+via.create_time = time
+via.modify_time = time
+
+lib.add via
+via.add Boundary.new(1, 0, [-500,-500, -500,500, 500,500, 500,-500, -500,-500])
+via.add Boundary.new(2, 0, [-800,-800, -800,800, 800,800, 800,-800, -800,-800])
+via.add Boundary.new(3, 0, [-600,-600, -600,600, 600,600, 600,-600, -600,-600])
+
+# Create a transistor structure - use our via cell for gate and source/drain
+# terminals
+lib.add trans = Structure.new('trans')
+trans.create_time = time
+trans.modify_time = time
+
+trans.add Boundary.new(1, 0, [-2500,-5000, -2500,5000, 2500,5000, 2500,-5000, -2500,-5000])
+trans.add Path.new(4, 0, 0, 800, [0,-7000, 0,7000])
+trans.add SRef.new('via', [-1700,0])
+trans.add SRef.new('via', [1700,0])
+trans.add SRef.new('via', [0,7000])
+
+# Drop transistor cell down every 1.5u using different rotations and flip/x
+x_offset = 0
+[false, true].each do |reflect_x|
+  0.step(270, 90) do |angle|
+    # Create an sref with the reflection and angle
+    SRef.new('trans', [x_offset, 12000]) do |sref|
+      sref.strans.reflect_x = reflect_x
+      sref.strans.angle = angle.to_f
+      top.add sref
+    end
+
+    # Add annotation text indicating reflection and angle
+    top.add Text.new(1, 0, [x_offset, 20000], "reflect_x=#{reflect_x}", 0, :c)
+    top.add Text.new(1, 0, [x_offset, 20500], "angle=#{angle.to_f.to_s}", 0, :c)
+             
+    x_offset += 15000
+  end
+end
+
+# Write the library to file
+lib.add top
+lib.write(out_file)

data/test/hs_pthru.rb

@@ -0,0 +1,31 @@
+require 'gdsii'
+include Gdsii
+
+in_file, out_file = ARGV
+unless in_file and out_file
+  abort "
+Uses the GDSII high-level *streamlined* methods to read in a GDSII file and
+write out the contents in one pass.  The resulting GDSII file should be
+identical - or at least just have just EOF null-padding differences.
+
+hs_pthru.rb <in-file> <out-file>
+
+"
+end
+
+File.open(in_file, 'rb') do |inf|
+  File.open(out_file, 'wb') do |outf|
+    puts "Reading from #{in_file}..."
+    puts "Writing to #{out_file}..."
+    Library.read_header(inf) do |lib|
+      lib.write_header(outf) do
+        Structure.read_each_header(inf) do |struct|
+          struct.write_header(outf) do
+            Element.read_each(inf) {|element| element.write(outf)}
+          end
+        end
+      end
+    end
+  end
+end
+

data/test/l_pthru.rb

@@ -0,0 +1,23 @@
+require 'gdsii/record'
+include Gdsii
+
+in_file, out_file = ARGV
+unless in_file and out_file
+  abort "
+Uses the GDSII low-level methods to read in a GDSII file and then write out
+the same GDSII file.  The file should be identical - or at least just have
+just EOF null-padding differences.
+
+l_pthru.rb <in-file> <out-file>
+
+"
+end
+
+File.open(in_file, 'rb') do |inf|
+  File.open(out_file, 'wb') do |outf|
+    while (rec = Record.read(inf))
+      rec.write(outf)
+    end
+  end
+end
+

data/test/test_gds_group.rb

@@ -0,0 +1,379 @@
+#!/usr/bin/env ruby
+require 'gdsii/boundary'
+require 'gdsii/path'
+require 'gdsii/strans'
+require 'gdsii/text'
+require 'gdsii/box'
+require 'gdsii/node'
+require 'gdsii/sref'
+require 'gdsii/aref'
+require 'gdsii/structure'
+require 'gdsii/library'
+require 'test/unit'
+
+
+class GdsGroupTest < Test::Unit::TestCase
+  
+  # This is just for Ruby In Steel bug
+  include Gdsii
+
+  # Test a property item
+  def test_property()
+    p = Property.new(1, 'test')
+    assert_equal 1, p.attr
+    assert_equal 'test', p.value
+  end
+
+  ############################################################################
+  
+  # Test BOUNDARY items
+  def test_boundary()
+    b = Boundary.new(0, 1, [2,3])
+    assert_equal(0, b.layer)
+    assert_equal(1, b.datatype)
+    assert_equal([2,3], b.xy)
+
+    b.xy=[4,5]
+    b.layer = 10
+    b.datatype = 11
+    assert_equal(10, b.layer)
+    assert_equal(11, b.datatype)
+    assert_equal([4,5], b.xy)
+
+    # test setting/removing of properties
+    b.properties.add Property.new(0, 'test1')
+    b.properties.add Property.new(0, 'test2')
+    b.properties.add Property.new(1, 'test3')
+    
+    assert_equal(3, b.properties.length)
+    assert_equal('test2', b.properties[1].value)
+
+    # test removing of properties
+    b.properties.remove {|p| p.attr == 0}
+    assert_equal(1, b.properties.length)
+    assert_equal('test3', b.properties[0].value)
+  end
+
+  ############################################################################
+
+  # Test Strans object
+  def test_strans(object=nil)
+    if object
+      #
+      # Test strans on an object
+      #
+      object.strans.abs_angle = true
+      object.strans.abs_mag = true
+      object.strans.reflect_x = true
+      object.strans.angle=50.0
+      object.strans.mag = 10.3 
+      assert object.strans.abs_angle?
+      assert object.strans.abs_mag?   
+      assert object.strans.reflect_x?  
+      assert_equal(50.0, object.strans.angle)   
+      assert_equal(10.3, object.strans.mag)
+    else
+      #
+      # stand alone test
+      #
+      
+      s = Strans.new(2.2, 90.0)
+      assert_equal 2.2, s.mag
+      assert_equal 90.0, s.angle
+      assert_equal false, s.reflect_x?
+      assert_equal false, s.abs_mag?
+      assert_equal false, s.abs_angle?
+
+      # Tweak x-reflection
+      s.reflect_x = true
+      assert s.reflect_x?
+      s.reflect_x = false
+      assert_equal false, s.reflect_x?
+      
+      # Tweak absolute magnification bit
+      s.abs_mag = true
+      assert s.abs_mag?
+      s.abs_mag = false
+      assert_equal false, s.abs_mag?
+
+      # Tweak absolute angle bit
+      s.abs_angle = true
+      assert s.abs_angle?
+      s.abs_angle = false
+      assert_equal false, s.abs_angle?
+    end
+  end
+    
+  ############################################################################
+
+  # Test PATH items
+  def test_path()
+    # Create a new path; check properties
+    a = Path.new(5, 3, 0, 10, [1,2])
+    assert_equal([1,2], a.xy)
+    assert_equal(5, a.layer)
+    assert_equal(3, a.datatype)
+    assert_equal(10, a.width)
+    assert_equal(0, a.pathtype)
+    assert_equal(nil, a.bgnextn)
+    assert_equal(nil, a.endextn)
+
+    # Change layer, datatype, width, and path type; add begin/end extensions
+    # Also change xy coordinates
+    a.layer = 1
+    a.datatype = 0
+    a.width = 100
+    a.xy = [9,10]
+    a.pathtype = 4
+    a.bgnextn = 50
+    a.endextn = 25
+    assert_equal(1, a.layer)
+    assert_equal(0, a.datatype)
+    assert_equal(100, a.width)
+    assert_equal([9,10], a.xy)
+    assert_equal(4, a.pathtype)   
+    assert_equal(50, a.bgnextn)
+    assert_equal(25, a.endextn)
+
+    # Try to set begin/end extensions for path type 0
+    a.pathtype = 0
+    assert_raise(TypeError) { a.bgnextn = 100 }
+    assert_raise(TypeError) { a.endextn = 100 }
+    assert_raise(TypeError) { a.pathtype = 3 }
+
+    # Create a path of type 4
+    b = Path.new4(2, 0, 100, 0, 50, [0,0, 2000,0, 2000,2000, 4000,2000])
+    assert_equal(4, b.pathtype)
+    assert_equal(0, b.bgnextn)
+    assert_equal(50, b.endextn)
+  end
+
+  ############################################################################
+
+  def test_text()
+    a = Text.new(1, 0, [0,0], 'test')
+    assert_equal(1, a.layer)
+    assert_equal(0, a.texttype)
+    assert_equal([0,0], a.xy)
+    assert_equal('test', a.string)
+
+    # Test font numbers
+    0.upto(3) do |i|
+      a.font = i
+      assert_equal i, a.font
+    end
+    assert_raise(ArgumentError) { a.font = 4 }
+
+    # Test compass points
+    [:c, :n, :ne, :e, :se, :s, :sw, :w, :nw].each do |point|
+      a.origin = point
+      assert_equal point, a.origin
+    end
+    assert_raise(RuntimeError) { a.origin = :foo }
+  end
+  
+  ############################################################################
+
+  # Test BOX items
+  def test_box()
+    a = Box.new(1, 0, [0,0, 0,10, 10,10, 10,0, 0,0])
+    assert_equal 1, a.layer
+    assert_equal 0, a.boxtype
+    assert_equal [0,0], a.xy[0,2]
+    
+    a.layer = 5
+    a.boxtype = 3
+    assert_equal(5, a.layer)
+    assert_equal(3, a.boxtype)
+  end
+  
+  ############################################################################
+
+  # Test NODE items
+  def test_node()
+    a = Node.new(1, 0, [0,0])
+    assert_equal 1, a.layer
+    assert_equal 0, a.nodetype
+    assert_equal [0,0], a.xy
+    
+    a.layer = 5
+    a.nodetype = 3
+    assert_equal(5, a.layer)
+    assert_equal(3, a.nodetype)  
+  end
+    
+  ############################################################################
+
+  # Test SRef items
+  def test_sref()
+    a = SRef.new('TestCell', [1,2])
+    assert_equal("TestCell", a.sname)
+    assert_equal([1,2], a.xy)
+
+    a.sname = 'Test2'
+    a.xy = [8,9]
+    assert_equal('Test2', a.sname)
+    assert_equal([8,9], a.xy)
+
+    # run tests on strans of this object
+    test_strans(a)
+  end
+
+  ############################################################################
+
+  # Test AREF items
+  def test_aref()
+    # basic testing
+    a = ARef.new('TestCell', [0,0], [2,8], [200, 300])
+    assert_equal([0,0], a.ref_xy)
+    assert_equal(2, a.columns)
+    assert_equal(8, a.rows)
+    assert_equal(200, a.column_space)
+    assert_equal(300, a.row_space)
+    assert_equal([0,0, 400,0, 0,2400], a.xy)
+
+    # property change testing
+    a.ref_xy = [100, 100]
+    a.columns = 4
+    a.rows = 2
+    a.column_space = 50
+    a.row_space = 25
+    assert_equal([100,100], a.ref_xy)
+    assert_equal(4, a.columns)
+    assert_equal(2, a.rows)
+    assert_equal(50, a.column_space)
+    assert_equal(25, a.row_space)
+    assert_equal([100,100, 300,100, 100,150], a.xy)
+
+    # Test omission of required XY properties
+    b = ARef.new('Test2')
+    assert_nil b.ref_xy
+    assert_nil b.column_space
+    assert_nil b.row_space
+    assert_nil b.columns
+    assert_nil b.rows
+    
+    assert_nil b.xy
+    b.ref_xy = [100, 100]
+    assert_nil b.xy
+    b.columns = 4
+    assert_nil b.xy
+    b.rows = 2
+    assert_nil b.xy
+    b.column_space = 50
+    assert_nil b.xy
+    b.row_space = 25
+    assert_equal([100,100, 300,100, 100,150], b.xy)
+ 
+    # run tests on strans of this object
+    test_strans(a)
+  end
+
+  ############################################################################
+
+  # Test Structure items
+  def test_structure()
+    a = Structure.new('MYNAME')
+    assert_equal("MYNAME", a.name)
+    assert (a.create_time and a.modify_time)
+    assert a.elements.empty?
+
+    # Change the name
+    a.name = 'NEWNAME'
+    assert_equal 'NEWNAME', a.name
+
+    # Set the time to an hour ahead
+    now = Time.new + 360
+    a.create_time = now
+    a.modify_time = now
+    assert_equal now, a.create_time
+    assert_equal now, a.modify_time
+
+    # Add some elements using the two different add methods
+    a.add Boundary.new(1, 0, [0,0, 0,10, 10,10, 10,0, 0,0])
+    a.elements.add Boundary.new(2, 0, [0,0, 0,10, 10,10, 10,0, 0,0])
+    assert_equal 2, a.elements.length
+    assert_equal 1, a.elements[0].layer
+    
+    # Manipulate the strclass bitarray
+    a.strclass = 0x0002
+    assert_equal(0x0002, a.strclass)
+
+    # Try adding garbage
+    assert_raise(TypeError) { a.add 1234 }
+  end
+  
+  ############################################################################
+
+  
+   # Test library items
+   def test_library()
+     lib = Library.new('MYLIB')
+     assert_equal 'MYLIB', lib.name
+     assert_equal lib.units, DEF_LIB_UNITS
+     assert_equal lib.header, DEF_LIB_VERSION
+     assert_equal lib.version, DEF_LIB_VERSION
+     assert (lib.access_time and lib.modify_time)
+     assert lib.structures.empty?
+
+     # test defaults
+     assert_nil lib.fonts
+     assert_nil lib.format
+     assert_nil lib.generations
+     assert_nil lib.secur
+     assert_equal [], lib.mask
+     assert_nil lib.srfname
+
+     # test units
+     user = lib.user_units
+     db = lib.database_units
+     assert_equal [user, db], lib.units
+     assert_equal 1e-6, lib.m_units
+
+     # tweak then verify all values
+     lib.name = 'LIB2'
+     lib.version = 7
+     lib.units = [0.001, 2e-9]
+     lib.fonts = ["one","two/three", "four","five"]
+     lib.generations = 3
+     lib.dirsize = 30
+     lib.secur = [1,2,7]
+     lib.mask = ['0 2-5 6 ; 0-64']
+     lib.srfname = "test"
+     assert_equal('LIB2', lib.name)
+     assert_equal(7, lib.version)
+     assert_equal(7, lib.header)
+     assert_equal([0.001, 2e-9], lib.units)
+     assert_equal(2e-6, lib.m_units)
+     assert_equal(["one","two/three", "four","five"], lib.fonts)    
+     assert_equal(3, lib.generations)
+     assert_equal(30, lib.dirsize)
+     assert_equal([1,2,7], lib.secur)
+     assert_equal(['0 2-5 6 ; 0-64'], lib.mask)
+     assert_equal("test", lib.srfname)
+
+     # mess with the format record
+     lib.format = 0
+     assert_equal(0, lib.format)
+     assert(lib.archive_format?)
+     lib.format = 1
+     assert_equal(1, lib.format)
+     assert(lib.filtered_format?)
+
+     # mess with the time
+     now = Time.new + 360
+     lib.access_time = now
+     lib.modify_time = now
+     assert_equal now, lib.access_time
+     assert_equal now, lib.modify_time
+
+     # test adding structures
+     lib.structures << Structure.new("first")
+     lib.structures.add(Structure.new("second"))
+     lib.add(Structure.new("third"))
+     assert_equal("first", lib.structures[0].name)
+     assert_equal("second", lib.structures[1].name)
+     assert_equal("third", lib.structures[2].name)
+  end
+  
+end