voruby 1.1.1 → 2.0.0

data/test/voruby/misc/test.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+
+require 'voruby/misc'
+include VORuby::Misc
+
+class ConnectionManagerTest < Test::Unit::TestCase
+  def setup
+    @num_iter = 0
+    
+    @monitor = ConnectionMonitor.new('http://www.noao.edu/', 2)
+    @monitor.on_success = Proc.new { |pinger, monitor|
+      monitor.stop if @num_iter == 2
+      @num_iter += 1
+    }
+    @monitor.on_failure = Proc.new{ |pinger, monitor|
+      monitor.stop
+      raise "Connection to #{monitor.url} failed: #{pinger.exception}"
+    }
+  end
+  
+  def test_success
+    assert_nothing_raised { @monitor.start }
+    assert_equal 3, @num_iter
+  end
+  
+  def test_failure
+    @monitor.url = 'http://www.noao.edu/blah/'
+    assert_raise RuntimeError do
+      @monitor.start
+    end
+  end
+end

data/test/voruby/resolver/sesame/test.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+
+require 'voruby/resolver/sesame'
+include VORuby::Resolver
+
+class SesameTest < Test::Unit::TestCase
+  def test_resolve
+    sesame = Sesame.resolve('m51', :all)
+    
+    assert_equal 'http://cdsws.u-strasbg.fr/axis/services/Sesame', sesame.end_point
+    assert_equal false, sesame.check_availability
+    assert_equal 'm51', sesame.target
+    assert_equal 3, sesame.resolvers.size
+    
+    resolver = sesame.resolvers.find { |r| r.name == 'Simbad' }
+    assert_equal 'Simbad', resolver.name
+    
+    assert_equal 'Seyfert_2', resolver.otype
+    assert_equal '13:29:52.36 +47:11:40.8', resolver.jpos
+    assert_equal 202.4682083, resolver.jradeg
+    assert_equal 47.1946667, resolver.jdedeg
+    assert_equal '1999ApJS..125..409C', resolver.ref_pos
+    assert_equal 10800, resolver.err_ra_mas
+    assert_equal 10800, resolver.err_de_mas
+    assert_equal nil, resolver.z
+    assert_equal nil, resolver.errz
+    assert_equal nil, resolver.refz
+    assert_equal 600, resolver.vel
+    assert_equal nil, resolver.err_vel
+    assert_equal '2004A&A...422...39S', resolver.ref_vel
+    assert_equal 'Sc', resolver.mtype
+    assert_equal nil, resolver.sptype
+    assert_equal 'M 51', resolver.oname
+    
+    assert_equal [202.4682083, 47.1946667], resolver.position
+    assert_equal ['13:29:52.36', '+47:11:40.8'], resolver.position(:sexigesimal)
+    
+    assert_equal [
+      "M 51", "NGC 5194", "4C 47.36A", "APG 85A", "APG 85", "BD+47 2063",
+      "[DML87] 671", "GB1 1327+475", "[H92] 27", "IRAS F13277+4727",
+      "IRAS 13277+4727", "ISOSS J13299+4714", "KHG 1-C 5", "KPG 379a",
+      "LEDA 47404", "[LPS2002] 16", "[M98c] 132746.9+472716", "MCG+08-25-012",
+      "NAME WHIRLPOOL", "NAME QUESTION MARK GALAXY", "NAME WHIRLPOOL GALAXY",
+      "PLX 3084", "RX J1329.8+4711", "1RXS J132953.8+471143", "[SLK2004] 853",
+      "[T76] 85A", "TC 827", "UGC 8493", "[VDD93] 187A", "VV 403", "VV 1a",
+      "VV 1", "[VV2000c] J132952.4+471141", "[VV2003c] J132952.4+471141",
+      "[VV2006c] J132952.4+471141", "[VV98c] J132952.7+471143",
+      "XMMU J132952.9+471140", "Z 1327.8+4727", "Z 246 - 8"
+    ], resolver.aliases
+  end
+  
+  def test_resolve_position
+    assert_equal [202.4682083, 47.1946667],
+      Sesame.resolve_position('m51')
+  end
+end

data/test/voruby/sky_query/test.rb

@@ -0,0 +1,107 @@
+require 'test/unit'
+
+require 'voruby/sky_query/sky_query'
+include VORuby::SkyQuery
+
+class SkyQueryTest < ::Test::Unit::TestCase
+  def setup
+    @portal = Service.new
+    @adql = 'SELECT o.objId, o.ra, o.dec, o.r, o.type, t.objId, t.ra, t.dec ' +
+      'FROM SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t ' +
+      'WHERE XMATCH(o, t) < 3.5 AND Region(\'CIRCLE J2000 181.3 -0.76 6.5\') AND o.type = 3'
+  end
+  
+  def test_sky_nodes
+    vot = nil
+    
+    assert_nothing_raised {
+      vot = @portal.sky_nodes
+    }
+    
+    assert_kind_of VORuby::VOTable::V1_1::VOTable, vot
+    
+    assert vot.resources.first.tables.first.fields.size > 0
+    assert vot.resources.first.tables.first.data.format.trs.size > 0
+  end
+  
+  def test_query
+    vot = nil
+    
+    assert_nothing_raised {
+      vot = @portal.query(@adql)
+    }
+    
+    assert_kind_of VORuby::VOTable::V1_1::VOTable, vot
+    
+    assert_equal 9, vot.resources.first.tables.first.fields.size
+    assert vot.resources.first.tables.first.data.format.trs.size > 0
+    
+    assert_nothing_raised {
+      vot = Service.query(@adql)
+    }
+    
+    assert_kind_of VORuby::VOTable::V1_1::VOTable, vot
+    
+    assert_equal 9, vot.resources.first.tables.first.fields.size
+    assert vot.resources.first.tables.first.data.format.trs.size > 0
+  end
+  
+  def test_get_tables
+    tables = nil
+    
+    assert_nothing_raised {
+      tables = @portal.tables('SDSS')
+    }
+  
+    assert tables.size > 0
+  end
+  
+  def test_get_table_info
+    tbl_info = nil
+    
+    assert_nothing_raised {
+      tbl_info = @portal.table_info('SDSS', 'PhotoPrimary')
+    }
+    
+    assert_equal 'These objects are the primary survey objects.', tbl_info.description
+    assert_equal 'PhotoPrimary', tbl_info.name
+    assert_equal -1, tbl_info.rows
+  end
+  
+  def test_get_columns
+    columns = nil
+    
+    assert_nothing_raised {
+      columns = @portal.columns('SDSS', 'PhotoPrimary')
+    }
+    
+    assert columns.size > 0
+  end
+  
+  def test_get_column_info
+    col_info = nil
+    
+    assert_nothing_raised {
+      col_info = @portal.column_info('SDSS', 'PhotoPrimary', 'modelMag_i')
+    }
+    
+    assert_equal 'modelMag_i', col_info.name
+    assert_equal 'mag', col_info.unit
+    assert_equal 'better of DeV/Exp magnitude fit', col_info.description
+    assert_equal 'PHOT_SDSS_I FIT_PARAM', col_info.ucd
+    
+    assert_raises SOAP::FaultError do
+      @portal.column_info('SDSS', 'PhotoPrimary', 'blah')
+    end
+  end
+  
+  def test_get_meta_columns
+    columns = nil
+    
+    assert_nothing_raised {
+      columns = @portal.meta_columns('SDSS', 'PhotoPrimary')
+    }
+    
+    assert columns.size > 0
+  end
+end

data/test/voruby/stc/1.10/coords_test.rb

