require 'test/unit'
require 'voruby/adql/parser'

include VORuby::ADQL

class ScalarExpressionTest < Test::Unit::TestCase
	def setup
		@exp = ScalarExpression.new('A string')
	end

	def test_to_adqls
		assert_equal('A string', @exp.to_adqls)
	end
end

class ClosedExprTest < Test::Unit::TestCase
	def setup
		@exp = ClosedExpr.new(Atom.new(12.5))
	end

	def test_to_adqls
		assert_equal('(12.5)', @exp.to_adqls)
	end
end

class BinaryOperatorTest < Test::Unit::TestCase
	def test_construct
		assert_raise(RuntimeError) {
			op = BinaryOperator.new('^')
		}

		assert_nothing_raised {
			op = BinaryOperator.new('+')
		}

		assert_nothing_raised {
			op = BinaryOperator.new('//', ['//', '+', '-'])
		}

		assert_raise(RuntimeError){
			op = BinaryOperator.new('\\', ['//', '+', '-'])
		}
	end

	def test_to_adqls
		op = BinaryOperator.new('*')
		assert_equal('*', op.to_adqls)
	end
end

class BinaryExprTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			expr = BinaryExpr.new('a', '+', 'b')
		}

		assert_raise(RuntimeError){
			expr = BinaryExpr.new('a', '++', 'b')
		}
	end

	def test_to_adqls
		expr = BinaryExpr.new('a', '+', 'b')
		assert_equal('a + b', expr.to_adqls)
	end
end

class UnaryOperatorTest < Test::Unit::TestCase
	def test_construct
		assert_raise(RuntimeError) {
			op = UnaryOperator.new('++')
		}

		assert_nothing_raised {
			op = UnaryOperator.new('+')
		}

		assert_nothing_raised {
			op = BinaryOperator.new('++', ['++', '--'])
		}

		assert_raise(RuntimeError){
			op = BinaryOperator.new('==', ['++', '--'])
		}
	end

	def test_to_adqls
		op = BinaryOperator.new('+')
		assert_equal('+', op.to_adqls)
	end
end

class UnaryExprTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			expr = UnaryExpr.new('-', 'a.ra')
		}

		assert_raise(RuntimeError){
			expr = UnaryExpr.new('++', 'a.ra')
		}
	end

	def test_to_adqls
		assert_equal('-a.ra', UnaryExpr.new('-', 'a.ra').to_adqls)
	end
end

class ColumnReferenceTest < Test::Unit::TestCase
	def setup
		@ref = ColumnReference.new('o', 'objid')
	end

	def test_to_adqls
		assert_equal('o.objid', @ref.to_adqls)
	end
end

class AtomTest < Test::Unit::TestCase
	def setup
		@real_literal = 1.0
		@int_literal = 2
		@string_literal = 'a'
	end

	def test_construct
		assert_nothing_raised {
			atom = Atom.new(@real_literal, 'cm')
			atom = Atom.new(@int_literal)
			atom = Atom.new(@string_literal)
		}
	end

	def test_to_adqls
		assert_equal('5cm', Atom.new(5, 'cm').to_adqls)
		assert_equal('100.0', Atom.new(100.0).to_adqls)
		assert_equal('\'a\'', Atom.new('a').to_adqls)
	end
end

class LiteralTypeTest < Test::Unit::TestCase
  def setup
    real_xml = '<Literal xsi:type="realType" Value="10.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>'
    int_xml = '<Literal xsi:type="integerType" Value="10" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>'
    string_xml = '<Literal xsi:type="stringType" Value="ten" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>'
    @real_doc = REXML::Document.new(real_xml)
    @int_doc = REXML::Document.new(int_xml)
    @string_doc = REXML::Document.new(string_xml)
  end

  def test_from_xml
    assert_nothing_raised {
      literal = LiteralType.from_xml(@real_doc.root)
      literal = LiteralType.from_xml(@int_doc.root)
      literal = LiteralType.from_xml(@string_doc.root)
    }
  end

  def test_to_adql
    assert_equal('10.0', LiteralType.from_xml(@real_doc.root).to_adqls)
    assert_equal('10', LiteralType.from_xml(@int_doc.root).to_adqls)
    assert_equal('ten', LiteralType.from_xml(@string_doc.root).to_adqls)
  end
end

class RealTypeTest < Test::Unit::TestCase
	def setup
		@float = RealType.new(3.14159)
	end

	def test_construct
		assert_raise(VORuby::VOTables::VOTable::Misc::TypeException){
			float = RealType.new('5')
		}
	end

	def test_equal
		assert_equal(3.14159, @float.value)
	end

	def test_to_adqls
		assert_equal('3.14159', @float.to_adqls)
	end
end

class IntegerTypeTest < Test::Unit::TestCase
	def setup
		@int = IntegerType.new(7)
	end

	def test_construct
		assert_raise(VORuby::VOTables::VOTable::Misc::TypeException){
			int = IntegerType.new(5.0)
		}
	end

	def test_equal
		assert_equal(7, @int.value)
	end

	def test_to_adqls
		assert_equal('7', @int.to_adqls)
	end
end

class StringTypeTest < Test::Unit::TestCase
	def setup
		@string = StringType.new('test string')
	end

	def test_construct
		assert_raise(VORuby::VOTables::VOTable::Misc::TypeException){
			string = StringType.new(3.1)
		}
	end

	def test_equal
		assert_equal('test string', @string.value)
	end

	def test_to_adqls
		assert_equal('test string', @string.to_adqls)
	end
end

class SelectionOptionTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			sel_op = SelectionOption.new('ALL')
		}

		assert_raise(RuntimeError){
			sel_op = SelectionOption.new('NEW')
		}
	end

	def test_to_adqls
		assert_equal('DISTINCT', SelectionOption.new('DISTINCT').to_adqls)
	end
end

class AllOrDistinctTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			all_dis = AllOrDistinct.new('ALL')
			all_dis = AllOrDistinct.new('NEW', ['ALL', 'DISTINCT', 'NEW'])
		}

		assert_raise(RuntimeError){
			all_dis = AllOrDistinct.new('NEW')
		}
	end

	def test_to_adqls
		assert_equal('DISTINCT', AllOrDistinct.new('DISTINCT').to_adqls)
	end
end

class TrigonometricFunctionNameTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			trig = TrigonometricFunctionName.new('COT')
			trig = TrigonometricFunctionName.new('ISIN', ['SIN', 'ASIN', 'ISIN'])
		}

		assert_raise(RuntimeError){
			trig = TrigonometricFunctionName.new('ISIN')
		}
	end

	def test_to_adqls
		assert_equal('COT', TrigonometricFunctionName.new('COT').to_adqls)
	end
end

class TrigonometricFunctionTest < Test::Unit::TestCase
  def setup
    @arg = ColumnReference.new('o', 'objid')
  end

	def test_construct
		assert_nothing_raised {
			trig_func = TrigonometricFunction.new('ASIN', @arg)
		}

		assert_raise(RuntimeError){
			trig_func = TrigonometricFunction.new('NEW', @arg)
		}
	end

	def test_to_adqls
		assert_equal('ASIN(o.objid)', TrigonometricFunction.new('ASIN', @arg).to_adqls)
	end
