voruby 1.1.1 → 2.0.0

data/test/voruby/adql/1.0/adql-group.sql

@@ -0,0 +1 @@
+SELECT g.fieldID, AVG(g.modelMag_u) AS avg_modelMag_u, AVG(g.modelMag_r) AS avg_modelMag_r FROM  Galaxy g WHERE g.run = 1458 AND g.rerun = 40 AND g.camcol = 1 GROUP BY g.fieldID ORDER BY g.fieldID

data/test/voruby/adql/1.0/adql-group.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Select xmlns="http://www.ivoa.net/xml/ADQL/v1.0" xmlns:coo="http://www.ivoa.net/xml/STC/STCcoords/v1.10" xmlns:reg="http://www.ivoa.net/xml/STC/STCregion/v1.10" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <SelectionList>
+    <Item xsi:type="columnReferenceType" Table="g" Name="fieldID"/>
+    <Item xsi:type="aliasSelectionItemType" As="avg_modelMag_u">
+      <Expression xsi:type="aggregateFunctionType" Name="AVG">
+        <Arg xsi:type="columnReferenceType" Table="g" Name="modelMag_u"/>
+      </Expression>
+    </Item>
+    <Item xsi:type="aliasSelectionItemType" As="avg_modelMag_r">
+      <Expression xsi:type="aggregateFunctionType" Name="AVG">
+        <Arg xsi:type="columnReferenceType" Table="g" Name="modelMag_r"/>
+      </Expression>
+    </Item>
+  </SelectionList>
+  <From>
+    <Table xsi:type="tableType" Name="Galaxy" Alias="g"/>
+  </From>
+  <Where>
+    <Condition xsi:type="intersectionSearchType">
+      <Condition xsi:type="intersectionSearchType">
+        <Condition xsi:type="comparisonPredType" Comparison="=">
+          <Arg xsi:type="columnReferenceType" Table="g" Name="run"/>
+          <Arg xsi:type="atomType">
+            <Literal xsi:type="integerType" Value="1458"/>
+          </Arg>
+        </Condition>
+        <Condition xsi:type="comparisonPredType" Comparison="=">
+          <Arg xsi:type="columnReferenceType" Table="g" Name="rerun"/>
+          <Arg xsi:type="atomType">
+            <Literal xsi:type="integerType" Value="40"/>
+          </Arg>
+        </Condition>
+      </Condition>
+      <Condition xsi:type="comparisonPredType" Comparison="=">
+        <Arg xsi:type="columnReferenceType" Table="g" Name="camcol"/>
+        <Arg xsi:type="atomType">
+          <Literal xsi:type="integerType" Value="1"/>
+        </Arg>
+      </Condition>
+    </Condition>
+  </Where>
+  <GroupBy>
+    <Column xsi:type="columnReferenceType" Table="g" Name="fieldID"/>
+  </GroupBy>
+  <OrderBy>
+    <Item xsi:type="orderType">
+      <Expression xsi:type="columnReferenceType" Table="g" Name="fieldID"/>
+    </Item>
+  </OrderBy>
+</Select>

data/test/voruby/adql/1.0/adql-having.sql

@@ -0,0 +1 @@
+SELECT t.b, b.d FROM Tab t, Tab b GROUP BY t.b, b.d HAVING t.b <> d.b

data/test/voruby/adql/1.0/adql-having.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Select xmlns="http://www.ivoa.net/xml/ADQL/v1.0" xmlns:coo="http://www.ivoa.net/xml/STC/STCcoords/v1.10" xmlns:reg="http://www.ivoa.net/xml/STC/STCregion/v1.10" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+  <SelectionList>
+    <Item xsi:type="columnReferenceType" Table="t" Name="b"/>
+    <Item xsi:type="columnReferenceType" Table="b" Name="d"/>
+  </SelectionList>
+
+  <From>
+    <Table xsi:type="tableType" Name="Tab" Alias="t" />
+    <Table xsi:type="tableType" Name="Tab" Alias="b" />
+  </From>
+
+  <GroupBy>
+     <Column xsi:type="columnReferenceType" Table="t" Name="b"/>
+     <Column xsi:type="columnReferenceType" Table="b" Name="d"/>
+  </GroupBy>
+
+  <Having>
+     <Condition xsi:type="comparisonPredType" Comparison="&lt;&gt;">
+        <Arg xsi:type="columnReferenceType" Table="t" Name="b"/>
+        <Arg xsi:type="columnReferenceType" Table="d" Name="b"/>
+     </Condition>
+  </Having>
+</Select>

data/test/voruby/adql/1.0/adql-like.sql

@@ -0,0 +1 @@
+SELECT * FROM resources r WHERE r.title LIKE '%quasar%'

data/test/voruby/adql/1.0/adql-like.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Select xmlns="http://www.ivoa.net/xml/ADQL/v1.0" xmlns:coo="http://www.ivoa.net/xml/STC/STCcoords/v1.10" xmlns:reg="http://www.ivoa.net/xml/STC/STCregion/v1.10" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <SelectionList>
+    <Item xsi:type="allSelectionItemType"/>
+  </SelectionList>
+  <From>
+    <Table xsi:type="tableType" Name="resources" Alias="r"/>
+  </From>
+  <Where>
+    <Condition xsi:type="likePredType">
+      <Arg xsi:type="columnReferenceType" Table="r" Name="title"/>
+      <Pattern xsi:type="atomType">
+        <Literal xsi:type="stringType" Value="%quasar%"/>
+      </Pattern>
+    </Condition>
+  </Where>
+</Select>

data/test/voruby/adql/1.0/adql-order.sql

@@ -0,0 +1 @@
+SELECT a.f, d.g FROM Tab a, Bob d WHERE a.d < d.e AND a.f < d.f ORDER BY a.f DESC, d.b

data/test/voruby/adql/1.0/adql-order.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Select xmlns="http://www.ivoa.net/xml/ADQL/v1.0" xmlns:coo="http://www.ivoa.net/xml/STC/STCcoords/v1.10" xmlns:reg="http://www.ivoa.net/xml/STC/STCregion/v1.10" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+  <SelectionList>
+    <Item xsi:type="columnReferenceType" Table="a" Name="f"/>
+    <Item xsi:type="columnReferenceType" Table="d" Name="g"/>
+  </SelectionList>
+
+  <From>
+    <Table xsi:type="tableType" Name="Tab" Alias="a" />
+    <Table xsi:type="tableType" Name="Bob" Alias="d" />
+  </From>
+
+  <Where>
+    <Condition xsi:type="intersectionSearchType">
+       <Condition xsi:type="comparisonPredType" Comparison="&lt;">
+          <Arg xsi:type="columnReferenceType" Table="a" Name="d"/>
+          <Arg xsi:type="columnReferenceType" Table="d" Name="e"/>
+       </Condition>
+       <Condition xsi:type="comparisonPredType" Comparison="&lt;">
+          <Arg xsi:type="columnReferenceType" Table="a" Name="f"/>
+          <Arg xsi:type="columnReferenceType" Table="d" Name="f"/>
+       </Condition>
+    </Condition>
+  </Where>
+
+  <OrderBy>
+     <Item xsi:type="orderType">
+        <Expression xsi:type="columnReferenceType" Table="a" Name="f"/>
+        <Order xsi:type="orderOptionType" Direction="DESC"/>
+     </Item>
+     <Item xsi:type="orderType">
+        <Expression xsi:type="columnReferenceType" Table="d" Name="b"/>
+     </Item>
+  </OrderBy>
+
+</Select>

data/test/voruby/adql/1.0/adql-simple.sql

@@ -0,0 +1 @@
+SELECT * FROM Tab a

data/test/voruby/adql/1.0/adql-simple.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Select xmlns="http://www.ivoa.net/xml/ADQL/v1.0" xmlns:coo="http://www.ivoa.net/xml/STC/STCcoords/v1.10" xmlns:reg="http://www.ivoa.net/xml/STC/STCregion/v1.10" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+  <SelectionList>
+    <Item xsi:type="allSelectionItemType" />
+  </SelectionList>
+
+  <From>
+    <Table xsi:type="tableType" Name="Tab" Alias="a" />
+  </From>
+
+</Select>

data/test/voruby/adql/1.0/adql-top.sql

@@ -0,0 +1 @@
+SELECT TOP 100 a.f, d.g FROM Tab a, Bob d WHERE a.d < d.e AND a.f < d.f ORDER BY a.f DESC, d.b

data/test/voruby/adql/1.0/adql-top.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Select xmlns="http://www.ivoa.net/xml/ADQL/v1.0" xmlns:coo="http://www.ivoa.net/xml/STC/STCcoords/v1.10" xmlns:reg="http://www.ivoa.net/xml/STC/STCregion/v1.10" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <Restrict Top="100"/>
+  <SelectionList>
+    <Item xsi:type="columnReferenceType" Table="a" Name="f"/>
+    <Item xsi:type="columnReferenceType" Table="d" Name="g"/>
+  </SelectionList>
+  <From>
+    <Table xsi:type="tableType" Name="Tab" Alias="a"/>
+    <Table xsi:type="tableType" Name="Bob" Alias="d"/>
+  </From>
+  <Where>
+    <Condition xsi:type="intersectionSearchType">
+      <Condition xsi:type="comparisonPredType" Comparison="&lt;">
+        <Arg xsi:type="columnReferenceType" Table="a" Name="d"/>
+        <Arg xsi:type="columnReferenceType" Table="d" Name="e"/>
+      </Condition>
+      <Condition xsi:type="comparisonPredType" Comparison="&lt;">
+        <Arg xsi:type="columnReferenceType" Table="a" Name="f"/>
+        <Arg xsi:type="columnReferenceType" Table="d" Name="f"/>
+      </Condition>
+    </Condition>
+  </Where>
+  <OrderBy>
+    <Item xsi:type="orderType">
+      <Expression xsi:type="columnReferenceType" Table="a" Name="f"/>
+      <Order xsi:type="orderOptionType" Direction="DESC"/>
+    </Item>
+    <Item xsi:type="orderType">
+      <Expression xsi:type="columnReferenceType" Table="d" Name="b"/>
+    </Item>
+  </OrderBy>
+</Select>

