voruby 1.0.1

data/test/stc/unittest_v1_20.rb

@@ -0,0 +1,620 @@
+require 'test/unit'
+
+require 'voruby/stc/stc_v1_20'
+
+include VORuby::STC::V1_20
+
+class STCTest < Test::Unit::TestCase
+  def test_space_frame
+    frame = nil
+    assert_nothing_raised {
+      frame = SpaceFrame.load_from_xml(
+        REXML::Document.new(
+          '<SpaceFrame>' +
+            '<Name>GeoLongLatElev</Name>' +
+            '<GEO_D/>' +
+            '<TOPOCENTER/>' +
+            '<SPHERICAL coord_naxes="3"/>' +
+            '<OffsetCenter><Value>23.2</Value></OffsetCenter>' +
+          '</SpaceFrame>').root
+      )
+    }
+    
+    assert_equal('GeoLongLatElev', frame.value.name)
+    assert_equal(true, frame.value.space_ref_frame.is_a?(GEO_D))
+    assert_equal(true, frame.value.reference_position.is_a?(TOPOCENTER))
+    assert_equal(true, frame.value.coord_flavor.is_a?(SPHERICAL))
+    assert_equal(3, frame.value.coord_flavor.value.coord_naxes)
+    assert_equal(23.2, frame.value.offset_center.value)
+  end
+  
+  def test_time_frame
+    frame = nil
+    assert_nothing_raised {
+      frame = TimeFrame.load_from_xml(
+        REXML::Document.new(
+          '<TimeFrame>' +
+            '<Name>CrazyTime</Name>' +
+            '<TimeScale>LOCAL</TimeScale>' +
+            '<HELIOCENTER />' +
+          '</TimeFrame>').root
+      )
+    }
+    
+    assert_equal('CrazyTime', frame.value.name)
+    assert_equal('LOCAL', frame.value.time_scale.value)
+    assert_equal(true, frame.value.reference_position.is_a?(HELIOCENTER))
+  end
+  
+  def test_astro_coord_area
+    area = nil
+    assert_nothing_raised {
+      area = AstroCoordArea.load_from_xml(
+        REXML::Document.new(
+          '<AstroCoordArea ID="myID" coord_system_id="myCoordSystem">' +
+            '<Sphere unit="deg" radius_unit="deg">' +
+              '<Radius>23</Radius>' +
+              '<Center>0 0 0</Center>' +
+            '</Sphere>' +
+            '<VelocityInterval unit="m" vel_time_unit="s">' +
+              '<CoordScalarInterval>' +
+                '<LoLimit>0</LoLimit>' +
+                '<HiLimit>10</HiLimit>' +
+              '</CoordScalarInterval>' +
+            '</VelocityInterval>' +
+            '<CoordScalarInterval>' +
+              '<LoLimit>0</LoLimit>' +
+              '<HiLimit>10</HiLimit>' + 
+            '</CoordScalarInterval>' +
+            '<CoordScalarInterval>' +
+              '<LoLimit>10</LoLimit>' +
+              '<HiLimit>50</HiLimit>' +
+            '</CoordScalarInterval>' +
+          '</AstroCoordArea>').root
+      )
+    }
+    
+    assert_equal('myID', area.value.coord_area_id)
+    assert_equal('myCoordSystem', area.value.coord_system_id)
+    
+    assert_equal('deg', area.value.spatial_interval.value.unit.value)
+    assert_equal('deg', area.value.spatial_interval.value.radius_unit.value)
+    assert_equal(23, area.value.spatial_interval.value.radius)
+    assert_equal([0, 0, 0], area.value.spatial_interval.value.center.value)
+    
+    assert_equal(0, area.value.coord_intervals[0].value.lo_limit)
+    assert_equal(10, area.value.coord_intervals[0].value.hi_limit)
+    assert_equal(10, area.value.coord_intervals[1].value.lo_limit)
+    assert_equal(50, area.value.coord_intervals[1].value.hi_limit)
+    
+    assert_equal('m', area.value.vel_intervals[0].value.unit.value)
+    assert_equal('s', area.value.vel_intervals[0].value.vel_time_unit.value)
+    assert_equal(10, area.value.vel_intervals[0].value.coord_interval.value.hi_limit)
+  end
+  
+  def test_stc_resoure_profile
+    profile = nil
+    assert_nothing_raised {
+      profile = STCResourceProfile.load_from_file('test/stc/stc_resource_profile_v1_20.xml')
+    }
+    
+    coord_sys = profile.value.coord_sys[0].value
+    assert_equal('ICRS-TT-CXO', coord_sys.coord_sys_type_id)
+    assert_equal('Time', coord_sys.time_frame.value.name)
+    assert_equal('TT', coord_sys.time_frame.value.time_scale.value)
+    assert_equal(TOPOCENTER, coord_sys.time_frame.value.reference_position.class)
+    assert_equal('Space', coord_sys.space_frame.value.name)
+    assert_equal(ICRS, coord_sys.space_frame.value.space_ref_frame.class)
+    assert_equal(TOPOCENTER, coord_sys.space_frame.value.reference_position.class)
+    assert_equal(SPHERICAL, coord_sys.space_frame.value.coord_flavor.class)
+    assert_equal(2, coord_sys.space_frame.value.coord_flavor.value.coord_naxes)
+    assert_equal('Energy', coord_sys.spectral_frame.value.name)
+    assert_equal(TOPOCENTER, coord_sys.spectral_frame.value.reference_position.class)
+    
+    coords = profile.value.coords[0].value
+    assert_equal('ICRS-TT-CXO', coords.coord_system_id)
+    assert_equal('s', coords.time.unit.value)
+    assert_equal('Time', coords.time.name)
+    assert_equal(0.0001, coords.time.error[0].value)
+    assert_equal([0.000016, 3.0], coords.time.resolution.collect{ |res| res.value })
+    assert_equal([1000, 170000], coords.time.size.collect{ |size| size.value })
+    assert_equal('Position', coords.position.name)
+    assert_equal([1.0, 1.0], coords.position.error[0].value.value)
+    assert_equal([0.5, 0.5], coords.position.resolution[0].value.value)
+    assert_equal([1000, 1000], coords.position.size[0].value.value)
+    assert_equal([4000, 4000], coords.position.size[1].value.value)
+    assert_equal('keV', coords.spectral.unit.value)
+    assert_equal('Energy', coords.spectral.name)
+    assert_equal(0.1, coords.spectral.error[0].value)
+    assert_equal(0.02, coords.spectral.resolution[0].value)
+    assert_equal(2.0, coords.spectral.resolution[1].value)
+    assert_equal(2, coords.spectral.size[0].value)
+    assert_equal(10, coords.spectral.size[1].value)
+    
+    coord_area = profile.value.coord_area[0].value
+    assert_equal('AllSky-CXO', coord_area.coord_area_id)
+    assert_equal('ICRS-TT-CXO', coord_area.coord_system_id)
+    assert_equal('TT', coord_area.time_intervals[0].start_time.timescale.value)
+    assert_equal('1999-07-23T16:00:00', coord_area.time_intervals[0].start_time.absolute_time.value.strftime('%Y-%m-%dT%H:%M:%S'))
+    assert_equal(true, coord_area.spatial_interval.value.region.is_a?(AllSky))
+    assert_equal(0.02, coord_area.spatial_interval.value.region.value.fill_factor)
+    assert_equal('keV', coord_area.spectral_intervals[0].unit.value)
+    assert_equal(0.12, coord_area.spectral_intervals[0].lo_limit)
+    assert_equal(10.0, coord_area.spectral_intervals[0].hi_limit)
+  end
+  
+  def test_catalog_entry_location
+    catalog = nil
+    assert_nothing_raised {
+      catalog = CatalogEntryLocation.load_from_file('test/stc/catalog_entry_location_v1_20.xml')
+    }
+    
+    coord_sys1 = catalog.value.coord_sys[0].value
+    assert_equal('B1950-OPTICAL-ET', coord_sys1.coord_sys_type_id)
+    assert_equal('Time', coord_sys1.time_frame.value.name)
+    assert_equal('ET', coord_sys1.time_frame.value.time_scale.value)
+    assert_equal(true, coord_sys1.time_frame.value.reference_position.is_a?(TOPOCENTER))
+    assert_equal('PosEq', coord_sys1.space_frame.value.name)
+    assert_equal('B1950.0', coord_sys1.space_frame.value.space_ref_frame.value.equinox.value)
+    assert_equal(true, coord_sys1.space_frame.value.reference_position.is_a?(BARYCENTER))
+    assert_equal(true, coord_sys1.space_frame.value.coord_flavor.is_a?(SPHERICAL))
+    assert_equal(2, coord_sys1.space_frame.value.coord_flavor.value.coord_naxes)
+    assert_equal(true, coord_sys1.space_frame.value.coord_flavor.value.coord_vel)
+    assert_equal('Optical', coord_sys1.spectral_frame.value.name)
+    assert_equal(true, coord_sys1.spectral_frame.value.reference_position.is_a?(TOPOCENTER))
+    assert_equal('DopplerVelocity', coord_sys1.redshift_frame.value.name)
+    assert_equal('OPTICAL', coord_sys1.redshift_frame.value.doppler_definition.value)
+    assert_equal(true, coord_sys1.redshift_frame.value.reference_position.is_a?(BARYCENTER))
+    
+    coord1 = catalog.value.coords[0].value
+    assert_equal('B1950-OPTICAL-ET', coord1.coord_system_id)
+    assert_equal('deg', coord1.position.unit.value)
+    assert_equal('RA,Dec', coord1.position.name)
+    assert_equal('Column3', coord1.position.value.value)
+    assert_equal('Column4', coord1.position.error[0].value)
+    assert_equal('Column5', coord1.position.size[0].value)
+    assert_equal('km', coord1.redshift.unit.value)
+    assert_equal('s', coord1.redshift.vel_time_unit.value)
+    assert_equal('Vrad(barycenter)', coord1.redshift.name)
+    assert_equal('Column6', coord1.redshift.value.value)
+    assert_equal('Column7', coord1.redshift.error[0].value)
+    
+    coord_area1 = catalog.value.coord_area[0].value
+    assert_equal('B1950-OPTICAL-ET', coord_area1.coord_system_id)
+    assert_equal('RA6-18hDec20-70deg', coord_area1.coord_area_id)
+    assert_equal('ET', coord_area1.time_intervals[0].start_time.timescale.value)
+    assert_equal('1968-05-23T00:00:00Z', coord_area1.time_intervals[0].start_time.absolute_time.value.to_s)
+    assert_equal('ET', coord_area1.time_intervals[0].end_time.timescale.value)
+    assert_equal('1971-02-17T00:00:00Z', coord_area1.time_intervals[0].end_time.absolute_time.value.to_s)
+    assert_equal(true, coord_area1.spatial_interval.value.region.is_a?(Polygon))
+    assert_equal('deg', coord_area1.spatial_interval.value.region.value.unit.value)
+    assert_equal([270, 70], coord_area1.spatial_interval.value.region.value.vertices[3].position.value)
+    assert_equal(true, coord_area1.spatial_interval.value.region.value.vertices[3].small_circle.is_a?(SmallCircleType))
+    assert_equal('Angstrom', coord_area1.spectral_intervals[0].unit.value)
+    assert_equal(5000, coord_area1.spectral_intervals[0].lo_limit)
+    assert_equal(6500, coord_area1.spectral_intervals[0].hi_limit)
+    assert_equal('km', coord_area1.redshift_intervals[0].unit.value)
+    assert_equal('s', coord_area1.redshift_intervals[0].vel_time_unit.value)
+    assert_equal(10000, coord_area1.redshift_intervals[0].hi_limit)
+  end
+  
+  def test_obs_data_location
+    obs_data = nil
+    assert_nothing_raised {
+      obs_data = ObsDataLocation.load_from_file('test/stc/obs_data_location_v1_20.xml')
+    }
+    
+    observ_loc = obs_data.value.observatory_location
+    assert_equal('KPNO', observ_loc.type_id)
+    assert_equal('ICRS-TT-TOPO', observ_loc.coord_sys[0].value.coord_sys_type_id)
+    assert_equal('Time', observ_loc.coord_sys[0].value.time_frame.value.name)
+    assert_equal('GeoLongLatElev', observ_loc.coord_sys[0].value.space_frame.value.name)
+    assert_equal('KPNO', observ_loc.coords.value.coord_system_id)
+    assert_equal('deg deg m', observ_loc.coords.value.position.unit.value)
+    assert_equal('LongLatElev', observ_loc.coords.value.position.name)
+    
+    obs_loc = obs_data.value.observation_location
+    assert_equal('M81', obs_loc.type_id)
+    assert_equal('ICRS-TT-WAVELENGTH-TOPO', obs_loc.coord_sys[0].value.coord_sys_type_id)
+    assert_equal('TT', obs_loc.coord_sys[0].value.time_frame.value.time_scale.value)
+    assert_equal(true, obs_loc.coord_sys[0].value.space_frame.value.reference_position.is_a?(TOPOCENTER))
+    assert_equal('Wavelength', obs_loc.coord_sys[0].value.spectral_frame.value.name)
+    assert_equal('ICRS-TT-WAVELENGTH-TOPO', obs_loc.coords.value.coord_system_id)
+    assert_equal('2004-07-15T08:23:56', obs_loc.coords.value.time.time_instant.absolute_time.value.strftime('%Y-%m-%dT%H:%M:%S'))
+    assert_equal([148.88821, 69.06529], obs_loc.coords.value.position.value.value.value)
+    assert_equal(400, obs_loc.coords.value.spectral.resolution[0].value)
+    assert_equal('M81Image', obs_loc.coord_area.value.coord_area_id)
+    assert_equal('TT', obs_loc.coord_area.value.time_intervals[0].start_time.timescale.value)
+    assert_equal([148.18821, 68.81529], obs_loc.coord_area.value.spatial_interval.value.coord_interval.value.lo_limit_2vec.value)
+    assert_equal(4400, obs_loc.coord_area.value.spectral_intervals[0].lo_limit)
+    
+    pix_space = obs_data.value.pixel_space
+    assert_equal('M81Pix', pix_space.coord_sys.value.coord_sys_type_id)
+    assert_equal('Y', pix_space.coord_sys.value.coord_frames[1].value.name)
+    assert_equal(1024, pix_space.coord_area.value.coord_intervals[0].value.hi_limit)
+  end
+  
+  def test_search_location
+    loc = nil
+    assert_nothing_raised {
+      loc = SearchLocation.load_from_file('test/stc/search_location_v1_20.xml')
+    }
+  end
+end
+
+class RegionTest < Test::Unit::TestCase
+  def test_circle
+    region = nil
+    assert_nothing_raised {
+      region = Circle.load_from_xml(
+        REXML::Document.new(
+          '<Circle unit="deg">' +
+            '<Center>233.73 23.49</Center>' +
+            '<Radius>1.0</Radius>' +
+          '</Circle>').root
+        )
+    }
+    
+    assert_equal('deg', region.value.unit.value)
+    assert_equal([233.73, 23.49], region.value.center.value)
+    assert_equal(1.0, region.value.radius)
+  end
+  
+  def test_all_sky
+    region = nil
+    assert_nothing_raised {
+      region = AllSky.load_from_xml(
+        REXML::Document.new(
+          '<AllSky fill_factor="0.3" note="My note" />').root
+        )
+    }
+    
+    assert_equal(0.3, region.value.fill_factor)
+    assert_equal('My note', region.value.note)
+  end
+  
+  def test_ellipse
+    region = nil
+    assert_nothing_raised {
+      region = Ellipse.load_from_xml(
+        REXML::Document.new(
+          '<Ellipse unit="deg">' +
+            '<Center>233.73 23.49</Center>' +
+            '<Radius>1.0</Radius>' +
+            '<MinorRadius>10</MinorRadius>' +
+            '<PosAngle reference="X">23.2</PosAngle>' +
+          '</Ellipse>').root
+        )
+    }
+    
+    assert_equal('deg', region.value.unit.value)
+    assert_equal([233.73, 23.49], region.value.center.value)
+    assert_equal(1.0, region.value.radius)
+    assert_equal(10, region.value.minor_radius)
+    assert_equal('X', region.value.pos_angle.reference.value)
+    assert_equal(23.2, region.value.pos_angle.value)
+  end
+  
+  def test_polygon
+    region = nil
+    assert_nothing_raised {
+      region = Polygon.load_from_xml(
+        REXML::Document.new(
+          '<Polygon>' +
+            '<Vertex><Position>12.3 3.1</Position></Vertex>' +
+            '<Vertex><Position>13.1 6.2</Position></Vertex>' +
+            '<Vertex><Position>15.6 11.3</Position></Vertex>' +
+          '</Polygon>').root
+        )
+    }
+    
+    assert_equal([12.3, 3.1], region.value.vertices[0].position.value)
+    assert_equal([13.1, 6.2], region.value.vertices[1].position.value)
+    assert_equal([15.6, 11.3], region.value.vertices[2].position.value)
+  end
+  
+  def test_box
+    region = nil
+    assert_nothing_raised {
+      region = Box.load_from_xml(
+        REXML::Document.new(
+          '<Box>' +
+            '<Center>56 72</Center>' +
+            '<Size>10 23</Size>' +
+          '</Box>').root
+      )
+    }
+    
+    assert_equal([56, 72], region.value.center.value)
+    assert_equal([10, 23], region.value.size.value)
+  end
+  
+  def test_sector
+    region = nil
+    assert_nothing_raised {
+      region = Sector.load_from_xml(
+        REXML::Document.new(
+          '<Sector>' +
+            '<Position>12.4 10.2</Position>' +
+            '<PosAngle1>2.0</PosAngle1>' +
+            '<PosAngle2>33.1</PosAngle2>' +
+          '</Sector>').root
+        )
+    }
+    
+    assert_equal([12.4, 10.2], region.value.position.value)
+    assert_equal(2.0, region.value.pos_angle1.value)
+    assert_equal(33.1, region.value.pos_angle2.value)
+  end
+  
+  def test_convex
+    region = nil
+    assert_nothing_raised {
+      region = Convex.load_from_xml(
+        REXML::Document.new(
+          '<Convex>' +
+            '<Constraint><Offset>0.5</Offset><Vector>4 6 8</Vector></Constraint>' +
+            '<Constraint><Offset>0.1</Offset><Vector>10 12 14</Vector></Constraint>' +
+          '</Convex>').root
+        )
+    }
+    
+    assert_equal(0.5, region.value.constraints[0].offset)
+    assert_equal([4, 6, 8], region.value.constraints[0].vector.value)
+    assert_equal(0.1, region.value.constraints[1].offset)
+    assert_equal([10, 12, 14], region.value.constraints[1].vector.value)
+  end
+  
+  def test_convex_hull
+    region = nil
+    assert_nothing_raised {
+      region = ConvexHull.load_from_xml(
+        REXML::Document.new(
+          '<ConvexHull>' +
+            '<Point>1.2 3.4 5.6</Point><Point>6.7 8.9 10.11</Point>' +
+          '</ConvexHull>').root
+        )
+    }
+    
+    assert_equal([1.2, 3.4, 5.6], region.value.points[0].value)
+    assert_equal([6.7, 8.9, 10.11], region.value.points[1].value)
+  end
+  
+  def test_union
+    region = nil
+    assert_nothing_raised {
+      region = Union.load_from_xml(
+        REXML::Document.new(
+          '<Union>' +
+            '<Region>' +
+              '<Circle unit="deg">' +
+                '<Center>233.73 23.49</Center>' +
+                '<Radius>1.0</Radius>' +
+              '</Circle>' +
+            '</Region>' +
+            '<Region>' +
+              '<Circle unit="deg">' +
+                '<Center>223.73 53.49</Center>' +
+                '<Radius>20.0</Radius>' +
+              '</Circle>' +
+            '</Region>' +
+          '</Union>').root
+        )
+    }
+    
+    assert_equal([233.73, 23.49], region.value.regions[0].center.value)
+    assert_equal(1.0, region.value.regions[0].radius)
+    assert_equal([223.73, 53.49], region.value.regions[1].center.value)
+    assert_equal(20.0, region.value.regions[1].radius)
+  end
+  
+  def test_intersection
+    region = nil
+    assert_nothing_raised {
+      region = Intersection.load_from_xml(
+        REXML::Document.new(
+          '<Intersection>' +
+            '<Region>' +
+              '<Circle unit="deg">' +
+                '<Center>233.73 23.49</Center>' +
+                '<Radius>1.0</Radius>' +
+              '</Circle>' +
+            '</Region>' +
+            '<Region>' +
+              '<Box>' +
+                '<Center>56 72</Center>' +
+                '<Size>10 23</Size>' +
+              '</Box>' +
+            '</Region>' +
+          '</Intersection>').root
+        )
+    }
+    
+    assert_equal([233.73, 23.49], region.value.regions[0].center.value)
+    assert_equal(1.0, region.value.regions[0].radius)
+    assert_equal([56, 72], region.value.regions[1].center.value)
+    assert_equal([10, 23], region.value.regions[1].size.value)
+  end
+  
+  def test_negation
+    region = nil
+    assert_nothing_raised {
+      region = Negation.load_from_xml(
+        REXML::Document.new(
+          '<Negation>' +
+            '<Region>' +
+              '<Circle unit="deg">' +
+                '<Center>233.73 23.49</Center>' +
+                '<Radius>1.0</Radius>' +
+              '</Circle>' +
+            '</Region>' +
+          '</Negation>').root
+        )
+      }
+      
+      assert_equal([233.73, 23.49], region.value.region.center.value)
+      assert_equal(1.0, region.value.region.radius)
+  end
+ 
+end
+
+class CoordsTest < Test::Unit::TestCase
+  def test_astron_time_type
+    type = nil
+    assert_nothing_raised {
+      type = AstronTimeType.load_from_xml(
+        REXML::Document.new(
+          '<AstronTime>' +
+            '<Timescale>LOCAL</Timescale>' +
+            '<TimeOffset unit="s">12.2</TimeOffset>' +
+            '<ISOTime>2006-09-07T15:32:51</ISOTime>' +
+          '</AstronTime>').root
+      )
+    }
+        
+    assert_equal('LOCAL', type.timescale.value)
+    assert_equal('s', type.relative_time.unit.value)
+    assert_equal(12.2, type.relative_time.value)
+    assert_equal('2006-09-07T15:32:51', type.absolute_time.value.strftime('%Y-%m-%dT%H:%M:%S'))
+  end
+  
+  def test_scalar_coordinate_type
+    type = nil
+    assert_nothing_raised {
+      type = ScalarCoordinateType.load_from_xml(
+        REXML::Document.new(
+          '<ScalarCoordinate>' +
+            '<Name>Comment</Name>' +
+            '<Value>23.2</Value>' +
+            '<Error>0.1</Error><Error>0.5</Error>' +
+            '<Resolution>0.5</Resolution><Resolution>0.8</Resolution>' +
+            '<Size>5</Size><Size>10</Size>' +
+            '<PixSize>0.3</PixSize><PixSize>0.4</PixSize>' +
+          '</ScalarCoordinate>').root
+      )
+    }
+    
+    assert_equal(23.2, type.value.value)
+    assert_equal(0.1, type.error[0].value)
+    assert_equal(0.5, type.error[1].value)
+    assert_equal(0.5, type.resolution[0].value)
+    assert_equal(0.8, type.resolution[1].value)
+    assert_equal(5, type.size[0].value)
+    assert_equal(10, type.size[1].value)
+    assert_equal(0.3, type.pix_size[0].value)
+    assert_equal(0.4, type.pix_size[1].value)
+  end
+  
+  def test_time_coordinate_type
+    type = nil
+    assert_nothing_raised {
+      type = TimeCoordinateType.load_from_xml(
+        REXML::Document.new(
+          '<Time>' +
+            '<Name>Blah</Name>' +
+            '<TimeInstant>' +
+              '<Timescale>LOCAL</Timescale>' +
+              '<TimeOffset unit="s">12.2</TimeOffset>' +
+              '<ISOTime>2006-09-07T15:32:51</ISOTime>' +
+            '</TimeInstant>' +
+            '<Error>0.1</Error><Error>0.5</Error>' +
+            '<Resolution>0.5</Resolution><Resolution>0.8</Resolution>' +
+            '<Size>5</Size><Size>10</Size>' +
+            '<PixSize>0.3</PixSize><PixSize>0.4</PixSize>' +
+          '</Time>').root
+      )
+    }
+    
+    assert_equal('LOCAL', type.time_instant.timescale.value)
+    assert_equal('s', type.time_instant.relative_time.unit.value)
+    assert_equal(12.2, type.time_instant.relative_time.value)
+    assert_equal('2006-09-07T15:32:51', type.time_instant.absolute_time.value.strftime('%Y-%m-%dT%H:%M:%S'))
+    assert_equal(0.1, type.error[0].value)
+    assert_equal(0.5, type.error[1].value)
+    assert_equal(0.5, type.resolution[0].value)
+    assert_equal(0.8, type.resolution[1].value)
+    assert_equal(5, type.size[0].value)
+    assert_equal(10, type.size[1].value)
+    assert_equal(0.3, type.pix_size[0].value)
+    assert_equal(0.4, type.pix_size[1].value)
+  end
+  
+  def test_size2_type
+    type = nil
+    assert_nothing_raised {
+      type = Size2Type.load_from_xml(
+        REXML::Document.new(
+          '<Size2>' +
+            '<Size>2 4</Size>' +
+            '<PosAngle unit="deg" reference="X">35</PosAngle>' +
+          '</Size2>').root
+      )
+    }
+    
+    assert_equal(2, type.size.value[0])
+    assert_equal(4, type.size.value[1])
+    assert_equal('deg', type.pos_angle.unit.value)
+    assert_equal('X', type.pos_angle.reference.value)
+    assert_equal(35, type.pos_angle.value)
+  end
+  
+  def test_vector2_coordinate_type
+    type = nil
+    assert_nothing_raised {
+      type = Vector2CoordinateType.load_from_xml(
+        REXML::Document.new(
+          '<Vector2Coordinate>' +
+            '<Name>Blah</Name>' +
+            '<Value2>23.2 2.3</Value2>' +
+            '<Error2>0.1 0.1</Error2><Error2>0.5 0.5</Error2>' +
+            '<Resolution2>0.5 1</Resolution2><Resolution2>0.8 1.1</Resolution2>' +
+            '<Size2>5 4</Size2><Size2>10 2</Size2>' +
+            '<PixSize2>0.3 0.2</PixSize2><PixSize2>0.4 0.2</PixSize2>' +
+          '</Vector2Coordinate>').root
+      )
+    }
+    
+    assert_equal(23.2, type.value.value.value[0])
+    assert_equal(2.3, type.value.value.value[1])
+    assert_equal(0.1, type.error[0].value.value[0])
+    assert_equal(0.1, type.error[0].value.value[1])
+    assert_equal(0.5, type.error[1].value.value[0])
+    assert_equal(0.5, type.error[1].value.value[1])
+    assert_equal(0.5, type.resolution[0].value.value[0])
+    assert_equal(1, type.resolution[0].value.value[1])
+    assert_equal(0.8, type.resolution[1].value.value[0])
+    assert_equal(1.1, type.resolution[1].value.value[1])
+    assert_equal(5, type.size[0].value.value[0])
+    assert_equal(4, type.size[0].value.value[1])
+    assert_equal(10, type.size[1].value.value[0])
+    assert_equal(2, type.size[1].value.value[1])
+    assert_equal(0.3, type.pix_size[0].value.value[0])
+    assert_equal(0.2, type.pix_size[0].value.value[1])
+    assert_equal(0.4, type.pix_size[1].value.value[0])
+    assert_equal(0.2, type.pix_size[1].value.value[1])
+  end
+  
+  def test_size3_type
+    type = nil
+    assert_nothing_raised {
+      type = Size3Type.load_from_xml(
+        REXML::Document.new(
+          '<Size3>' +
+            '<Size>2 4 6</Size>' +
+            '<PosAngle1 unit="deg" reference="X">35</PosAngle1>' +
+            '<PosAngle2 unit="deg" reference="X">21.1</PosAngle2>' +
+          '</Size3>').root
+      )
+    }
+    
+    assert_equal(2, type.size.value[0])
+    assert_equal(4, type.size.value[1])
+    assert_equal(6, type.size.value[2])
+    assert_equal('deg', type.pos_angle1.unit.value)
+    assert_equal('X', type.pos_angle1.reference.value)
+    assert_equal(35, type.pos_angle1.value)
+    assert_equal('deg', type.pos_angle2.unit.value)
+    assert_equal('X', type.pos_angle2.reference.value)
+    assert_equal(21.1, type.pos_angle2.value)
+  end
+end