end

class MathFunctionNameTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			math = MathFunctionName.new('ABS')
			math = MathFunctionName.new('GRAD', ['ABS', 'CEILING', 'GRAD'])
		}

		assert_raise(RuntimeError){
			math = MathFunctionName.new('GRAD')
		}
	end

	def test_to_adqls
		assert_equal('ABS', MathFunctionName.new('ABS').to_adqls)
	end
end

#class MathFunctionTest < Test::Unit::TestCase
	#def test_construct
	#	assert_nothing_raised {
	#		math_func = MathFunction.new('ABS')
	#	}

	#	assert_raise (RuntimeError){
	#		math_func = TrigonometricFunction.new('NEW')
	#	}
	#end

	#def test_to_adqls
	#	assert_equal('ABS', MathFunction.new('ABS').to_adqls)
	#end
#end

class AggregateFunctionNameTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			agg = AggregateFunctionName.new('MAX')
			agg = AggregateFunctionName.new('DISP', ['AVG', 'DISP', 'MIN'])
		}

		assert_raise(RuntimeError){
			agg = AggregateFunctionName.new('DISP')
		}
	end

	def test_to_adqls
		assert_equal('COUNT', AggregateFunctionName.new('COUNT').to_adqls)
	end	
end

#		class AggregateFunctionTest < Test::Unit::TestCase
#			def test_construct
#				assert_nothing_raised {
#					agg_func = AggregateFunction.new('MAX')
#				}

#				assert_raise (RuntimeError){
#					agg_func = AggregateFunction.new('NEW')
#				}
#			end

#			def test_to_adqls
#				assert_equal('SUM', AggregateFunction.new('SUM').to_adqls)
#			end
#		end

class AliasSelectionItemTest < Test::Unit::TestCase
	def setup
		@alias_sel1 = AliasSelectionItem.new('o.objid', 'ObjId')
		@alias_sel2 = AliasSelectionItem.new('o.objid')
	end

	def test_to_adqls
		assert_equal('o.objid AS ObjId', @alias_sel1.to_adqls)
		assert_equal('o.objid', @alias_sel2.to_adqls)
	end
end

class ComparisonTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			comp = Comparison.new('<>')
			comp = Comparison.new('()', ['<>', '=', '()'])
		}

		assert_raise(RuntimeError){
			comp = Comparison.new('!')
		}
	end

	def test_to_adqls
		assert_equal('<>', Comparison.new('<>').to_adqls)
	end
end

class ArchiveTableTest < Test::Unit::TestCase
	def setup
		@archive1 = ArchiveTable.new('SDSS', 'PhotoPrimary', 'o')
		@archive2 = ArchiveTable.new('SDSS', 'PhotoPrimary')
	end

	def test_to_adqls
		assert_equal('SDSS:PhotoPrimary o', @archive1.to_adqls)
		assert_equal('SDSS:PhotoPrimary', @archive2.to_adqls)
	end
end

class IncludeTableTest < Test::Unit::TestCase
	def setup
		@table = IncludeTable.new('o')
	end

	def test_to_adqls
		assert_equal('o', @table.to_adqls)
	end
end

class DropTableTest < Test::Unit::TestCase
	def setup
		@table = DropTable.new('o')
	end

	def test_to_adqls
		assert_equal('!o', @table.to_adqls)
	end
end

class IntersectionSearchTest < Test::Unit::TestCase
	def setup
		@tables = [IncludeTable.new('o'),
					IncludeTable.new('t'),
					DropTable.new('z')]
		@cond1 = XMatch.new(@tables, '>=', 0.5)
		@cond2 = XMatch.new(@tables, '<=', 1.1)
	end

	def test_construct
		assert_nothing_raised {
			search = IntersectionSearch.new(@cond1, @cond2)
		}
	end

	def test_to_adqls
		search = IntersectionSearch.new(@cond1, @cond2)
		assert_equal("XMATCH(o, t, !z) >= 0.5 AND XMATCH(o, t, !z) <= 1.1",
			search.to_adqls)
	end
end

class UnionSearchTest < Test::Unit::TestCase
	def setup
		@tables = [IncludeTable.new('o'),
					IncludeTable.new('t'),
					DropTable.new('z')]
		@cond1 = XMatch.new(@tables, '>=', 0.5)
		@cond2 = XMatch.new(@tables, '<=', 1.1)
	end

	def test_construct
		assert_nothing_raised {
			search = UnionSearch.new(@cond1, @cond2)
		}
	end

	def test_to_adqls
		search = UnionSearch.new(@cond1, @cond2)
		assert_equal("XMATCH(o, t, !z) >= 0.5 OR XMATCH(o, t, !z) <= 1.1",
			search.to_adqls)
	end
end

class XMatchTest < Test::Unit::TestCase
	def setup
		@tables = [IncludeTable.new('o'),
					IncludeTable.new('t'),
					DropTable.new('z')]
	end

	def test_construct
		assert_nothing_raised {
			xmatch = XMatch.new(@tables, '<=', 3.5)
			xmatch = XMatch.new(@tables,
				Comparison.new('<='),
				RealType.new(3.5))
		}
	end

	def test_to_adqls
		xmatch = XMatch.new(@tables, '<=', 3.5)
		assert_equal("XMATCH(o, t, !z) <= 3.5", xmatch.to_adqls)
	end
end

class LikePredTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			like = LikePred.new('name', '%my_name%')
		}
	end

	def test_to_adqls
		assert_equal('name LIKE \'%my_name%\'',
			LikePred.new('name', '%my_name%').to_adqls)
	end
end

class NotLikePredTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			like = NotLikePred.new('name', '%my_name%')
		}
	end

	def test_to_adqls
		assert_equal('name NOT LIKE \'%my_name%\'',
			NotLikePred.new('name', '%my_name%').to_adqls)
	end
end

#class ExclusiveSearchTest < Test::Unit::TestCase; end

#class SubQuerySetTest < Test::Unit::TestCase; end

class ClosedSearchTest < Test::Unit::TestCase
	def setup
		@tables = [IncludeTable.new('o'),
						   IncludeTable.new('t'),
						   DropTable.new('z')]
		@search = XMatch.new(@tables, '<=', 3.5)
	end

	def test_construct
		assert_nothing_raised {
			cs = ClosedSearch.new(@search)
		}
	end

	def test_to_adqls
		assert_equal('(XMATCH(o, t, !z) <= 3.5)',
			ClosedSearch.new(@search).to_adqls)
	end
end

class ComparisonPredTest < Test::Unit::TestCase
	def setup
		@cond1 = ColumnReference.new('PhotoPrimary', 'objid')
		@cond2 = BinaryExpr.new('a', '+', 'b')
	end

	def test_construct
		assert_nothing_raised {
			cp = ComparisonPred.new(@cond1, '<>', @cond2)
		}
	end

	def test_to_adqls
		assert_equal('PhotoPrimary.objid <> a + b',
			ComparisonPred.new(@cond1, '<>', @cond2).to_adqls)
	end