data/test/voruby/adql/1.0/test.rb

@@ -0,0 +1,2220 @@
+require 'voruby/adql/1.0/adql'
+require 'test/unit'
+
+include VORuby::ADQL::V1_0
+
+module VORuby
+  module ADQL
+    module V1_0
+      module Test
+        
+        class ClosedExprTest < ::Test::Unit::TestCase
+          def setup
+            @scalar_expression = ColumnReference.new('a', 'ra', 'right_ascension')
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              ClosedExpr.new(@scalar_expression)
+            }
+            
+            assert_raises ArgumentError do
+              ClosedExpr.new(nil)
+            end
+            
+            assert_raises TypeError do
+              ClosedExpr.new('blah')
+            end
+          end
+          
+          def test_accessors
+            e = ClosedExpr.new(@scalar_expression)
+            
+            assert_equal @scalar_expression, e.arg
+            e.arg = ColumnReference.new('b', 'dec')
+            assert_equal ColumnReference.new('b', 'dec'), e.arg
+          end
+          
+          def test_relationships
+            assert_kind_of ScalarExpression, ClosedExpr.new(@scalar_expression)
+          end
+          
+          def test_to_s
+            e = ClosedExpr.new(@scalar_expression)
+            assert_equal '(a.ra)', e.to_s
+          end
+          
+          def test_xml
+            e1 = ClosedExpr.new(@scalar_expression)
+            e2 = ClosedExpr.from_xml(e1.to_xml)
+            assert_equal e1, e2
+          end
+        end
+        
+        class BinaryExprTest < ::Test::Unit::TestCase
+          def setup
+            @scalar_expression1 = ColumnReference.new('a', 'ra', 'right_ascension')
+            @scalar_expression2 = ColumnReference.new('a', 'dec', 'declination')
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              BinaryExpr.new(@scalar_expression1, BinaryOperator.new('*'), @scalar_expression2)
+              BinaryExpr.new(@scalar_expression1, '*', @scalar_expression2)
+            }
+            
+            assert_raises ArgumentError do
+              BinaryExpr.new(@scalar_expression1, BinaryOperator.new('*'), nil)
+            end
+            assert_raises ArgumentError do
+              BinaryExpr.new(@scalar_expression1, nil, @scalar_expression2)
+            end
+            assert_raises ArgumentError do
+              BinaryExpr.new(nil, BinaryOperator.new('*'), @scalar_expression2)
+            end
+            
+            assert_raises TypeError do
+              BinaryExpr.new(@scalar_expression1, BinaryOperator.new('*'), 'blah')
+            end
+            assert_raises TypeError do
+              BinaryExpr.new(@scalar_expression1, UnaryOperator.new('+'), @scalar_expression2)
+            end
+            assert_raises TypeError do
+              BinaryExpr.new('blah', BinaryOperator.new('*'), @scalar_expression2)
+            end
+          end
+          
+          def test_accessors
+            e = BinaryExpr.new(@scalar_expression1, BinaryOperator.new('*'), @scalar_expression2)
+            
+            assert_equal @scalar_expression1, e.arg1
+            assert_equal BinaryOperator.new('*'), e.oper
+            assert_equal @scalar_expression2, e.arg2
+            
+            e.arg1 = ColumnReference.new('b', 'flux')
+            assert_equal ColumnReference.new('b', 'flux'), e.arg1
+            e.oper = BinaryOperator.new('+')
+            assert_equal BinaryOperator.new('+'), e.oper
+            e.arg2 = ColumnReference.new('b', 'flux_err')
+            assert_equal ColumnReference.new('b', 'flux_err'), e.arg2
+          end
+          
+          def test_relationships
+            e = BinaryExpr.new(@scalar_expression1, BinaryOperator.new('*'), @scalar_expression2)
+            assert_kind_of ScalarExpression, e
+          end
+          
+          def test_to_s
+            e = BinaryExpr.new(@scalar_expression1, BinaryOperator.new('*'), @scalar_expression2)
+            assert_equal "a.ra * a.dec", e.to_s
+          end
+          
+          def test_xml
+            e1 = BinaryExpr.new(@scalar_expression1, BinaryOperator.new('*'), @scalar_expression2)
+            e2 = BinaryExpr.from_xml(e1.to_xml)
+            assert_equal e1, e2
+          end
+        end
+        
+        class UnaryExprTest < ::Test::Unit::TestCase
+          def setup
+            @scalar_expression = ColumnReference.new('a', 'ra', '/xpath')
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              UnaryExpr.new(UnaryOperator.new('-'), @scalar_expression)
+              UnaryExpr.new('-', @scalar_expression)
+            }
+            
+            assert_raises ArgumentError do
+              UnaryExpr.new(nil, @scalar_expression)
+            end
+            assert_raises ArgumentError do
+              UnaryExpr.new('blah', nil)
+            end
+            assert_raises ArgumentError do
+              UnaryExpr.new(nil, nil)
+            end
+            
+            assert_raises TypeError do
+              UnaryExpr.new(BinaryOperator.new('*'), @scalar_expression)
+            end
+            assert_raises TypeError do
+              UnaryExpr.new('-', 'blah')
+            end
+          end
+          
+          def test_accessors
+            e = UnaryExpr.new(UnaryOperator.new('-'), @scalar_expression)
+            
+            assert_equal UnaryOperator.new('-'), e.oper
+            assert_equal @scalar_expression, e.arg
+            
+            e.oper = UnaryOperator.new('+')
+            assert_equal UnaryOperator.new('+'), e.oper
+            e.arg = ColumnReference.new('a', 'dec')
+            assert_equal ColumnReference.new('a', 'dec'), e.arg
+          end
+          
+          def test_relationships
+            assert_kind_of ScalarExpression, UnaryExpr.new(UnaryOperator.new('-'), @scalar_expression)
+          end
+          
+          def test_to_s
+            e = UnaryExpr.new(UnaryOperator.new('-'), @scalar_expression)
+            assert_equal '-(a.ra)', e.to_s
+          end
+          
+          def test_xml
+            e1 = UnaryExpr.new(UnaryOperator.new('-'), @scalar_expression)
+            e2 = UnaryExpr.from_xml(e1.to_xml)
+            assert_equal e1, e2
+          end
+        end
+        
+        class ColumnReferenceTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              ColumnReference.new('Table1', '*', '/xpath')
+              ColumnReference.new('Table1', '*')
+            }
+            
+            assert_raises ArgumentError do
+              ColumnReference.new('Table1')
+            end
+            assert_raises ArgumentError do
+              ColumnReference.new(nil)
+            end
+            assert_raises ArgumentError do
+              ColumnReference.new('Table1', nil)
+            end
+            assert_raises ArgumentError do
+              ColumnReference.new(nil, nil)
+            end
+          end
+          
+          def test_accessors
+            r = ColumnReference.new('Table1', '*', '/xpath')
+            
+            assert_equal 'Table1', r.table
+            assert_equal '*', r.name
+            assert_equal '/xpath', r.xpath_name
+            
+            r.table = 'Table2'
+            assert_equal 'Table2', r.table
+            r.name = 'column1'
+            assert_equal 'column1', r.name
+            r.xpath_name = '/my/path'
+            assert_equal '/my/path', r.xpath_name
+          end
+          
+          def test_relationships
+            assert_kind_of ScalarExpression, ColumnReference.new('Table1', '*', '/xpath')
+          end
+          
+          def test_to_s
+            r = ColumnReference.new('Table1', '*', '/xpath')
+            assert_equal 'Table1.*', r.to_s
+          end
+          
+          def test_xml
+            r1 = ColumnReference.new('Table1', '*', '/xpath')
+            r2 = ColumnReference.from_xml(r1.to_xml)
+            assert_equal r1, r2
+          end
+        end
+        
+        class RealLiteralTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              RealLiteral.new(10.1)
+            }
+            
+            assert_raises ArgumentError do
+              RealLiteral.new(nil)
+            end
+            assert_raises ArgumentError do
+              RealLiteral.new('blah')
+            end
+          end
+          
+          def test_accessors
+            r = RealLiteral.new(10.1)
+            
+            assert_equal 10.1, r.value
+            r.value = 1.2
+            assert_equal 1.2, r.value
+          end
+          
+          def test_relationships
+            assert_kind_of NumberLiteral, RealLiteral.new(10.1)
+          end
+          
+          def test_to_s
+            assert_equal "10.1", RealLiteral.new(10.1).to_s
+          end
+          
+          def test_xml
+            r1 = RealLiteral.new(10.1)
+            r2 = RealLiteral.from_xml(r1.to_xml)
+            assert_equal r1, r2
+          end
+        end
+        
+        class IntegerLiteralTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              IntegerLiteral.new(10)
+            }
+            
+            assert_raises ArgumentError do
+              IntegerLiteral.new(nil)
+            end
+            assert_raises ArgumentError do
+              IntegerLiteral.new('blah')
+            end
+          end
+          
+          def test_accessors
+            r = IntegerLiteral.new(10)
+            
+            assert_equal 10, r.value
+            r.value = 1
+            assert_equal 1, r.value
+          end
+          
+          def test_relationships
+            assert_kind_of NumberLiteral, IntegerLiteral.new(10)
+          end
+          
+          def test_to_s
+            assert_equal "10", IntegerLiteral.new(10.1).to_s
+          end
+          
+          def test_xml
+            r1 = IntegerLiteral.new(10)
+            r2 = IntegerLiteral.from_xml(r1.to_xml)
+            assert_equal r1, r2
+          end
+        end
+        
+        class StringLiteralTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              StringLiteral.new('test')
+            }
+            
+            assert_raises ArgumentError do
+              StringLiteral.new(nil)
+            end
+          end
+          
+          def test_accessors
+            r = StringLiteral.new('test')
+            
+            assert_equal 'test', r.value
+            r.value = 'test2'
+            assert_equal 'test2', r.value
+          end
+          
+          def test_relationships
+            assert_kind_of Literal, StringLiteral.new('test')
+          end
+          
+          def test_to_s
+            assert_equal "'test'", StringLiteral.new('test').to_s
+          end
+          
+          def test_xml
+            r1 = StringLiteral.new('test')
+            r2 = StringLiteral.from_xml(r1.to_xml)
+            assert_equal r1, r2
+          end
+        end
+        
+        class AtomTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              Atom.new(RealLiteral.new(10.1), 'm')
+              Atom.new(RealLiteral.new(10.1))
+              Atom.new(IntegerLiteral.new(10))
+              Atom.new(StringLiteral.new('blah'))
+            }
+            
+            assert_raises ArgumentError do
+              Atom.new
+            end
+            
+            assert_raises TypeError do
+              Atom.new(ColumnReference.new('Table1', '*', '/xpath'))
+            end
+          end
+          
+          def test_accessors
+            a = Atom.new(123.4, 's')
+            
+            assert_equal RealLiteral.new(123.4), a.literal
+            a.literal = 51.2
+            assert_equal RealLiteral.new(51.2), a.literal
+            assert_equal 's', a.unit
+            a.unit = 'm'
+            assert_equal 'm', a.unit
+          end
+          
+          def test_relationships
+            assert_kind_of ScalarExpression, Atom.new(123.4, 's')
+          end
+          
+          def test_to_s
+            assert_equal '123.4', Atom.new(123.4, 's').to_s
+          end
+          
+          def test_xml
+            a1 = Atom.new(123.4, 's')
+            a2 = Atom.from_xml(a1.to_xml)
+            assert_equal a1, a2
+          end
+        end
+        
+        class SelectionOptionTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              SelectionOption.new(AllOrDistinct.new('All'))
+              SelectionOption.new('DISTINCT')
+            }
+            
+            assert_raises ArgumentError do
+              SelectionOption.new(nil)
+            end
+            
+            assert_raises TypeError do
+              SelectionOption.new(Atom.new(123.4))
+            end
+          end
+          
+          def test_accessors
+            o = SelectionOption.new('All')
+            
+            assert_equal AllOrDistinct.new('All'), o.option
+            o.option = AllOrDistinct.new('DISTINCT')
+            assert_equal AllOrDistinct.new('DISTINCT'), o.option
+          end
+          
+          def test_to_s
+            assert_equal 'DISTINCT', SelectionOption.new('DISTINCT').to_s
+            assert_equal 'All', SelectionOption.new('All').to_s
+          end
+          
+          def test_xml
+            o1 = SelectionOption.new('DISTINCT')
+            o2 = SelectionOption.from_xml(o1.to_xml)
+            assert_equal o1, o2
+          end
+        end
+        
+        class TrigonometricFunctionTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              TrigonometricFunction.new('COS', ColumnReference.new('a', 'period'), SelectionOption.new('DISTINCT'))
+              TrigonometricFunction.new('COS', ColumnReference.new('a', 'period'))
+            }
+            
+            assert_raises ArgumentError do
+              TrigonometricFunction.new('COS', nil)
+            end
+            assert_raises ArgumentError do
+              TrigonometricFunction.new(nil, ColumnReference.new('a', 'period'))
+            end
+            
+            assert_raises TypeError do
+              TrigonometricFunction.new(SelectionOption.new('DISTINCT'), ColumnReference.new('a', 'period'))
+            end
+            assert_raises TypeError do
+              TrigonometricFunction.new('COS', SelectionOption.new('DISTINCT'))
+            end
+          end
+          
+          def test_accessors
+            f = TrigonometricFunction.new('COS', ColumnReference.new('a', 'period'), SelectionOption.new('DISTINCT'))
+            
+            assert_equal TrigonometricFunctionName.new('COS'), f.name
+            assert_equal ColumnReference.new('a', 'period'), f.arg
+            assert_equal SelectionOption.new('DISTINCT'), f.allow
+            f.name = TrigonometricFunctionName.new('TAN')
+            assert_equal TrigonometricFunctionName.new('TAN'), f.name
+            f.arg = Atom.new(101.2)
+            assert_equal Atom.new(101.2), f.arg
+            f.allow = SelectionOption.new('All')
+            assert_equal SelectionOption.new('All'), f.allow
+          end
+          
+          def test_relationships
+            assert_kind_of Function, TrigonometricFunction.new('COS', ColumnReference.new('a', 'period'))
+          end
+          
+          def test_to_s
+            f = TrigonometricFunction.new('COS', ColumnReference.new('a', 'period'), SelectionOption.new('All'))
+            assert_equal 'All COS(a.period)', f.to_s
+            
+            f = TrigonometricFunction.new('TAN', Atom.new(90.2))
+            assert_equal 'TAN(90.2)', f.to_s
+          end
+          
+          def test_xml
+            f1 = TrigonometricFunction.new('COS', ColumnReference.new('a', 'period'), SelectionOption.new('All'))
+            f2 = TrigonometricFunction.from_xml(f1.to_xml)
+            assert_equal f1, f2
+          end
+        end
+        
+        class MathFunctionTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              MathFunction.new('SQRT', ColumnReference.new('a', 'period'), SelectionOption.new('DISTINCT'))
+              MathFunction.new('LOG10', ColumnReference.new('a', 'period'))
+            }
+            
+            assert_raises ArgumentError do
+              MathFunction.new('SQRT', nil)
+            end
+            assert_raises ArgumentError do
+              MathFunction.new(nil, ColumnReference.new('a', 'period'))
+            end
+            
+            assert_raises TypeError do
+              MathFunction.new(SelectionOption.new('DISTINCT'), ColumnReference.new('a', 'period'))
+            end
+            assert_raises TypeError do
+              MathFunction.new('COS', SelectionOption.new('DISTINCT'))
+            end
+          end
+          
+          def test_accessors
+            f = MathFunction.new('SQRT', ColumnReference.new('a', 'period'), SelectionOption.new('DISTINCT'))
+            
+            assert_equal MathFunctionName.new('SQRT'), f.name
+            assert_equal ColumnReference.new('a', 'period'), f.arg
+            assert_equal SelectionOption.new('DISTINCT'), f.allow
+            f.name = MathFunctionName.new('EXP')
+            assert_equal MathFunctionName.new('EXP'), f.name
+            f.arg = Atom.new(101.2)
+            assert_equal Atom.new(101.2), f.arg
+            f.allow = SelectionOption.new('All')
+            assert_equal SelectionOption.new('All'), f.allow
+          end
+          
+          def test_relationships
+            assert_kind_of Function, MathFunction.new('ABS', ColumnReference.new('a', 'period'))
+          end
+          
+          def test_to_s
+            f = MathFunction.new('ABS', ColumnReference.new('a', 'period'), SelectionOption.new('All'))
+            assert_equal 'All ABS(a.period)', f.to_s
+            
+            f = MathFunction.new('FLOOR', Atom.new(90.2))
+            assert_equal 'FLOOR(90.2)', f.to_s
+          end
+          
+          def test_xml
+            f1 = MathFunction.new('ABS', ColumnReference.new('a', 'period'), SelectionOption.new('All'))
+            f2 = MathFunction.from_xml(f1.to_xml)
+            assert_equal f1, f2
+          end
+        end
+        
+        class AggregateFunctionTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              AggregateFunction.new('AVG', ColumnReference.new('a', 'period'), SelectionOption.new('DISTINCT'))
+              AggregateFunction.new('MIN', ColumnReference.new('a', 'period'))
+            }
+            
+            assert_raises ArgumentError do
+              AggregateFunction.new('AVG', nil)
+            end
+            assert_raises ArgumentError do
+              AggregateFunction.new(nil, ColumnReference.new('a', 'period'))
+            end
+            
+            assert_raises TypeError do
+              AggregateFunction.new(SelectionOption.new('DISTINCT'), ColumnReference.new('a', 'period'))
+            end
+            assert_raises TypeError do
+              AggregateFunction.new('COS', SelectionOption.new('DISTINCT'))
+            end
+          end
+          
+          def test_accessors
+            f = AggregateFunction.new('SUM', ColumnReference.new('a', 'period'), SelectionOption.new('DISTINCT'))
+            
+            assert_equal AggregateFunctionName.new('SUM'), f.name
+            assert_equal ColumnReference.new('a', 'period'), f.arg
+            assert_equal SelectionOption.new('DISTINCT'), f.allow
+            f.name = AggregateFunctionName.new('MAX')
+            assert_equal AggregateFunctionName.new('MAX'), f.name
+            f.arg = Atom.new(101.2)
+            assert_equal Atom.new(101.2), f.arg
+            f.allow = SelectionOption.new('All')
+            assert_equal SelectionOption.new('All'), f.allow
+          end
+          
+          def test_relationships
+            assert_kind_of Function, AggregateFunction.new('MIN', ColumnReference.new('a', 'period'))
+          end
+          
+          def test_to_s
+            f = AggregateFunction.new('AVG', ColumnReference.new('a', 'period'), SelectionOption.new('All'))
+            assert_equal 'All AVG(a.period)', f.to_s
+            
+            f = AggregateFunction.new('COUNT', Atom.new(90.2))
+            assert_equal 'COUNT(90.2)', f.to_s
+          end
+          
+          def test_xml
+            f1 = AggregateFunction.new('COUNT', ColumnReference.new('a', 'period'), SelectionOption.new('All'))
+            f2 = AggregateFunction.from_xml(f1.to_xml)
+            assert_equal f1, f2
+          end
+        end
+        
+        class AliasSelectionItemTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              AliasSelectionItem.new(ColumnReference.new('a', 'period'), 'frequency')
+              AliasSelectionItem.new(ColumnReference.new('a', 'period'))
+            }
+            
+            assert_raises ArgumentError do
+              AliasSelectionItem.new
+            end
+            
+            assert_raises TypeError do
+              AliasSelectionItem.new('blah')
+            end
+          end
+          
+          def test_accessors
+            a = AliasSelectionItem.new(ColumnReference.new('a', 'period'), 'frequency')
+            
+            assert_equal ColumnReference.new('a', 'period'), a.expression
+            assert_equal 'frequency', a.as
+            a.expression = ColumnReference.new('b', 'count')
+            assert_equal ColumnReference.new('b', 'count'), a.expression
+            a.as = 'sum'
+            assert_equal 'sum', a.as
+          end
+          
+          def test_relationships
+            assert_kind_of SelectionItem, AliasSelectionItem.new(ColumnReference.new('a', 'period'), 'frequency')
+          end
+          
+          def test_to_s
+            a = AliasSelectionItem.new(ColumnReference.new('a', 'period'), 'frequency')
+            assert_equal 'a.period AS frequency', a.to_s
+          end
+          
+          def test_xml
+            a1 = AliasSelectionItem.new(ColumnReference.new('a', 'period'), 'frequency')
+            a2 = AliasSelectionItem.from_xml(a1.to_xml)
+            assert_equal a1, a2
+          end
+        end
+        
+        class AllSelectionItemTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised { AllSelectionItem.new }
+          end
+          
+          def test_relationships
+            assert_kind_of SelectionItem, AllSelectionItem.new
+          end
+          
+          def test_to_s
+            assert_equal '*', AllSelectionItem.new.to_s
+          end
+          
+          def test_xml
+            a1 = AllSelectionItem.new
+            a2 = AllSelectionItem.from_xml(a1.to_xml)
+            assert_equal a1, a2
+          end
+        end
+        
+        class ArchiveTableTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              ArchiveTable.new('NOAO', 'photometry', 'NOAOPhot')
+              ArchiveTable.new('NOAO', 'photometry')
+            }
+            
+            assert_raises ArgumentError do
+              ArchiveTable.new('NOAO')
+            end
+            assert_raises ArgumentError do
+              ArchiveTable.new(nil, 'photometry')
+            end
+          end
+          
+          def test_accessors
+            t = ArchiveTable.new('NOAO', 'photometry', 'NOAOPhot')
+            
+            assert_equal 'NOAO', t.archive
+            assert_equal 'photometry', t.name
+            assert_equal 'NOAOPhot', t.table_alias
+            t.archive = 'STSCI'
+            assert_equal 'STSCI', t.archive
+            t.name = 'spectra'
+            assert_equal 'spectra', t.name
+            t.table_alias = 'STSCISpec'
+            assert_equal 'STSCISpec', t.table_alias
+          end
+          
+          def test_relationships
+            assert_kind_of FromTable, ArchiveTable.new('NOAO', 'photometry', 'NOAOPhot')
+          end
+          
+          def test_to_s
+            t = ArchiveTable.new('NOAO', 'photometry', 'NOAOPhot')
+            assert_equal 'NOAO:photometry NOAOPhot', t.to_s
+            
+            t = ArchiveTable.new('NOAO', 'photometry')
+            assert_equal 'NOAO:photometry', t.to_s
+          end
+          
+          def test_xml
+            t1 = ArchiveTable.new('NOAO', 'photometry', 'NOAOPhot')
+            t2 = ArchiveTable.from_xml(t1.to_xml)
+            assert_equal t1, t2
+          end
+        end
+        
+        class TableTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              Table.new('photometry', 'phot', '/phot')
+              Table.new('photometry', 'phot')
+              Table.new('photometry')
+            }
+            
+            assert_raises ArgumentError do
+              Table.new
+            end
+          end
+          
+          def test_accessors
+            t = Table.new('photometry', 'phot', '/phot')
+            
+            assert_equal 'photometry', t.name
+            assert_equal 'phot', t.table_alias
+            assert_equal '/phot', t.xpath_name
+            t.name = 'spectroscopy'
+            assert_equal 'spectroscopy', t.name
+            t.table_alias = 'spec'
+            assert_equal 'spec', t.table_alias
+            t.xpath_name = '/spec'
+            assert_equal '/spec', t.xpath_name
+          end
+          
+          def test_relationships
+            assert_kind_of FromTable, Table.new('photometry', 'phot', '/phot')
+          end
+          
+          def test_to_s
+            t = Table.new('photometry', 'phot', '/phot')
+            assert_equal 'photometry phot', t.to_s
+            
+            t = Table.new('photometry')
+            assert_equal 'photometry', t.to_s
+          end
+          
+          def test_xml
+            t1 = Table.new('photometry', 'phot', '/phot')
+            t2 = Table.from_xml(t1.to_xml)
+            assert_equal t1, t2
+          end
+        end
+        
+        class IncludeTableTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised { IncludeTable.new('photometry') }
+            assert_raises ArgumentError do
+              IncludeTable.new
+            end
+          end
+          
+          def test_accessors
+            t = IncludeTable.new('photometry')
+            
+            assert_equal 'photometry', t.name
+            t.name = 'spectroscopy'
+            assert_equal 'spectroscopy', t.name
+          end
+          
+          def test_relationships
+            assert_kind_of XMatchTableAlias, IncludeTable.new('photometry')
+          end
+          
+          def test_to_s
+            t = IncludeTable.new('photometry')
+            assert_equal 'photometry', t.to_s
+          end
+          
+          def test_xml
+            t1 = IncludeTable.new('photometry')
+            t2 = IncludeTable.from_xml(t1.to_xml)
+            assert_equal t1, t2
+          end
+        end
+        
+        class DropTableTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised { DropTable.new('photometry') }
+            assert_raises ArgumentError do
+              DropTable.new
+            end
+          end
+          
+          def test_accessors
+            t = DropTable.new('photometry')
+            
+            assert_equal 'photometry', t.name
+            t.name = 'spectroscopy'
+            assert_equal 'spectroscopy', t.name
+          end
+          
+          def test_relationships
+            assert_kind_of XMatchTableAlias, DropTable.new('photometry')
+          end
+          
+          def test_to_s
+            t = DropTable.new('photometry')
+            assert_equal '!photometry', t.to_s
+          end
+          
+          def test_xml
+            t1 = DropTable.new('photometry')
+            t2 = DropTable.from_xml(t1.to_xml)
+            assert_equal t1, t2
+          end
+        end
+        
+        class IntersectionSearchTest < ::Test::Unit::TestCase
+          def setup
+            @condition1 = XMatch.new(
+              [IncludeTable.new('phot'), IncludeTable.new('spec'), DropTable.new('aux')],
+              '<',
+              3.5
+            )
+            
+            @condition2 = XMatch.new(
+              [IncludeTable.new('tbl1'), IncludeTable.new('tbl2'),],
+              '=',
+              1.1
+            )
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              IntersectionSearch.new(@condition1, @condition2)
+            }
+            
+            assert_raises ArgumentError do
+              IntersectionSearch.new(@condition1, nil)
+            end
+            assert_raises ArgumentError do
+              IntersectionSearch.new(nil, @condition2)
+            end
+            
+            assert_raises TypeError do
+              IntersectionSearch.new(@condition1, 'blah')
+            end
+            assert_raises TypeError do
+              IntersectionSearch.new('blah', @condition2)
+            end
+          end
+          
+          def test_accessors
+            s = IntersectionSearch.new(@condition1, @condition2)
+            
+            assert_equal @condition1, s.condition1
+            assert_equal @condition2, s.condition2
+          end
+          
+          def test_relationships
+            assert_kind_of Search, IntersectionSearch.new(@condition1, @condition2)
+          end
+          
+          def test_to_s
+            s = IntersectionSearch.new(@condition1, @condition2)
+            assert_equal 'XMATCH(phot, spec, !aux) < 3.5 AND XMATCH(tbl1, tbl2) = 1.1', s.to_s
+          end
+          
+          def test_xml
+            s1 = IntersectionSearch.new(@condition1, @condition2)
+            s2 = IntersectionSearch.from_xml(s1.to_xml)
+            assert_equal s1, s2
+          end
+        end
+        
+        class UnionSearchTest < ::Test::Unit::TestCase
+          def setup
+            @condition1 = XMatch.new(
+              [IncludeTable.new('phot'), IncludeTable.new('spec'), DropTable.new('aux')],
+              '<',
+              3.5
+            )
+            
+            @condition2 = XMatch.new(
+              [IncludeTable.new('tbl1'), IncludeTable.new('tbl2'),],
+              '=',
+              1.1
+            )
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              UnionSearch.new(@condition1, @condition2)
+            }
+            
+            assert_raises ArgumentError do
+              UnionSearch.new(@condition1, nil)
+            end
+            assert_raises ArgumentError do
+              UnionSearch.new(nil, @condition2)
+            end
+            
+            assert_raises TypeError do
+              UnionSearch.new(@condition1, 'blah')
+            end
+            assert_raises TypeError do
+              UnionSearch.new('blah', @condition2)
+            end
+          end
+          
+          def test_accessors
+            s = UnionSearch.new(@condition1, @condition2)
+            
+            assert_equal @condition1, s.condition1
+            assert_equal @condition2, s.condition2
+          end
+          
+          def test_relationships
+            assert_kind_of Search, UnionSearch.new(@condition1, @condition2)
+          end
+          
+          def test_to_s
+            s = UnionSearch.new(@condition1, @condition2)
+            assert_equal 'XMATCH(phot, spec, !aux) < 3.5 OR XMATCH(tbl1, tbl2) = 1.1', s.to_s
+          end
+          
+          def test_xml
+            s1 = UnionSearch.new(@condition1, @condition2)
+            s2 = UnionSearch.from_xml(s1.to_xml)
+            assert_equal s1, s2
+          end
+        end
+        
+        class XMatchTest < ::Test::Unit::TestCase
+          def setup
+            @tables = [IncludeTable.new('phot'), IncludeTable.new('spec'), DropTable.new('aux')]
+            @nature = '<'
+            @sigma = 3.5
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              XMatch.new(@tables, @nature, @sigma)
+            }
+            
+            assert_raises ArgumentError do
+              XMatch.new(nil, @nature, @sigma)
+            end
+            assert_raises ArgumentError do
+              XMatch.new(@tables, nil, @sigma)
+            end
+            assert_raises ArgumentError do
+              XMatch.new(@tables, @nature, nil)
+            end
+            
+            assert_raises TypeError do
+              XMatch.new('blah', @nature, @sigma)
+            end
+            assert_raises TypeError do
+              XMatch.new(@tables, BinaryOperator.new('+'), @sigma)
+            end
+            assert_raises TypeError do
+              XMatch.new(@tables, @nature, StringLiteral.new('blah'))
+            end
+          end
+          
+          def test_accessors
+            m = XMatch.new(@tables, @nature, @sigma)
+            
+            assert_equal @tables, m.tables
+            assert_equal Comparison.new(@nature), m.nature
+            assert_equal RealLiteral.new(3.5), m.sigma
+            m.tables = [IncludeTable.new('phot'), DropTable.new('spec')]
+            assert_equal [IncludeTable.new('phot'), DropTable.new('spec')], m.tables
+            m.nature = '<>'
+            assert_equal Comparison.new('<>'), m.nature
+            m.sigma = 4
+            assert_equal IntegerLiteral.new(4), m.sigma
+          end
+          
+          def test_relationships
+            assert_kind_of Search, XMatch.new(@tables, @nature, @sigma)
+          end
+          
+          def test_to_s
+            m = XMatch.new(@tables, @nature, @sigma)
+            assert_equal 'XMATCH(phot, spec, !aux) < 3.5', m.to_s
+          end
+          
+          def test_xml
+            m1 = XMatch.new(@tables, @nature, @sigma)
+            m2 = XMatch.from_xml(m1.to_xml)
+            assert_equal m1, m2
+          end
+        end
+        
+        class LikePredTest < ::Test::Unit::TestCase
+          def setup
+            @arg = ColumnReference.new('a', 'name')
+            @pattern = Atom.new(StringLiteral.new('m%'))
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              LikePred.new(@arg, @pattern)
+            }
+          
+            assert_raises ArgumentError do
+              LikePred.new(@arg, nil)
+            end
+            assert_raises ArgumentError do
+              LikePred.new(nil, @pattern)
+            end
+            
+            assert_raises TypeError do
+              LikePred.new('blah', @pattern)
+            end
+            assert_raises TypeError do
+              LikePred.new(@arg, @arg)
+            end
+          end
+          
+          def test_accessors
+            p = LikePred.new(@arg, @pattern)
+            
+            assert_equal @arg, p.arg
+            assert_equal @pattern, p.pattern
+            p.arg = Atom.new(10.1)
+            assert_equal Atom.new(10.1), p.arg
+            p.pattern = Atom.new(10.1)
+            assert_equal Atom.new(10.1), p.pattern
+          end
+          
+          def test_relationships
+            assert_kind_of Search, LikePred.new(@arg, @pattern)
+          end
+          
+          def test_to_s
+            p = LikePred.new(@arg, @pattern)
+            assert_equal "a.name LIKE 'm%'", p.to_s
+          end
+          
+          def test_xml
+            p1 = LikePred.new(@arg, @pattern)
+            p2 = LikePred.from_xml(p1.to_xml)
+            assert_equal p1, p2
+          end
+        end
+        
+        class NotLikePredTest < ::Test::Unit::TestCase
+          def setup
+            @arg = ColumnReference.new('a', 'name')
+            @pattern = Atom.new(StringLiteral.new('m%'))
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              NotLikePred.new(@arg, @pattern)
+            }
+          
+            assert_raises ArgumentError do
+              NotLikePred.new(@arg, nil)
+            end
+            assert_raises ArgumentError do
+              NotLikePred.new(nil, @pattern)
+            end
+            
+            assert_raises TypeError do
+              NotLikePred.new('blah', @pattern)
+            end
+            assert_raises TypeError do
+              NotLikePred.new(@arg, @arg)
+            end
+          end
+          
+          def test_accessors
+            p = NotLikePred.new(@arg, @pattern)
+            
+            assert_equal @arg, p.arg
+            assert_equal @pattern, p.pattern
+            p.arg = Atom.new(10.1)
+            assert_equal Atom.new(10.1), p.arg
+            p.pattern = Atom.new(10.1)
+            assert_equal Atom.new(10.1), p.pattern
+          end
+          
+          def test_relationships
+            assert_kind_of LikePred, NotLikePred.new(@arg, @pattern)
+          end
+          
+          def test_to_s
+            p = NotLikePred.new(@arg, @pattern)
+            assert_equal "a.name NOT LIKE 'm%'", p.to_s
+          end
+          
+          def test_xml
+            p1 = NotLikePred.new(@arg, @pattern)
+            p2 = NotLikePred.from_xml(p1.to_xml)
+            assert_equal p1, p2
+          end
+        end
+        
+        class ClosedSearchTest < ::Test::Unit::TestCase
+          def setup
+            @condition = UnionSearch.new(
+              XMatch.new(
+                [IncludeTable.new('phot'), IncludeTable.new('spec'), DropTable.new('aux')],
+                '<',
+                3.5
+              ),
+              XMatch.new(
+                [IncludeTable.new('tbl1'), IncludeTable.new('tbl2'),],
+                '=',
+                1.1
+              )
+            )
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              ClosedSearch.new(@condition)
+            }
+            
+            assert_raises ArgumentError do
+              ClosedSearch.new(nil)
+            end
+            
+            assert_raises TypeError do
+              ClosedSearch.new('blah')
+            end
+          end
+          
+          def test_accessors
+            s = ClosedSearch.new(@condition)
+            
+            assert_equal @condition, s.condition
+          end
+          
+          def test_relationships
+            assert_kind_of Search, ClosedSearch.new(@condition)
+          end
+          
+          def test_to_s
+            e = ClosedSearch.new(@condition)
+            assert_equal "(XMATCH(phot, spec, !aux) < 3.5 OR XMATCH(tbl1, tbl2) = 1.1)", e.to_s
+          end
+          
+          def test_xml
+            e1 = ClosedSearch.new(@condition)
+            e2 = ClosedSearch.from_xml(e1.to_xml)
+            assert_equal e1, e2
+          end
+        end
+        
+        class ComparisonPredTest < ::Test::Unit::TestCase
+          def setup
+            @arg1 = ColumnReference.new('phot', 'mag')
+            @comparison = Comparison.new('>')
+            @arg2 = Atom.new(15)
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              ComparisonPred.new(@arg1, @comparison, @arg2)
+            }
+            
+            assert_raises ArgumentError do
+              ComparisonPred.new(@arg1, @comparison, nil)
+            end
+            assert_raises ArgumentError do
+              ComparisonPred.new(@arg1, nil, @arg2)
+            end
+            assert_raises ArgumentError do
+              ComparisonPred.new(nil, @comparison, @arg2)
+            end
+            
+            assert_raises TypeError do
+              ComparisonPred.new(@arg1, @comparison, 'blah')
+            end
+            assert_raises TypeError do
+              ComparisonPred.new(@arg1, Atom.new('='), @arg2)
+            end
+            assert_raises TypeError do
+              ComparisonPred.new('blah', @comparison, @arg2)
+            end
+          end
+          
+          def test_accessors
+            p = ComparisonPred.new(@arg1, @comparison, @arg2)
+            
+            assert_equal @arg1, p.arg1
+            assert_equal @comparison, p.comparison
+            assert_equal @arg2, p.arg2
+          end
+          
+          def test_relationships
+            assert_kind_of Search, ComparisonPred.new(@arg1, @comparison, @arg2)
+          end
+          
+          def test_to_s
+            p = ComparisonPred.new(@arg1, @comparison, @arg2)
+            assert_equal 'phot.mag > 15', p.to_s
+          end
+          
+          def test_xml
+            p1 = ComparisonPred.new(@arg1, @comparison, @arg2)
+            p2 = ComparisonPred.from_xml(p1.to_xml)
+            assert_equal p1, p2
+          end
+        end
+        
+        class BetweenPredTest < ::Test::Unit::TestCase
+          def setup
+            @arg1 = ColumnReference.new('phot', 'mag')
+            @arg2 = Atom.new(15)
+            @arg3 = Atom.new(20)
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              BetweenPred.new(@arg1, @arg2, @arg3)
+            }
+            
+            assert_raises ArgumentError do
+              BetweenPred.new(@arg1, @arg2, nil)
+            end
+            assert_raises ArgumentError do
+              BetweenPred.new(@arg1, nil, @arg3)
+            end
+            assert_raises ArgumentError do
+              BetweenPred.new(nil, @arg2, @arg3)
+            end
+            
+            assert_raises TypeError do
+              BetweenPred.new(@arg1, @arg2, 'blah')
+            end
+            assert_raises TypeError do
+              BetweenPred.new(@arg1, 'blah', @arg3)
+            end
+            assert_raises TypeError do
+              BetweenPred.new('blah', @arg2, @arg3)
+            end
+          end
+          
+          def test_accessors
+            p = BetweenPred.new(@arg1, @arg2, @arg3)
+            
+            assert_equal @arg1, p.arg1
+            assert_equal @arg2, p.arg2
+            assert_equal @arg3, p.arg3
+          end
+          
+          def test_relationships
+            assert_kind_of Search, BetweenPred.new(@arg1, @arg2, @arg3)
+          end
+          
+          def test_to_s
+            p = BetweenPred.new(@arg1, @arg2, @arg3)
+            assert_equal 'phot.mag BETWEEN 15 AND 20', p.to_s
+          end
+          
+          def test_xml
+            p1 = BetweenPred.new(@arg1, @arg2, @arg3)
+            p2 = BetweenPred.from_xml(p1.to_xml)
+            assert_equal p1, p2
+          end
+        end
+        
+        class NotBetweenPredTest < ::Test::Unit::TestCase
+          def setup
+            @arg1 = ColumnReference.new('phot', 'mag')
+            @arg2 = Atom.new(15)
+            @arg3 = Atom.new(20)
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              NotBetweenPred.new(@arg1, @arg2, @arg3)
+            }
+            
+            assert_raises ArgumentError do
+              NotBetweenPred.new(@arg1, @arg2, nil)
+            end
+            assert_raises ArgumentError do
+              NotBetweenPred.new(@arg1, nil, @arg3)
+            end
+            assert_raises ArgumentError do
+              NotBetweenPred.new(nil, @arg2, @arg3)
+            end
+            
+            assert_raises TypeError do
+              NotBetweenPred.new(@arg1, @arg2, 'blah')
+            end
+            assert_raises TypeError do
+              NotBetweenPred.new(@arg1, 'blah', @arg3)
+            end
+            assert_raises TypeError do
+              NotBetweenPred.new('blah', @arg2, @arg3)
+            end
+          end
+          
+          def test_accessors
+            p = NotBetweenPred.new(@arg1, @arg2, @arg3)
+            
+            assert_equal @arg1, p.arg1
+            assert_equal @arg2, p.arg2
+            assert_equal @arg3, p.arg3
+          end
+          
+          def test_relationships
+            assert_kind_of Search, NotBetweenPred.new(@arg1, @arg2, @arg3)
+          end
+          
+          def test_to_s
+            p = NotBetweenPred.new(@arg1, @arg2, @arg3)
+            assert_equal 'phot.mag NOT BETWEEN 15 AND 20', p.to_s
+          end
+          
+          def test_xml
+            p1 = NotBetweenPred.new(@arg1, @arg2, @arg3)
+            p2 = NotBetweenPred.from_xml(p1.to_xml)
+            assert_equal p1, p2
+          end
+        end
+        
+        class InverseSearchTest < ::Test::Unit::TestCase
+          def setup
+            @condition = ComparisonPred.new(
+              ColumnReference.new('phot', 'mag'),
+              Comparison.new('>'),
+              Atom.new(15)
+            )
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              InverseSearch.new(@condition)
+            }
+            
+            assert_raises ArgumentError do
+              InverseSearch.new(nil)
+            end
+            
+            assert_raises TypeError do
+              InverseSearch.new('blah')
+            end
+          end
+          
+          def test_accessors
+            s = InverseSearch.new(@condition)
+            assert_equal @condition, s.condition
+          end
+          
+          def test_relationships
+            s = InverseSearch.new(@condition)
+            assert_kind_of Search, s
+          end
+          
+          def test_to_s
+            s = InverseSearch.new(@condition)
+            assert_equal 'NOT phot.mag > 15', s.to_s
+          end
+          
+          def test_xml
+            s1 = InverseSearch.new(@condition)
+            s2 = InverseSearch.from_xml(s1.to_xml)
+            assert_equal s1, s2
+          end
+        end
+        
+        class RegionSearchTest < ::Test::Unit::TestCase
+          def setup
+            @region = Circle.new(:center => [12.5, 23.0], :radius => 5.0, :unit => 'deg', :coord_system_id => 'J2000')
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              RegionSearch.new(@region)
+            }
+            
+            assert_raises ArgumentError do
+              RegionSearch.new(nil)
+            end
+            
+            assert_raises TypeError do
+              RegionSearch.new('blah')
+            end
+          end
+          
+          def test_accessors
+            s = RegionSearch.new(@region)
+            assert_equal @region, s.region
+          end
+          
+          def test_relationships
+            assert_kind_of Search, RegionSearch.new(@region)
+          end
+          
+          def test_to_s
+            s = RegionSearch.new(@region)
+            assert_equal 'REGION(CIRCLE J2000 12.5 23.0 5.0)', s.to_s
+          end
+          
+          def test_xml
+            s1 = RegionSearch.new(@region)
+            s2 = RegionSearch.from_xml(s1.to_xml)
+
+            assert_equal s1, s2
+          end
+        end
+        
+        class HavingTest < ::Test::Unit::TestCase
+          def setup
+            @condition = RegionSearch.new(
+              Circle.new(:center => [12.5, 23.0], :radius => 5.0, :unit => 'deg', :coord_system_id => 'J2000')
+            )
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              Having.new(@condition)
+            }
+            
+            assert_raises ArgumentError do
+              Having.new(nil)
+            end
+            
+            assert_raises TypeError do
+              Having.new('blah')
+            end
+          end
+          
+          def test_accessors
+            h = Having.new(@condition)
+            assert_equal @condition, h.condition
+          end
+          
+          def test_to_s
+            h = Having.new(@condition)
+            assert_equal 'HAVING REGION(CIRCLE J2000 12.5 23.0 5.0)', h.to_s
+          end
+          
+          def test_xml
+            h1 = Having.new(@condition)
+            h2 = Having.from_xml(h1.to_xml)
+            assert_equal h1, h2
+          end
+        end
+        
+        class GroupByTest < ::Test::Unit::TestCase
+          def setup
+            @columns = [
+              ColumnReference.new('Phot', 'vmag'),
+              ColumnReference.new('Phot', 'imag')
+            ]
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              GroupBy.new(@columns)
+            }
+            
+            assert_raises ArgumentError do
+              GroupBy.new(nil)
+            end
+            
+            assert_raises RuntimeError do
+              GroupBy.new([])
+            end
+            
+            assert_raises TypeError do
+              GroupBy.new('blah')
+            end
+          end
+          
+          def test_accessors
+            g = GroupBy.new(@columns)
+            assert_equal @columns, g.columns
+          end
+        
+          def test_to_s
+            g = GroupBy.new(@columns)
+            assert_equal 'GROUP BY Phot.vmag, Phot.imag', g.to_s
+          end
+          
+          def test_xml
+            g1 = GroupBy.new(@columns)
+            g2 = GroupBy.from_xml(g1.to_xml)
+            assert_equal g1, g2
+          end
+        end
+        
+        class WhereTest < ::Test::Unit::TestCase
+          def setup
+            @condition = ComparisonPred.new(
+              ColumnReference.new('phot', 'mag'),
+              Comparison.new('>'),
+              Atom.new(15)
+            )
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              Where.new(@condition)
+            }
+            
+            assert_raises ArgumentError do
+              Where.new(nil)
+            end
+            
+            assert_raises TypeError do
+              Where.new('blah')
+            end
+          end
+          
+          def test_accessors
+            w = Where.new(@condition)
+            assert_equal @condition, w.condition
+          end
+          
+          def test_to_s
+            w = Where.new(@condition)
+            assert_equal 'WHERE phot.mag > 15', w.to_s
+          end
+          
+          def test_xml
+            w1 = Where.new(@condition)
+            w2 = Where.from_xml(w1.to_xml)
+            assert_equal w1, w2
+          end
+        end
+        
+        class FromTest < ::Test::Unit::TestCase
+          def setup
+            @tables = [
+              Table.new('phot', 'p'),
+              Table.new('spec', 's')
+            ]
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              From.new(@tables)
+            }
+            
+            assert_raises ArgumentError do
+              From.new(nil)
+            end
+            
+            assert_raises RuntimeError do
+              From.new([])
+            end
+            
+            assert_raises TypeError do
+              From.new('blah')
+            end
+          end
+          
+          def test_accessors
+            f = From.new(@tables)
+            assert_equal @tables, f.tables
+          end
+          
+          def test_to_s
+            f = From.new(@tables)
+            assert_equal 'FROM phot p, spec s', f.to_s
+          end
+          
+          def test_xml
+            f1 = From.new(@tables)
+            f2 = From.from_xml(f1.to_xml)
+            assert_equal f1, f2
+          end
+        end
+        
+        class SelectionListTest < ::Test::Unit::TestCase
+          def setup
+            @items = [
+              ColumnReference.new('images', 'xdim'),
+              TrigonometricFunction.new('SIN', ColumnReference.new('images', 'period'))
+            ]
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              SelectionList.new(@items)
+            }
+            
+            assert_raises ArgumentError do
+              SelectionList.new(nil)
+            end
+            
+            assert_raises RuntimeError do
+              SelectionList.new([])
+            end
+            
+            assert_raises TypeError do
+              SelectionList.new('blah')
+            end
+          end
+          
+          def test_accessors
+            l = SelectionList.new(@items)
+            assert_equal @items, l.items
+          end
+          
+          def test_to_s
+            l = SelectionList.new(@items)
+            assert_equal 'images.xdim, SIN(images.period)', l.to_s
+          end
+          
+          def test_xml
+            l1 = SelectionList.new(@items)
+            l2 = SelectionList.from_xml(l1.to_xml)
+            assert_equal l1, l2
+          end
+        end
+        
+        class SelectionLimitTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              SelectionLimit.new(10)
+            }
+            
+            assert_raises ArgumentError do
+              SelectionLimit.new(nil)
+            end
+            assert_raises ArgumentError do
+              SelectionLimit.new('blah')
+            end
+          end
+          
+          def test_accessors
+            l = SelectionLimit.new(10)
+            
+            assert_equal 10, l.top
+            l.top = 5
+            assert_equal 5, l.top
+          end
+          
+          def test_to_s
+            assert_equal 'TOP 10', SelectionLimit.new(10).to_s
+          end
+          
+          def test_xml
+            l1 = SelectionLimit.new(10)
+            l2 = SelectionLimit.from_xml(l1.to_xml)
+            assert_equal l1, l2
+          end
+        end
+        
+        class IntoTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              Into.new('phot')
+            }
+            
+            assert_raises ArgumentError do
+              Into.new(nil)
+            end
+          end
+          
+          def test_accessors
+            i = Into.new('phot')
+            
+            assert_equal 'phot', i.table_name
+            i.table_name = 'spec'
+            assert_equal 'spec', i.table_name
+          end
+          
+          def test_to_s
+            assert_equal 'INTO phot', Into.new('phot').to_s
+          end
+          
+          def test_xml
+            i1 = Into.new('phot')
+            i2 = Into.from_xml(i1.to_xml)
+            assert_equal i1, i2
+          end
+        end
+        
+        class OrderOptionTest < ::Test::Unit::TestCase
+          def test_construction
+            assert_nothing_raised {
+              OrderOption.new('ASC')
+              OrderOption.new(OrderDirection.new('DESC'))
+            }
+            
+            assert_raises ArgumentError do
+              OrderOption.new(nil)
+            end
+            
+            assert_raises TypeError do
+              OrderOption.new(Into.new('phot'))
+            end
+          end
+          
+          def test_accessors
+            o = OrderOption.new('DESC')
+            
+            assert_equal OrderDirection.new('DESC'), o.direction
+            o.direction = 'ASC'
+            assert_equal OrderDirection.new('ASC'), o.direction
+          end
+          
+          def test_to_s
+            assert_equal 'ASC', OrderOption.new('ASC').to_s
+          end
+          
+          def test_xml
+            o1 = OrderOption.new('DESC')
+            o2 = OrderOption.from_xml(o1.to_xml)
+            assert_equal o1, o2
+          end
+        end
+        
+        class OrderTest < ::Test::Unit::TestCase
+          def setup
+            @expression = ColumnReference.new('phot', 'mag')
+            @order = OrderOption.new('DESC')
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              Order.new(@expression, @order)
+              Order.new(@expression, nil)
+              Order.new(@expression)
+            }
+            
+            assert_raises ArgumentError do
+              Order.new(nil, @order)
+            end
+            
+            assert_raises TypeError do
+              Order.new('blah', @order)
+            end
+            assert_raises TypeError do
+              Order.new(@expression, @expression)
+            end
+          end
+          
+          def test_accessors
+            o = Order.new(@expression, @order)
+            
+            assert_equal @expression, o.expression
+            assert_equal @order, o.order
+          end
+          
+          def test_to_s
+            assert_equal 'phot.mag DESC', Order.new(@expression, @order).to_s
+            assert_equal 'phot.mag', Order.new(@expression).to_s
+          end
+          
+          def test_xml
+            o1 = Order.new(@expression, @order)
+            o2 = Order.from_xml(o1.to_xml)
+            assert_equal o1, o2
+          end
+        end
+        
+        class OrderExpressionTest < ::Test::Unit::TestCase
+          def setup
+            @items = [
+              Order.new(ColumnReference.new('phot', 'mag'), OrderOption.new('DESC')),
+              Order.new(ColumnReference.new('spec', 'flux'), OrderOption.new('ASC'))
+            ]
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              OrderExpression.new(@items)
+            }
+            
+            assert_raises ArgumentError do
+              OrderExpression.new(nil)
+            end
+            
+            assert_raises RuntimeError do
+              OrderExpression.new([])
+            end
+            
+            assert_raises TypeError do
+              OrderExpression.new('blah')
+            end
+          end
+          
+          def test_accessors
+            e = OrderExpression.new(@items)
+            assert_equal @items, e.items
+          end
+          
+          def test_to_s
+            e = OrderExpression.new(@items)
+            assert_equal 'ORDER BY phot.mag DESC, spec.flux ASC', e.to_s
+          end
+          
+          def test_xml
+            e1 = OrderExpression.new(@items)
+            e2 = OrderExpression.from_xml(e1.to_xml)
+            assert_equal e1, e2
+          end
+        end
+        
+        class ConstantListSetTest < ::Test::Unit::TestCase
+          def setup
+            @items = [
+              RealLiteral.new(10.2),
+              RealLiteral.new(5.4),
+              RealLiteral.new(7.2)
+            ]
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              ConstantListSet.new(@items)
+            }
+            
+            assert_raises ArgumentError do
+              ConstantListSet.new(nil)
+            end
+            
+            assert_raises RuntimeError do
+              ConstantListSet.new([])
+            end
+            
+            assert_raises TypeError do
+              ConstantListSet.new('blah')
+            end
+          end
+          
+          def test_accessors
+            s = ConstantListSet.new(@items)
+            assert_equal @items, s.items
+          end
+          
+          def test_relationships
+            assert_kind_of InclusionSet, ConstantListSet.new(@items)
+          end
+          
+          def test_to_s
+            assert_equal '(10.2, 5.4, 7.2)', ConstantListSet.new(@items).to_s
+          end
+          
+          def test_xml
+            s1 = ConstantListSet.new(@items)
+            s2 = ConstantListSet.from_xml(s1.to_xml)
+            assert_equal s1, s2
+          end
+        end
+        
+        class InclusiveSearchTest < ::Test::Unit::TestCase
+          def setup
+            @expression = ColumnReference.new('phot', 'flag')
+            @set = ConstantListSet.new([IntegerLiteral.new(1), IntegerLiteral.new(2), IntegerLiteral.new(3)])
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              InclusiveSearch.new(@expression, @set)
+            }
+            
+            assert_raises ArgumentError do
+              InclusiveSearch.new(@expression, nil)
+            end
+            assert_raises ArgumentError do
+              InclusiveSearch.new(nil, @set)
+            end
+            
+            assert_raises TypeError do
+              InclusiveSearch.new(@expression, 'blah')
+            end
+            assert_raises TypeError do
+              InclusiveSearch.new('blah', @set)
+            end
+          end
+          
+          def test_accessors
+            s = InclusiveSearch.new(@expression, @set)
+            
+            assert_equal @expression, s.expression
+            assert_equal @set, s.set
+          end
+          
+          def test_relationships
+            assert_kind_of Search, InclusiveSearch.new(@expression, @set)
+          end
+          
+          def test_to_s
+            s = InclusiveSearch.new(@expression, @set)
+            assert_equal 'phot.flag IN (1, 2, 3)', s.to_s
+          end
+          
+          def test_xml
+            s1 = InclusiveSearch.new(@expression, @set)
+            s2 = InclusiveSearch.from_xml(s1.to_xml)
+            assert_equal s1, s2
+          end
+        end
+        
+        class ExclusiveSearchTest < ::Test::Unit::TestCase
+          def setup
+            @expression = ColumnReference.new('phot', 'flag')
+            @set = ConstantListSet.new([IntegerLiteral.new(1), IntegerLiteral.new(2), IntegerLiteral.new(3)])
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              ExclusiveSearch.new(@expression, @set)
+            }
+            
+            assert_raises ArgumentError do
+              ExclusiveSearch.new(@expression, nil)
+            end
+            assert_raises ArgumentError do
+              ExclusiveSearch.new(nil, @set)
+            end
+            
+            assert_raises TypeError do
+              ExclusiveSearch.new(@expression, 'blah')
+            end
+            assert_raises TypeError do
+              ExclusiveSearch.new('blah', @set)
+            end
+          end
+          
+          def test_accessors
+            s = ExclusiveSearch.new(@expression, @set)
+            
+            assert_equal @expression, s.expression
+            assert_equal @set, s.set
+          end
+          
+          def test_relationships
+            assert_kind_of Search, ExclusiveSearch.new(@expression, @set)
+          end
+          
+          def test_to_s
+            s = ExclusiveSearch.new(@expression, @set)
+            assert_equal 'phot.flag NOT IN (1, 2, 3)', s.to_s
+          end
+          
+          def test_xml
+            s1 = ExclusiveSearch.new(@expression, @set)
+            s2 = ExclusiveSearch.from_xml(s1.to_xml)
+            assert_equal s1, s2
+          end
+        end
+        
+        class SelectTest < ::Test::Unit::TestCase
+          def setup
+            @allow = SelectionOption.new('DISTINCT')
+            @restrict = SelectionLimit.new(10)
+            @selection_list = SelectionList.new([
+              ColumnReference.new('phot', 'xdim'),
+              TrigonometricFunction.new('SIN', ColumnReference.new('phot', 'period'))
+            ])
+            @into = Into.new('phot')
+            @from = From.new([Table.new('phot', 'p'), Table.new('spec', 's')])
+            @where = Where.new(
+              ComparisonPred.new(
+                ColumnReference.new('phot', 'mag'),
+                Comparison.new('>'),
+                Atom.new(15)
+              )
+            )
+            @group_by = GroupBy.new([
+              ColumnReference.new('phot', 'vmag'),
+              ColumnReference.new('phot', 'imag')
+            ])
+            @having = Having.new(
+              RegionSearch.new(
+                Circle.new(:center => [12.5, 23.0], :radius => 5.0, :unit => 'deg', :coord_system_id => 'J2000')
+              )
+            )
+            @order_by = OrderExpression.new([
+              Order.new(ColumnReference.new('phot', 'mag'), OrderOption.new('DESC')),
+              Order.new(ColumnReference.new('spec', 'flux'), OrderOption.new('ASC'))
+            ])
+            @start_comment = 'The Start'
+            @end_comment = 'The End'
+            
+            @options = {
+              :allow => @allow,
+              :restrict => @restrict,
+              :into => @into,
+              :from => @from,
+              :where => @where,
+              :group_by => @group_by,
+              :having => @having,
+              :order_by => @order_by,
+              :start_comment => @start_comment,
+              :end_comment => @end_comment
+            }
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              Select.new(@selection_list)
+              Select.new(@selection_list, @options)
+            }
+            
+            assert_raises ArgumentError do
+              Select.new(nil)
+            end
+            
+            @options.each do |key, value|
+              next if key == 'start_comment' or key == 'end_comment'
+              @options[key] = 'blah'
+              assert_raises TypeError do
+                Select.new(@selection_list, @options)
+              end
+            end
+          end
+          
+          def test_accessors
+            s = Select.new(@selection_list, @options)
+            
+            assert_equal @selection_list, s.selection_list
+            @options.each do |key, value|
+              assert_equal value, s.send(key)
+            end
+          end
+          
+          def test_to_s
+            s = Select.new(@selection_list, @options)
+            assert_equal(
+              'SELECT DISTINCT TOP 10 phot.xdim, SIN(phot.period) ' +
+              'INTO phot ' +
+              'FROM phot p, spec s ' +
+              'WHERE phot.mag > 15 ' +
+              'GROUP BY phot.vmag, phot.imag ' +
+              'HAVING REGION(CIRCLE J2000 12.5 23.0 5.0) ' +
+              'ORDER BY phot.mag DESC, spec.flux ASC',
+              s.to_s
+            )
+            
+            s = Select.new(@selection_list)
+            assert_equal 'SELECT phot.xdim, SIN(phot.period)', s.to_s
+            
+            s = Select.new(@selection_list, :allow => @allow)
+            assert_equal 'SELECT DISTINCT phot.xdim, SIN(phot.period)', s.to_s
+            
+            s = Select.new(@selection_list, :restrict => @restrict)
+            assert_equal 'SELECT TOP 10 phot.xdim, SIN(phot.period)', s.to_s
+            
+            s = Select.new(@selection_list, :into => @into)
+            assert_equal 'SELECT phot.xdim, SIN(phot.period) INTO phot', s.to_s
+            
+            s = Select.new(@selection_list, :from => @from)
+            assert_equal 'SELECT phot.xdim, SIN(phot.period) FROM phot p, spec s', s.to_s
+            
+            s = Select.new(@selection_list, :where => @where)
+            assert_equal 'SELECT phot.xdim, SIN(phot.period) WHERE phot.mag > 15', s.to_s
+            
+            s = Select.new(@selection_list, :group_by => @group_by)
+            assert_equal 'SELECT phot.xdim, SIN(phot.period) GROUP BY phot.vmag, phot.imag', s.to_s
+            
+            s = Select.new(@selection_list, :having => @having)
+            assert_equal 'SELECT phot.xdim, SIN(phot.period) HAVING REGION(CIRCLE J2000 12.5 23.0 5.0)', s.to_s
+            
+            s = Select.new(@selection_list, :order_by => @order_by)
+            assert_equal 'SELECT phot.xdim, SIN(phot.period) ORDER BY phot.mag DESC, spec.flux ASC', s.to_s
+          end
+          
+          def test_xml
+            s1 = Select.new(@selection_list, @options)
+            s2 = Select.from_xml(s1.to_xml)
+            assert_equal s1, s2
+          end
+        end
+        
+        class UserDefinedFunctionTest < ::Test::Unit::TestCase
+          def setup
+            @name = 'MyErrorFunc'
+            @params = [
+              ColumnReference.new('phot', 'mag'),
+              ColumnReference.new('phot', 'error')
+            ]
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              UserDefinedFunction.new(@name, @params)
+              UserDefinedFunction.new(@name)
+            }
+            
+            assert_raises ArgumentError do
+              UserDefinedFunction.new(nil)
+            end
+            
+            assert_raises TypeError do
+              UserDefinedFunction.new(@name, 'blah')
+            end
+          end
+          
+          def test_accessors
+            f = UserDefinedFunction.new(@name, @params)
+            assert_equal @name, f.name
+            assert_equal @params, f.params
+          end
+          
+          def test_relationships
+            assert_kind_of ScalarExpression, UserDefinedFunction.new(@name, @params)
+          end
+          
+          def test_to_s
+            f = UserDefinedFunction.new(@name, @params)
+            assert_equal 'MyErrorFunc(phot.mag, phot.error)', f.to_s
+            
+            f = UserDefinedFunction.new(@name)
+            assert_equal 'MyErrorFunc()', f.to_s
+          end
+          
+          def test_xml
+            f1 = UserDefinedFunction.new(@name, @params)
+            f2 = UserDefinedFunction.from_xml(f1.to_xml)
+            assert_equal f1, f2
+          end
+        end
+        
+        class JoinTableTest < ::Test::Unit::TestCase
+          def setup
+            @qualifier = JointTableQualifier.new('LEFT_OUTER')
+            @tables = [
+              Table.new('table1', 't1'),
+              Table.new('table2', 't2')
+            ]
+            @condition = ComparisonPred.new(
+              ColumnReference.new('t1', 'id'),
+              Comparison.new('='),
+              ColumnReference.new('t2', 'table1_id')
+            )
+          end
+          
+          def test_construction
+            assert_nothing_raised {
+              JoinTable.new(@qualifier, @tables, @condition)
+            }
+            
+            assert_raises ArgumentError do
+              JoinTable.new(@qualifier, @tables, nil)
+            end
+            assert_raises ArgumentError do
+              JoinTable.new(@qualifier, nil, @condition)
+            end
+            assert_raises ArgumentError do
+              JoinTable.new(nil, @tables, @condition)
+            end
+            
+            assert_raises RuntimeError do
+              JoinTable.new(@qualifier, [], @condition)
+            end
+            
+            assert_raises TypeError do
+              JoinTable.new(@qualifier, @tables, 'blah')
+            end
+            assert_raises TypeError do
+              JoinTable.new(@qualifier, 'blah', @condition)
+            end
+            assert_raises TypeError do
+              JoinTable.new(@condition, @tables, @condition)
+            end
+          end
+          
+          def test_accessors
+            t = JoinTable.new(@qualifier, @tables, @condition)
+            assert_equal @qualifier, t.qualifier
+            assert_equal @tables, t.tables
+            assert_equal @condition, t.condition
+          end
+
+          def test_relationships
+            assert_kind_of FromTable, JoinTable.new(@qualifier, @tables, @condition)
+          end
+
+          def test_to_s
+            t = JoinTable.new(@qualifier, @tables, @condition)
+            assert_equal 'LEFT_OUTER table1 t1, table2 t2 ON t1.id = t2.table1_id', t.to_s
+          end
+
+          def test_xml
+            t1 = JoinTable.new(@qualifier, @tables, @condition)
+            t2 = JoinTable.from_xml(t1.to_xml)
+            assert_equal t1, t2
+          end
+        end
+      end
+      
+      class SubQuerySetTest < ::Test::Unit::TestCase
+        def setup
+          @select = Select.new(
+            SelectionList.new([
+              ColumnReference.new('phot', 'xdim'),
+              TrigonometricFunction.new('SIN', ColumnReference.new('phot', 'period'))
+            ])
+          )
+        end
+        
+        def test_construction
+          assert_nothing_raised {
+            SubQuerySet.new(@select)
+          }
+          
+          assert_raises ArgumentError do
+            SubQuerySet.new(nil)
+          end
+          
+          assert_raises TypeError do
+            SubQuerySet.new('blah')
+          end
+        end
+        
+        def test_accessors
+          s = SubQuerySet.new(@select)
+          assert_equal @select, s.selection
+        end
+        
+        def test_relationships
+          assert_kind_of InclusionSet, SubQuerySet.new(@select)
+        end
+        
+        def test_to_s
+          q = SubQuerySet.new(@select)
+          assert_equal '(SELECT phot.xdim, SIN(phot.period))', q.to_s
+        end
+        
+        def test_xml
+          q1 = SubQuerySet.new(@select)
+          q2 = SubQuerySet.from_xml(q1.to_xml)
+          assert_equal q1, q2
+        end
+      end
+      
+    end
+  end
+end