@@ -0,0 +1,3704 @@
+require 'voruby/stc/1.10/coords'
+require 'test/unit'
+
+include VORuby::STC::V1_10::Coords
+
+module VORuby
+  module STC
+    module V1_10
+      module Coords
+        module Test
+        
+          class TimeUnitTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                TimeUnit.new('h')
+              end
+            end
+          
+            def test_accessors
+              unit = TimeUnit.new('d')
+              assert_equal 'd', unit.value
+            
+              unit.value = 'cy'
+              assert_equal 'cy', unit.value
+            end
+          
+            def test_enumeration
+              assert_raise ArgumentError do
+                TimeUnit.new('z')
+              end
+            
+              unit = TimeUnit.new()
+              assert_raise ArgumentError do
+                unit.value = 'blah'
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Unit, TimeUnit.new()
+            end
+          end
+        
+          class PosUnitTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                PosUnit.new('rad')
+              end
+            end
+          
+            def test_accessors
+              unit = PosUnit.new('km')
+              assert_equal 'km', unit.value
+            
+              unit.value = 'Mpc'
+              assert_equal 'Mpc', unit.value
+            end
+          
+            def test_enumeration
+              assert_raise ArgumentError do
+                PosUnit.new('in')
+              end
+            
+              unit = PosUnit.new()
+              assert_raise ArgumentError do
+                unit.value = 'blah'
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Unit, PosUnit.new()
+            end
+          end
+        
+          class VelTimeUnitTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                VelTimeUnit.new('d')
+              end
+            end
+          
+            def test_accessors
+              unit = VelTimeUnit.new('s')
+              assert_equal 's', unit.value
+            
+              unit.value = 'a'
+              assert_equal 'a', unit.value
+            end
+          
+            def test_enumeration
+              assert_raise ArgumentError do
+                VelTimeUnit.new('')
+              end
+            
+              unit = VelTimeUnit.new('a')
+              assert_raise ArgumentError do
+                unit.value = 'blah'
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Unit, VelTimeUnit.new('a')
+            end
+          end
+        
+          class SpectralUnitTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                SpectralUnit.new('A')
+              end
+            end
+          
+            def test_accessors
+              unit = SpectralUnit.new('m')
+              assert_equal 'm', unit.value
+            
+              unit.value = 'Hz'
+              assert_equal 'Hz', unit.value
+            end
+          
+            def test_enumeration
+              assert_raise ArgumentError do
+                SpectralUnit.new('')
+              end
+            
+              unit = SpectralUnit.new('micron')
+              assert_raise ArgumentError do
+                unit.value = 'blah'
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Unit, SpectralUnit.new('m')
+            end
+          end
+        
+          class TimeScaleTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                TimeScale.new('TAI')
+              end
+            end
+          
+            def test_accessors
+              ts = TimeScale.new('UTC')
+              assert_equal 'UTC', ts.value
+            
+              ts.value = 'ET'
+              assert_equal 'ET', ts.value
+            end
+          
+            def test_enumeration
+              assert_raise ArgumentError do
+                TimeScale.new('')
+              end
+            
+              ts = TimeScale.new('LST')
+              assert_raise ArgumentError do
+                ts.value = 'blah'
+              end
+            end
+          end
+        
+          class ISOTimeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                ISOTime.new(DateTime.now)
+                ISOTime.new(DateTime.now.to_s)
+              end
+            
+              assert_raise ArgumentError do
+                ISOTime.new('blah')
+              end
+            end
+          
+            def test_accessors
+              time = ISOTime.new('2007-02-26T09:20:23')
+              assert_equal DateTime.parse('2007-02-26T09:20:23'), time.value
+            
+              assert_raise ArgumentError do
+                time.value = 'blah'
+              end
+            end
+          
+            def test_to_s
+              time = ISOTime.new('2007-02-26T09:20:23')
+              assert_equal '2007-02-26T09:20:23.000', time.to_s
+            end
+          
+            def test_relationships
+              assert_kind_of AbsoluteTime, ISOTime.new('2007-02-26T09:20:23')
+            end
+          
+            def test_xml
+              date = '2007-02-26T09:20:23'
+            
+              t1 = ISOTime.new(date)
+              assert_equal "<crd:ISOTime xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{date}.000</crd:ISOTime>", t1.to_xml.to_s
+            
+              t2 = ISOTime.from_xml("<crd:ISOTime xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{date}.000</crd:ISOTime>")
+              assert_equal t1, t2
+            end
+          end
+        
+          class ISOTimeRefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                ISOTimeRef.new('ref1')
+              end
+            
+              assert_raise ArgumentError do
+                ISOTimeRef.new(' ')
+              end
+            end
+          
+            def test_accessors
+              time = ISOTimeRef.new('ref2')
+              assert_equal 'ref2', time.value
+            end
+          
+            def test_relationships
+              assert_kind_of AbsoluteTime, ISOTimeRef.new('ref3')
+            end
+          
+            def test_xml
+              id = 'ref1'
+            
+              ref1 = ISOTimeRef.new(id)
+              assert_equal "<crd:ISOTimeRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{id}</crd:ISOTimeRef>", ref1.to_xml.to_s
+            
+              ref2 = ISOTimeRef.from_xml("<crd:ISOTimeRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{id}</crd:ISOTimeRef>")
+              assert_equal ref1, ref2
+            end
+          end
+        
+          class JDTimeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                JDTime.new('1234.5')
+                JDTime.new(1234.5)
+              end
+            
+              assert_raise ArgumentError do
+                JDTime.new('blah')
+              end
+            end
+          
+            def test_accessors
+              time = JDTime.new('1234.5')
+              assert_equal 1234.5, time.value
+            
+              time = JDTime.new(1234.5)
+              assert_equal 1234.5, time.value
+            end
+          
+            def test_relationships
+              assert_kind_of AbsoluteTime, JDTime.new(1234.5)
+            end
+          
+            def test_xml
+              date = 2454466.5
+            
+              t1 = JDTime.new(date)
+              assert_equal "<crd:JDTime xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{date}</crd:JDTime>", t1.to_xml.to_s
+            
+              t2 = JDTime.from_xml("<crd:JDTime xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{date}</crd:JDTime>")
+              assert_equal t1, t2
+            end
+          end
+        
+          class JDTimeRefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                JDTimeRef.new('ref1')
+              end
+            
+              assert_raise ArgumentError do
+                JDTimeRef.new(' ')
+              end
+            end
+          
+            def test_accessors
+              time = JDTimeRef.new('ref2')
+              assert_equal 'ref2', time.value
+            end
+          
+            def test_relationships
+              assert_kind_of AbsoluteTime, JDTimeRef.new('ref3')
+            end
+          
+            def test_xml
+              id = 'ref1'
+            
+              ref1 = JDTimeRef.new(id)
+              assert_equal "<crd:JDTimeRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{id}</crd:JDTimeRef>", ref1.to_xml.to_s
+            
+              ref2 = JDTimeRef.from_xml("<crd:JDTimeRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{id}</crd:JDTimeRef>")
+              assert_equal ref1, ref2
+            end
+          end
+        
+          class MJDTimeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                MJDTime.new('1234.5')
+                MJDTime.new(1234.5)
+              end
+            
+              assert_raise ArgumentError do
+                MJDTime.new('blah')
+              end
+            end
+          
+            def test_accessors
+              time = MJDTime.new('1234.5')
+              assert_equal 1234.5, time.value
+            
+              time = MJDTime.new(1234.5)
+              assert_equal 1234.5, time.value
+            end
+          
+            def test_relationships
+              assert_kind_of AbsoluteTime, MJDTime.new(1234.5)
+            end
+          
+            def test_xml
+              date = 2454466.5
+            
+              t1 = MJDTime.new(date)
+              assert_equal "<crd:MJDTime xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{date}</crd:MJDTime>", t1.to_xml.to_s
+            
+              t2 = MJDTime.from_xml("<crd:MJDTime xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{date}</crd:MJDTime>")
+              assert_equal t1, t2
+            end
+          end
+        
+          class MJDTimeRefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                MJDTimeRef.new('ref1')
+              end
+            
+              assert_raise ArgumentError do
+                MJDTimeRef.new(' ')
+              end
+            end
+          
+            def test_accessors
+              time = MJDTimeRef.new('ref2')
+              assert_equal 'ref2', time.value
+            end
+          
+            def test_relationships
+              assert_kind_of AbsoluteTime, MJDTimeRef.new('ref3')
+            end
+          
+            def test_xml
+              id = 'ref1'
+            
+              ref1 = MJDTimeRef.new(id)
+              assert_equal "<crd:MJDTimeRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{id}</crd:MJDTimeRef>", ref1.to_xml.to_s
+            
+              ref2 = MJDTimeRef.from_xml("<crd:MJDTimeRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>#{id}</crd:MJDTimeRef>")
+              assert_equal ref1, ref2
+            end
+          end
+        
+          class TimeOriginTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                TimeOrigin.new
+              end
+            
+              assert_raise ArgumentError do
+                TimeOrigin.new('blah')
+              end
+            end
+          
+            def test_accessors
+              to = TimeOrigin.new
+              assert_equal 'RELOCATABLE', to.value
+            
+              to = TimeOrigin.new('RELOCATABLE')
+              assert_equal 'RELOCATABLE', to.value
+            end
+          
+            def test_relationships
+              assert_kind_of AbsoluteTime, TimeOrigin.new
+            end
+          
+            def test_xml
+              ref1 = TimeOrigin.new('RELOCATABLE')
+              assert_equal "<crd:TimeOrigin xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>RELOCATABLE</crd:TimeOrigin>", ref1.to_xml.to_s
+            
+              ref2 = TimeOrigin.from_xml("<crd:TimeOrigin xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>RELOCATABLE</crd:TimeOrigin>")
+              assert_equal ref1, ref2
+            end
+          end
+        
+          class TimeOffsetTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                TimeOffset.new('1234.5')
+                TimeOffset.new(1234.5)
+                TimeOffset.new(1234.5, 'h')
+                TimeOffset.new(1234.5, TimeUnit.new('h')) 
+              end
+            
+              assert_raise ArgumentError do
+                TimeOffset.new('blah')
+              end
+              assert_raise ArgumentError do
+                TimeOffset.new(1234.6, 'blah')
+              end
+            end
+          
+            def test_accessors
+              to = TimeOffset.new(1234.5, 'h')
+              assert_equal 1234.5, to.offset
+              assert_equal TimeUnit.new('h'), to.unit
+            
+              to.offset = 3456
+              assert_equal 3456, to.offset
+            
+              to.unit = 'yr'
+              assert_equal TimeUnit.new('yr'), to.unit
+            end
+          
+            def test_relationships
+              assert_kind_of RelativeTime, TimeOffset.new(1234.5)
+            end
+          
+            def test_to_s
+              to = TimeOffset.new(1234.5, 'yr')
+              assert_equal '1234.5 yr', to.to_s
+            end
+          
+            def test_xml
+              o1 = TimeOffset.new(1234.5, TimeUnit.new('h'))
+              assert_equal "<crd:TimeOffset crd:unit='h' xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1234.5</crd:TimeOffset>", o1.to_xml.to_s
+            
+              o2 = TimeOffset.from_xml("<crd:TimeOffset crd:unit='h' xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1234.5</crd:TimeOffset>")
+              assert_equal o1, o2
+            end
+          end
+        
+          class TimeOffsetRefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                TimeOffsetRef.new('ref1')
+                TimeOffsetRef.new('ref1', 'h')
+                TimeOffsetRef.new('ref1', TimeUnit.new('h'))
+              end
+            
+              assert_raise ArgumentError do
+                TimeOffsetRef.new(' ')
+              end
+              assert_raise ArgumentError do
+                TimeOffsetRef.new('ref1', 'blah')
+              end
+            end
+          
+            def test_accessors
+              to = TimeOffsetRef.new('ref2', 'yr')
+              assert_equal 'ref2', to.value
+              assert_equal TimeUnit.new('yr'), to.unit
+            
+              to.value = 'ref3'
+              assert_equal 'ref3', to.value
+            
+              to.unit = 's'
+              assert_equal TimeUnit.new('s'), to.unit
+            end
+          
+            def test_relationships
+              assert_kind_of RelativeTime, TimeOffsetRef.new('ref3')
+            end
+          
+            def test_to_s
+              to = TimeOffsetRef.new('ref2', 'yr')
+              assert_equal 'ref2 yr', to.to_s
+            end
+          
+            def test_xml
+              r1 = TimeOffsetRef.new('ref1', 'h')
+              assert_equal "<crd:TimeOffsetRef crd:unit='h' xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:TimeOffsetRef>", r1.to_xml.to_s
+            
+              r2 = TimeOffsetRef.from_xml("<crd:TimeOffsetRef crd:unit='h' xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:TimeOffsetRef>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class AstronTimeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                AstronTime.new('UTC', ISOTime.new(DateTime.now))
+                AstronTime.new(TimeScale.new('UTC'), ISOTime.new(DateTime.now))
+                AstronTime.new(TimeScale.new('UTC'), ISOTime.new(DateTime.now), TimeOffset.new(123, 's'))
+              end
+            
+              assert_raise TypeError do
+                AstronTime.new('UTC', nil)
+              end
+              assert_raise TypeError do
+                AstronTime.new('UTC', TimeOffset.new(1234, 's'))
+              end
+              assert_raise TypeError do
+                AstronTime.new('UTC', ISOTime.new(DateTime.now), ISOTime.new(DateTime.now))
+              end
+            end
+          
+            def test_accessors
+              now = DateTime.now
+              time = AstronTime.new(TimeScale.new('UTC'), ISOTime.new(now), TimeOffset.new(123, 's'))
+              assert_equal TimeScale.new('UTC'), time.timescale
+              assert_equal ISOTime.new(now), time.absolute_time
+              assert_equal TimeOffset.new(123, 's'), time.relative_time
+            
+              time.timescale = 'ET'
+              assert_equal TimeScale.new('ET'), time.timescale
+            
+              time.absolute_time = JDTime.new(1234.5)
+              assert_equal JDTime.new(1234.5), time.absolute_time
+            
+              time.relative_time = TimeOffset.new(1234.5, 'h')
+              assert_equal TimeOffset.new(1234.5, 'h'), time.relative_time
+            end
+          
+            def test_xml
+              t1 = AstronTime.new(TimeScale.new('UTC'), ISOTime.new(DateTime.parse('2007-01-01')), TimeOffset.new(123, 's'))
+            
+              t2 = AstronTime.from_xml(t1.to_xml)
+              assert_equal t1, t2
+            end
+          end
+        
+          class DoubleArrayTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                DoubleArray.new([1.0, 2.0, 3.0])
+              end
+            
+              assert_raise TypeError do
+                DoubleArray.new([1.0, 'blah', 2.0])
+              end
+            end
+          
+            def test_assignment
+              da = DoubleArray.new([1.0, 2.0, 3.0])
+            
+              assert_raises TypeError do
+                da[1] = 'blah'
+              end
+              assert_raises TypeError do
+                da << 'blah'
+              end
+              assert_raises TypeError do
+                da.replace([4.5, 2.3, 'blah'])
+              end
+              assert_raises TypeError do
+                da.insert(2, 3.4, 'blah')
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Array, DoubleArray.new([1.0, 2.0, 3.0])
+            end
+          end
+        
+          class Double2Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Double2.new([3.2, 1.1])
+              end
+            
+              assert_raises RuntimeError do
+                Double2.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Double2.new([3.2, 2.5, 5.1])
+              end
+              assert_raises TypeError do
+                Double2.new([3.2, 'blah'])
+              end
+            end
+          
+            def test_assignment
+              d2 = Double2.new([1.1, 2.2])
+            
+              assert_raises TypeError do
+                d2[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                d2 << 1.5
+              end
+              assert_raises RuntimeError do
+                d2.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of DoubleArray, Double2.new([1.1, 2.2])
+            end
+          end
+        
+          class ValueTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Value.new(1.2)
+              end
+            
+              assert_raises ArgumentError do
+                Value.new('blah')
+              end
+            end
+          
+            def test_accessors
+              value = Value.new(1.2)
+              assert_equal 1.2, value.value
+            
+              value.value = 3.4
+              assert_equal 3.4, value.value
+            end
+          
+            def test_relationships
+              assert_kind_of CValue, Value.new(1.2)
+            end
+          
+            def test_xml
+              v1 = Value.new(1.2)
+              assert_equal "<crd:Value xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.2</crd:Value>", v1.to_xml.to_s
+            
+              v2 = Value.from_xml("<crd:Value xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.2</crd:Value>")
+              assert_equal v1, v2
+            end
+          end
+        
+          class ValueRefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                ValueRef.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                ValueRef.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = ValueRef.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CValue, ValueRef.new('ref1')
+            end
+          
+            def test_xml
+              r1 = ValueRef.new('ref1')
+              assert_equal "<crd:ValueRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:ValueRef>", r1.to_xml.to_s
+            
+              r2 = ValueRef.from_xml("<crd:ValueRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:ValueRef>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class ErrorTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Error.new(1.2)
+              end
+
+              assert_raises ArgumentError do
+                Error.new('blah')
+              end
+            end
+
+            def test_accessors
+              err = Error.new(1.2)
+              assert_equal 1.2, err.value
+
+              err.value = 3.4
+              assert_equal 3.4, err.value
+            end
+
+            def test_relationships
+              assert_kind_of CError, Error.new(1.2)
+            end
+          
+            def test_xml
+              e1 = Error.new(1.2)
+              assert_equal "<crd:Error xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.2</crd:Error>", e1.to_xml.to_s
+            
+              e2 = Error.from_xml("<crd:Error xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.2</crd:Error>")
+              assert_equal e1, e2
+            end
+          end
+        
+          class ErrorRefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                ErrorRef.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                ErrorRef.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = ErrorRef.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CError, ErrorRef.new('ref1')
+            end
+          
+            def test_xml
+              r1 = ErrorRef.new('ref1')
+              assert_equal "<crd:ErrorRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:ErrorRef>", r1.to_xml.to_s
+            
+              r2 = ErrorRef.from_xml("<crd:ErrorRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:ErrorRef>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class ResolutionTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Resolution.new(1.2)
+              end
+
+              assert_raises ArgumentError do
+                Resolution.new('blah')
+              end
+            end
+
+            def test_accessors
+              res = Resolution.new(1.2)
+              assert_equal 1.2, res.value
+
+              res.value = 3.4
+              assert_equal 3.4, res.value
+            end
+
+            def test_relationships
+              assert_kind_of CResolution, Resolution.new(1.2)
+            end
+          
+            def test_xml
+              r1 = Resolution.new(1.2)
+              assert_equal "<crd:Resolution xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.2</crd:Resolution>", r1.to_xml.to_s
+            
+              r2 = Resolution.from_xml("<crd:Resolution xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.2</crd:Resolution>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class ResolutionRefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                ResolutionRef.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                ResolutionRef.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = ResolutionRef.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CResolution, ResolutionRef.new('ref1')
+            end
+          
+            def test_xml
+              r1 = ResolutionRef.new('ref1')
+              assert_equal "<crd:ResolutionRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:ResolutionRef>", r1.to_xml.to_s
+            
+              r2 = ResolutionRef.from_xml("<crd:ResolutionRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:ResolutionRef>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class SizeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Size.new(1.2)
+              end
+
+              assert_raises ArgumentError do
+                Size.new('blah')
+              end
+            end
+
+            def test_accessors
+              size = Size.new(1.2)
+              assert_equal 1.2, size.value
+
+              size.value = 3.4
+              assert_equal 3.4, size.value
+            end
+
+            def test_relationships
+              assert_kind_of CSize, Size.new(1.2)
+            end
+          
+            def test_xml
+              s1 = Size.new(1.2)
+              assert_equal "<crd:Size xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.2</crd:Size>", s1.to_xml.to_s
+            
+              s2 = Size.from_xml("<crd:Size xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.2</crd:Size>")
+              assert_equal s1, s2
+            end
+          end
+        
+          class SizeRefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                SizeRef.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                SizeRef.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = SizeRef.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CSize, SizeRef.new('ref1')
+            end
+          
+            def test_xml
+              r1 = SizeRef.new('ref1')
+              assert_equal "<crd:SizeRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:SizeRef>", r1.to_xml.to_s
+            
+              r2 = SizeRef.from_xml("<crd:SizeRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:SizeRef>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class PixSizeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                PixSize.new(1.2)
+              end
+
+              assert_raises ArgumentError do
+                PixSize.new('blah')
+              end
+            end
+
+            def test_accessors
+              size = PixSize.new(1.2)
+              assert_equal 1.2, size.value
+
+              size.value = 3.4
+              assert_equal 3.4, size.value
+            end
+
+            def test_relationships
+              assert_kind_of CPixSize, PixSize.new(1.2)
+            end
+          
+            def test_xml
+              p1 = PixSize.new(1.2)
+              assert_equal "<crd:PixSize xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.2</crd:PixSize>", p1.to_xml.to_s
+            
+              p2 = PixSize.from_xml("<crd:PixSize xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.2</crd:PixSize>")
+              assert_equal p1, p2
+            end
+          end
+        
+          class PixSizeRefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                PixSizeRef.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                PixSizeRef.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = PixSizeRef.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CPixSize, PixSizeRef.new('ref1')
+            end
+          
+            def test_xml
+              r1 = PixSizeRef.new('ref1')
+              assert_equal "<crd:PixSizeRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:PixSizeRef>", r1.to_xml.to_s
+            
+              r2 = PixSizeRef.from_xml("<crd:PixSizeRef xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:PixSizeRef>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class ScalarCoordinateTypeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                ScalarCoordinateType.new(
+                  :value => Value.new(123.4),
+                  :error => [Error.new(1.1), Error.new(2.2)],
+                  :resolution => [Resolution.new(0.1), Resolution.new(0.5)],
+                  :size => [Size.new(10.1), Size.new(8.7)],
+                  :pix_size => [PixSize.new(1.9), PixSize.new(2.2)]
+                )
+              
+                ScalarCoordinateType.new(
+                  :value => Value.new(123.4),
+                  :error => Error.new(1.1),
+                  :resolution => Resolution.new(0.1),
+                  :size => Size.new(10.1),
+                  :pix_size => PixSize.new(1.9)
+                )
+              
+                ScalarCoordinateType.new(
+                  :value => Value.new(123.4),
+                  :error => Error.new(1.1)
+                )
+              
+                ScalarCoordinateType.new()
+              end
+            
+              sc = ScalarCoordinateType.new
+              assert_raises TypeError do
+                sc.value = Error.new(10.2)
+              end
+            
+              assert_raises TypeError do
+                sc.error = Value.new(123.4)
+              end
+              assert_raises ArgumentError do
+                sc.error = [Error.new(123.4), Error.new(123.4), Error.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                sc.resolution = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                sc.resolution = [Resolution.new(123.4), Resolution.new(123.4), Resolution.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                sc.size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                sc.size = [Size.new(123.4), Size.new(123.4), Size.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                sc.pix_size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                sc.pix_size = [PixSize.new(123.4), PixSize.new(123.4), PixSize.new(123.4)]
+              end
+            end
+          
+            def test_accessors
+              sc = ScalarCoordinateType.new(
+                :name => 'MyCoordinate',
+                :value => Value.new(123.4),
+                :error => [Error.new(1.1), Error.new(2.2)],
+                :resolution => [Resolution.new(0.1), Resolution.new(0.2)],
+                :size => [Size.new(10.1), Size.new(8.7)],
+                :pix_size => [PixSize.new(1.9), PixSize.new(2.2)]
+              )
+            
+              assert_equal 'MyCoordinate', sc.name
+              assert_equal Value.new(123.4), sc.value
+              assert_equal [Error.new(1.1), Error.new(2.2)], sc.error
+              assert_equal [Resolution.new(0.1), Resolution.new(0.2)], sc.resolution
+              assert_equal [Size.new(10.1), Size.new(8.7)], sc.size
+              assert_equal [PixSize.new(1.9), PixSize.new(2.2)], sc.pix_size
+            
+              sc.name = 'MyOtherCoordinate'
+              assert_equal 'MyOtherCoordinate', sc.name
+              sc.error = Error.new(3.3)
+              assert_equal [Error.new(3.3)], sc.error
+              sc.resolution = Resolution.new(0.6)
+              assert_equal [Resolution.new(0.6)], sc.resolution
+              sc.size = Size.new(5.1)
+              assert_equal [Size.new(5.1)], sc.size
+              sc.pix_size = PixSize.new(3.1)
+              assert_equal [PixSize.new(3.1)], sc.pix_size
+            end
+          
+            def test_relationships
+              assert_kind_of CoordinateType, ScalarCoordinateType.new
+            end
+          end
+        
+          class TimeCoordinateTest < ::Test::Unit::TestCase
+            def test_constructors
+              assert_nothing_raised do
+                TimeCoordinate.new(
+                  :time_instant => AstronTime.new('UTC', ISOTime.new(DateTime.now)),
+                  :error => [Error.new(1.1), Error.new(2.2)],
+                  :resolution => [Resolution.new(0.1), Resolution.new(0.5)],
+                  :size => [Size.new(10.1), Size.new(8.7)],
+                  :pix_size => [PixSize.new(1.9), PixSize.new(2.2)],
+                  :unit => TimeUnit.new('s')
+                )
+              
+                TimeCoordinate.new(
+                  :time_instant => AstronTime.new('UTC', ISOTime.new(DateTime.now)),
+                  :error => Error.new(1.1),
+                  :resolution => Resolution.new(0.1),
+                  :size => Size.new(10.1),
+                  :pix_size => PixSize.new(1.9)
+                )
+              
+                TimeCoordinate.new(
+                  :time_instant => AstronTime.new('UTC', ISOTime.new(DateTime.now))
+                )
+              
+                TimeCoordinate.new()
+              end
+            
+              tc = TimeCoordinate.new
+              assert_raises TypeError do
+                tc.time_instant = Error.new(10.2)
+              end
+            
+              assert_raises TypeError do
+                tc.error = Value.new(123.4)
+              end
+              assert_raises ArgumentError do
+                tc.error = [Error.new(123.4), Error.new(123.4), Error.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                tc.resolution = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                tc.resolution = [Resolution.new(123.4), Resolution.new(123.4), Resolution.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                tc.size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                tc.size = [Size.new(123.4), Size.new(123.4), Size.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                tc.pix_size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                tc.pix_size = [PixSize.new(123.4), PixSize.new(123.4), PixSize.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                tc.unit = PosUnit.new('rad')
+              end
+            end
+          
+            def test_accessors
+              now = DateTime.now
+            
+              tc = TimeCoordinate.new(
+                :name => 'MyCoordinate',
+                :time_instant => AstronTime.new('UTC', ISOTime.new(now)),
+                :error => [Error.new(1.1), Error.new(2.2)],
+                :resolution => [Resolution.new(0.1), Resolution.new(0.2)],
+                :size => [Size.new(10.1), Size.new(8.7)],
+                :pix_size => [PixSize.new(1.9), PixSize.new(2.2)],
+                :unit => TimeUnit.new('h')
+              )
+            
+              assert_equal 'MyCoordinate', tc.name
+              assert_equal AstronTime.new('UTC', ISOTime.new(now)), tc.time_instant
+              assert_equal [Error.new(1.1), Error.new(2.2)], tc.error
+              assert_equal [Resolution.new(0.1), Resolution.new(0.2)], tc.resolution
+              assert_equal [Size.new(10.1), Size.new(8.7)], tc.size
+              assert_equal [PixSize.new(1.9), PixSize.new(2.2)], tc.pix_size
+              assert_equal TimeUnit.new('h'), tc.unit
+            
+              tc.name = 'MyOtherCoordinate'
+              assert_equal 'MyOtherCoordinate', tc.name
+              tc.time_instant = AstronTime.new('LOCAL', ISOTime.new('2007-02-26T16:31:40'))
+              assert_equal AstronTime.new('LOCAL', ISOTime.new('2007-02-26T16:31:40')), tc.time_instant
+              tc.error = Error.new(3.3)
+              assert_equal [Error.new(3.3)], tc.error
+              tc.resolution = Resolution.new(0.6)
+              assert_equal [Resolution.new(0.6)], tc.resolution
+              tc.size = Size.new(5.1)
+              assert_equal [Size.new(5.1)], tc.size
+              tc.pix_size = PixSize.new(3.1)
+              assert_equal [PixSize.new(3.1)], tc.pix_size
+              tc.unit = TimeUnit.new('cy')
+              assert_equal TimeUnit.new('cy'), tc.unit
+            end
+          
+            def test_relationships
+              assert_kind_of CoordinateType, TimeCoordinate.new
+            end
+          
+            def test_xml
+              tc1 = TimeCoordinate.new(
+                :name => 'MyCoordinate',
+                :time_instant => AstronTime.new('UTC', ISOTime.new(DateTime.parse('2007-01-01'))),
+                :error => [Error.new(1.1), Error.new(2.2)],
+                :resolution => [Resolution.new(0.1), Resolution.new(0.2)],
+                :size => [Size.new(10.1), Size.new(8.7)],
+                :pix_size => [PixSize.new(1.9), PixSize.new(2.2)],
+                :unit => TimeUnit.new('h')
+              )
+            
+              tc2 = TimeCoordinate.from_xml(tc1.to_xml)
+              assert_equal tc1, tc2
+            end
+          end
+        
+          class Value2Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Value2.new([3.2, 1.1])
+              end
+            
+              assert_raises RuntimeError do
+                Value2.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Value2.new([3.2, 2.5, 5.1])
+              end
+              assert_raises TypeError do
+                Value2.new([3.2, 'blah'])
+              end
+            end
+          
+            def test_assignment
+              d2 = Value2.new([1.1, 2.2])
+            
+              assert_raises TypeError do
+                d2[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                d2 << 1.5
+              end
+              assert_raises RuntimeError do
+                d2.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Double2, Value2.new([1.1, 2.2])
+              assert_kind_of CValue2, Value2.new([1.1, 2.2])
+            end
+          
+            def test_xml
+              v1 = Value2.new([1.1, 2.2])
+              assert_equal "<crd:Value2 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2</crd:Value2>", v1.to_xml.to_s
+            
+              v2 = Value2.from_xml("<crd:Value2 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2</crd:Value2>")
+              assert_equal v1, v2
+            end
+          end
+        
+          class Value2RefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Value2Ref.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                Value2Ref.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = Value2Ref.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CValue2, Value2Ref.new('ref1')
+            end
+          
+            def test_xml
+              r1 = Value2Ref.new('ref1')
+              assert_equal "<crd:Value2Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Value2Ref>", r1.to_xml.to_s
+            
+              r2 = Value2Ref.from_xml("<crd:Value2Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Value2Ref>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class Error2Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Error2.new([3.2, 1.1])
+              end
+            
+              assert_raises RuntimeError do
+                Error2.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Error2.new([3.2, 2.5, 5.1])
+              end
+              assert_raises TypeError do
+                Error2.new([3.2, 'blah'])
+              end
+            end
+          
+            def test_assignment
+              e2 = Error2.new([1.1, 2.2])
+            
+              assert_raises TypeError do
+                e2[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                e2 << 1.5
+              end
+              assert_raises RuntimeError do
+                e2.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Size2Type, Error2.new([1.1, 2.2])
+              assert_kind_of CError2, Error2.new([1.1, 2.2])
+            end
+          
+            def test_xml
+              e1 = Error2.new([1.1, 2.2])
+              assert_equal "<crd:Error2 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2</crd:Error2>", e1.to_xml.to_s
+            
+              e2 = Error2.from_xml("<crd:Error2 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2</crd:Error2>")
+              assert_equal e1, e2
+            end
+          end
+        
+          class Error2MatrixTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Error2Matrix.new([3.2, 1.1, 5.5, 0.1])
+              end
+            
+              assert_raises RuntimeError do
+                Error2Matrix.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Error2Matrix.new([3.2, 2.5, 5.1, 0.3, 10.9])
+              end
+              assert_raises TypeError do
+                Error2Matrix.new([3.2, 'blah', 9.1, 'yeeha'])
+              end
+            end
+          
+            def test_assignment
+              e2m = Error2Matrix.new([1.1, 2.2, 10.2, 0.1])
+            
+              assert_raises TypeError do
+                e2m[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                e2m << 1.5
+              end
+              assert_raises RuntimeError do
+                e2m.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Double4, Error2Matrix.new([1.1, 2.2, 3.3, 4.4])
+              assert_kind_of CError2, Error2Matrix.new([1.1, 2.2, 3.3, 4.4])
+            end
+          
+            def test_xml
+              m1 = Error2Matrix.new([1.1, 2.2, 3.3, 4.4])
+              assert_equal "<crd:Error2Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4</crd:Error2Matrix>", m1.to_xml.to_s
+            
+              m2 = Error2Matrix.from_xml(
+                "<crd:Error2Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4</crd:Error2Matrix>"
+              )
+              assert_equal m1, m2
+            end
+          end
+        
+          class Error2RefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Error2Ref.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                Error2Ref.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = Error2Ref.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CError2, Error2Ref.new('ref1')
+            end
+          
+            def test_xml
+              r1 = Error2Ref.new('ref1')
+              assert_equal "<crd:Error2Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Error2Ref>", r1.to_xml.to_s
+            
+              r2 = Error2Ref.from_xml("<crd:Error2Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Error2Ref>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class Resolution2Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Resolution2.new([3.2, 1.1])
+              end
+            
+              assert_raises RuntimeError do
+                Resolution2.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Resolution2.new([3.2, 2.5, 5.1])
+              end
+              assert_raises TypeError do
+                Resolution2.new([3.2, 'blah'])
+              end
+            end
+          
+            def test_assignment
+              r2 = Resolution2.new([1.1, 2.2])
+            
+              assert_raises TypeError do
+                r2[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                r2 << 1.5
+              end
+              assert_raises RuntimeError do
+                r2.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Size2Type, Resolution2.new([1.1, 2.2])
+              assert_kind_of CResolution2, Resolution2.new([1.1, 2.2])
+            end
+          
+            def test_xml
+              r1 = Resolution2.new([1.1, 2.2])
+              assert_equal "<crd:Resolution2 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2</crd:Resolution2>", r1.to_xml.to_s
+            
+              r2 = Resolution2.from_xml("<crd:Resolution2 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2</crd:Resolution2>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class Resolution2MatrixTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Resolution2Matrix.new([3.2, 1.1, 5.5, 0.1])
+              end
+            
+              assert_raises RuntimeError do
+                Resolution2Matrix.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Resolution2Matrix.new([3.2, 2.5, 5.1, 0.3, 10.9])
+              end
+              assert_raises TypeError do
+                Resolution2Matrix.new([3.2, 'blah', 9.1, 'yeeha'])
+              end
+            end
+          
+            def test_assignment
+              r2m = Resolution2Matrix.new([1.1, 2.2, 10.2, 0.1])
+            
+              assert_raises TypeError do
+                r2m[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                r2m << 1.5
+              end
+              assert_raises RuntimeError do
+                r2m.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Double4, Resolution2Matrix.new([1.1, 2.2, 3.3, 4.4])
+              assert_kind_of CResolution2, Resolution2Matrix.new([1.1, 2.2, 3.3, 4.4])
+            end
+          
+            def test_xml
+              m1 = Resolution2Matrix.new([1.1, 2.2, 3.3, 4.4])
+              assert_equal(
+                "<crd:Resolution2Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4</crd:Resolution2Matrix>",
+                m1.to_xml.to_s
+              )
+            
+              m2 = Resolution2Matrix.from_xml(
+                "<crd:Resolution2Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4</crd:Resolution2Matrix>"
+              )
+              assert_equal m1, m2
+            end
+          end
+        
+          class Resolution2RefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Resolution2Ref.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                Resolution2Ref.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = Resolution2Ref.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CResolution2, Resolution2Ref.new('ref1')
+            end
+          
+            def test_xml
+              r1 = Resolution2Ref.new('ref1')
+              assert_equal "<crd:Resolution2Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Resolution2Ref>", r1.to_xml.to_s
+            
+              r2 = Resolution2Ref.from_xml("<crd:Resolution2Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Resolution2Ref>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class Size2Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Size2.new([3.2, 1.1])
+              end
+            
+              assert_raises RuntimeError do
+                Size2.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Size2.new([3.2, 2.5, 5.1])
+              end
+              assert_raises TypeError do
+                Size2.new([3.2, 'blah'])
+              end
+            end
+          
+            def test_assignment
+              s2 = Size2.new([1.1, 2.2])
+            
+              assert_raises TypeError do
+                s2[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                s2 << 1.5
+              end
+              assert_raises RuntimeError do
+                s2.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Size2Type, Size2.new([1.1, 2.2])
+              assert_kind_of CSize2, Size2.new([1.1, 2.2])
+            end
+          
+            def test_xml
+              s1 = Size2.new([1.1, 2.2])
+              assert_equal "<crd:Size2 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2</crd:Size2>", s1.to_xml.to_s
+            
+              s2 = Size2.from_xml("<crd:Size2 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2</crd:Size2>")
+              assert_equal s1, s2
+            end
+          end
+        
+          class Size2MatrixTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Size2Matrix.new([3.2, 1.1, 5.5, 0.1])
+              end
+            
+              assert_raises RuntimeError do
+                Size2Matrix.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Size2Matrix.new([3.2, 2.5, 5.1, 0.3, 10.9])
+              end
+              assert_raises TypeError do
+                Size2Matrix.new([3.2, 'blah', 9.1, 'yeeha'])
+              end
+            end
+          
+            def test_assignment
+              s2m = Size2Matrix.new([1.1, 2.2, 10.2, 0.1])
+            
+              assert_raises TypeError do
+                s2m[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                s2m << 1.5
+              end
+              assert_raises RuntimeError do
+                s2m.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Double4, Size2Matrix.new([1.1, 2.2, 3.3, 4.4])
+              assert_kind_of CSize2, Size2Matrix.new([1.1, 2.2, 3.3, 4.4])
+            end
+          
+            def test_xml
+              m1 = Size2Matrix.new([1.1, 2.2, 3.3, 4.4])
+              assert_equal(
+                "<crd:Size2Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4</crd:Size2Matrix>",
+                m1.to_xml.to_s
+              )
+            
+              m2 = Size2Matrix.from_xml("<crd:Size2Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4</crd:Size2Matrix>")
+              assert_equal m1, m2
+            end
+          end
+        
+          class Size2RefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Size2Ref.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                Size2Ref.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = Size2Ref.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CSize2, Size2Ref.new('ref1')
+            end
+          
+            def test_xml
+              r1 = Size2Ref.new('ref1')
+              assert_equal "<crd:Size2Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Size2Ref>", r1.to_xml.to_s
+            
+              r2 = Size2Ref.from_xml("<crd:Size2Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Size2Ref>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class PixSize2Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                PixSize2.new([3.2, 1.1])
+              end
+            
+              assert_raises RuntimeError do
+                PixSize2.new([3.2])
+              end
+              assert_raises RuntimeError do
+                PixSize2.new([3.2, 2.5, 5.1])
+              end
+              assert_raises TypeError do
+                PixSize2.new([3.2, 'blah'])
+              end
+            end
+          
+            def test_assignment
+              p2 = PixSize2.new([1.1, 2.2])
+            
+              assert_raises TypeError do
+                p2[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                p2 << 1.5
+              end
+              assert_raises RuntimeError do
+                p2.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Size2Type, PixSize2.new([1.1, 2.2])
+              assert_kind_of CPixSize2, PixSize2.new([1.1, 2.2])
+            end
+          
+            def test_xml
+              p1 = PixSize2.new([1.1, 2.2])
+              assert_equal "<crd:PixSize2 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2</crd:PixSize2>", p1.to_xml.to_s
+            
+              p2 = PixSize2.from_xml("<crd:PixSize2 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2</crd:PixSize2>")
+              assert_equal p1, p2
+            end
+          end
+        
+          class PixSize2MatrixTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                PixSize2Matrix.new([3.2, 1.1, 5.5, 0.1])
+              end
+            
+              assert_raises RuntimeError do
+                PixSize2Matrix.new([3.2])
+              end
+              assert_raises RuntimeError do
+                PixSize2Matrix.new([3.2, 2.5, 5.1, 0.3, 10.9])
+              end
+              assert_raises TypeError do
+                PixSize2Matrix.new([3.2, 'blah', 9.1, 'yeeha'])
+              end
+            end
+          
+            def test_assignment
+              p2m = PixSize2Matrix.new([1.1, 2.2, 10.2, 0.1])
+            
+              assert_raises TypeError do
+                p2m[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                p2m << 1.5
+              end
+              assert_raises RuntimeError do
+                p2m.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Double4, PixSize2Matrix.new([1.1, 2.2, 3.3, 4.4])
+              assert_kind_of CPixSize2, PixSize2Matrix.new([1.1, 2.2, 3.3, 4.4])
+            end
+          
+            def test_xml
+              m1 = PixSize2Matrix.new([1.1, 2.2, 3.3, 4.4])
+              assert_equal(
+                "<crd:PixSize2Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4</crd:PixSize2Matrix>",
+                m1.to_xml.to_s
+              )
+            
+              m2 = PixSize2Matrix.from_xml(
+                "<crd:PixSize2Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4</crd:PixSize2Matrix>"
+              )
+              assert_equal m1, m2
+            end
+          end
+        
+          class PixSize2RefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                PixSize2Ref.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                PixSize2Ref.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = PixSize2Ref.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CPixSize2, PixSize2Ref.new('ref1')
+            end
+          
+            def test_xml
+              r1 = PixSize2Ref.new('ref1')
+              assert_equal "<crd:PixSize2Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:PixSize2Ref>", r1.to_xml.to_s
+            
+              r2 = PixSize2Ref.from_xml("<crd:PixSize2Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:PixSize2Ref>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class Vector2CoordinateTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Vector2Coordinate.new(
+                  :name => 'My Coordinate',
+                  :value => Value2.new([123.4, 345.6]),
+                  :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                  :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                  :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                  :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])]
+                )
+              
+                Vector2Coordinate.new(
+                  :value => Value2.new([123.4, 345.6]),
+                  :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                  :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                  :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                  :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])]
+                )
+              
+                Vector2Coordinate.new(
+                  :value => Value2.new([123.4, 345.6]),
+                  :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])]
+                )
+              
+                Vector2Coordinate.new()
+              end
+            
+              vc = Vector2Coordinate.new
+              assert_raises TypeError do
+                vc.value = Error.new(10.2)
+              end
+            
+              assert_raises TypeError do
+                vc.error = Value.new(123.4)
+              end
+              assert_raises ArgumentError do
+                vc.error = [Error2.new([123.4, 5.1]), Error2.new([123.4, 5.1]), Error2.new([123.4, 5.1])]
+              end
+            
+              assert_raises TypeError do
+                vc.resolution = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                vc.resolution = [Resolution2.new([123.4, 123.5]), Resolution2.new([123.4, 123.5]), Resolution2.new([123.4, 123.5])]
+              end
+            
+              assert_raises TypeError do
+                vc.size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                vc.size = [Size2.new([123.4, 123.4]), Size2.new([123.4, 123.4]), Size2.new([123.4, 123.4])]
+              end
+            
+              assert_raises TypeError do
+                vc.pix_size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                vc.pix_size = [PixSize2.new([123.4, 123.4]), PixSize2.new([123.4, 123.4]), PixSize2.new([123.4, 123.4])]
+              end
+            end
+          
+            def test_accessors
+              vc = Vector2Coordinate.new(
+                :name => 'MyCoordinate',
+                :value => Value2.new([123.4, 345.6]),
+                :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])]
+              )
+            
+              assert_equal 'MyCoordinate', vc.name
+              assert_equal Value2.new([123.4, 345.6]), vc.value
+              assert_equal [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])], vc.error
+              assert_equal [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])], vc.resolution
+              assert_equal [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])], vc.size
+              assert_equal [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])], vc.pix_size
+            
+              vc.name = 'MyOtherCoordinate'
+              assert_equal 'MyOtherCoordinate', vc.name
+              vc.error = Error2.new([3.3, 4.4])
+              assert_equal [Error2.new([3.3, 4.4])], vc.error
+              vc.resolution = Resolution2.new([0.6, 0.7])
+              assert_equal [Resolution2.new([0.6, 0.7])], vc.resolution
+              vc.size = Size2.new([5.1, 5.2])
+              assert_equal [Size2.new([5.1, 5.2])], vc.size
+              vc.pix_size = PixSize2.new([3.1, 3.2])
+              assert_equal [PixSize2.new([3.1, 3.2])], vc.pix_size
+            end
+          
+            def test_relationships
+              assert_kind_of CoordinateType, Vector2Coordinate.new
+            end
+          end
+        
+          class Value3Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Value3.new([3.2, 1.1, 2.2])
+              end
+            
+              assert_raises RuntimeError do
+                Value3.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Value3.new([3.2, 2.5, 5.1, 6.9])
+              end
+              assert_raises TypeError do
+                Value3.new([3.2, 'blah'])
+              end
+            end
+          
+            def test_assignment
+              d3 = Value3.new([1.1, 2.2, 3.3])
+            
+              assert_raises TypeError do
+                d3[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                d3 << 1.5
+              end
+              assert_raises RuntimeError do
+                d3.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Double3, Value3.new([1.1, 2.2, 3.3])
+              assert_kind_of CValue3, Value3.new([1.1, 2.2, 3.3])
+            end
+          
+            def test_xml
+              v1 = Value3.new([1.1, 2.2, 3.3])
+              assert_equal "<crd:Value3 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3</crd:Value3>", v1.to_xml.to_s
+            
+              v2 = Value3.from_xml("<crd:Value3 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3</crd:Value3>")
+              assert_equal v1, v2
+            end
+          end
+        
+          class Value3RefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Value3Ref.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                Value3Ref.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = Value3Ref.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CValue3, Value3Ref.new('ref1')
+            end
+          
+            def test_xml
+              r1 = Value3Ref.new('ref1')
+              assert_equal "<crd:Value3Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Value3Ref>", r1.to_xml.to_s
+            
+              r2 = Value3Ref.from_xml("<crd:Value3Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Value3Ref>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class Error3Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Error3.new([3.2, 1.1, 2.2])
+              end
+            
+              assert_raises RuntimeError do
+                Error3.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Error3.new([3.2, 2.5, 5.1, 6.6])
+              end
+              assert_raises TypeError do
+                Error3.new([3.2, 'blah'])
+              end
+            end
+          
+            def test_assignment
+              e3 = Error3.new([1.1, 2.2, 7.7])
+            
+              assert_raises TypeError do
+                e3[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                e3 << 1.5
+              end
+              assert_raises RuntimeError do
+                e3.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Size3Type, Error3.new([1.1, 2.2, 3.4])
+              assert_kind_of CError3, Error3.new([1.1, 2.2, 7.5])
+            end
+          
+            def test_xml
+              e1 = Error3.new([1.1, 2.2, 3.3])
+              assert_equal "<crd:Error3 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3</crd:Error3>", e1.to_xml.to_s
+            
+              e2 = Error3.from_xml("<crd:Error3 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3</crd:Error3>")
+              assert_equal e1, e2
+            end
+          end
+        
+          class Error3MatrixTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Error3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+              end
+            
+              assert_raises RuntimeError do
+                Error3Matrix.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Error3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1, 5.4])
+              end
+              assert_raises TypeError do
+                Error3Matrix.new([3.2, 1.1, 9.2, 5.5, 'blah', 6.6, 4.3, 6.0, 1.1])
+              end
+            end
+          
+            def test_assignment
+              e3m = Error3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+            
+              assert_raises TypeError do
+                e3m[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                e3m << 1.5
+              end
+              assert_raises RuntimeError do
+                e3m.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Double9, Error3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+              assert_kind_of CError3, Error3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+            end
+          
+            def test_xml
+              m1 = Error3Matrix.new([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9])
+              assert_equal(
+                "<crd:Error3Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9</crd:Error3Matrix>",
+                m1.to_xml.to_s
+              )
+            
+              m2 = Error3Matrix.from_xml(
+                "<crd:Error3Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9</crd:Error3Matrix>"
+              )
+              assert_equal m1, m2
+            end
+          end
+        
+          class Error3RefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Error3Ref.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                Error3Ref.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = Error3Ref.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CError3, Error3Ref.new('ref1')
+            end
+          
+            def test_xml
+              r1 = Error3Ref.new('ref1')
+              assert_equal "<crd:Error3Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Error3Ref>", r1.to_xml.to_s
+            
+              r2 = Error3Ref.from_xml("<crd:Error3Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Error3Ref>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class Resolution3Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Resolution3.new([3.2, 1.1, 5.6])
+              end
+            
+              assert_raises RuntimeError do
+                Resolution3.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Resolution3.new([3.2, 2.5, 5.1, 1.1])
+              end
+              assert_raises TypeError do
+                Resolution3.new([3.2, 4.5, 'blah'])
+              end
+            end
+          
+            def test_assignment
+              r3 = Resolution3.new([1.1, 2.2, 0.4])
+            
+              assert_raises TypeError do
+                r3[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                r3 << 1.5
+              end
+              assert_raises RuntimeError do
+                r3.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Size3Type, Resolution3.new([1.1, 2.2, 0.1])
+              assert_kind_of CResolution3, Resolution3.new([1.1, 2.2, 0.1])
+            end
+          
+            def test_xml
+              r1 = Resolution3.new([1.1, 2.2, 3.3])
+              assert_equal "<crd:Resolution3 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3</crd:Resolution3>", r1.to_xml.to_s
+            
+              r2 = Resolution3.from_xml("<crd:Resolution3 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3</crd:Resolution3>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class Resolution3RefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Resolution3Ref.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                Resolution3Ref.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = Resolution3Ref.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CResolution3, Resolution3Ref.new('ref1')
+            end
+          
+            def test_xml
+              r1 = Resolution3Ref.new('ref1')
+              assert_equal "<crd:Resolution3Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Resolution3Ref>", r1.to_xml.to_s
+            
+              r2 = Resolution3Ref.from_xml("<crd:Resolution3Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Resolution3Ref>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class Size3Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Size3.new([3.2, 1.1, 5.1])
+              end
+            
+              assert_raises RuntimeError do
+                Size3.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Size3.new([3.2, 2.5, 5.1, 1.1])
+              end
+              assert_raises TypeError do
+                Size3.new([3.2, 'blah', 0.1])
+              end
+            end
+          
+            def test_assignment
+              s3 = Size3.new([1.1, 2.2, 3.3])
+            
+              assert_raises TypeError do
+                s3[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                s3 << 1.5
+              end
+              assert_raises RuntimeError do
+                s3.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Size3Type, Size3.new([1.1, 2.2, 3.3])
+              assert_kind_of CSize3, Size3.new([1.1, 2.2, 3.3])
+            end
+          
+            def test_xml
+              s1 = Size3.new([1.1, 2.2, 3.3])
+              assert_equal "<crd:Size3 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3</crd:Size3>", s1.to_xml.to_s
+            
+              s2 = Size3.from_xml("<crd:Size3 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3</crd:Size3>")
+              assert_equal s1, s2
+            end
+          end
+        
+          class Size3MatrixTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Size3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+              end
+            
+              assert_raises RuntimeError do
+                Size3Matrix.new([3.2])
+              end
+              assert_raises RuntimeError do
+                Size3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1, 5.4])
+              end
+              assert_raises TypeError do
+                Size3Matrix.new([3.2, 1.1, 9.2, 5.5, 'blah', 6.6, 4.3, 6.0, 1.1])
+              end
+            end
+          
+            def test_assignment
+              s3m = Size3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+            
+              assert_raises TypeError do
+                s3m[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                s3m << 1.5
+              end
+              assert_raises RuntimeError do
+                s3m.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Double9, Size3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+              assert_kind_of CSize3, Size3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+            end
+          
+            def test_xml
+              m1 = Size3Matrix.new([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9])
+              assert_equal(
+                "<crd:Size3Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9</crd:Size3Matrix>",
+                m1.to_xml.to_s
+              )
+            
+              m2 = Size3Matrix.from_xml(
+                "<crd:Size3Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9</crd:Size3Matrix>"
+              )
+              assert_equal m1, m2
+            end
+          end
+        
+          class Size3RefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Size3Ref.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                Size3Ref.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = Size3Ref.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CSize3, Size3Ref.new('ref1')
+            end
+          
+            def test_xml
+              r1 = Size3Ref.new('ref1')
+              assert_equal "<crd:Size3Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Size3Ref>", r1.to_xml.to_s
+            
+              r2 = Size3Ref.from_xml("<crd:Size3Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:Size3Ref>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class PixSize3Test < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                PixSize3.new([3.2, 1.1, 5.1])
+              end
+            
+              assert_raises RuntimeError do
+                PixSize3.new([3.2])
+              end
+              assert_raises RuntimeError do
+                PixSize3.new([3.2, 2.5, 5.1, 0.1])
+              end
+              assert_raises TypeError do
+                PixSize3.new([3.2, 1.1, 'blah'])
+              end
+            end
+          
+            def test_assignment
+              p3 = PixSize3.new([1.1, 2.2, 0.5])
+            
+              assert_raises TypeError do
+                p3[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                p3 << 1.5
+              end
+              assert_raises RuntimeError do
+                p3.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Size3Type, PixSize3.new([1.1, 2.2, 0.1])
+              assert_kind_of CPixSize3, PixSize3.new([1.1, 2.2, 0.1])
+            end
+          
+            def test_xml
+              p1 = PixSize3.new([1.1, 2.2, 3.3])
+              assert_equal "<crd:PixSize3 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3</crd:PixSize3>", p1.to_xml.to_s
+            
+              p2 = PixSize3.from_xml("<crd:PixSize3 xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3</crd:PixSize3>")
+              assert_equal p1, p2
+            end
+          end
+        
+          class PixSize3MatrixTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                PixSize3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+              end
+            
+              assert_raises RuntimeError do
+                PixSize3Matrix.new([3.2])
+              end
+              assert_raises RuntimeError do
+                PixSize3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1, 5.4])
+              end
+              assert_raises TypeError do
+                PixSize3Matrix.new([3.2, 1.1, 9.2, 5.5, 'blah', 6.6, 4.3, 6.0, 1.1])
+              end
+            end
+          
+            def test_assignment
+              p3m = PixSize3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+            
+              assert_raises TypeError do
+                p3m[1] = 'blah'
+              end
+              assert_raises RuntimeError do
+                p3m << 1.5
+              end
+              assert_raises RuntimeError do
+                p3m.clear
+              end
+            end
+          
+            def test_relationships
+              assert_kind_of Double9, PixSize3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+              assert_kind_of CPixSize3, PixSize3Matrix.new([3.2, 1.1, 9.2, 5.5, 0.1, 6.6, 4.3, 6.0, 1.1])
+            end
+          
+            def test_xml
+              m1 = PixSize3Matrix.new([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9])
+              assert_equal(
+                "<crd:PixSize3Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9</crd:PixSize3Matrix>",
+                m1.to_xml.to_s
+              )
+          
+              m2 = PixSize3Matrix.from_xml(
+                "<crd:PixSize3Matrix xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9</crd:PixSize3Matrix>"
+              )
+              assert_equal m1, m2
+            end
+          end
+        
+          class PixSize3RefTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                PixSize3Ref.new('ref1')
+              end
+            
+              assert_raises ArgumentError do
+                PixSize3Ref.new(' ')
+              end
+            end
+          
+            def test_accessors
+              ref = PixSize3Ref.new('ref1')
+              assert_equal 'ref1', ref.value
+            
+              ref.value = 'ref2'
+              assert_equal 'ref2', ref.value
+            end
+          
+            def test_relationships
+              assert_kind_of CPixSize3, PixSize3Ref.new('ref1')
+            end
+          
+            def test_xml
+              r1 = PixSize3Ref.new('ref1')
+              assert_equal "<crd:PixSize3Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:PixSize3Ref>", r1.to_xml.to_s
+            
+              r2 = PixSize3Ref.from_xml("<crd:PixSize3Ref xmlns:crd='http://www.ivoa.net/xml/STC/STCcoords/v1.10'>ref1</crd:PixSize3Ref>")
+              assert_equal r1, r2
+            end
+          end
+        
+          class Vector3CoordinateTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Vector3Coordinate.new(
+                  :name => 'My Coordinate',
+                  :value => Value3.new([123.4, 345.6, 567.8]),
+                  :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])],
+                  :resolution => [Resolution3.new([0.1, 0.2, 0.3]), Resolution3.new([0.5, 0.6, 0.7])],
+                  :size => [Size3.new([10.1, 10.2, 10.3]), Size3.new([8.7, 8.8, 8.9])],
+                  :pix_size => [PixSize3.new([1.9, 2.0, 2.1]), PixSize3.new([2.2, 3.3, 4.4])]
+                )
+              
+                Vector3Coordinate.new(
+                  :value => Value3.new([123.4, 345.6, 567.8]),
+                  :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])],
+                  :resolution => [Resolution3.new([0.1, 0.2, 0.3]), Resolution3.new([0.5, 0.6, 0.7])],
+                  :size => [Size3.new([10.1, 10.2, 10.3]), Size3.new([8.7, 8.8, 8.9])],
+                  :pix_size => [PixSize3.new([1.9, 2.0, 2.1]), PixSize3.new([2.2, 3.3, 4.4])]
+                )
+              
+                Vector3Coordinate.new(
+                  :value => Value3.new([123.4, 345.6, 567.8]),
+                  :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])]
+                )
+              
+                Vector3Coordinate.new()
+              end
+            
+              vc = Vector3Coordinate.new
+              assert_raises TypeError do
+                vc.value = Error.new(10.2)
+              end
+            
+              assert_raises TypeError do
+                vc.error = Value.new(123.4)
+              end
+              assert_raises ArgumentError do
+                vc.error = [Error3.new([123.4, 5.1, 2.2]), Error3.new([123.4, 5.1, 2.2]), Error3.new([123.4, 5.1, 2.2])]
+              end
+            
+              assert_raises TypeError do
+                vc.resolution = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                vc.resolution = [Resolution3.new([123.4, 123.5, 1.1]), Resolution3.new([123.4, 123.5, 1.1]), Resolution3.new([123.4, 123.5, 1.1])]
+              end
+            
+              assert_raises TypeError do
+                vc.size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                vc.size = [Size3.new([123.4, 123.4, 123.4]), Size3.new([123.4, 123.4, 123.4]), Size3.new([123.4, 123.4, 123.4])]
+              end
+            
+              assert_raises TypeError do
+                vc.pix_size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                vc.pix_size = [PixSize3.new([123.4, 123.4, 123.4]), PixSize3.new([123.4, 123.4, 123.4]), PixSize3.new([123.4, 123.4, 123.4])]
+              end
+            end
+          
+            def test_accessors
+              vc = Vector3Coordinate.new(
+                :name => 'MyCoordinate',
+                :value => Value3.new([123.4, 345.6, 789.0]),
+                :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 2.2])],
+                :resolution => [Resolution3.new([0.1, 0.2, 0.5]), Resolution3.new([0.5, 0.6, 0.5])],
+                :size => [Size3.new([10.1, 10.2, 1.1]), Size3.new([8.7, 8.8, 1.1])],
+                :pix_size => [PixSize3.new([1.9, 2.0, 3.0]), PixSize3.new([2.2, 3.3, 4.1])]
+              )
+            
+              assert_equal 'MyCoordinate', vc.name
+              assert_equal Value3.new([123.4, 345.6, 789.0]), vc.value
+              assert_equal [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 2.2])], vc.error
+              assert_equal [Resolution3.new([0.1, 0.2, 0.5]), Resolution3.new([0.5, 0.6, 0.5])], vc.resolution
+              assert_equal [Size3.new([10.1, 10.2, 1.1]), Size3.new([8.7, 8.8, 1.1])], vc.size
+              assert_equal [PixSize3.new([1.9, 2.0, 3.0]), PixSize3.new([2.2, 3.3, 4.1])], vc.pix_size
+            
+              vc.name = 'MyOtherCoordinate'
+              assert_equal 'MyOtherCoordinate', vc.name
+              vc.error = Error3.new([3.3, 4.4, 5.5])
+              assert_equal [Error3.new([3.3, 4.4, 5.5])], vc.error
+              vc.resolution = Resolution3.new([0.6, 0.7, 0.8])
+              assert_equal [Resolution3.new([0.6, 0.7, 0.8])], vc.resolution
+              vc.size = Size3.new([5.1, 5.2, 5.3])
+              assert_equal [Size3.new([5.1, 5.2, 5.3])], vc.size
+              vc.pix_size = PixSize3.new([3.1, 3.2, 3.3])
+              assert_equal [PixSize3.new([3.1, 3.2, 3.3])], vc.pix_size
+            end
+          
+            def test_relationships
+              assert_kind_of CoordinateType, Vector3Coordinate.new
+            end
+          end
+        
+          class ScalarCoordinateTest < ::Test::Unit::TestCase
+            def test_unit
+              sc = ScalarCoordinate.new(:unit => 'mm')
+              assert_equal 'mm', sc.unit
+            
+              sc.unit = 'cm'
+              assert_equal 'cm', sc.unit
+            
+              assert_kind_of Coordinate, sc
+            end
+          
+            def test_xml
+              sc1 = ScalarCoordinate.new(
+                :name => 'myScalarCoordinate',
+                :unit => 'm',
+                :value => Value.new(1.1),
+                :error => [ErrorRef.new('error_ref1'), Error.new(0.1)],
+                :resolution => [ResolutionRef.new('pix_size_ref1')],
+                :size => [Size.new(10.0)],
+                :pix_size => [PixSizeRef.new('pix_size_ref1')]
+              )
+            
+              sc2 = ScalarCoordinate.from_xml(sc1.to_xml)
+              assert_equal sc1, sc2
+            end
+          end
+        
+          class CoordinateTypeTest < ::Test::Unit::TestCase
+            def test_constructor
+              assert_nothing_raised do 
+                c = CoordinateType.new('coord1')
+                assert_equal 'coord1', c.name
+              end
+            end
+          
+            def test_accessors
+              c = CoordinateType.new('coord1')
+            
+              assert_equal 'coord1', c.name
+              c.name = 'coord2'
+              assert_equal 'coord2', c.name
+            end
+          end
+        
+          class StringCoordinateTest < ::Test::Unit::TestCase
+            def test_constructors
+              assert_nothing_raised do
+                StringCoordinate.new(:name => 'coord1', :unit => 'mm', :value => 'a bunch of')
+                StringCoordinate.new(:name => 'coord1', :value => 'a bunch of')
+              end
+            end
+          
+            def test_accessors
+              sc = StringCoordinate.new(:name => 'coord1', :unit => 'mm', :value => 'a bunch of')
+              assert_equal 'coord1', sc.name
+              assert_equal 'mm', sc.unit
+              assert_equal 'a bunch of', sc.value
+            
+              sc.name = 'coord2'
+              assert_equal 'coord2', sc.name
+              sc.unit = 'cm'
+              assert_equal 'cm', sc.unit
+              sc.value = 'some'
+              assert_equal 'some', sc.value
+            end
+          
+            def test_relationships
+              sc = StringCoordinate.new(:name => 'coord1', :value => 'a bunch of')
+              assert_kind_of CoordinateType, sc
+              assert_kind_of Coordinate, sc
+            end
+          
+            def test_xml
+              sc1 = StringCoordinate.new(
+                :unit => 'm',
+                :name => 'myCoordinate',
+                :value => 'blah'
+              )
+            
+              sc2 = StringCoordinate.from_xml(sc1.to_xml)
+              assert_equal sc1, sc2
+            end
+          end
+        
+          class PixelCoordinateTest < ::Test::Unit::TestCase
+            def test_constructors
+              assert_nothing_raised do
+                PixelCoordinate.new(:name => 'coord1', :value => 10.1)
+              end
+            end
+          
+            def test_accessors
+              pc = PixelCoordinate.new(:name => 'coord1', :value => 10.1)
+              assert_equal 'coord1', pc.name
+              assert_equal 10.1, pc.value
+            
+              pc.name = 'coord2'
+              assert_equal 'coord2', pc.name
+              pc.value = 1.1
+              assert_equal 1.1, pc.value
+            end
+          
+            def test_relationships
+              pc = PixelCoordinate.new(:name => 'coord1', :value => 10.1)
+              assert_kind_of CoordinateType, pc
+              assert_kind_of Coordinate, pc
+            end
+          
+            def test_xml
+              pc1 = PixelCoordinate.new(
+                :name => 'myCoordinate',
+                :value => 100.1
+              )
+            
+              pc2 = PixelCoordinate.from_xml(pc1.to_xml)
+              assert_equal pc1, pc2
+            end
+          end
+        
+          class Position1DTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Position1D.new(
+                  :value => Value.new(123.4),
+                  :error => [Error.new(1.1), Error.new(2.2)],
+                  :resolution => [Resolution.new(0.1), Resolution.new(0.5)],
+                  :size => [Size.new(10.1), Size.new(8.7)],
+                  :pix_size => [PixSize.new(1.9), PixSize.new(2.2)],
+                  :unit => PosUnit.new('m')
+                )
+              
+                Position1D.new(
+                  :value => Value.new(123.4),
+                  :error => Error.new(1.1),
+                  :resolution => Resolution.new(0.1),
+                  :size => Size.new(10.1),
+                  :pix_size => PixSize.new(1.9),
+                  :unit => PosUnit.new('m')
+                )
+              
+                Position1D.new(
+                  :value => Value.new(123.4),
+                  :error => Error.new(1.1),
+                  :unit => PosUnit.new('m')
+                )
+              
+                Position1D.new(:unit => PosUnit.new('m'))
+              end
+            
+              assert_raises ArgumentError do
+                Position1D.new
+              end
+            
+              p = Position1D.new(:unit => PosUnit.new('lyr'))
+              assert_raises TypeError do
+                p.value = Error.new(10.2)
+              end
+            
+              assert_raises TypeError do
+                p.error = Value.new(123.4)
+              end
+              assert_raises ArgumentError do
+                p.error = [Error.new(123.4), Error.new(123.4), Error.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                p.resolution = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                p.resolution = [Resolution.new(123.4), Resolution.new(123.4), Resolution.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                p.size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                p.size = [Size.new(123.4), Size.new(123.4), Size.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                p.pix_size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                p.pix_size = [PixSize.new(123.4), PixSize.new(123.4), PixSize.new(123.4)]
+              end
+            end
+          
+            def test_accessors
+              p = Position1D.new(
+                :name => 'MyCoordinate',
+                :value => Value.new(123.4),
+                :error => [Error.new(1.1), Error.new(2.2)],
+                :resolution => [Resolution.new(0.1), Resolution.new(0.2)],
+                :size => [Size.new(10.1), Size.new(8.7)],
+                :pix_size => [PixSize.new(1.9), PixSize.new(2.2)],
+                :unit => PosUnit.new('m')
+              )
+            
+              assert_equal 'MyCoordinate', p.name
+              assert_equal Value.new(123.4), p.value
+              assert_equal [Error.new(1.1), Error.new(2.2)], p.error
+              assert_equal [Resolution.new(0.1), Resolution.new(0.2)], p.resolution
+              assert_equal [Size.new(10.1), Size.new(8.7)], p.size
+              assert_equal [PixSize.new(1.9), PixSize.new(2.2)], p.pix_size
+              assert_equal PosUnit.new('m'), p.unit
+            
+              p.name = 'MyOtherCoordinate'
+              assert_equal 'MyOtherCoordinate', p.name
+              p.error = Error.new(3.3)
+              assert_equal [Error.new(3.3)], p.error
+              p.resolution = Resolution.new(0.6)
+              assert_equal [Resolution.new(0.6)], p.resolution
+              p.size = Size.new(5.1)
+              assert_equal [Size.new(5.1)], p.size
+              p.pix_size = PixSize.new(3.1)
+              assert_equal [PixSize.new(3.1)], p.pix_size
+              p.unit = PosUnit.new('m')
+              assert_equal PosUnit.new('m'), p.unit
+            end
+          
+            def test_relationships
+              p = Position1D.new(:unit => PosUnit.new('m'))
+              assert_kind_of ScalarCoordinateType, p
+              assert_kind_of Position, p
+            end
+          
+            def test_xml
+              p1 = Position1D.new(
+                :name => 'MyCoordinate',
+                :value => Value.new(123.4),
+                :error => [Error.new(1.1), Error.new(2.2)],
+                :resolution => [Resolution.new(0.1), Resolution.new(0.2)],
+                :size => [Size.new(10.1), Size.new(8.7)],
+                :pix_size => [PixSize.new(1.9), PixSize.new(2.2)],
+                :unit => PosUnit.new('m')
+              )
+            
+              p2 = Position1D.from_xml(p1.to_xml)
+              assert_equal p1, p2
+            end
+          end
+        
+          class Position2DTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Position2D.new(
+                  :name => 'My Coordinate',
+                  :value => Value2.new([123.4, 345.6]),
+                  :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                  :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                  :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                  :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])],
+                  :unit => PosUnit.new('m')
+                )
+              
+                Position2D.new(
+                  :value => Value2.new([123.4, 345.6]),
+                  :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                  :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                  :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                  :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])],
+                  :unit => PosUnit.new('m')
+                )
+              
+                Position2D.new(
+                  :value => Value2.new([123.4, 345.6]),
+                  :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                  :unit => PosUnit.new('m')
+                )
+              
+                Position2D.new(:unit => PosUnit.new('m'))
+              end
+            
+              assert_raises ArgumentError do
+                Position2D.new
+              end
+            
+              p = Position2D.new(:unit => PosUnit.new('m'))
+              assert_raises TypeError do
+                p.value = Error.new(10.2)
+              end
+            
+              assert_raises TypeError do
+                p.error = Value.new(123.4)
+              end
+              assert_raises ArgumentError do
+                p.error = [Error2.new([123.4, 5.1]), Error2.new([123.4, 5.1]), Error2.new([123.4, 5.1])]
+              end
+            
+              assert_raises TypeError do
+                p.resolution = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                p.resolution = [Resolution2.new([123.4, 123.5]), Resolution2.new([123.4, 123.5]), Resolution2.new([123.4, 123.5])]
+              end
+            
+              assert_raises TypeError do
+                p.size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                p.size = [Size2.new([123.4, 123.4]), Size2.new([123.4, 123.4]), Size2.new([123.4, 123.4])]
+              end
+            
+              assert_raises TypeError do
+                p.pix_size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                p.pix_size = [PixSize2.new([123.4, 123.4]), PixSize2.new([123.4, 123.4]), PixSize2.new([123.4, 123.4])]
+              end
+            end
+          
+            def test_accessors
+              p = Position2D.new(
+                :name => 'MyCoordinate',
+                :value => Value2.new([123.4, 345.6]),
+                :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])],
+                :unit => PosUnit.new('m')
+              )
+            
+              assert_equal 'MyCoordinate', p.name
+              assert_equal Value2.new([123.4, 345.6]), p.value
+              assert_equal [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])], p.error
+              assert_equal [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])], p.resolution
+              assert_equal [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])], p.size
+              assert_equal [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])], p.pix_size
+              assert_equal PosUnit.new('m'), p.unit
+            
+              p.name = 'MyOtherCoordinate'
+              assert_equal 'MyOtherCoordinate', p.name
+              p.error = Error2.new([3.3, 4.4])
+              assert_equal [Error2.new([3.3, 4.4])], p.error
+              p.resolution = Resolution2.new([0.6, 0.7])
+              assert_equal [Resolution2.new([0.6, 0.7])], p.resolution
+              p.size = Size2.new([5.1, 5.2])
+              assert_equal [Size2.new([5.1, 5.2])], p.size
+              p.pix_size = PixSize2.new([3.1, 3.2])
+              assert_equal [PixSize2.new([3.1, 3.2])], p.pix_size
+              p.unit = PosUnit.new('lyr')
+              assert_equal PosUnit.new('lyr'), p.unit
+            end
+          
+            def test_relationships
+              p = Position2D.new(:unit => PosUnit.new('m'))
+              assert_kind_of Vector2Coordinate, p
+              assert_kind_of Position, p
+            end
+          
+            def test_xml
+              p1 = Position2D.new(
+                :name => 'My2DCoordinate',
+                :value => Value2.new([123.4, 345.6]),
+                :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])],
+                :unit => PosUnit.new('m')
+              )
+            
+              p2 = Position2D.from_xml(p1.to_xml)
+              assert_equal p1, p2
+            end
+          end
+        
+          class Position3DTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Position3D.new(
+                  :name => 'My Coordinate',
+                  :value => Value3.new([123.4, 345.6, 456.7]),
+                  :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])],
+                  :resolution => [Resolution3.new([0.1, 0.2, 0.3]), Resolution3.new([0.5, 0.6, 0.7])],
+                  :size => [Size3.new([10.1, 10.2, 10.3]), Size3.new([8.7, 8.8, 8.9])],
+                  :pix_size => [PixSize3.new([1.9, 2.0, 2.1]), PixSize3.new([2.2, 3.3, 4.4])],
+                  :unit => PosUnit.new('m')
+                )
+              
+                Position3D.new(
+                  :value => Value3.new([123.4, 345.6, 456.7]),
+                  :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])],
+                  :resolution => [Resolution3.new([0.1, 0.2, 0.3]), Resolution3.new([0.5, 0.6, 0.7])],
+                  :size => [Size3.new([10.1, 10.2, 10.3]), Size3.new([8.7, 8.8, 8.9])],
+                  :pix_size => [PixSize3.new([1.9, 2.0, 2.1]), PixSize3.new([2.2, 3.3, 4.4])],
+                  :unit => PosUnit.new('m')
+                )
+              
+                Position3D.new(
+                  :value => Value3.new([123.4, 345.6, 456.7]),
+                  :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])],
+                  :unit => PosUnit.new('m')
+                )
+              
+                Position3D.new(:unit => PosUnit.new('m'))
+              end
+            
+              assert_raises ArgumentError do
+                Position3D.new
+              end
+            
+              p = Position3D.new(:unit => PosUnit.new('m'))
+              assert_raises TypeError do
+                p.value = Error.new(10.2)
+              end
+            
+              assert_raises TypeError do
+                p.error = Value.new(123.4)
+              end
+              assert_raises ArgumentError do
+                p.error = [Error3.new([123.4, 5.1, 1.1]), Error3.new([123.4, 5.1, 1.1]), Error3.new([123.4, 5.1, 1.1])]
+              end
+            
+              assert_raises TypeError do
+                p.resolution = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                p.resolution = [Resolution3.new([123.4, 123.5, 1.1]), Resolution3.new([123.4, 123.5, 1.1]), Resolution3.new([123.4, 123.5, 1.1])]
+              end
+            
+              assert_raises TypeError do
+                p.size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                p.size = [Size3.new([123.4, 123.4, 1.1]), Size3.new([123.4, 123.4, 1.1]), Size3.new([123.4, 123.4, 1.1])]
+              end
+            
+              assert_raises TypeError do
+                p.pix_size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                p.pix_size = [PixSize3.new([123.4, 123.4, 1.1]), PixSize3.new([123.4, 123.4, 1.1]), PixSize3.new([123.4, 123.4, 1.1])]
+              end
+            end
+          
+            def test_accessors
+              p = Position3D.new(
+                :name => 'MyCoordinate',
+                :value => Value3.new([123.4, 345.6, 456.7]),
+                :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])],
+                :resolution => [Resolution3.new([0.1, 0.2, 0.3]), Resolution3.new([0.5, 0.6, 0.7])],
+                :size => [Size3.new([10.1, 10.2, 10.3]), Size3.new([8.7, 8.8, 8.9])],
+                :pix_size => [PixSize3.new([1.9, 2.0, 2.1]), PixSize3.new([2.2, 3.3, 4.4])],
+                :unit => PosUnit.new('m')
+              )
+            
+              assert_equal 'MyCoordinate', p.name
+              assert_equal Value3.new([123.4, 345.6, 456.7]), p.value
+              assert_equal [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])], p.error
+              assert_equal [Resolution3.new([0.1, 0.2, 0.3]), Resolution3.new([0.5, 0.6, 0.7])], p.resolution
+              assert_equal [Size3.new([10.1, 10.2, 10.3]), Size3.new([8.7, 8.8, 8.9])], p.size
+              assert_equal [PixSize3.new([1.9, 2.0, 2.1]), PixSize3.new([2.2, 3.3, 4.4])], p.pix_size
+              assert_equal PosUnit.new('m'), p.unit
+            
+              p.name = 'MyOtherCoordinate'
+              assert_equal 'MyOtherCoordinate', p.name
+              p.error = Error3.new([3.3, 4.4, 5.5])
+              assert_equal [Error3.new([3.3, 4.4, 5.5])], p.error
+              p.resolution = Resolution3.new([0.6, 0.7, 0.8])
+              assert_equal [Resolution3.new([0.6, 0.7, 0.8])], p.resolution
+              p.size = Size3.new([5.1, 5.2, 5.3])
+              assert_equal [Size3.new([5.1, 5.2, 5.3])], p.size
+              p.pix_size = PixSize3.new([3.1, 3.2, 3.3])
+              assert_equal [PixSize3.new([3.1, 3.2, 3.3])], p.pix_size
+              p.unit = PosUnit.new('lyr')
+              assert_equal PosUnit.new('lyr'), p.unit
+            end
+          
+            def test_relationships
+              p = Position3D.new(:unit => PosUnit.new('m'))
+              assert_kind_of Vector3Coordinate, p
+              assert_kind_of Position, p
+            end
+          
+            def test_xml
+              p1 = Position3D.new(
+                :name => 'MyCoordinate',
+                :value => Value3.new([123.4, 345.6, 456.7]),
+                :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])],
+                :resolution => [Resolution3.new([0.1, 0.2, 0.3]), Resolution3.new([0.5, 0.6, 0.7])],
+                :size => [Size3.new([10.1, 10.2, 10.3]), Size3.new([8.7, 8.8, 8.9])],
+                :pix_size => [PixSize3.new([1.9, 2.0, 2.1]), PixSize3.new([2.2, 3.3, 4.4])],
+                :unit => PosUnit.new('m')
+              )
+            
+              p2 = Position3D.from_xml(p1.to_xml)
+              assert_equal p1, p2
+            end
+          end
+        
+          class Velocity1DTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised do
+                Velocity1D.new(
+                  :value => Value.new(123.4),
+                  :error => [Error.new(1.1), Error.new(2.2)],
+                  :resolution => [Resolution.new(0.1), Resolution.new(0.5)],
+                  :size => [Size.new(10.1), Size.new(8.7)],
+                  :pix_size => [PixSize.new(1.9), PixSize.new(2.2)],
+                  :unit => PosUnit.new('m'),
+                  :vel_time_unit => VelTimeUnit.new('s')
+                )
+              
+                Velocity1D.new(
+                  :value => Value.new(123.4),
+                  :error => Error.new(1.1),
+                  :resolution => Resolution.new(0.1),
+                  :size => Size.new(10.1),
+                  :pix_size => PixSize.new(1.9),
+                  :unit => PosUnit.new('m'),
+                  :vel_time_unit => VelTimeUnit.new('s')
+                )
+              
+                Velocity1D.new(
+                  :value => Value.new(123.4),
+                  :error => Error.new(1.1),
+                  :unit => PosUnit.new('m'),
+                  :vel_time_unit => VelTimeUnit.new('s')
+                )
+              
+                Velocity1D.new(
+                  :unit => PosUnit.new('m'),
+                  :vel_time_unit => VelTimeUnit.new('s')
+                )
+              end
+            
+              assert_raises ArgumentError do
+                Velocity1D.new(:unit => PosUnit.new('m'))
+              end
+              assert_raises ArgumentError do
+                Velocity1D.new(:vel_time_unit => VelTimeUnit.new('s'))
+              end
+            
+              sc = Velocity1D.new(
+                :unit => PosUnit.new('m'),
+                :vel_time_unit => VelTimeUnit.new('s')
+              )
+              assert_raises TypeError do
+                sc.value = Error.new(10.2)
+              end
+            
+              assert_raises TypeError do
+                sc.error = Value.new(123.4)
+              end
+              assert_raises ArgumentError do
+                sc.error = [Error.new(123.4), Error.new(123.4), Error.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                sc.resolution = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                sc.resolution = [Resolution.new(123.4), Resolution.new(123.4), Resolution.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                sc.size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                sc.size = [Size.new(123.4), Size.new(123.4), Size.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                sc.pix_size = Error.new(10.2)
+              end
+              assert_raises ArgumentError do
+                sc.pix_size = [PixSize.new(123.4), PixSize.new(123.4), PixSize.new(123.4)]
+              end
+            
+              assert_raises TypeError do
+                sc.unit = VelTimeUnit.new('s')
+              end
+              assert_raises TypeError do
+                sc.vel_time_unit = PosUnit.new('m')
+              end
+            end
+          
+            def test_accessors
+              sc = Velocity1D.new(
+                :name => 'MyCoordinate',
+                :value => Value.new(123.4),
+                :error => [Error.new(1.1), Error.new(2.2)],
+                :resolution => [Resolution.new(0.1), Resolution.new(0.2)],
+                :size => [Size.new(10.1), Size.new(8.7)],
+                :pix_size => [PixSize.new(1.9), PixSize.new(2.2)],
+                :unit => PosUnit.new('m'),
+                :vel_time_unit => VelTimeUnit.new('s')
+              )
+            
+              assert_equal 'MyCoordinate', sc.name
+              assert_equal Value.new(123.4), sc.value
+              assert_equal [Error.new(1.1), Error.new(2.2)], sc.error
+              assert_equal [Resolution.new(0.1), Resolution.new(0.2)], sc.resolution
+              assert_equal [Size.new(10.1), Size.new(8.7)], sc.size
+              assert_equal [PixSize.new(1.9), PixSize.new(2.2)], sc.pix_size
+              assert_equal PosUnit.new('m'), sc.unit
+              assert_equal VelTimeUnit.new('s'), sc.vel_time_unit
+            
+              sc.name = 'MyOtherCoordinate'
+              assert_equal 'MyOtherCoordinate', sc.name
+              sc.error = Error.new(3.3)
+              assert_equal [Error.new(3.3)], sc.error
+              sc.resolution = Resolution.new(0.6)
+              assert_equal [Resolution.new(0.6)], sc.resolution
+              sc.size = Size.new(5.1)
+              assert_equal [Size.new(5.1)], sc.size
+              sc.pix_size = PixSize.new(3.1)
+              assert_equal [PixSize.new(3.1)], sc.pix_size
+              sc.unit = PosUnit.new('lyr')
+              assert_equal PosUnit.new('lyr'), sc.unit
+              sc.vel_time_unit = VelTimeUnit.new('h')
+              assert_equal VelTimeUnit.new('h'), sc.vel_time_unit
+            end
+          
+            def test_relationships
+              v = Velocity1D.new(:unit => PosUnit.new('m'), :vel_time_unit => VelTimeUnit.new('s'))
+              assert_kind_of ScalarCoordinateType, v
+              assert_kind_of Velocity, v
+            end
+          
+            def test_xml
+              v1 = Velocity1D.new(
+                :name => 'MyCoordinate',
+                :value => Value.new(123.4),
+                :error => [Error.new(1.1), Error.new(2.2)],
+                :resolution => [Resolution.new(0.1), Resolution.new(0.2)],
+                :size => [Size.new(10.1), Size.new(8.7)],
+                :pix_size => [PixSize.new(1.9), PixSize.new(2.2)],
+                :unit => PosUnit.new('m'),
+                :vel_time_unit => VelTimeUnit.new('s')
+              )
+            
+              v2 = Velocity1D.from_xml(v1.to_xml)
+              assert_equal v1, v2
+            end
+          end
+        
+          class Velocity2DTest < ::Test::Unit::TestCase
+             def test_construction
+               assert_nothing_raised do
+                 Velocity2D.new(
+                   :name => 'My Coordinate',
+                   :value => Value2.new([123.4, 345.6]),
+                   :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                   :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                   :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                   :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])],
+                   :unit => PosUnit.new('m'),
+                   :vel_time_unit => VelTimeUnit.new('s')      
+                 )
+
+                 Velocity2D.new(
+                   :value => Value2.new([123.4, 345.6]),
+                   :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                   :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                   :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                   :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])],
+                   :unit => PosUnit.new('m'),
+                   :vel_time_unit => VelTimeUnit.new('s')
+                 )
+
+                 Velocity2D.new(
+                   :value => Value2.new([123.4, 345.6]),
+                   :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                   :unit => PosUnit.new('m'),
+                   :vel_time_unit => VelTimeUnit.new('s')
+                 )
+
+                 Velocity2D.new(
+                  :unit => PosUnit.new('m'),
+                  :vel_time_unit => VelTimeUnit.new('s')
+                 )
+               end
+             
+               assert_raises ArgumentError do
+                 Velocity2D.new(:unit => PosUnit.new('m'))
+               end
+               assert_raises ArgumentError do
+                 Velocity2D.new(:vel_time_unit => VelTimeUnit.new('s'))
+               end
+
+               vc = Velocity2D.new(:unit => PosUnit.new('m'), :vel_time_unit => VelTimeUnit.new('s'))
+               assert_raises TypeError do
+                 vc.value = Error.new(10.2)
+               end
+
+               assert_raises TypeError do
+                 vc.error = Value.new(123.4)
+               end
+               assert_raises ArgumentError do
+                 vc.error = [Error2.new([123.4, 5.1]), Error2.new([123.4, 5.1]), Error2.new([123.4, 5.1])]
+               end
+
+               assert_raises TypeError do
+                 vc.resolution = Error.new(10.2)
+               end
+               assert_raises ArgumentError do
+                 vc.resolution = [Resolution2.new([123.4, 123.5]), Resolution2.new([123.4, 123.5]), Resolution2.new([123.4, 123.5])]
+               end
+
+               assert_raises TypeError do
+                 vc.size = Error.new(10.2)
+               end
+               assert_raises ArgumentError do
+                 vc.size = [Size2.new([123.4, 123.4]), Size2.new([123.4, 123.4]), Size2.new([123.4, 123.4])]
+               end
+
+               assert_raises TypeError do
+                 vc.pix_size = Error.new(10.2)
+               end
+               assert_raises ArgumentError do
+                 vc.pix_size = [PixSize2.new([123.4, 123.4]), PixSize2.new([123.4, 123.4]), PixSize2.new([123.4, 123.4])]
+               end
+             
+               assert_raises TypeError do
+                  vc.unit = VelTimeUnit.new('s')
+                end
+                assert_raises TypeError do
+                  vc.vel_time_unit = PosUnit.new('m')
+                end
+             end
+
+             def test_accessors
+               vc = Velocity2D.new(
+                 :name => 'MyCoordinate',
+                 :value => Value2.new([123.4, 345.6]),
+                 :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                 :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                 :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                 :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])],
+                 :unit => PosUnit.new('m'),
+                 :vel_time_unit => VelTimeUnit.new('s')
+               )
+
+               assert_equal 'MyCoordinate', vc.name
+               assert_equal Value2.new([123.4, 345.6]), vc.value
+               assert_equal [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])], vc.error
+               assert_equal [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])], vc.resolution
+               assert_equal [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])], vc.size
+               assert_equal [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])], vc.pix_size
+               assert_equal PosUnit.new('m'), vc.unit
+               assert_equal VelTimeUnit.new('s'), vc.vel_time_unit
+
+               vc.name = 'MyOtherCoordinate'
+               assert_equal 'MyOtherCoordinate', vc.name
+               vc.error = Error2.new([3.3, 4.4])
+               assert_equal [Error2.new([3.3, 4.4])], vc.error
+               vc.resolution = Resolution2.new([0.6, 0.7])
+               assert_equal [Resolution2.new([0.6, 0.7])], vc.resolution
+               vc.size = Size2.new([5.1, 5.2])
+               assert_equal [Size2.new([5.1, 5.2])], vc.size
+               vc.pix_size = PixSize2.new([3.1, 3.2])
+               assert_equal [PixSize2.new([3.1, 3.2])], vc.pix_size
+               vc.unit = PosUnit.new('lyr')
+               assert_equal PosUnit.new('lyr'), vc.unit
+               vc.vel_time_unit = VelTimeUnit.new('h')
+               assert_equal VelTimeUnit.new('h'), vc.vel_time_unit
+             end
+
+             def test_relationships
+               v = Velocity2D.new(:unit => PosUnit.new('m'), :vel_time_unit => VelTimeUnit.new('s'))
+               assert_kind_of Vector2Coordinate, v
+               assert_kind_of Velocity, v
+             end
+           
+             def test_xml
+               v1 = Velocity2D.new(
+                  :name => 'MyCoordinate',
+                  :value => Value2.new([123.4, 345.6]),
+                  :error => [Error2.new([1.1, 2.2]), Error2.new([2.2, 3.3])],
+                  :resolution => [Resolution2.new([0.1, 0.2]), Resolution2.new([0.5, 0.6])],
+                  :size => [Size2.new([10.1, 10.2]), Size2.new([8.7, 8.8])],
+                  :pix_size => [PixSize2.new([1.9, 2.0]), PixSize2.new([2.2, 3.3])],
+                  :unit => PosUnit.new('m'),
+                  :vel_time_unit => VelTimeUnit.new('s')
+                )
+              
+                v2 = Velocity2D.from_xml(v1.to_xml)
+                assert_equal v1, v2
+             end
+           end
+         
+           class Velocity3DTest < ::Test::Unit::TestCase
+             def test_construction
+               assert_nothing_raised do
+                 Velocity3D.new(
+                   :name => 'My Coordinate',
+                   :value => Value3.new([123.4, 345.6, 567.8]),
+                   :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])],
+                   :resolution => [Resolution3.new([0.1, 0.2, 0.3]), Resolution3.new([0.5, 0.6, 0.7])],
+                   :size => [Size3.new([10.1, 10.2, 10.3]), Size3.new([8.7, 8.8, 8.9])],
+                   :pix_size => [PixSize3.new([1.9, 2.0, 2.1]), PixSize3.new([2.2, 3.3, 4.4])],
+                   :unit => PosUnit.new('m'),
+                   :vel_time_unit => VelTimeUnit.new('s')
+                 )
+
+                 Velocity3D.new(
+                   :value => Value3.new([123.4, 345.6, 567.8]),
+                   :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])],
+                   :resolution => [Resolution3.new([0.1, 0.2, 0.3]), Resolution3.new([0.5, 0.6, 0.7])],
+                   :size => [Size3.new([10.1, 10.2, 10.3]), Size3.new([8.7, 8.8, 8.9])],
+                   :pix_size => [PixSize3.new([1.9, 2.0, 2.1]), PixSize3.new([2.2, 3.3, 4.4])],
+                   :unit => PosUnit.new('m'),
+                   :vel_time_unit => VelTimeUnit.new('s')
+                 )
+
+                 Velocity3D.new(
+                   :value => Value3.new([123.4, 345.6, 567.8]),
+                   :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 4.4])],
+                   :unit => PosUnit.new('m'),
+                  :vel_time_unit => VelTimeUnit.new('s')
+                 )
+
+                 Velocity3D.new(
+                  :unit => PosUnit.new('m'),
+                  :vel_time_unit => VelTimeUnit.new('s')
+                 )
+               end
+             
+               assert_raises ArgumentError do
+                 Velocity3D.new(:unit => PosUnit.new('m'))
+               end
+               assert_raises ArgumentError do
+                 Velocity3D.new(:vel_time_unit => VelTimeUnit.new('s'))
+               end
+
+               vc = Velocity3D.new(:unit => PosUnit.new('m'), :vel_time_unit => VelTimeUnit.new('s'))
+               assert_raises TypeError do
+                 vc.value = Error.new(10.2)
+               end
+
+               assert_raises TypeError do
+                 vc.error = Value.new(123.4)
+               end
+               assert_raises ArgumentError do
+                 vc.error = [Error3.new([123.4, 5.1, 2.2]), Error3.new([123.4, 5.1, 2.2]), Error3.new([123.4, 5.1, 2.2])]
+               end
+
+               assert_raises TypeError do
+                 vc.resolution = Error.new(10.2)
+               end
+               assert_raises ArgumentError do
+                 vc.resolution = [Resolution3.new([123.4, 123.5, 1.1]), Resolution3.new([123.4, 123.5, 1.1]), Resolution3.new([123.4, 123.5, 1.1])]
+               end
+
+               assert_raises TypeError do
+                 vc.size = Error.new(10.2)
+               end
+               assert_raises ArgumentError do
+                 vc.size = [Size3.new([123.4, 123.4, 123.4]), Size3.new([123.4, 123.4, 123.4]), Size3.new([123.4, 123.4, 123.4])]
+               end
+
+               assert_raises TypeError do
+                 vc.pix_size = Error.new(10.2)
+               end
+               assert_raises ArgumentError do
+                 vc.pix_size = [PixSize3.new([123.4, 123.4, 123.4]), PixSize3.new([123.4, 123.4, 123.4]), PixSize3.new([123.4, 123.4, 123.4])]
+               end
+             
+               assert_raises TypeError do
+                 vc.unit = VelTimeUnit.new('s')
+               end
+               assert_raises TypeError do
+                 vc.vel_time_unit = PosUnit.new('m')
+               end
+             end
+
+             def test_accessors
+               vc = Velocity3D.new(
+                 :name => 'MyCoordinate',
+                 :value => Value3.new([123.4, 345.6, 789.0]),
+                 :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 2.2])],
+                 :resolution => [Resolution3.new([0.1, 0.2, 0.5]), Resolution3.new([0.5, 0.6, 0.5])],
+                 :size => [Size3.new([10.1, 10.2, 1.1]), Size3.new([8.7, 8.8, 1.1])],
+                 :pix_size => [PixSize3.new([1.9, 2.0, 3.0]), PixSize3.new([2.2, 3.3, 4.1])],
+                 :unit => PosUnit.new('m'),
+                 :vel_time_unit => VelTimeUnit.new('s')
+               )
+
+               assert_equal 'MyCoordinate', vc.name
+               assert_equal Value3.new([123.4, 345.6, 789.0]), vc.value
+               assert_equal [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 2.2])], vc.error
+               assert_equal [Resolution3.new([0.1, 0.2, 0.5]), Resolution3.new([0.5, 0.6, 0.5])], vc.resolution
+               assert_equal [Size3.new([10.1, 10.2, 1.1]), Size3.new([8.7, 8.8, 1.1])], vc.size
+               assert_equal [PixSize3.new([1.9, 2.0, 3.0]), PixSize3.new([2.2, 3.3, 4.1])], vc.pix_size
+               assert_equal PosUnit.new('m'), vc.unit
+               assert_equal VelTimeUnit.new('s'), vc.vel_time_unit
+
+               vc.name = 'MyOtherCoordinate'
+               assert_equal 'MyOtherCoordinate', vc.name
+               vc.error = Error3.new([3.3, 4.4, 5.5])
+               assert_equal [Error3.new([3.3, 4.4, 5.5])], vc.error
+               vc.resolution = Resolution3.new([0.6, 0.7, 0.8])
+               assert_equal [Resolution3.new([0.6, 0.7, 0.8])], vc.resolution
+               vc.size = Size3.new([5.1, 5.2, 5.3])
+               assert_equal [Size3.new([5.1, 5.2, 5.3])], vc.size
+               vc.pix_size = PixSize3.new([3.1, 3.2, 3.3])
+               assert_equal [PixSize3.new([3.1, 3.2, 3.3])], vc.pix_size
+               vc.unit = PosUnit.new('lyr')
+               assert_equal PosUnit.new('lyr'), vc.unit
+               vc.vel_time_unit = VelTimeUnit.new('h')
+               assert_equal VelTimeUnit.new('h'), vc.vel_time_unit
+             end
+
+             def test_relationships
+               v = Velocity3D.new(:unit => PosUnit.new('m'), :vel_time_unit => VelTimeUnit.new('s'))
+               assert_kind_of Vector3Coordinate, v
+               assert_kind_of Velocity, v
+             end
+           
+             def test_xml
+               v1 = Velocity3D.new(
+                  :name => 'MyCoordinate',
+                  :value => Value3.new([123.4, 345.6, 789.0]),
+                  :error => [Error3.new([1.1, 2.2, 3.3]), Error3.new([2.2, 3.3, 2.2])],
+                  :resolution => [Resolution3.new([0.1, 0.2, 0.5]), Resolution3.new([0.5, 0.6, 0.5])],
+                  :size => [Size3.new([10.1, 10.2, 1.1]), Size3.new([8.7, 8.8, 1.1])],
+                  :pix_size => [PixSize3.new([1.9, 2.0, 3.0]), PixSize3.new([2.2, 3.3, 4.1])],
+                  :unit => PosUnit.new('m'),
+                  :vel_time_unit => VelTimeUnit.new('s')
+                )
+              
+                v2 = Velocity3D.from_xml(v1.to_xml)
+                assert_equal v1, v2
+             end
+           end
+         
+           class FitsTest < ::Test::Unit::TestCase
+             def test_constructor
+               assert_nothing_raised do 
+                 Fits.new(:uri => 'http://www.noao.edu/')
+                 Fits.new(:uri => 'http://www.noao.edu/', :hdu_num => 1)
+                 Fits.new(:uri => 'http://www.noao.edu/', :hdu_name => 'ext1')
+               end
+             end
+           
+             def test_accessors
+               f = Fits.new(:uri => 'http://www.noao.edu/', :hdu_num => 1, :hdu_name => 'ext1')
+               assert_equal URI.parse('http://www.noao.edu/'), f.uri
+               assert_equal 1, f.hdu_num
+               assert_equal 'ext1', f.hdu_name
+             
+               f.uri = 'http://www.stsci.edu/'
+               assert_equal URI.parse('http://www.stsci.edu/'), f.uri
+               f.hdu_num = 2
+               assert_equal 2, f.hdu_num
+               f.hdu_name = 'ext2'
+               assert_equal 'ext2', f.hdu_name
+             end
+           
+             def test_xml
+               f1 = Fits.new(:uri => 'http://www.noao.edu/', :hdu_name => 'ext1', :hdu_num => 1)
+             
+               f2 = Fits.from_xml(f1.to_xml)
+               assert_equal f1, f2
+             end
+           end
+         
+           class CoordFitsColumnsTest < ::Test::Unit::TestCase
+             def test_constructor
+               assert_nothing_raised do
+                 CoordFitsColumns.new(:name => 'column1')
+                 CoordFitsColumns.new(
+                  :name => 'column1',
+                  :value => 'OBJECT1',
+                  :error => 'ERROR1',
+                  :resolution => 'RESOLUTION1',
+                  :size => 'SIZE1',
+                  :pix_size => 'PIXSIZE1'
+                 )
+               end
+             
+               assert_raises ArgumentError do
+                 CoordFitsColumns.new
+               end
+             end
+           
+             def test_accessors
+               c = CoordFitsColumns.new(
+                 :name => 'column1',
+                 :value => 'OBJECT1',
+                 :error => 'ERROR1',
+                 :resolution => 'RESOLUTION1',
+                 :size => 'SIZE1',
+                 :pix_size => 'PIXSIZE1'
+               )
+               assert_equal 'column1', c.name
+               assert_equal 'OBJECT1', c.value
+               assert_equal 'ERROR1', c.error
+               assert_equal 'RESOLUTION1', c.resolution
+               assert_equal 'SIZE1', c.size
+               assert_equal 'PIXSIZE1', c.pix_size
+             
+               c.name = 'column2'
+               assert_equal 'column2', c.name
+               c.value = 'OBJECT2'
+               assert_equal 'OBJECT2', c.value
+               c.error = 'ERROR2'
+               assert_equal 'ERROR2', c.error
+               c.resolution = 'RESOLUTION2'
+               assert_equal 'RESOLUTION2', c.resolution
+               c.size = 'SIZE2'
+               assert_equal 'SIZE2', c.size
+               c.pix_size = 'PIXSIZE2'
+               assert_equal c.pix_size, 'PIXSIZE2'
+             end
+           
+             def test_xml
+               c1 = CoordFitsColumns.new(
+                  :name => 'column1',
+                  :value => 'OBJECT1',
+                  :error => 'ERROR1',
+                  :resolution => 'RESOLUTION1',
+                  :size => 'SIZE1',
+                  :pix_size => 'PIXSIZE1'
+                )
+            
+                c2 = CoordFitsColumns.from_xml(c1.to_xml('FITSPosition'))
+                assert_equal c1, c2
+             end
+           end
+         
+           class AstroCoordsFileTest < ::Test::Unit::TestCase
+             def test_constructor
+                assert_nothing_raised do
+                  AstroCoordsFile.new(:file => Fits.new(:uri => 'http://www.noao.edu/'))
+                  AstroCoordsFile.new(
+                    :file => Fits.new(:uri => 'http://www.noao.edu/'),
+                    :time => CoordFitsColumns.new(:name => 'col1'),
+                    :position => CoordFitsColumns.new(:name => 'col2'),
+                    :velocity => CoordFitsColumns.new(:name => 'col3'),
+                    :spectral => CoordFitsColumns.new(:name => 'col4'),
+                    :redshift => CoordFitsColumns.new(:name => 'col5')
+                  )
+                end
+              
+                assert_raises ArgumentError do
+                  AstroCoordsFile.new
+                end
+             end
+           
+             def test_accessors
+               c = AstroCoordsFile.new(
+                 :file => Fits.new(:uri => 'http://www.noao.edu/'),
+                 :time => CoordFitsColumns.new(:name => 'col1'),
+                 :position => CoordFitsColumns.new(:name => 'col2'),
+                 :velocity => CoordFitsColumns.new(:name => 'col3'),
+                 :spectral => CoordFitsColumns.new(:name => 'col4'),
+                 :redshift => CoordFitsColumns.new(:name => 'col5')
+               )
+             
+               assert_equal Fits.new(:uri => 'http://www.noao.edu/'), c.file
+               assert_equal CoordFitsColumns.new(:name => 'col1'), c.time
+               assert_equal CoordFitsColumns.new(:name => 'col2'), c.position
+               assert_equal CoordFitsColumns.new(:name => 'col3'), c.velocity
+               assert_equal CoordFitsColumns.new(:name => 'col4'), c.spectral
+               assert_equal CoordFitsColumns.new(:name => 'col5'), c.redshift
+             
+               c.file = Fits.new(:uri => 'http://www.stsci.edu/')
+               assert_equal Fits.new(:uri => 'http://www.stsci.edu/'), c.file
+               c.time = CoordFitsColumns.new(:name => 'col0')
+               assert_equal CoordFitsColumns.new(:name => 'col0'), c.time
+               c.position = CoordFitsColumns.new(:name => 'col1')
+               assert_equal CoordFitsColumns.new(:name => 'col1'), c.position
+               c.velocity = CoordFitsColumns.new(:name => 'col2')
+               assert_equal CoordFitsColumns.new(:name => 'col2'), c.velocity
+               c.spectral = CoordFitsColumns.new(:name => 'col3')
+               assert_equal CoordFitsColumns.new(:name => 'col3'), c.spectral
+               c.redshift = CoordFitsColumns.new(:name => 'col4')
+               assert_equal CoordFitsColumns.new(:name => 'col4'), c.redshift
+             end
+           
+             def test_xml
+               c1 = AstroCoordsFile.new(
+                  :file => Fits.new(:uri => 'http://www.noao.edu/'),
+                  :time => CoordFitsColumns.new(:name => 'col1'),
+                  :position => CoordFitsColumns.new(:name => 'col2'),
+                  :velocity => CoordFitsColumns.new(:name => 'col3'),
+                  :spectral => CoordFitsColumns.new(:name => 'col4'),
+                  :redshift => CoordFitsColumns.new(:name => 'col5')
+               )
+             
+               c2 = AstroCoordsFile.from_xml(c1.to_xml)
+               assert_equal c1, c2
+             end
+           end
+        
+           class CoordsTypeTest < ::Test::Unit::TestCase
+             def test_constructor
+               assert_nothing_raised do
+                 CoordsType.new(:coord_system_id => 'coord_ref')
+                 CoordsType.new(
+                  :coord_system_id => 'coord_ref',
+                  :coordinates => [PixelCoordinate.new(:value => 1.2), StringCoordinate.new(:value => 'column')]
+                 )
+               end
+             
+               assert_raises ArgumentError do
+                 ::CoordsType.new
+               end
+             end
+           
+             def test_accessor
+               c = CoordsType.new(
+                 :coord_system_id => 'coord_ref',
+                 :coordinates => [PixelCoordinate.new(:value => 1.2), StringCoordinate.new(:value => 'column')]
+               )
+             
+               assert_equal IdRef.new('coord_ref'), c.coord_system_id
+               assert_equal ListOfCoordinates.new([PixelCoordinate.new(:value => 1.2), StringCoordinate.new(:value => 'column')]), c.coordinates
+             
+               c.coord_system_id = 'coord_ref2'
+               assert_equal IdRef.new('coord_ref2'), c.coord_system_id
+               c.coordinates = [PixelCoordinate.new(:value => 1.2), StringCoordinate.new(:value => 'column'), PixelCoordinate.new(:value => 5.4)]
+               assert_equal(
+                ListOfCoordinates.new([PixelCoordinate.new(:value => 1.2), StringCoordinate.new(:value => 'column'), PixelCoordinate.new(:value => 5.4)]),
+                c.coordinates
+               )
+             end
+           end
+         
+           class AstroCoordsTypeTest < ::Test::Unit::TestCase
+             def test_constructor
+               assert_nothing_raised do
+                 AstroCoordsType.new(
+                  :coord_system_id => 'FK5-UTC-VEL',
+                  :time => TimeCoordinate.new(:name => 'Time'),
+                  :position => Position1D.new(:name => 'FK5Cart', :unit => PosUnit.new('m')),
+                  :velocity => Velocity1D.new(:name => 'Vel', :unit => PosUnit.new('m'), :vel_time_unit => VelTimeUnit.new('h')),
+                  :spectral => Spectral.new(:name => 'Spectrum'),
+                  :redshift => Redshift.new(:name => 'Redshift'),
+                  :coord_file => AstroCoordsFile.new(:file => Fits.new(:uri => 'http://www.noao.edu/'))
+                 )
+               end
+             
+               assert_raises ArgumentError do
+                 AstroCoordsType.new
+               end
+             end
+           
+             def test_accessors
+               c = AstroCoordsType.new(
+                 :coord_system_id => 'FK5-UTC-VEL',
+                 :time => TimeCoordinate.new(:name => 'Time'),
+                 :position => Position1D.new(:name => 'FK5Cart', :unit => PosUnit.new('m')),
+                 :velocity => Velocity1D.new(:name => 'Vel', :unit => PosUnit.new('m'), :vel_time_unit => VelTimeUnit.new('h')),
+                 :spectral => Spectral.new(:name => 'Spectrum'),
+                 :redshift => Redshift.new(:name => 'Redshift'),
+                 :coord_file => AstroCoordsFile.new(:file => Fits.new(:uri => 'http://www.noao.edu/'))
+               )
+              
+               assert_equal IdRef.new('FK5-UTC-VEL'), c.coord_system_id
+               assert_equal TimeCoordinate.new(:name => 'Time'), c.time
+               assert_equal Position1D.new(:name => 'FK5Cart', :unit => PosUnit.new('m')), c.position
+               assert_equal Velocity1D.new(:name => 'Vel', :unit => PosUnit.new('m'), :vel_time_unit => VelTimeUnit.new('h')), c.velocity
+               assert_equal Spectral.new(:name => 'Spectrum'), c.spectral
+               assert_equal Redshift.new(:name => 'Redshift'), c.redshift
+               assert_equal AstroCoordsFile.new(:file => Fits.new(:uri => 'http://www.noao.edu/')), c.coord_file
+             
+               c.coord_system_id = 'FK5-LOCAL-VEL'
+               assert_equal IdRef.new('FK5-LOCAL-VEL'), c.coord_system_id
+               c.time = TimeCoordinate.new(:name => 'Time1')
+               assert_equal TimeCoordinate.new(:name => 'Time1'), c.time
+               c.position = Position1D.new(:name => 'FK5Cart', :unit => PosUnit.new('lyr'))
+               assert_equal Position1D.new(:name => 'FK5Cart', :unit => PosUnit.new('lyr')), c.position
+               c.velocity = Velocity1D.new(:name => 'Vel', :unit => PosUnit.new('lyr'), :vel_time_unit => VelTimeUnit.new('s'))
+               assert_equal Velocity1D.new(:name => 'Vel', :unit => PosUnit.new('lyr'), :vel_time_unit => VelTimeUnit.new('s')), c.velocity
+               c.spectral = Spectral.new(:name => 'Spectrum1')
+               assert_equal Spectral.new(:name => 'Spectrum1'), c.spectral
+               c.redshift = Redshift.new(:name => 'Redshift1')
+               assert_equal Redshift.new(:name => 'Redshift1'), c.redshift
+               c.coord_file = AstroCoordsFile.new(:file => Fits.new(:uri => 'http://www.stsci.edu/'))
+               assert_equal AstroCoordsFile.new(:file => Fits.new(:uri => 'http://www.stsci.edu/')), c.coord_file
+             end
+           
+             def test_relationships
+               c = AstroCoordsType.new(:coord_system_id => 'FK5-UTC-VEL')
+               assert_kind_of CoordsType, c
+             end
+           end
+         
+           class AstroCoordsTest < ::Test::Unit::TestCase
+             def test_xml
+               c1 = AstroCoords.new(
+                  :coord_system_id => 'FK5-UTC-VEL',
+                  :time => TimeCoordinate.new(:name => 'Time'),
+                  :position => Position1D.new(:name => 'FK5Cart', :unit => PosUnit.new('m')),
+                  :velocity => Velocity1D.new(:name => 'Vel', :unit => PosUnit.new('m'), :vel_time_unit => VelTimeUnit.new('h')),
+                  :spectral => Spectral.new(:name => 'Spectrum'),
+                  :redshift => Redshift.new(:name => 'Redshift'),
+                  :coord_file => AstroCoordsFile.new(:file => Fits.new(:uri => 'http://www.noao.edu/'))
+                )
+              
+                c2 = AstroCoords.from_xml(c1.to_xml)
+                assert_equal c1, c2
+             end
+           end
+         
+           class PixelCoordsTypeTest < ::Test::Unit::TestCase
+             def test_initialize
+               assert_nothing_raised do
+                 PixelCoordsType.new(
+                 :coordinates => [PixelCoordinate.new(:value => 2.3)],
+                 :coord_system_id => IdRef.new('ref')
+                )
+               end
+             
+               assert_raises ArgumentError do
+                 PixelCoordsType.new
+               end
+             
+               assert_raises RuntimeError do
+                 PixelCoordsType.new(
+                  :coordinates => [],
+                  :coord_system_id => IdRef.new('ref')
+                 )
+               end
+             end
+           
+             def test_accessors
+               c = PixelCoordsType.new(
+                :coordinates => [PixelCoordinate.new(:value => 2.3)],
+                :coord_system_id => IdRef.new('ref')
+               )
+             
+               assert_equal ListOfPixelCoordinates.new([PixelCoordinate.new(:value => 2.3)]), c.coordinates
+               assert_equal IdRef.new('ref'), c.coord_system_id
+             
+               c.coordinates = [PixelCoordinate.new(:value => 2.3), PixelCoordinate.new(:value => 1.1)]
+               assert_equal ListOfPixelCoordinates.new([PixelCoordinate.new(:value => 2.3), PixelCoordinate.new(:value => 1.1)]), c.coordinates
+               c.coord_system_id = 'ref2'
+               assert_equal IdRef.new('ref2'), c.coord_system_id
+             end
+           
+             def test_relationships
+               assert_kind_of CoordsType, PixelCoordsType.new(:coord_system_id => IdRef.new('ref'))
+             end
+           end
+         
+           class PixelCoordsTest < ::Test::Unit::TestCase
+             def test_xml
+               c1 = PixelCoords.new(
+                 :coordinates => [PixelCoordinate.new(:value => 2.3, :name => 'pixcoord1')],
+                 :coord_system_id => IdRef.new('ref')
+                )
+             
+               c2 = PixelCoords.from_xml(c1.to_xml)
+               assert_equal c1, c2
+             end
+           end
+         
+        end
+      end
+    end
+  end
+end