end

class NotBetweenPredTest < Test::Unit::TestCase
	def setup
		@arg1 = ColumnReference.new('PhotoPrimary', 'objid')
		@arg2 = UnaryExpr.new('-', 2)
		@arg3 = UnaryExpr.new('+', 3)
	end

	def test_construct
		assert_nothing_raised {
			bp = NotBetweenPred.new(@arg1, @arg2, @arg3)
		}
	end

	def test_to_adqls
		assert_equal('PhotoPrimary.objid NOT BETWEEN -2 AND +3',
			NotBetweenPred.new(@arg1, @arg2, @arg3).to_adqls)
	end
end

class RegionSearchTest < Test::Unit::TestCase
	def test_construct
		assert_nothing_raised {
			rs = RegionSearch.new(Circle.new(182.5, -0.89, 8), 'overlaps')
		}
	end

	def test_to_adqls
		assert_equal('Region(\'CIRCLE J2000 182.5 -0.89 8.0\')',
			RegionSearch.new(Circle.new(182.5, -0.89, 8), 'overlaps').to_adqls)
	end
end

class HavingTest < Test::Unit::TestCase
	def setup
		@cond = RegionSearch.new(Circle.new(182.5, -0.89, 8.0), 'overlaps')
	end

	def test_construct
		assert_nothing_raised {
			h = Having.new(@cond)
		}
	end

	def test_to_adqls
		assert_equal('HAVING Region(\'CIRCLE J2000 182.5 -0.89 8.0\')',
			Having.new(@cond).to_adqls)
	end

	def test_from_xml
	  xml = '<Having xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' +
	          '<Condition xsi:type="likePredType">' +
              '<Arg xsi:type="columnReferenceType" Table="opt" Name="org" />' +
              '<Pattern>' +
                '<Literal xsi:type="stringType" Value="%esa%" />' +
              '</Pattern>' +
            '</Condition>' +
          '</Having>'
    doc = REXML::Document.new(xml)

    assert_equal("HAVING opt.org LIKE '%esa%'",
      Having.from_xml(doc.root).to_adqls)
  end
end

class GroupByTest < Test::Unit::TestCase
	def setup
		@columns = [ColumnReference.new('o', 'objid'),
					ColumnReference.new('o', 'type'),
					ColumnReference.new('t', 'objid')]
	end

	def test_construct
		assert_nothing_raised {
			gb = GroupBy.new(@columns)
		}
	end

	def test_to_adqls
		assert_equal('GROUP BY o.objid, o.type, t.objid',
			GroupBy.new(@columns).to_adqls)
	end

	def test_from_xml
	  xml = '<GroupBy xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' +
	          '<Column Table="o" Name="recid"/>' +
	          '<Column Table="o" Name="ra"/>' +
	          '<Column Table="o" Name="dec"/>' +
	        '</GroupBy>'
	  doc = REXML::Document.new(xml)

	  assert_equal('GROUP BY o.recid, o.ra, o.dec',
	    GroupBy.from_xml(doc.root).to_adqls)
  end
end

class WhereTest < Test::Unit::TestCase
	def setup
		@tables = [IncludeTable.new('o'), IncludeTable.new('t')]
		@xmatch = XMatch.new(@tables, '<', 3.5)
		@region = RegionSearch.new(Circle.new(182.5, -0.89, 8.5), 'overlaps')
		@comp = ComparisonPred.new(
			ColumnReference.new('o', 'type'),
			'=',
			ScalarExpression.new(3))

		@cond1 = IntersectionSearch.new(@xmatch, @region)
		@condition = UnionSearch.new(@cond1, @comp)
	end

	def test_construct
		assert_nothing_raised {
			w = Where.new(@condition)
		}
	end

	def test_to_adql
		assert_equal('WHERE XMATCH(o, t) < 3.5 AND Region(\'CIRCLE J2000 182.5 -0.89 8.5\') OR o.type = 3',
			Where.new(@condition).to_adqls)
	end

	def test_from_xml
	  xml = '<Where xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' +
	          '<Condition xsi:type="likePredType">' +
              '<Arg xsi:type="columnReferenceType" Table="opt" Name="org" />' +
              '<Pattern>' +
                '<Literal xsi:type="stringType" Value="%esa%" />' +
              '</Pattern>' +
            '</Condition>' +
	        '</Where>'
	  doc = REXML::Document.new(xml)

	  assert_equal("WHERE opt.org LIKE '%esa%'",
	    Where.from_xml(doc.root).to_adqls)
  end
end

class FromTest < Test::Unit::TestCase
  def setup
    @tables = [ArchiveTable.new('SDSS', 'PhotoPrimary', 'o'),
               ArchiveTable.new('2MASS', 'PhotoPrimary', 't')]
  end

  def test_construct
    assert_nothing_raised {
      from = From.new(@tables)
    }
  end

  def test_to_adql
      assert_equal("FROM SDSS:PhotoPrimary o, 2MASS:PhotoPrimary t",
        From.new(@tables).to_adqls)
  end

  def test_from_xml
    xml = '<From xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' +
            '<Table xsi:type="archiveTableType" Archive="SDSS" Name="PhotoPrimary" Alias="o"/>' +
            '<Table xsi:type="archiveTableType" Archive="TWOMASS" Name="PhotoPrimary" Alias="a"/>' +
          '</From>'
    doc = REXML::Document.new(xml)

    assert_equal('FROM SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary a',
      From.from_xml(doc.root).to_adqls)
  end
end

class SelectionListTest < Test::Unit::TestCase
  def setup
    @items = [ColumnReference.new('o', 'objid'),
              ColumnReference.new('o', 'ra'),
              ColumnReference.new('o', 'dec')]
  end

  def test_construct
    assert_nothing_raised {
      list = SelectionList.new(@items)
    }
  end

  def test_to_adql
    assert_equal("o.objid, o.ra, o.dec",
      SelectionList.new(@items).to_adqls)
  end

  def test_from_xml
    xml = '<SelectionList xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' +
            '<Item xsi:type="columnReferenceType" Table="o" Name="recid" />' +
            '<Item xsi:type="columnReferenceType" Table="o" Name="ra" />' +
            '<Item xsi:type="columnReferenceType" Table="o" Name="dec" />' +
          '</SelectionList>'
    doc = REXML::Document.new(xml)

    assert_equal('o.recid, o.ra, o.dec',
      SelectionList.from_xml(doc.root).to_adqls)
  end
end

class SelectionLimitTest < Test::Unit::TestCase
  def test_construct
    assert_nothing_raised {
      limit = SelectionLimit.new(10)
    }

    assert_raise(RuntimeError){
      limit = SelectionLimit.new(-1)
      limit = SelectionLimit.new(10.2)
    }
  end

  def test_to_adqls
    assert_equal("TOP 10", SelectionLimit.new(10).to_adqls)
  end

  def test_from_xml
    xml = '<SelectionLimit Top="10"/>'
    doc = REXML::Document.new(xml)

    assert_equal('TOP 10', SelectionLimit.from_xml(doc.root).to_adqls)
  end
end

