voruby 1.1.1 → 2.0.0

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

@@ -0,0 +1,993 @@
+require 'voruby/stc/1.10/region'
+require 'test/unit'
+
+include VORuby::STC::V1_10::Region
+
+module VORuby
+  module STC
+    module V1_10
+      module Region
+        module Test
+        
+          class RegionTypeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                RegionType.new(:fill_factor => 0.1, :note => 'My note')
+                RegionType.new(:fill_factor => 0.1)
+                RegionType.new(:note => 'My Note')
+                RegionType.new
+              }
+            
+              assert_raises ArgumentError do
+                RegionType.new(:fill_factor => 2.0)
+              end
+            
+              assert_raises ArgumentError do
+                RegionType.new(:fill_factor => 'blah')
+              end
+            end
+          
+            def test_accessors
+              reg = RegionType.new(:fill_factor => 0.4, :note => 'My note')
+            
+              assert_equal 0.4, reg.fill_factor
+              assert_equal 'My note', reg.note
+            
+              reg.fill_factor = 0.5
+              assert_equal 0.5, reg.fill_factor
+              reg.note = 'A note'
+              assert_equal 'A note', reg.note
+            
+              reg = RegionType.new
+              assert_equal 1.0, reg.fill_factor
+            end
+          end
+        
+          class ShapeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                Shape.new(:coord_system_id => 'system1', :unit => 'm')
+              }
+              
+              assert_raises ArgumentError do
+                Shape.new(:unit => 'm')
+              end
+              assert_raises ArgumentError do
+                Shape.new
+              end
+            end
+            
+            def test_accessors
+              shape = Shape.new(:coord_system_id => 'system1', :unit => 'm')
+              
+              assert_equal IdRef.new('system1'), shape.coord_system_id
+              assert_equal PosUnit.new('m'), shape.unit
+              
+              shape.coord_system_id = IdRef.new('system2')
+              assert_equal IdRef.new('system2'), shape.coord_system_id
+              shape.unit = PosUnit.new('lyr')
+              assert_equal PosUnit.new('lyr'), shape.unit
+              
+              #assert_equal(
+              #  "<reg:Shape reg:coord_system_id='system2' reg:unit='lyr' reg:fill_factor='1.0' xmlns:reg='http://www.ivoa.net/xml/STC/STCregion/v1.10'/>",
+              #  shape.to_xml.to_s
+              #)
+            end
+          end
+          
+          class CircleTypeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                CircleType.new(:coord_system_id => 'system1', :unit => 'm', :center => [1.1, 2.2], :radius => 100.1)
+              }
+              
+              assert_raises TypeError do
+                CircleType.new(:coord_system_id => 'system1', :unit => 'm', :center => 'blah', :radius => 100.1)
+              end
+              assert_raises ArgumentError do
+                CircleType.new(:coord_system_id => 'system1', :unit => 'm', :center => [1.1, 2.2], :radius => 'blah')
+              end
+            end
+            
+            def test_accessors
+              circle = CircleType.new(:coord_system_id => 'system1', :unit => 'm', :center => [1.1, 2.2], :radius => 100.1)
+              
+              assert_equal Double2.new([1.1, 2.2]), circle.center
+              assert_equal 100.1, circle.radius
+              
+              circle.center = Double2.new([5.5, 5.5])
+              assert_equal Double2.new([5.5, 5.5]), circle.center
+              circle.radius = 10.2
+              assert_equal 10.2, circle.radius
+            end
+            
+            def test_relationships
+              assert_kind_of Shape, CircleType.new(:coord_system_id => 'system1', :unit => 'm', :center => [1.1, 2.2], :radius => 100.1)
+            end
+            
+            def test_xml
+              c1 = CircleType.new(:coord_system_id => 'system1', :unit => 'm', :center => [1.1, 2.2], :radius => 100.1)
+       
+              c2 = CircleType.from_xml(c1.to_xml)
+              assert_equal c1, c2
+            end
+            
+            def test_s
+              c = CircleType.new(:coord_system_id => 'J2000', :unit => 'm', :center => [1.1, 2.2], :radius => 100.1)
+              assert_equal 'CIRCLE J2000 1.1 2.2 100.1', c.to_s
+            end
+          end
+          
+          class EllipseTypeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                EllipseType.new(
+                  :coord_system_id => 'system1',
+                  :unit => 'm',
+                  :center => [1.1, 2.2],
+                  :radius => 100.1,
+                  :minor_radius => 50.2,
+                  :pos_angle => 81.2,
+                  :pos_angle_unit => 'rad'
+                )
+                
+                EllipseType.new(
+                  :coord_system_id => 'system1',
+                  :unit => 'm',
+                  :center => [1.1, 2.2],
+                  :radius => 100.1,
+                  :minor_radius => 50.2,
+                  :pos_angle => 81.2
+                )
+              }
+              
+              assert_raises ArgumentError do
+                 EllipseType.new(
+                    :coord_system_id => 'system1',
+                    :unit => 'm',
+                    :center => [1.1, 2.2],
+                    :radius => 100.1,
+                    :minor_radius => 50.2,
+                    :pos_angle => 81.2,
+                    :pos_angle_unit => PosUnit.new('m')
+                  )
+              end
+              
+              assert_raises ArgumentError do
+                 EllipseType.new(
+                    :coord_system_id => 'system1',
+                    :unit => 'm',
+                    :center => [1.1, 2.2],
+                    :radius => 100.1,
+                    :minor_radius => 50.2,
+                    :pos_angle => 'blah',
+                    :pos_angle_unit => 'rad'
+                  )
+              end
+            end
+            
+            def test_accessors
+              e = EllipseType.new(
+                :coord_system_id => 'system1',
+                :unit => 'm',
+                :center => [1.1, 2.2],
+                :radius => 100.1,
+                :minor_radius => 50.2,
+                :pos_angle => 81.2,
+                :pos_angle_unit => 'rad'
+              )
+              
+              assert_equal IdRef.new('system1'), e.coord_system_id
+              assert_equal PosUnit.new('m'), e.unit
+              assert_equal [1.1, 2.2], e.center
+              assert_equal 100.1, e.radius
+              assert_equal 50.2, e.minor_radius
+              assert_equal 81.2, e.pos_angle
+              assert_equal AngleUnit.new('rad'), e.pos_angle_unit
+              
+              e.minor_radius = 150.1
+              assert_equal 150.1, e.minor_radius
+              e.pos_angle = 12.2
+              assert_equal 12.2, e.pos_angle
+              e.pos_angle_unit = 'deg'
+              assert_equal AngleUnit.new('deg'), e.pos_angle_unit
+            end
+            
+            def test_relationships
+              e = EllipseType.new(
+                :coord_system_id => 'system1',
+                :unit => 'm',
+                :center => [1.1, 2.2],
+                :radius => 100.1,
+                :minor_radius => 50.2,
+                :pos_angle => 81.2,
+                :pos_angle_unit => 'rad'
+              )
+              assert_kind_of CircleType, e
+            end
+            
+            def test_xml
+              e1 = EllipseType.new(
+                :coord_system_id => 'system1',
+                :unit => 'm',
+                :center => [1.1, 2.2],
+                :radius => 100.1,
+                :minor_radius => 50.2,
+                :pos_angle => 81.2,
+                :pos_angle_unit => 'rad'
+              )
+                
+              e2 = EllipseType.from_xml(e1.to_xml)
+              assert_equal e1, e2
+            end
+            
+            def test_s
+              e = EllipseType.new(
+                :coord_system_id => 'J2000',
+                :unit => 'm',
+                :center => [1.1, 2.2],
+                :radius => 100.1,
+                :minor_radius => 50.2,
+                :pos_angle => 81.2,
+                :pos_angle_unit => 'rad'
+              )
+              assert_equal 'ELLIPSE J2000 1.1 2.2 100.1 50.2 81.2', e.to_s
+            end
+          end
+          
+          class SmallCircleTypeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                SmallCircle.new
+                SmallCircle.new(Double2.new([1.1, 2.2]))
+                SmallCircle.new(:pole => Double2.new([1.1, 2.2]))
+              }
+              
+              assert_raises TypeError do
+                SmallCircle.new(1.12)
+              end
+            end
+            
+            def test_accessors
+              c = SmallCircle.new(Double2.new([1.1, 2.2]))
+              
+              assert_equal Double2.new([1.1, 2.2]), c.pole
+              
+              c.pole = Double2.new([2.2, 3.3])
+              assert_equal Double2.new([2.2, 3.3]), c.pole
+            end
+            
+            def test_xml
+              c1 = SmallCircle.new(Double2.new([1.1, 2.2]))
+              
+              c2 = SmallCircle.from_xml(c1.to_xml)
+              assert_equal c1, c2
+            end
+          end
+          
+          class VertexTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                Vertex.new(:position => Double2.new([1.2, 3.3]), :small_circle => SmallCircle.new([2.3, 4.5]))
+                Vertex.new(:position => Double2.new([1.2, 3.3]))
+              }
+              
+              assert_raises ArgumentError do
+                Vertex.new
+              end
+              assert_raises ArgumentError do
+                Vertex.new(:small_circle => SmallCircle.new([2.3, 4.5]))
+              end
+              assert_raises TypeError do
+                Vertex.new(:position => 'blah')
+              end
+              assert_raises TypeError do
+                Vertex.new(:position => Double2.new([1.2, 3.3]), :small_circle => [1.1, 2.3])
+              end
+            end
+            
+            def test_accessors
+              v = Vertex.new(:position => Double2.new([1.2, 3.3]), :small_circle => SmallCircle.new([2.3, 4.5]))
+              
+              assert_equal Double2.new([1.2, 3.3]), v.position
+              assert_equal SmallCircle.new([2.3, 4.5]), v.small_circle
+              
+              v.position = Double2.new([5.2, 9.1])
+              assert_equal Double2.new([5.2, 9.1]), v.position
+              v.small_circle = SmallCircle.new([8.2, 7.8])
+              assert_equal SmallCircle.new([8.2, 7.8]), v.small_circle
+            end
+            
+            def test_xml
+              v1 = Vertex.new(:position => Double2.new([1.2, 3.3]), :small_circle => SmallCircle.new([2.3, 4.5]))
+              
+              v2 = Vertex.from_xml(v1.to_xml)
+              assert_equal v1, v2
+            end
+          end
+          
+          class PolygonTypeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                PolygonType.new(
+                  :coord_system_id => 'system1',
+                  :unit => 'm',
+                  :vertices => [Vertex.new(:position => [1.1, 1.2]), Vertex.new(:position => [2.2, 3.4])]
+                )
+              }
+              
+              assert_raises TypeError do
+                PolygonType.new(
+                  :coord_system_id => 'system1',
+                  :unit => 'm',
+                  :vertices => 'blah'
+                )
+              end
+            end
+            
+            def test_accessors
+              p = PolygonType.new(
+                :coord_system_id => 'system1',
+                :unit => 'm',
+                :vertices => [Vertex.new(:position => [1.1, 1.2]), Vertex.new(:position => [2.2, 3.4])]
+              )
+              
+              assert_equal VertexList.new([Vertex.new(:position => [1.1, 1.2]), Vertex.new(:position => [2.2, 3.4])]), p.vertices
+              p.vertices = [Vertex.new(:position => [2.2, 2.3]), Vertex.new(:position => [3.3, 4.4])]
+              assert_equal [Vertex.new(:position => [2.2, 2.3]), Vertex.new(:position => [3.3, 4.4])], p.vertices
+            end
+            
+            def test_relationships
+              assert_kind_of(
+                Shape,
+                PolygonType.new(
+                  :coord_system_id => 'system1',
+                  :unit => 'm',
+                  :vertices => [Vertex.new(:position => [1.1, 1.2]), Vertex.new(:position => [2.2, 3.4])]
+                )
+              )
+            end
+            
+            def test_xml
+              p1 = PolygonType.new(
+                :coord_system_id => 'system1',
+                :unit => 'm',
+                :vertices => [Vertex.new(:position => [1.1, 1.2]), Vertex.new(:position => [2.2, 3.4])]
+              )
+              
+              p2 = PolygonType.from_xml(p1.to_xml)
+              assert_equal p1, p2
+            end
+            
+            def test_s
+              p = PolygonType.new(
+                :coord_system_id => 'J2000',
+                :unit => 'm',
+                :vertices => [Vertex.new(:position => [1.1, 1.2]), Vertex.new(:position => [2.2, 3.4])]
+              )
+              
+              assert_equal 'POLYGON J2000 1.1 1.2 2.2 3.4', p.to_s
+            end
+          end
+        
+          class SectorTypeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                SectorType.new(
+                  :coord_system_id => 'system1',
+                  :position => [1.1, 2.3],
+                  :pos_angle1 => 12.3,
+                  :pos_angle2 => 4.5,
+                  :pos_angle_unit => 'lyr'
+                )
+                
+                SectorType.new(
+                  :coord_system_id => 'system1',
+                  :position => [1.1, 2.3],
+                  :pos_angle1 => 12.3,
+                  :pos_angle2 => 4.5
+                )
+              }
+              
+              assert_raises ArgumentError do
+                SectorType.new(:coord_system_id => 'system1')
+              end
+              assert_raises ArgumentError do
+                SectorType.new(
+                  :coord_system_id => 'system1',
+                  :position => [1.1, 2.3]
+                )
+              end
+              assert_raises ArgumentError do
+                SectorType.new(
+                  :coord_system_id => 'system1',
+                  :position => [1.1, 2.3],
+                  :pos_angle1 => 12.3
+                )
+              end
+              assert_raises ArgumentError do
+                SectorType.new(
+                  :coord_system_id => 'system1',
+                  :position => [1.1, 2.3],
+                  :pos_angle1 => 12.3,
+                  :pos_angle2 => 4.5,
+                  :pos_angle_unit => 'blah'
+                )
+              end
+            end
+            
+            def test_accessors
+              s = SectorType.new(
+                :coord_system_id => 'system1',
+                :position => [1.1, 2.3],
+                :pos_angle1 => 12.3,
+                :pos_angle2 => 4.5,
+                :pos_angle_unit => 'lyr'
+              )
+              
+              assert_equal Double2.new([1.1, 2.3]), s.position
+              assert_equal 12.3, s.pos_angle1
+              assert_equal 4.5, s.pos_angle2
+              assert_equal PosUnit.new('lyr'), s.pos_angle_unit
+              
+              s.position = [2.3, 4.5]
+              assert_equal Double2.new([2.3, 4.5]), s.position
+              s.pos_angle1 = 12.3
+              assert_equal 12.3, s.pos_angle1
+              s.pos_angle2 = 5.6
+              assert_equal 5.6, s. pos_angle2
+              s.pos_angle_unit = PosUnit.new('m')
+              assert_equal PosUnit.new('m'), s.pos_angle_unit
+            end
+            
+            def test_relationships
+              assert_kind_of(
+                Shape,
+                SectorType.new(
+                  :coord_system_id => 'system1',
+                  :position => [1.1, 2.3],
+                  :pos_angle1 => 12.3,
+                  :pos_angle2 => 4.5,
+                  :pos_angle_unit => 'lyr'
+                )
+              ) 
+            end
+            
+            def test_xml
+              s1 = SectorType.new(
+                :coord_system_id => 'system1',
+                :position => [1.1, 2.3],
+                :pos_angle1 => 12.3,
+                :pos_angle2 => 4.5,
+                :pos_angle_unit => 'lyr'
+              )
+              
+              s2 = SectorType.from_xml(s1.to_xml)
+              assert_equal s1.pos_angle_unit, s2.pos_angle_unit
+            end
+            
+            def test_s
+              s = SectorType.new(
+                :coord_system_id => 'J2000',
+                :position => [1.1, 2.3],
+                :pos_angle1 => 12.3,
+                :pos_angle2 => 4.5,
+                :pos_angle_unit => 'lyr'
+              )
+              
+              assert_equal 'SECTOR J2000 1.1 2.3 12.3 4.5', s.to_s
+            end
+          end
+          
+          class ConstraintTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                Constraint.new(:vector => [1.3, 5.3, 2.2], :offset => 10.2)
+              }
+              
+              assert_raises ArgumentError do
+                Constraint.new(:vector => [1.3, 5.3, 2.2])
+              end
+              assert_raises ArgumentError do
+                Constraint.new(:offset => 10.2)
+              end
+              assert_raises ArgumentError do
+                Constraint.new
+              end
+            end
+            
+            def test_accessors
+              c = Constraint.new(:vector => [1.3, 5.3, 2.2], :offset => 10.2)
+              
+              assert_equal Double3.new([1.3, 5.3, 2.2]), c.vector
+              assert_equal 10.2, c.offset
+              
+              c.vector = Double3.new([3.3, 5.6, 1.1])
+              assert_equal Double3.new([3.3, 5.6, 1.1]), c.vector
+              c.offset = 1.2
+              assert_equal 1.2, c.offset
+            end
+            
+            def test_xml
+              c1 = Constraint.new(:vector => [1.3, 5.3, 1.1], :offset => 10.2)
+              
+              c2 = Constraint.from_xml(c1.to_xml)
+              assert_equal c1, c2
+            end
+          end
+          
+          class ConvexTypeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                ConvexType.new(:coord_system_id => 'system1', :constraints => [Constraint.new(:vector => [1.1, 2.2, 3.3], :offset => 1.2)])
+              }
+              
+              assert_raises TypeError do
+                ConvexType.new(:coord_system_id => 'system1', :constraints => 'blah')
+              end
+              assert_raises RuntimeError do
+                ConvexType.new(:coord_system_id => 'system1', :constraints => [])
+              end
+            end
+            
+            def test_accessors
+              c = ConvexType.new(:coord_system_id => 'system1', :constraints => [Constraint.new(:vector => [1.1, 2.2, 3.3], :offset => 1.2)])
+              
+              assert_equal(
+                ConstraintList.new([Constraint.new(:vector => [1.1, 2.2, 3.3], :offset => 1.2)]),
+                c.constraints
+              )
+              
+              c.constraints = [Constraint.new(:vector => [2.2, 3.3, 4.4], :offset => 6.1)]
+              assert_equal(
+                ConstraintList.new([Constraint.new(:vector => [2.2, 3.3, 4.4], :offset => 6.1)]),
+                c.constraints
+              )
+            end
+            
+            def test_relationships
+              assert_kind_of(
+                Shape,
+                ConvexType.new(:coord_system_id => 'system1', :constraints => [Constraint.new(:vector => [1.1, 2.2, 3.3], :offset => 1.2)])
+              )
+            end
+            
+            def test_xml
+              c1 = ConvexType.new(:coord_system_id => 'system1', :constraints => [Constraint.new(:vector => [1.1, 2.2, 3.3], :offset => 1.2)])
+              
+              c2 = ConvexType.from_xml(c1.to_xml)
+              assert_equal c1, c2
+            end
+            
+            def test_s
+              c = ConvexType.new(:coord_system_id => 'J2000', :constraints => [Constraint.new(:vector => [1.1, 2.2, 3.3], :offset => 1.2)])
+              assert_equal 'CONVEX J2000 1.1 2.2 3.3 1.2', c.to_s
+            end
+          end
+          
+          class ConvexHullTypeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                ConvexHullType.new(
+                  :coord_system_id => 'system1',
+                  :points => [Double3.new([1.1, 2.2, 3.3])]
+                )
+              }
+              
+              assert_raises TypeError do
+                ConvexHullType.new(:coord_system_id => 'system1', :points => 'blah')
+              end
+              assert_raises RuntimeError do
+                ConvexHullType.new(:coord_system_id => 'system1', :points => [])
+              end
+            end
+            
+            def test_accessors
+              c = ConvexHullType.new(
+                :coord_system_id => 'system1',
+                :points => [Double3.new([1.1, 2.2, 3.3])]
+              )
+              
+              assert_equal IdRef.new('system1'), c.coord_system_id
+              assert_equal PointList.new([Double3.new([1.1, 2.2, 3.3])]), c.points
+              
+              c.points = [Double3.new([1.1, 2.2, 3.3]), Double3.new([4.4, 5.5, 6.6])]
+              assert_equal(
+                PointList.new([Double3.new([1.1, 2.2, 3.3]), Double3.new([4.4, 5.5, 6.6])]),
+                c.points
+              )
+            end
+            
+            def test_relationships
+              assert_kind_of(
+                Shape,
+                ConvexHullType.new(
+                  :coord_system_id => 'system1',
+                  :points => [Double3.new([1.1, 2.2, 3.3])]
+                )
+              )
+            end
+            
+            def test_xml
+              c1 = ConvexHullType.new(
+                :coord_system_id => 'system1',
+                :points => [Double3.new([1.1, 2.2, 3.3]), Double3.new([4.4, 5.5, 6.6])]
+              )
+              
+              c2 = ConvexHullType.from_xml(c1.to_xml)
+              assert_equal c1, c2
+            end
+            
+            def test_s
+              c = ConvexHullType.new(
+                :coord_system_id => 'J2000',
+                :points => [Double3.new([1.1, 2.2, 3.3]), Double3.new([4.4, 5.5, 6.6])]
+              )
+              
+              assert_equal 'CHULL J2000 1.1 2.2 3.3 4.4 5.5 6.6', c.to_s
+            end
+          end
+          
+          class UnionTypeTest < ::Test::Unit::TestCase
+            def test_construction
+               assert_nothing_raised {
+                 UnionType.new(
+                   :regions => [
+                     Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                     Circle.new(:coord_system_id => 'system1', :center => [3.3, 4.4], :radius => 51.2)
+                   ]
+                 )
+               }
+               
+               assert_raises TypeError do
+                 UnionType.new(
+                   :regions => [
+                     CircleType.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                     Circle.new(:coord_system_id => 'system1', :center => [3.3, 4.4], :radius => 51.2)
+                   ]
+                 )
+                 assert_raises ArgumentError do
+                   UnionType.new(
+                     :regions => [
+                       CircleType.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1)
+                     ]
+                   )
+                 end
+               end
+              end
+              
+              def test_accessors
+                u = UnionType.new(
+                  :regions => [
+                    Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                    Circle.new(:coord_system_id => 'system1', :center => [3.3, 4.4], :radius => 51.2)
+                  ]
+                )
+                
+                assert_equal(
+                  RegionList.new([
+                    Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                    Circle.new(:coord_system_id => 'system1', :center => [3.3, 4.4], :radius => 51.2)
+                  ]),
+                  u.regions
+                )
+                
+                u.regions = [
+                  Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                  Ellipse.new(
+                    :coord_system_id => 'system1',
+                    :unit => 'm',
+                    :center => [1.1, 2.2],
+                    :radius => 100.1,
+                    :minor_radius => 50.2,
+                    :pos_angle => 81.2,
+                    :pos_angle_unit => 'rad'
+                  )
+                ]
+                assert_equal(
+                  RegionList.new([
+                    Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                    Ellipse.new(
+                      :coord_system_id => 'system1',
+                      :unit => 'm',
+                      :center => [1.1, 2.2],
+                      :radius => 100.1,
+                      :minor_radius => 50.2,
+                      :pos_angle => 81.2,
+                      :pos_angle_unit => 'rad'
+                    )
+                  ]),
+                  u.regions
+                )
+              end
+              
+              def test_relationships
+                u = UnionType.new(
+                  :regions => [
+                    Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                    Circle.new(:coord_system_id => 'system1', :center => [3.3, 4.4], :radius => 51.2)
+                  ]
+                )
+                
+                assert_kind_of RegionType, u
+                assert_kind_of BooleanOperatorType, u
+              end
+              
+              def test_xml
+                u1 = UnionType.new(
+                  :regions => [
+                    Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                    Ellipse.new(
+                      :coord_system_id => 'system1',
+                      :unit => 'm',
+                      :center => [1.1, 2.2],
+                      :radius => 100.1,
+                      :minor_radius => 50.2,
+                      :pos_angle => 81.2,
+                      :pos_angle_unit => 'rad'
+                    )
+                  ]
+                )
+                
+                u2 = UnionType.from_xml(u1.to_xml)
+                assert_equal u1, u2
+              end
+              
+              def test_s
+                u = UnionType.new(
+                  :regions => [
+                    Circle.new(:coord_system_id => 'J2000', :center => [1.1, 2.2], :radius => 100.1),
+                    Ellipse.new(
+                      :coord_system_id => 'J2000',
+                      :unit => 'm',
+                      :center => [1.1, 2.2],
+                      :radius => 100.1,
+                      :minor_radius => 50.2,
+                      :pos_angle => 81.2,
+                      :pos_angle_unit => 'rad'
+                    )
+                  ]
+                )
+                
+                assert_equal 'UNION(CIRCLE J2000 1.1 2.2 100.1 ELLIPSE J2000 1.1 2.2 100.1 50.2 81.2)', u.to_s
+              end
+          end
+          
+          class IntersectionTypeTest < ::Test::Unit::TestCase
+            def test_construction
+               assert_nothing_raised {
+                 IntersectionType.new(
+                   :regions => [
+                     Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                     Circle.new(:coord_system_id => 'system1', :center => [3.3, 4.4], :radius => 51.2)
+                   ]
+                 )
+               }
+               
+               assert_raises TypeError do
+                 IntersectionType.new(
+                   :regions => [
+                     CircleType.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                     Circle.new(:coord_system_id => 'system1', :center => [3.3, 4.4], :radius => 51.2)
+                   ]
+                 )
+                 assert_raises ArgumentError do
+                   IntersectionType.new(
+                     :regions => [
+                       CircleType.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1)
+                     ]
+                   )
+                 end
+               end
+              end
+              
+              def test_accessors
+                u = IntersectionType.new(
+                  :regions => [
+                    Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                    Circle.new(:coord_system_id => 'system1', :center => [3.3, 4.4], :radius => 51.2)
+                  ]
+                )
+                
+                assert_equal(
+                  RegionList.new([
+                    Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                    Circle.new(:coord_system_id => 'system1', :center => [3.3, 4.4], :radius => 51.2)
+                  ]),
+                  u.regions
+                )
+                
+                u.regions = [
+                  Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                  Ellipse.new(
+                    :coord_system_id => 'system1',
+                    :unit => 'm',
+                    :center => [1.1, 2.2],
+                    :radius => 100.1,
+                    :minor_radius => 50.2,
+                    :pos_angle => 81.2,
+                    :pos_angle_unit => 'rad'
+                  )
+                ]
+                assert_equal(
+                  RegionList.new([
+                    Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                    Ellipse.new(
+                      :coord_system_id => 'system1',
+                      :unit => 'm',
+                      :center => [1.1, 2.2],
+                      :radius => 100.1,
+                      :minor_radius => 50.2,
+                      :pos_angle => 81.2,
+                      :pos_angle_unit => 'rad'
+                    )
+                  ]),
+                  u.regions
+                )
+              end
+              
+              def test_relationships
+                i = IntersectionType.new(
+                  :regions => [
+                    Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                    Circle.new(:coord_system_id => 'system1', :center => [3.3, 4.4], :radius => 51.2)
+                  ]
+                )
+                
+                assert_kind_of RegionType, i
+                assert_kind_of BooleanOperatorType, i
+              end
+              
+              def test_xml
+                u1 = IntersectionType.new(
+                  :regions => [
+                    Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1),
+                    Ellipse.new(
+                      :coord_system_id => 'system1',
+                      :unit => 'm',
+                      :center => [1.1, 2.2],
+                      :radius => 100.1,
+                      :minor_radius => 50.2,
+                      :pos_angle => 81.2,
+                      :pos_angle_unit => 'rad'
+                    )
+                  ]
+                )
+                
+                u2 = IntersectionType.from_xml(u1.to_xml)
+                assert_equal u1, u2
+              end
+              
+              def test_s
+                u = IntersectionType.new(
+                  :regions => [
+                    Circle.new(:coord_system_id => 'J2000', :center => [1.1, 2.2], :radius => 100.1),
+                    Ellipse.new(
+                      :coord_system_id => 'J2000',
+                      :unit => 'm',
+                      :center => [1.1, 2.2],
+                      :radius => 100.1,
+                      :minor_radius => 50.2,
+                      :pos_angle => 81.2,
+                      :pos_angle_unit => 'rad'
+                    )
+                  ]
+                )
+                
+                assert_equal 'INTERSECT(CIRCLE J2000 1.1 2.2 100.1 ELLIPSE J2000 1.1 2.2 100.1 50.2 81.2)', u.to_s
+              end
+          end
+          
+          class NegationTypeTest < ::Test::Unit::TestCase
+            def test_construction
+              assert_nothing_raised {
+                NegationType.new(
+                  :region => Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1)
+                )
+              }
+              
+              assert_raises TypeError do
+                NegationType.new(:region => 'blah')
+              end
+            end
+            
+            def test_accessors
+              n = NegationType.new(
+                :region => Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1)
+              )
+              
+              assert_equal Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1), n.region
+              
+              n.region = Circle.new(:coord_system_id => 'system1', :center => [5.5, 6.6], :radius => 50.1)
+              assert_equal Circle.new(:coord_system_id => 'system1', :center => [5.5, 6.6], :radius => 50.1), n.region
+            end
+            
+            def test_relationships
+              assert_kind_of(
+                RegionType,
+                NegationType.new(
+                  :region => Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1)
+                )
+              )
+            end
+            
+            def test_xml
+              n1 = NegationType.new(
+                :region => Circle.new(:coord_system_id => 'system1', :center => [1.1, 2.2], :radius => 100.1)
+              )
+              
+              n2 = NegationType.from_xml(n1.to_xml)
+              assert_equal n1, n2
+            end
+            
+            def test_s
+              n = NegationType.new(
+                :region => Circle.new(:coord_system_id => 'J2000', :center => [1.1, 2.2], :radius => 100.1)
+              )
+              
+              assert_equal 'NOT(CIRCLE J2000 1.1 2.2 100.1)', n.to_s
+            end
+          end
+        
+          class RealWorldRegionTest < ::Test::Unit::TestCase
+            def test_circle
+              assert_nothing_raised {
+                Circle.from_xml(File.open('test/voruby/stc/1.10/stc-region-circle.xml'))
+              }
+            end
+            
+            def test_convex
+              assert_nothing_raised {
+                Convex.from_xml(File.open('test/voruby/stc/1.10/stc-region-convex.xml'))
+              }
+            end
+            
+            def test_convex_hull
+              assert_nothing_raised {
+                ConvexHull.from_xml(File.open('test/voruby/stc/1.10/stc-region-convexhull.xml'))
+              }
+            end
+            
+            def test_ellipse
+              assert_nothing_raised {
+                Ellipse.from_xml(File.open('test/voruby/stc/1.10/stc-region-ellipse.xml'))
+              }
+            end
+            
+            def test_intersection
+              assert_nothing_raised {
+                Intersection.from_xml(File.open('test/voruby/stc/1.10/stc-region-intersection.xml'))
+              }
+            end
+            
+            def test_negation
+              assert_nothing_raised {
+                Negation.from_xml(File.open('test/voruby/stc/1.10/stc-region-negation.xml'))
+              }
+            end
+            
+            def test_polygon
+              assert_nothing_raised {
+                Polygon.from_xml(File.open('test/voruby/stc/1.10/stc-region-polygon.xml'))
+              }
+            end
+            
+            def test_sector
+              assert_nothing_raised {
+                Sector.from_xml(File.open('test/voruby/stc/1.10/stc-region-sector.xml'))
+              }
+            end
+            
+            def test_union
+              assert_nothing_raised {
+                Union.from_xml(File.open('test/voruby/stc/1.10/stc-region-union.xml'))
+              }
+            end
+          end
+
+        end
+        
+      end
+    end
+  end
+end