class IntoTest < Test::Unit::TestCase
  def test_construct
    assert_nothing_raised {
      into = Into.new('my_table')
    }
  end

  def test_to_adqls
    assert_equal('INTO my_table', Into.new('my_table').to_adqls)
  end

  def test_from_xml
    xml = '<InTo><TableName>my_table</TableName></InTo>'
    doc = REXML::Document.new(xml)

    assert_equal('INTO my_table',
      Into.from_xml(doc.root).to_adqls)
  end
end

class OrderDirectionTest < Test::Unit::TestCase
  def test_construct
    assert_nothing_raised {
      dir = OrderDirection.new('ASC')
      dir = OrderDirection.new('NEW', ['ASC', 'DESC', 'NEW'])
    }

    assert_raise(RuntimeError){
      dir = OrderDirection.new('NEW')
    }
  end

  def test_to_adqls
    assert_equal('ASC', OrderDirection.new('ASC').to_adqls)
  end
end

class OrderOptionTest < Test::Unit::TestCase
  def test_construct
    assert_nothing_raised {
      order = OrderOption.new('ASC')
    }
  end

  def test_to_adqls
    assert_equal('ASC', OrderOption.new('ASC').to_adqls)
  end
end

class OrderTest < Test::Unit::TestCase
   def setup
     @expression = ColumnReference.new('o', 'objid')
   end

   def test_construct
     assert_nothing_raised {
       order = Order.new(@expression)
     }
   end

   def test_to_adqls
     assert_equal('o.objid DESC', Order.new(@expression, 'DESC').to_adqls)
   end
end

class OrderExpressionTest < Test::Unit::TestCase
  def setup
    @orders = [Order.new(ColumnReference.new('o', 'objid')),
               Order.new(ColumnReference.new('o', 'ra'), 'DESC'),
               Order.new(ColumnReference.new('o', 'dec'), 'ASC')]
  end

  def test_construct
    assert_nothing_raised {
      ord_expr = OrderExpression.new(@orders)
    }
  end

  def test_to_adqls
    assert_equal('ORDER BY o.objid, o.ra DESC, o.dec ASC',
      OrderExpression.new(@orders).to_adqls)
  end
end

class InclusiveSearchTest < Test::Unit::TestCase
  def setup
    @expression = ColumnReference.new('o', 'objid')
    @set = ConstantListSet.new(['IBM', 'Microsoft', 'Apple'])
  end

  def test_construct
    assert_nothing_raised {
      isearch = InclusiveSearch.new(@expression, @set)
    }
  end

  def test_to_adqls
    assert_equal("o.objid IN (\"IBM\", \"Microsoft\", \"Apple\")",
      InclusiveSearch.new(@expression, @set).to_adqls)
  end
end

class SelectTest < Test::Unit::TestCase
  def setup
    @allow = SelectionOption.new('DISTINCT')

    @restrict = SelectionLimit.new(10)

    @columns = [ColumnReference.new('o', 'objid'),
                ColumnReference.new('o', 'ra'),
                ColumnReference.new('o', 'dec'),
                ColumnReference.new('o', 'type'),
                ColumnReference.new('t', 'objid'),
                ColumnReference.new('t', 'ra'),
                ColumnReference.new('t', 'dec'),
                ColumnReference.new('t', 'j_m'),
                ColumnReference.new('o', 'i')]
    @sel_list = SelectionList.new(@columns)

    @into = Into.new('myTable')

    @from_list = [ArchiveTable.new('SDSS', 'PhotoPrimary', 'o'),
                  ArchiveTable.new('TWOMASS', 'PhotoPrimary', 't')]
    @from = From.new(@from_list)

    @xmatch_tables = [IncludeTable.new('o'),
                      IncludeTable.new('t')]
    @xmatch = XMatch.new(@xmatch_tables, '<', 3.5)
    @region = RegionSearch.new(Circle.new(182.5, -0.89, 8), 'overlaps')
    @xmatchregion = IntersectionSearch.new(@xmatch, @region)

    @otype = ComparisonPred.new(
      ColumnReference.new('o', 'type'),
      '=',
      Atom.new(3))
    @xmatchregion_otype = IntersectionSearch.new(@xmatchregion, @otype)

    @oi = ComparisonPred.new(
      ColumnReference.new('o', 'i'),
      '<',
      Atom.new(21))
    @xmatchregion_otype_oi =
      IntersectionSearch.new(@xmatchregion_otype, @oi)
  
    @tjm = ComparisonPred.new(
      ColumnReference.new('t', 'j_m'),
      '<',
      Atom.new(18))
    @xmatchregion_otype_oi_tjm =
      IntersectionSearch.new(@xmatchregion_otype_oi, @tjm)
  
    @oitjmdiff = ComparisonPred.new(
      ClosedExpr.new(
        BinaryExpr.new(
          ColumnReference.new('o', 'i'),
          '-',
          ColumnReference.new('t', 'j_m')
        )
      ),
      '>',
      Atom.new(2))

    @conditions = IntersectionSearch.new(
      @xmatchregion_otype_oi_tjm,
      @oitjmdiff)
    @where = Where.new(@conditions)

    @group_by = GroupBy.new(
      [ColumnReference.new('o', 'ra'),
       ColumnReference.new('o', 'dec')])
   
    @having = Having.new(
      ComparisonPred.new(
        ColumnReference.new('o', 'objid'),
        '=',
        Atom.new('1234')
      )
    )

    @order_by = OrderExpression.new(
      [Order.new(ColumnReference.new('o', 'objid')),
       Order.new(ColumnReference.new('o', 'ra'), 'DESC')]
    )
  end

  def test_construct
    assert_nothing_raised {
      select = Select.new(@sel_list)
      select = Select.new(@sel_list, @allow)
      select = Select.new(@sel_list, @allow, @restrict)
      select = Select.new(@sel_list, @allow, @restrict, @into)
      select = Select.new(@sel_list, @allow, @restrict, @into, @from)
      select = Select.new(@sel_list, nil, nil, nil,
        @from, @where)
      select = Select.new(@sel_list, nil, nil, nil,
        @from, @where, @group_by)
      select = Select.new(@sel_list, nil, nil, nil,
        @from, @where, @group_by, @having, @order_by)
    }
  end

  def test_to_adqls
    adqls = 'SELECT o.objid, o.ra, o.dec, o.type, t.objid, t.ra, t.dec, t.j_m, o.i'
    assert_equal(adqls, Select.new(@sel_list).to_adqls)

    adqls = 
    'SELECT DISTINCT ' +
      'o.objid, o.ra, o.dec, o.type, t.objid, t.ra, t.dec, t.j_m, o.i'
    assert_equal(adqls, Select.new(@sel_list, @allow).to_adqls)

    adqls = 'SELECT DISTINCT TOP 10 o.objid, o.ra, o.dec, o.type, t.objid, t.ra, t.dec, t.j_m, o.i'
    assert_equal(adqls, Select.new(@sel_list, @allow, @restrict).to_adqls)

    adqls = 
      'SELECT DISTINCT TOP 10 ' +
        'o.objid, o.ra, o.dec, o.type, t.objid, t.ra, t.dec, t.j_m, o.i ' +
      'INTO myTable'
    assert_equal(adqls, Select.new(@sel_list, @allow, @restrict, @into).to_adqls)

    adqls = 
      'SELECT DISTINCT TOP 10 ' +
        'o.objid, o.ra, o.dec, o.type, t.objid, t.ra, t.dec, t.j_m, o.i ' +
      'INTO myTable ' +
      'FROM SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t'
    assert_equal(adqls, Select.new(@sel_list, @allow, @restrict, @into, @from).to_adqls)

    adqls = 
      'SELECT ' +
        'o.objid, o.ra, o.dec, o.type, t.objid, t.ra, t.dec, t.j_m, o.i ' +
      'FROM SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t ' +
      'WHERE ' +
        'XMATCH(o, t) < 3.5 AND ' +
        'Region(\'CIRCLE J2000 182.5 -0.89 8.0\') AND ' +
        'o.type = 3 AND ' +
        'o.i < 21 AND ' +
        't.j_m < 18 AND ' +
        '(o.i - t.j_m) > 2 ' +
      'GROUP BY o.ra, o.dec ' +
      'HAVING o.objid = \'1234\' ' +
      'ORDER BY o.objid, o.ra DESC'
    assert_equal(adqls,
      Select.new(@sel_list, nil, nil, nil, @from,
        @where, @group_by, @having, @order_by).to_adqls)
  end
end

class UserDefinedFunctionTest < Test::Unit::TestCase
  def setup
    @params = [ColumnReference.new('o', 'ra'), ColumnReference.new('o', 'dec')]
  end

  def test_construct
    assert_nothing_raised {
      udf = UserDefinedFunction.new('my_func', @params)
    }
  end

  def test_to_adqls
    assert_equal('my_func(o.ra, o.dec)',
      UserDefinedFunction.new('my_func', @params).to_adqls)
  end
end

class JointTableQualifierTest < Test::Unit::TestCase
  def test_construct
    assert_nothing_raised {
      qual = JointTableQualifier.new('INNER')
      qual = JointTableQualifier.new('FAKE', ['INNER', 'FAKE', 'CROSS'])
    }

    assert_raise(RuntimeError){
      qual = JointTableQualifier.new('FAKE')
    }
  end

  def test_to_adqls
      assert_equal('INNER', JointTableQualifier.new('INNER').to_adqls)
  end
end

class JoinTableTest < Test::Unit::TestCase
  def setup
    @tables = ArrayOfFromTable.new(
      [ArchiveTable.new('SDSS', 'PhotoPrimary', 'o'),
       ArchiveTable.new('TWOMASS', 'PhotoPrimary', 't')]
    )
    @comp = ComparisonPred.new(
      ColumnReference.new('o', 'objid'),
      '=',
      ColumnReference.new('t', 'objid')
    )
  end

  def test_construct
    assert_nothing_raised {
      jt = JoinTable.new('INNER', @tables, @comp)
    }
  end

  def test_to_adqls
    assert_equal('INNER SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t ON o.objid = t.objid',
      JoinTable.new('INNER', @tables, @comp).to_adqls)
  end
end

class ArrayOfFromTableTest < Test::Unit::TestCase
  def setup
    @froms =
      [ArchiveTable.new('SDSS', 'PhotoPrimary', 'o'),
       ArchiveTable.new('TWOMASS', 'PhotoPrimary', 't')]
  end

  def test_construct
    assert_nothing_raised {
     aoft = ArrayOfFromTable.new(@froms)
    }
  end

  def test_to_adqls
    assert_equal('SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t',
      ArrayOfFromTable.new(@froms).to_adqls)
  end
end

class ArgTest < Test::Unit::TestCase
  def setup
    xml1 = '<Arg xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="columnReferenceType" Table="o" Name="objid" xpathName="description" />'
    xml2 = '<Arg xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="atomType">' +
              '<Literal xsi:type="stringType" Value="CDS" />' +
           '</Arg>'
    xml3 = '<Arg xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Oper="-" xsi:type="binaryExprType">' +
              '<Arg Table="opt" Name="R" xsi:type="columnReferenceType"/>' +
              '<Arg Table="opt" Name="B" xsi:type="columnReferenceType"/>' +
           '</Arg>'
    xml4 = '<Arg xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Oper="-" xsi:type="unaryExprType">' +
              '<Arg Table="opt" Name="R" xsi:type="columnReferenceType"/>' +
            '</Arg>'
    xml5 = '<Arg xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="closedExprType">' +
              '<Arg Table="opt" Name="R" xsi:type="columnReferenceType"/>' +
            '</Arg>'
    xml6 = '<Arg xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="trigonometricFunctionType" Name="SIN">' +
              '<Allow Option="DISTINCT"/>' +
              '<Arg Table="opt" Name="R" xsi:type="columnReferenceType"/>' +
            '</Arg>'
    xml7 =  '<Arg xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="mathFunctionType" Name="ABS">' +
              '<Allow Option="ALL"/>' +
              '<Arg Table="opt" Name="R" xsi:type="columnReferenceType"/>' +
            '</Arg>'
    xml8 = '<Arg xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="aggregateFunctionType" Name="AVG">' +
              '<Arg Table="opt" Name="R" xsi:type="columnReferenceType"/>' +
           '</Arg>'
    xml9 = '<Arg xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="userDefinedFunctionType">' +
              '<Name>MyFunc</Name>' +
              '<Params Table="opt" Name="R" xsi:type="columnReferenceType"/>' +
           '</Arg>'
    xml10 = '<Arg xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="aliasSelectionItemType" As="myCol">' +
              '<Expression Table="opt" Name="R" xsi:type="columnReferenceType"/>' +
            '</Arg>'
    @doc1 = REXML::Document.new(xml1)
    @doc2 = REXML::Document.new(xml2)
    @doc3 = REXML::Document.new(xml3)
    @doc4 = REXML::Document.new(xml4)
    @doc5 = REXML::Document.new(xml5)
    @doc6 = REXML::Document.new(xml6)
    @doc7 = REXML::Document.new(xml7)
    @doc8 = REXML::Document.new(xml8)
    @doc9 = REXML::Document.new(xml9)
    @doc10 = REXML::Document.new(xml10)
  end

  def test_from_xml
    assert_nothing_raised {
      arg = Arg.from_xml(@doc1.root)
      arg = Arg.from_xml(@doc2.root)
      arg = Arg.from_xml(@doc3.root)
      arg = Arg.from_xml(@doc4.root)
      arg = Arg.from_xml(@doc5.root)
      arg = Arg.from_xml(@doc6.root)
      arg = Arg.from_xml(@doc7.root)
      arg = Arg.from_xml(@doc8.root)
      arg = Arg.from_xml(@doc9.root)
      arg = Arg.from_xml(@doc10.root)
    }
  end

  def test_to_adql
    assert_equal('o.objid', Arg.from_xml(@doc1.root).to_adqls)
    assert_equal("'CDS'", Arg.from_xml(@doc2.root).to_adqls)
    assert_equal('opt.R - opt.B', Arg.from_xml(@doc3.root).to_adqls)
    assert_equal('-opt.R', Arg.from_xml(@doc4.root).to_adqls)
    assert_equal('(opt.R)', Arg.from_xml(@doc5.root).to_adqls)
    assert_equal('SIN(DISTINCT opt.R)', Arg.from_xml(@doc6.root).to_adqls)
    assert_equal('ABS(ALL opt.R)', Arg.from_xml(@doc7.root).to_adqls)
    assert_equal('AVG(opt.R)', Arg.from_xml(@doc8.root).to_adqls)
    assert_equal('MyFunc(opt.R)', Arg.from_xml(@doc9.root).to_adqls)
    assert_equal('opt.R AS myCol', Arg.from_xml(@doc10.root).to_adqls)
  end
end

class LiteralTest < Test::Unit::TestCase
  def setup
    @doc1 = REXML::Document.new('<Literal xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Value="10.0" xsi:type="realType"/>')
    @doc2 = REXML::Document.new('<Literal xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Value="10" xsi:type="integerType"/>')
    @doc3 = REXML::Document.new('<Literal xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Value="ten" xsi:type="stringType"/>')
  end

  def test_from_xml
    assert_nothing_raised {
      lit = LiteralType.from_xml(@doc1.root)
      lit = LiteralType.from_xml(@doc2.root)
      lit = LiteralType.from_xml(@doc3.root)
    }
  end

  def test_to_adql
    assert_equal("10.0", LiteralType.from_xml(@doc1.root).to_adqls)
    assert_equal("10", LiteralType.from_xml(@doc2.root).to_adqls)
    assert_equal('ten', LiteralType.from_xml(@doc3.root).to_adqls)
  end
end

class UnitTest < Test::Unit::TestCase
  def setup
    @doc = REXML::Document.new('<Unit>cm</Unit>')
  end

  def text_from_xml
    assert_nothing_raised {
      unit = Unit.from_xml(@doc.root)
    }
  end

  def test_to_adqls
    assert_equal('cm', Unit.from_xml(@doc.root).to_adqls)
  end
end

class AllowTest < Test::Unit::TestCase
  def setup
    @doc = REXML::Document.new('<Allow xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="selectionOptionType" Option="DISTINCT"/>')
  end

  def test_from_xml
    assert_nothing_raised {
      allow = Allow.from_xml(@doc.root)
    }
  end

  def test_to_adqls
    assert_equal('DISTINCT', Allow.from_xml(@doc.root).to_adqls)
  end
end

class ExpressionTest < Test::Unit::TestCase
  def setup
    @doc = REXML::Document.new('<Expression xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Table="opt" Name="R" xsi:type="columnReferenceType"/>')
  end

  def test_from_xml
    assert_nothing_raised {
      expr = Expression.from_xml(@doc.root)
    }
  end

  def test_to_adqls
    assert_equal('opt.R', Expression.from_xml(@doc.root).to_adqls)
  end
end

class ConditionTest < Test::Unit::TestCase
  def setup
    @xml1 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="likePredType">' +
              '<Arg xsi:type="columnReferenceType" Table="opt" Name="org" />' +
              '<Pattern>' +
                '<Literal xsi:type="stringType" Value="%esa%" />' +
              '</Pattern>' +
            '</Condition>'
    @doc1 = REXML::Document.new(@xml1)

    @xml2 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="notLikePredType">' +
               '<Arg xsi:type="columnReferenceType" Table="opt" Name="org" />' +
               '<Pattern>' +
                 '<Literal xsi:type="stringType" Value="%esa%" />' +
               '</Pattern>' +
             '</Condition>'
    @doc2 = REXML::Document.new(@xml2)
 
    @xml3 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="closedSearchType">' +
              @xml1 +
            '</Condition>'
    @doc3 = REXML::Document.new(@xml3)

    @xml4 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="comparisonPredType" Comparison="&lt;&gt;">' +
              '<Arg xsi:type="columnReferenceType" Table="opt" Name="publisher" />' +
              '<Arg xsi:type="atomType">' +
                '<Literal xsi:type="stringType" Value="CDS" />' +
              '</Arg>' +
            '</Condition>'
    @doc4 = REXML::Document.new(@xml4)

    @xml5 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="betweenPredType">' +
              '<Arg xsi:type="columnReferenceType" Table="opt" Name="R" />' +
              '<Arg xsi:type="atomType">' +
                '<Literal xsi:type="realType" Value="1.2" />' +
              '</Arg>' +
              '<Arg xsi:type="atomType">' +
                '<Literal xsi:type="realType" Value="1.6" />' +
              '</Arg>' +
            '</Condition>'
    @doc5 = REXML::Document.new(@xml5)

    @xml6 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="notBetweenPredType">' +
              '<Arg xsi:type="columnReferenceType" Table="opt" Name="R" />' +
              '<Arg xsi:type="atomType">' +
                '<Literal xsi:type="realType" Value="1.2" />' +
              '</Arg>' +
              '<Arg xsi:type="atomType">' +
                '<Literal xsi:type="realType" Value="1.6" />' +
              '</Arg>' +
            '</Condition>'
    @doc6 = REXML::Document.new(@xml6)

    @xml7 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="intersectionSearchType">' +
              @xml4 +
              @xml5 +
            '</Condition>'
    @doc7 = REXML::Document.new(@xml7)

    @xml8 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="unionSearchType">' +
               @xml4 +
               @xml5 +
             '</Condition>'
    @doc8 = REXML::Document.new(@xml8)
 
    @xml9 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xMatchType">' +
              '<Table xsi:type="includeTableType" Name="opt"/>' +
              '<Table xsi:type="includeTableType" Name="apt"/>' +
              '<Table xsi:type="dropTableType" Name="drop_me"/>' +
              '<Nature xsi:type="comparisonType" Comparison="&lt;"/>' +
              '<Sigma xsi:type="realType" Value="0.5"/>' +
            '</Condition>'
    @doc9 = REXML::Document.new(@xml9)

    @xml10 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="regionSearchType">' +
                '<Region xmlns:q1="http://www.ivoa.net/xml/STC/STCregion/v1.10" xsi:type="q1:circleType" unit="deg">' +
                  '<q1:Center>181.3 -0.76</q1:Center>' +
                  '<q1:Radius>6.5</q1:Radius>' +
                '</Region>' +
             '</Condition>'
    @doc10 = REXML::Document.new(@xml10)

    @xml11 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="inverseSearchType">' +
                @xml4 +
              '</Condition>'
    @doc11 = REXML::Document.new(@xml11)

    @xml12 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="inclusiveSearchType">' +
                '<Expression xsi:type="columnReferenceType" Table="opt" Name="R" />' +
                '<Set xsi:type="subQuerySetType">' +
                  '<Select>' +
                    '<SelectionList>' +
                      '<Item xsi:type="columnReferenceType" Table="opt" Name="R" />' +
                      '<Item xsi:type="columnReferenceType" Table="opt" Name="V" />' +
                      '<Item xsi:type="columnReferenceType" Table="opt" Name="ra" />' +
                      '<Item xsi:type="columnReferenceType" Table="opt" Name="dec" />' +
                    '</SelectionList>' +
                  '</Select>' +
                '</Set>' +
              '</Condition>'
    @doc12 = REXML::Document.new(@xml12)

    @xml13 = '<Condition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="exclusiveSearchType">' +
                '<Expression xsi:type="columnReferenceType" Table="opt" Name="R" />' +
                '<Set xsi:type="subQuerySetType">' +
                  '<Select>' +
                    '<SelectionList>' +
                      '<Item xsi:type="columnReferenceType" Table="opt" Name="R" />' +
                      '<Item xsi:type="columnReferenceType" Table="opt" Name="V" />' +
                      '<Item xsi:type="columnReferenceType" Table="opt" Name="ra" />' +
                      '<Item xsi:type="columnReferenceType" Table="opt" Name="dec" />' +
                    '</SelectionList>' +
                  '</Select>' +
                '</Set>' +
              '</Condition>'
    @doc13 = REXML::Document.new(@xml13)
  end

  def test_from_xml
    assert_nothing_raised {
      cond = Condition.from_xml(@doc1.root)
      cond = Condition.from_xml(@doc2.root)
      cond = Condition.from_xml(@doc3.root)
      cond = Condition.from_xml(@doc4.root)
      cond = Condition.from_xml(@doc5.root)
      cond = Condition.from_xml(@doc6.root)
      cond = Condition.from_xml(@doc7.root)
      cond = Condition.from_xml(@doc8.root)
      cond = Condition.from_xml(@doc9.root)
      cond = Condition.from_xml(@doc10.root)
      cond = Condition.from_xml(@doc11.root)
      cond = Condition.from_xml(@doc12.root)
      cond = Condition.from_xml(@doc13.root)
    }
  end

  def test_to_adqls
    assert_equal("opt.org LIKE '%esa%'",
      Condition.from_xml(@doc1.root).to_adqls)
    assert_equal("opt.org NOT LIKE '%esa%'",
      Condition.from_xml(@doc2.root).to_adqls)
    assert_equal("(opt.org LIKE '%esa%')",
      Condition.from_xml(@doc3.root).to_adqls)
    assert_equal("opt.publisher <> 'CDS'",
      Condition.from_xml(@doc4.root).to_adqls)
    assert_equal("opt.R BETWEEN 1.2 AND 1.6",
      Condition.from_xml(@doc5.root).to_adqls)
    assert_equal("opt.R NOT BETWEEN 1.2 AND 1.6",
      Condition.from_xml(@doc6.root).to_adqls)
    assert_equal("opt.publisher <> 'CDS' AND opt.R BETWEEN 1.2 AND 1.6",
      Condition.from_xml(@doc7.root).to_adqls)
    assert_equal("opt.publisher <> 'CDS' OR opt.R BETWEEN 1.2 AND 1.6",
      Condition.from_xml(@doc8.root).to_adqls)
    assert_equal('XMATCH(opt, apt, !drop_me) < 0.5',
      Condition.from_xml(@doc9.root).to_adqls)
    assert_equal("Region('CIRCLE J2000 181.3 -0.76 6.5')",
      Condition.from_xml(@doc10.root).to_adqls)
    assert_equal("NOT opt.publisher <> 'CDS'",
      Condition.from_xml(@doc11.root).to_adqls)
    assert_equal('opt.R IN (SELECT opt.R, opt.V, opt.ra, opt.dec)',
      Condition.from_xml(@doc12.root).to_adqls)
    assert_equal('opt.R NOT IN (SELECT opt.R, opt.V, opt.ra, opt.dec)',
      Condition.from_xml(@doc13.root).to_adqls)
  end
end

class TableTest < Test::Unit::TestCase
  def setup
    @xml1 = '<Table Name="my_table" xsi:type="includeTableType" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>'
    @doc1 = REXML::Document.new(@xml1)

    @xml2 = '<Table Name="my_table" xsi:type="dropTableType" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>'
    @doc2 = REXML::Document.new(@xml2)

    @xml3 = '<Table Archive="SDSS" Name="PhotoPrimary" Alias="o" xsi:type="archiveTableType" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>'
    @doc3 = REXML::Document.new(@xml3)

    @xml4 = '<Table xsi:type="joinTableType" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' +
              '<Qualifier xsi:type="jointTableQualifierType">INNER</Qualifier>' +
              '<Tables xsi:type="arrayOfFromTableType">' +
                '<Table Archive="SDSS" Name="PhotoPrimary" Alias="o" xsi:type="archiveTableType"/>' +
                '<Table Archive="TWOMASS" Name="PhotoPrimary" Alias="t" xsi:type="archiveTableType"/>' +
              '</Tables>' +
              '<Condition xsi:type="comparisonPredType" Comparison="=">' +
                '<Arg xsi:type="columnReferenceType" Table="o" Name="publisher" />' +
                '<Arg xsi:type="atomType">' +
                  '<Literal xsi:type="stringType" Value="CDS" />' +
                '</Arg>' +
              '</Condition>' +
            '</Table>'
    @doc4 = REXML::Document.new(@xml4)

  	@table1 = Table.new('PhotoPrimary', 'o')
  	@table2 = Table.new('PhotoPrimary')
  end

  def test_from_xml
    assert_nothing_raised {
      tbl = Table.from_xml(@doc1.root)
      tbl = Table.from_xml(@doc2.root)
      tbl = Table.from_xml(@doc3.root)
      tbl = Table.from_xml(@doc4.root)
    }
  end

  def test_to_adqls
    assert_equal('my_table', Table.from_xml(@doc1.root).to_adqls)
    assert_equal('!my_table', Table.from_xml(@doc2.root).to_adqls)
    assert_equal('SDSS:PhotoPrimary o', Table.from_xml(@doc3.root).to_adqls)
    assert_equal("INNER SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t ON o.publisher = 'CDS'",
      Table.from_xml(@doc4.root).to_adqls)
    assert_equal('PhotoPrimary o', @table1.to_adqls)
		assert_equal('PhotoPrimary', @table2.to_adqls)
  end
end

class ConstantListSetTest < Test::Unit::TestCase
  def setup
    @xml = '<Set xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="constantListSetType">' +
              '<Item xsi:type="realType" Value="10.1" />' +
              '<Item xsi:type="stringType" Value="hello" />' +
              '<Item xsi:type="integerType" Value="5" />' +
           '</Set>'
    @doc = REXML::Document.new(@xml)
  end

  def test_from_xml
    assert_nothing_raised {
      set = ConstantListSet.from_xml(@doc.root)
    }
  end

  def test_to_adqls
    assert_equal('10.1, "hello", 5',
      ConstantListSet.from_xml(@doc.root).to_adqls)
  end
end

class ColumnTest < Test::Unit::TestCase
  def setup
    @xml = '<Column xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="columnReferenceType" Table="o" Name="publisher" />' 
    @doc = REXML::Document.new(@xml)
  end

  def test_from_xml
    assert_nothing_raised {
      col = Column.from_xml(@doc.root)
    }
  end

  def test_to_adqls
    assert_equal('o.publisher', Column.from_xml(@doc.root).to_adqls)
  
    xml = '<Column Table="o" Name="ra"/>'
    doc = REXML::Document.new(xml)
    assert_equal('o.ra', Column.from_xml(doc.root).to_adqls)
  end
end

class ItemTest < Test::Unit::TestCase
  def setup
    @xml1 = '<Item xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="orderType">' +
              '<Expression xsi:type="columnReferenceType" Table="o" Name="ra" />' +
              '<Order Direction="ASC"/>' +
            '</Item>'
    @doc1 = REXML::Document.new(@xml1)
  end

  def test_from_xml
    assert_nothing_raised {
      item = Item.from_xml(@doc1.root)
    }
  end

  def test_from_adqls
    assert_equal('o.ra ASC', Item.from_xml(@doc1.root).to_adqls)
  end
end

class OrderByTest < Test::Unit::TestCase
  def setup
    xml = '<OrderBy xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' +
            '<Item xsi:type="orderType">' +
              '<Expression xsi:type="columnReferenceType" Table="o" Name="ra" />' +
              '<Order Direction="ASC"/>' +
            '</Item>' +
            '<Item xsi:type="orderType">' +
              '<Expression xsi:type="columnReferenceType" Table="o" Name="dec" />' +
              '<Order Direction="DESC"/>' +
            '</Item>' +
          '</OrderBy>'
    @doc = REXML::Document.new(xml)
  end

  def test_from_xml
    assert_equal('ORDER BY o.ra ASC, o.dec DESC',
      OrderBy.from_xml(@doc.root).to_adqls)
  end
end

class ParamsTest < Test::Unit::TestCase
  def setup
    xml = '<Params xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Oper="-" xsi:type="binaryExprType">' +
            '<Arg Table="o" Name="R" xsi:type="columnReferenceType"/>' +
            '<Arg Table="o" Name="B" xsi:type="columnReferenceType"/>' +
          '</Params>'
    @doc = REXML::Document.new(xml)
  end

  def test_from_xml
    assert_equal('o.R - o.B',
      Params.from_xml(@doc.root).to_adqls)
  end
end

class QualifierTest < Test::Unit::TestCase
  def setup
    xml = '<Qualifier>INNER</Qualifier>'
    @doc = REXML::Document.new(xml)
  end

  def test_from_xml
    assert_equal('INNER', Qualifier.from_xml(@doc.root).to_adqls)
  end
end

class TablesTest < Test::Unit::TestCase
  def setup
    xml = '<Tables xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">' +
            '<Table Archive="SDSS" Name="PhotoPrimary" Alias="o" xsi:type="archiveTableType"/>' +
            '<Table Archive="TWOMASS" Name="PhotoPrimary" Alias="t" xsi:type="archiveTableType"/>' +
          '</Tables>'
    @doc = REXML::Document.new(xml)
  end

  def test_from_xml
    assert_equal('SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t',
      Tables.from_xml(@doc.root).to_adqls)
  end
end

class RealWorldTests < Test::Unit::TestCase
  def setup
    @test1_doc = REXML::Document.new(File.new('test/adql/test1.adql'))
    @test2_doc = REXML::Document.new(File.new('test/adql/test2.adql'))
    @test3_doc = REXML::Document.new(File.new('test/adql/test3.adql'))
    @test4_doc = REXML::Document.new(File.new('test/adql/test4.adql'))
    @test5_doc = REXML::Document.new(File.new('test/adql/test5.adql'))
    @test6_doc = REXML::Document.new(File.new('test/adql/test6.adql'))
    @test7_doc = REXML::Document.new(File.new('test/adql/test7.adql'))
  end

  def test_test1
    assert_equal('SELECT o.objid, o.ra, o.dec, o.type, t.objid, t.ra, t.dec, t.j_m, o.i ' +
                 'FROM SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t, ' +
                 'INNER SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t ON o.objid = t.objid ' +
                 "WHERE Region('CIRCLE J2000 182.5 -0.89 8.0')",
                  Select.from_xml(@test1_doc.root).to_adqls)
  end

  def test_test2
    assert_equal('SELECT o.objid, o.ra, o.dec, o.r, o.type, t.objid, t.ra, t.dec ' +
                 'FROM SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t ' +
                 'WHERE ' +
                    'XMATCH(o, t) < 3.5 AND ' +
                    "Region('CIRCLE J2000 181.3 -0.76 6.5') AND " +
                    'o.type = 3',
                  Select.from_xml(@test2_doc.root).to_adqls)
  end

  def test_test3
    assert_equal('SELECT o.objid, o.ra, o.dec, o.type, t.objid, t.ra, t.dec, t.j_m, o.i ' +
                 'FROM SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t ' +
                 'WHERE ' +
                    'XMATCH(o, t) < 3.5 AND ' +
                    "Region('CIRCLE J2000 182.5 -0.89 8.0') AND " +
                    'o.type = 3 AND ' +
                    'o.i < 21 AND ' +
                    't.j_m < 18 AND ' +
                    '(o.i - t.j_m) > 2',
                  Select.from_xml(@test3_doc.root).to_adqls)
  end

  def test_test4
    assert_equal('SELECT o.objid, o.ra, o.dec, t.ra, t.dec, t.objid, o.type ' +
                 'FROM SDSS:PhotoPrimary o, TWOMASS:PhotoPrimary t, USNOB:PhotoPrimary p ' +
                 'WHERE ' +
                    'XMATCH(o, t, !p) < 3.5 AND ' +
                    "Region('CIRCLE J2000 182.5 -0.89 8.0') AND " +
                    'o.type = 3',
                  Select.from_xml(@test4_doc.root).to_adqls)
  end

  def test_test5
    assert_equal('SELECT o.objid, o.ra, o.dec, o.type, t.objid, t.j_m, o.z ' +
                 'FROM SDSSDR2:PhotoPrimary o, TWOMASS:PhotoPrimary t ' +
                 'WHERE ' +
                    'XMATCH(o, t) < 2.5 AND ' +
                    "Region('CIRCLE J2000 16.031 -0.891 30.0') AND " +
                    '(o.z - t.j_m) > 2',
                  Select.from_xml(@test5_doc.root).to_adqls)
  end

  def test_test6
    assert_equal('SELECT TOP 10 s.* FROM sdss:photoobjall s',
      Select.from_xml(@test6_doc.root).to_adqls)
  end

  def test_test7
    assert_equal('SELECT b.objid, b.ra, b.dec, b.u, s.z AS sdssRS ' +
                 'FROM sdss:photoprimary b, sdss:specobjall s ' +
                 'WHERE ' +
                    's.specobjid = b.specobjid AND ' +
                    's.z > 1.8 AND ' +
                    "Region('CIRCLE J2000 181.3 -0.76 30.0')",
                  Select.from_xml(@test7_doc.root).to_adqls)
  end
end

class ParserTest < Test::Unit::TestCase
  def test_construct
    assert_nothing_raised {
     select = Parser.new(File.new('test/adql/test3.adql')).parse
     select_s = Parser.convert_to_adqls(File.new('test/adql/test3.adql'))
    }
  end
end