voruby 1.1.1 → 2.0.0

data/test/voruby/votable/1.0/votable.html

@@ -0,0 +1,86 @@
+<div class="votable">
+  <div class="resource">
+    <h3>myFavouriteGalaxies</h3>
+    <table>
+      <caption>Velocities and Distance estimations</caption>
+      <thead>
+        <tr>
+          <th>
+            <div class="field" id="col1">
+              <div class="name">RA</div>
+              <div class="ucd">pos.eq.ra;meta.main</div>
+              <div class="unit">deg</div>
+              <span class="datatype">float</span>
+            </div>
+          </th>
+          <th>
+            <div class="field" id="col2">
+              <div class="name">Dec</div>
+              <div class="ucd">pos.eq.dec;meta.main</div>
+              <div class="unit">deg</div>
+              <span class="datatype">float</span>
+            </div>
+          </th>
+          <th>
+            <div class="field" id="col3">
+              <div class="name">Name</div>
+              <div class="ucd">meta.id;meta.main</div>
+              <span class="datatype">char</span>
+              <span class="arraysize">8*</span>
+            </div>
+          </th>
+          <th>
+            <div class="field" id="col4">
+              <div class="name">RVel</div>
+              <div class="ucd">src.veloc.hc</div>
+              <div class="unit">km/s</div>
+              <span class="datatype">int</span>
+            </div>
+          </th>
+          <th>
+            <div class="field" id="col5">
+              <div class="name">e_RVel</div>
+              <div class="ucd">stat.error;src.veloc.hc</div>
+              <div class="unit">km/s</div>
+              <span class="datatype">int</span>
+            </div>
+          </th>
+          <th>
+            <div class="field" id="col6">
+              <div class="name">R</div>
+              <div class="ucd">phys.distance</div>
+              <div class="unit">Mpc</div>
+              <span class="datatype">float</span>
+            </div>
+          </th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td>010.68</td>
+          <td>+41.27</td>
+          <td>N 224</td>
+          <td>-297</td>
+          <td>5</td>
+          <td>0.7</td>
+        </tr>
+        <tr>
+          <td>287.43</td>
+          <td>-63.85</td>
+          <td>N 6744</td>
+          <td>839</td>
+          <td>6</td>
+          <td>10.4</td>
+        </tr>
+        <tr>
+          <td>023.48</td>
+          <td>+30.66</td>
+          <td>N 598</td>
+          <td>-182</td>
+          <td>3</td>
+          <td>0.7</td>
+        </tr>
+      </tbody>
+    </table>
+  </div>
+</div>

data/test/voruby/votable/1.0/votable.ns.xml

@@ -0,0 +1,56 @@
+<ns1:VOTABLE xmlns:ns1="SkyPortal.ivoa.net">
+	<ns2:RESOURCE xmlns:ns2="http://vizier.u-strasbg.fr/xml/VOTable-1.1.xsd">
+		<ns2:TABLE name="Table 1">
+			<ns2:FIELD datatype="double" name="NUMBER" width="10"/>
+			<ns2:FIELD datatype="double" name="MAG_ISO" width="10"/>
+			<ns2:FIELD datatype="double" name="MAGERR_ISO" width="10"/>
+			<ns2:FIELD datatype="double" name="MAG_ISOCOR" width="10"/>
+			<ns2:FIELD datatype="double" name="MAGERR_ISOCOR" width="10"/>
+			<ns2:FIELD datatype="double" name="MAG_APER" width="10"/>
+			<ns2:FIELD datatype="double" name="MAGERR_APER" width="10"/>
+			<ns2:FIELD datatype="double" name="MAG_AUTO" width="10"/>
+			<ns2:FIELD datatype="double" name="MAGERR_AUTO" width="10"/>
+			<ns2:FIELD datatype="double" name="MAG_BEST" width="10"/>
+			<ns2:FIELD datatype="double" name="MAGERR_BEST" width="10"/>
+			<ns2:FIELD datatype="double" name="ra" width="10"/>
+			<ns2:FIELD datatype="double" name="dec" width="10"/>
+			<ns2:FIELD datatype="double" name="FLAGS" width="10"/>
+			<ns2:DATA>
+				<ns2:TABLEDATA>
+					<ns2:TR>
+						<ns2:TD>1</ns2:TD>
+						<ns2:TD>-14.0836</ns2:TD>
+						<ns2:TD>0.0008</ns2:TD>
+						<ns2:TD>-14.0986</ns2:TD>
+						<ns2:TD>0.0008</ns2:TD>
+						<ns2:TD>-12.6699</ns2:TD>
+						<ns2:TD>0.0002</ns2:TD>
+						<ns2:TD>-14.1114</ns2:TD>
+						<ns2:TD>0.0007</ns2:TD>
+						<ns2:TD>-14.1114</ns2:TD>
+						<ns2:TD>0.0007</ns2:TD>
+						<ns2:TD>2.9325730</ns2:TD>
+						<ns2:TD>+1.0539001</ns2:TD>
+						<ns2:TD>2</ns2:TD>
+					</ns2:TR>
+					<ns2:TR>
+						<ns2:TD>2</ns2:TD>
+						<ns2:TD>-6.0965</ns2:TD>
+						<ns2:TD>0.1047</ns2:TD>
+						<ns2:TD>-6.8029</ns2:TD>
+						<ns2:TD>0.1221</ns2:TD>
+						<ns2:TD>-5.5913</ns2:TD>
+						<ns2:TD>0.1576</ns2:TD>
+						<ns2:TD>-7.6463</ns2:TD>
+						<ns2:TD>0.0858</ns2:TD>
+						<ns2:TD>-7.6463</ns2:TD>
+						<ns2:TD>0.0858</ns2:TD>
+						<ns2:TD>2.9335704</ns2:TD>
+						<ns2:TD>+1.0456679</ns2:TD>
+						<ns2:TD>0</ns2:TD>
+					</ns2:TR>
+				</ns2:TABLEDATA>
+			</ns2:DATA>
+		</ns2:TABLE>
+	</ns2:RESOURCE>
+</ns1:VOTABLE>

data/test/voruby/votable/1.1/test.rb

@@ -0,0 +1,785 @@
+require 'voruby/votable/1.1/votable'
+require 'test/unit'
+
+include VORuby::VOTable::V1_1
+
+module VORuby
+  module VOTable
+    module V1_1
+      module Test
+      
+        module Methods
+          def test_construction
+             obj = self.class_to_test.new(self.inputs)
+             outputs = self.respond_to?(:expected_outputs) ? self.expected_outputs : self.inputs
+
+             outputs.each do |name, value|
+               result = obj.send(name)
+               assert_equal result, outputs[name]
+             end
+           end
+
+           def test_accessors
+             obj = self.class_to_test.new
+             outputs = self.respond_to?(:expected_outputs) ? self.expected_outputs : self.inputs
+
+             if self.inputs.is_a?(Hash)
+               self.inputs.each do |name, value|
+                 obj.send("#{name}=", value)
+                 assert_equal obj.send(name), outputs[name]
+               end
+             end
+           end
+        end
+        
+        class VOTableTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; VOTable end
+          
+          def inputs
+            {
+              :version => '1.1',
+              :id => 'my_test_votable',
+              :description => Description.new,
+              :definitions => Definitions.new,
+              :coordinate_systems => [Coosys.new],
+              :params => [Param.new],
+              :infos => [Info.new],
+              :resources => [Resource.new]
+            }
+          end
+          
+          def test_to_html
+            votable = VOTable.new(
+              :version => '1.1',
+              :coordinate_systems => [
+                Coosys.new(:id => 'J2000', :equinox => 'J2000.', :epoch => 'J2000.', :system => 'eq_FK5')
+              ],
+              :resources => [
+                Resource.new(
+                  :name => 'myFavouriteGalaxies',
+                  :tables => [
+                    Table.new(
+                      :name => 'results',
+                      :description => Description.new(:text => 'Velocities and Distance estimations'),
+                      :params => [
+                        Param.new(
+                          :name => 'Telescope',
+                          :datatype => 'float',
+                          :ucd => 'phys.size;instr.tel',
+                          :unit => 'm',
+                          :value => '3.6'
+                        )
+                      ],
+                      :fields => [
+                        Field.new(:name => 'RA', :id => 'col1', :ucd => 'pos.eq.ra;meta.main',
+                                  :ref => 'J2000', :datatype => 'float', :width => 6, :precision => '2', :unit => 'deg'),
+                        Field.new(:name => 'Dec', :id => 'col2', :ucd => 'pos.eq.dec;meta.main',
+                                  :ref => 'J2000', :datatype => 'float', :width => 6, :precision => '2', :unit => 'deg'),
+                        Field.new(:name => 'Name', :id => 'col3', :ucd => 'meta.id;meta.main',
+                                  :datatype => 'char', :arraysize => '8*'),
+                        Field.new(:name => 'RVel', :id => 'col4', :ucd => 'src.veloc.hc', :datatype => 'int',
+                                  :width => 5, :unit => 'km/s'),
+                        Field.new(:name => 'e_RVel', :id => 'col5', :ucd => 'stat.error;src.veloc.hc',
+                                  :datatype => 'int', :width => 3, :unit => 'km/s'),
+                        Field.new(:name => 'R', :id => 'col6', :ucd => 'phys.distance', :datatype => 'float',
+                                  :width => 4, :precision => '1', :unit => 'Mpc',
+                                  :description => Description.new(:text => 'Distance of Galaxy, assuming H=75km/s/Mpc'))
+                      ],
+                      :data => Data.new(
+                        :format => TableData.new(
+                          :trs => [
+                            Tr.new(:tds => [
+                              Td.new(:text => '010.68'), Td.new(:text => '+41.27'), Td.new(:text => 'N 224'),
+                              Td.new(:text => '-297'), Td.new(:text => '5'), Td.new(:text => '0.7')
+                            ]),
+                            Tr.new(:tds => [
+                              Td.new(:text => '287.43'), Td.new(:text => '-63.85'), Td.new(:text => 'N 6744'),
+                              Td.new(:text => '839'), Td.new(:text => '6'), Td.new(:text => '10.4')
+                            ]),
+                            Tr.new(:tds => [
+                              Td.new(:text => '023.48'), Td.new(:text => '+30.66'), Td.new(:text => 'N 598'),
+                              Td.new(:text => '-182'), Td.new(:text => '3'), Td.new(:text => '0.7')
+                            ])
+                          ]
+                        )
+                      )
+                    )
+                  ]
+                )
+              ]
+            )
+            
+            assert_equal(
+              File.read('test/voruby/votable/1.1/votable.html').strip.gsub(/\n+\s*/, ''),
+              votable.to_html.strip.gsub(/\n+\s*/, '')
+            )
+          end
+        end
+        
+        class DescriptionTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Description end
+          
+          def inputs; {:text => 'A description'} end
+        end
+        
+        class DefinitionsTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Definitions end
+          
+          def inputs
+            {
+              :coordinate_systems => [Coosys.new],
+              :params => [Param.new]
+            }
+          end
+        end
+        
+        class CoosysTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Coosys end
+          
+          def inputs
+            {:id => 'my_coosys', :equinox => 'J2000', :epoch => 'B1950', :system => 'supergalactic'}
+          end
+        end
+        
+        class ParamTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Param end
+          
+          def inputs
+            {
+              :id => 'my_param_test',
+              :unit => 'm/s',
+              :datatype => 'float',
+              :arraysize => '*',
+              :precision => '3',
+              :width => 6,
+              :ref => 'refer_to_1',
+              :name => 'My param test',
+              :ucd => 'phys.velocity',
+              :utype => 'my_utype',
+              :value => '123.456',
+              :description => Description.new,
+              :values => Values.new,
+              :links => [Link.new]
+            }
+          end
+          
+          def test_casting
+            param = Param.new(:datatype => 'float', :arraysize => '*')
+            param.value = [123.4, 21.5]
+            assert_equal [123.4, 21.5], param.value(true)
+          end
+        end
+        
+        class InfoTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Info end
+          
+          def inputs
+            {:id => 'my_info', :name => 'info_lite', :value => '123'}
+          end
+        end
+        
+        class ResourceTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Resource end
+          
+          def inputs
+            {
+              :name => 'Test Resource',
+              :id => 'my_test_resource',
+              :utype => 'a_utype',
+              :type => 'a_type',
+              :description => Description.new,
+              :infos => [Info.new],
+              :coordinate_systems => [Coosys.new],
+              :params => [Param.new],
+              :links => [Link.new],
+              :tables => [Table.new],
+              :resources => [Resource.new]
+            }
+          end
+        end
+        
+        class LinkTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Link end
+          
+          def inputs
+            {
+              :id => 'my_link', :content_role => 'hints', :content_type => 'text/html',
+              :title => 'link title', :value => 'this is value',
+              :href => 'http://www.google.com/', :gref => 'a gref',
+              :action => 'http://www.noao.edu/actions/mine'
+            }
+          end
+          
+          def expected_outputs
+            self.inputs.merge({
+              :href => URI.parse('http://www.google.com/'),
+              :action => URI.parse('http://www.noao.edu/actions/mine')
+            })
+          end
+        end
+        
+        class TableTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Table end
+          
+          def inputs
+            {
+              :id => 'my_table',
+              :name => 'My Table',
+              :ref => 'ref1',
+              :ucd => 'a_ucd',
+              :utype => 'a_utype',
+              :nrows => '5',
+              :description => Description.new,
+              :data => Data.new(),
+              :fields => [Field.new],
+              :params => [Param.new],
+              :groups => [Group.new],
+              :links => [Link.new]
+            }
+          end
+          
+          def expected_outputs
+            self.inputs.merge({:nrows => 5})
+          end
+          
+          def test_to_html
+            table = Table.new(
+              :id => 'table1',
+              :description => Description.new(:text => 'A test table'),
+              :fields => [
+                Field.new(:name => 'RA', :id => 'col1', :ucd => 'pos.eq.ra;meta.main',
+                          :ref => 'J2000', :datatype => 'float', :width => 6, :precision => '2', :unit => 'deg'),
+                Field.new(:name => 'Dec', :id => 'col2', :ucd => 'pos.eq.dec;meta.main',
+                          :ref => 'J2000', :datatype => 'float', :width => 6, :precision => '2', :unit => 'deg'),
+                Field.new(:name => 'Name', :id => 'col3', :ucd => 'meta.id;meta.main',
+                          :datatype => 'char', :arraysize => '8*')
+              ],
+              :data => Data.new(
+                :format => TableData.new(
+                  :trs => [
+                    Tr.new(:tds => [Td.new(:text => '123'), Td.new(:text => '456'), Td.new(:text => 'my_obj1')]),
+                    Tr.new(:tds => [Td.new(:text => '789'), Td.new(:text => '112'), Td.new(:text => 'my_obj2')]),
+                    Tr.new(:tds => [Td.new(:text => '145'), Td.new(:text => '178'), Td.new(:text => 'my_obj3')])
+                  ]
+                )
+              )
+            )
+            
+            assert_equal(
+              '<table id="table1">' +
+                '<caption>A test table</caption>' +
+                '<thead>' +
+                  '<tr>' +
+                    '<th>' +
+                      '<div class="field" id="col1">' +
+                        '<div class="name">RA</div>' +
+                        '<div class="ucd">pos.eq.ra;meta.main</div>' +
+                        '<div class="unit">deg</div>' +
+                        '<span class="datatype">float</span>' +
+                      '</div>' +
+                    '</th>' +
+                    '<th>' +
+                      '<div class="field" id="col2">' +
+                        '<div class="name">Dec</div>' +
+                        '<div class="ucd">pos.eq.dec;meta.main</div>' +
+                        '<div class="unit">deg</div>' +
+                        '<span class="datatype">float</span>' +
+                      '</div>' +
+                    '</th>' +
+                    '<th>' +
+                      '<div class="field" id="col3">' +
+                        '<div class="name">Name</div>' +
+                        '<div class="ucd">meta.id;meta.main</div>' +
+                        '<span class="datatype">char</span>' +
+                        '<span class="arraysize">8*</span>' +
+                      '</div>' +
+                    '</th>' +
+                  '</tr>' +
+                '</thead>' +
+                '<tbody>' +
+                  '<tr>' +
+                    '<td>123</td>' +
+                    '<td>456</td>' +
+                    '<td>my_obj1</td>' +
+                  '</tr>' +
+                  '<tr>' +
+                    '<td>789</td>' +
+                    '<td>112</td>' +
+                    '<td>my_obj2</td>' +
+                  '</tr>' +
+                  '<tr>' +
+                    '<td>145</td>' +
+                    '<td>178</td>' +
+                    '<td>my_obj3</td>' +
+                  '</tr>' +
+                '</tbody>' +
+              '</table>',
+              table.to_html.strip.gsub(/\n+\s*/, '')
+            )
+          end
+        end
+        
+        class FieldTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Field end
+          
+          def inputs
+            {
+              :id => 'my_field',
+              :unit => 'm/s',
+              :datatype => 'float',
+              :precision => '3',
+              :width => '6',
+              :precision => '3',
+              :ref => 'my_ref',
+              :name => 'Velocity',
+              :ucd => 'phys.velocity',
+              :utype => 'a_utype',
+              :arraysize => '*',
+              :type => 'a_type',
+              :description => Description.new,
+              :values => [Values.new],
+              :links => [Link.new]
+            }
+          end
+          
+          def expected_outputs
+            self.inputs.merge({:width => 6})
+          end
+          
+          def test_to_html
+            field = Field.new(:id => 'col1', :name => 'Name', :ucd => 'meta.id;meta.main', :datatype => 'char', :arraysize => '*')
+            assert_equal(
+              '<div class="field" id="col1">' +
+                '<div class="name">Name</div>' +
+                '<div class="ucd">meta.id;meta.main</div>' +
+                '<span class="datatype">char</span>' +
+                '<span class="arraysize">*</span>' +
+              '</div>',
+              field.to_html.strip.gsub(/\n+\s*/, '')
+            )
+          end
+        end
+        
+        class ValuesTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Values end
+          
+          def inputs
+            {
+              :id => 'my_values',
+              :type => 'a_type',
+              :null => ' ',
+              :ref => 'values_ref',
+              :max => Max.new,
+              :min => Min.new,
+              :options => [Option.new]
+            }
+          end
+        end
+        
+        class MinTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Min end
+          
+          def inputs
+            {:value => '10.2', :inclusive => 'no'}
+          end
+          
+          def test_inclusive
+            min = Min.new(self.inputs)
+            assert_equal false, min.inclusive?
+          end
+          
+          def test_alternate_inclusives
+            min = Min.new(:inclusive => false)
+            assert_equal 'no', min.inclusive
+            min.inclusive = true
+            assert_equal 'yes', min.inclusive
+          end
+        end
+        
+        class MaxTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Max end
+          
+          def inputs
+            {:value => '10.2', :inclusive => 'yes'}
+          end
+          
+          def test_inclusive
+            max = Max.new(self.inputs)
+            assert_equal true, max.inclusive?
+          end
+          
+          def test_alternate_inclusives
+            max = Max.new(:inclusive => false)
+            assert_equal 'no', max.inclusive
+            max.inclusive = true
+            assert_equal 'yes', max.inclusive
+          end
+        end
+        
+        class OptionTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Option end
+            
+          def inputs
+            {
+              :name => 'my_option',
+              :value => 'blahdeblah',
+              :options => [Option.new]
+            }
+          end
+        end
+        
+        class GroupTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Group end
+          
+          def inputs
+            {
+              :id => 'my_group',
+              :name => 'Group1',
+              :ref => 'group1',
+              :ucd => 'a_ucd',
+              :utype => 'a_utype',
+              :description => Description.new,
+              :field_refs => [FieldRef.new],
+              :param_refs => [ParamRef.new],
+              :params => [Param.new],
+              :groups => [Group.new]
+            }
+          end
+        end
+        
+        class FieldRefTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; FieldRef end
+          
+          def inputs; {:ref => 'my_field_ref'} end
+          
+          def test_field_retrieval
+            table = Table.new(
+              :fields => [Field.new(:id => 'col1', :name => 'my column')],
+              :groups => [
+                Group.new(
+                  :field_refs => [FieldRef.new(:ref => 'col1')]
+                )
+              ]
+            )
+            
+            assert_equal Field.new(:id => 'col1', :name => 'my column'), table.groups.first.field_refs.first.field
+          end
+        end
+        
+        class ParamRefTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; ParamRef end
+          
+          def inputs; {:ref => 'my_param_ref'} end
+          
+          def test_param_retrieval
+            table = Table.new(
+              :params => [Param.new(:id => 'param1', :name => 'my param')],
+              :groups => [
+                Group.new(
+                  :param_refs => [ParamRef.new(:ref => 'param1')]
+                )
+              ]
+            )
+            
+            assert_equal Param.new(:id => 'param1', :name => 'my param'), table.groups.first.param_refs.first.param
+          end
+        end
+        
+        class DataTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Data end
+          
+          def inputs
+            {
+              :format => TableData.new
+            }
+          end
+          
+          def test_alternative_formats
+            data = Data.new(:format => Binary.new)
+            assert_equal Binary.new, data.format
+            
+            data = Data.new(:format => Fits.new)
+            assert_equal Fits.new, data.format
+          end
+        end
+        
+        class TableDataTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; TableData end
+          
+          def inputs; {:trs => [Tr.new]} end
+        end
+        
+        class BinaryTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Binary end
+          
+          def inputs; {:stream => Stream.new()} end
+        end
+        
+        class StreamTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Stream end
+          
+          def inputs
+            {
+              :type => 'other', :href => 'http://www.noao.edu/', :actuate => 'onRequest',
+              :encoding => 'gzip', :expires => '2007-12-05T08:45:14', :rights => 'none',
+              :text => 'Some text'
+            }
+          end
+          
+          def expected_outputs
+            self.inputs.merge({
+              :href => URI.parse(self.inputs[:href]),
+              :expires => DateTime.parse(self.inputs[:expires])
+            })
+          end
+          
+          def test_retrieve
+            stream = Stream.new(:href => 'http://www.noao.edu/index.shtml')
+            file = stream.retrieve
+            #assert_kind_of Tempfile, file
+            assert_match /National Optical Astronomy Observatory/, file.read
+            
+            stream = Stream.new(:text => 'my text')
+            file = stream.retrieve
+            assert_kind_of StringIO, file
+            assert_equal 'my text', file.read
+          end
+        end
+        
+        class FitsTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Fits end
+          
+          def inputs
+            {
+              :extnum => '2',
+              :stream => Stream.new
+            }
+          end
+          
+          def expected_outputs
+            self.inputs.merge({:extnum => 2})
+          end
+          
+          # def test_to_rfits
+          #             fits = Fits.new(:stream => Stream.new(:href => 'http://fits.gsfc.nasa.gov/nrao_data/samples/image/swp05569slg.fits'))
+          #             rfits = fits.to_rfits
+          #             
+          #             (VORuby.rfits?) ? assert_kind_of(RFits::File, rfits) : assert_kind_of(Tempfile, rfits)
+          #           end
+        end
+        
+        class TrTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Tr end
+          
+          def inputs; {:tds => [Td.new]} end
+          
+          def test_to_html
+            tr = Tr.new(:tds => [Td.new(:text => 'hello'), Td.new(:text => 'world')])
+            assert_equal("<tr><td>hello</td><td>world</td></tr>", tr.to_html.strip.gsub(/\n+\s*/, ''))
+          end
+        end
+        
+        class TdTest < ::Test::Unit::TestCase
+          include Methods
+          
+          def class_to_test; Td end
+          
+          def inputs
+            {
+              :encoding => 'base64',
+              :text => 'my value'
+            }
+          end
+          
+          def test_casting
+            table = Table.new(
+              :fields => [
+                Field.new(:name => 'col1', :datatype => 'boolean'),
+                Field.new(:name => 'col1_2', :datatype => 'boolean', :arraysize => '*'),
+                Field.new(:name => 'col2', :datatype => 'bit'),
+                Field.new(:name => 'col2_2', :datatype => 'bit', :arraysize => '*'),
+                Field.new(:name => 'col3', :datatype => 'unsignedByte'),
+                Field.new(:name => 'col3_2', :datatype => 'unsignedByte', :arraysize => '*'),
+                Field.new(:name => 'col4', :datatype => 'short'),
+                Field.new(:name => 'col4_2', :datatype => 'short', :arraysize => '*'),
+                Field.new(:name => 'col5', :datatype => 'int'),
+                Field.new(:name => 'col5_2', :datatype => 'int', :arraysize => '*'),
+                Field.new(:name => 'col6', :datatype => 'long'),
+                Field.new(:name => 'col6_2', :datatype => 'long', :arraysize => '*'),
+                Field.new(:name => 'col7', :datatype => 'char'),
+                Field.new(:name => 'col7_2', :datatype => 'char', :arraysize => '*'),
+                Field.new(:name => 'col8', :datatype => 'unicodeChar'),
+                Field.new(:name => 'col8_2', :datatype => 'unicodeChar', :arraysize => '*'),
+                Field.new(:name => 'col9', :datatype => 'float'),
+                Field.new(:name => 'col9_2', :datatype => 'float', :arraysize => '*'),
+                Field.new(:name => 'col10', :datatype => 'double'),
+                Field.new(:name => 'col10_2', :datatype => 'double', :arraysize => '*'),
+                Field.new(:name => 'col11', :datatype => 'floatComplex'),
+                Field.new(:name => 'col11_2', :datatype => 'floatComplex', :arraysize => '*'),
+                Field.new(:name => 'col12', :datatype => 'doubleComplex'),
+                Field.new(:name => 'col12_2', :datatype => 'doubleComplex', :arraysize => '*')
+              ],
+              :data => Data.new(
+                :format => TableData.new(
+                  :trs => [
+                    Tr.new(:tds => [
+                      Td.new(:text => 't'),
+                      Td.new(:text => 't f 1 true false 0'),
+                      Td.new(:text => '1'),
+                      Td.new(:text => '1 1 0 1 1'),
+                      Td.new(:text => 'a'),
+                      Td.new(:text => 'a b c d'),
+                      Td.new(:text => '34'),
+                      Td.new(:text => '34 12 4 1'),
+                      Td.new(:text => '100'),
+                      Td.new(:text => '100 101 102'),
+                      Td.new(:text => '1000'),
+                      Td.new(:text => '1000 1001 1002'),
+                      Td.new(:text => 'a'),
+                      Td.new(:text => 'hello'),
+                      Td.new(:text => 'b'),
+                      Td.new(:text => 'world'),
+                      Td.new(:text => '12.1'),
+                      Td.new(:text => '1.1 2.2 3.3'),
+                      Td.new(:text => '1000'),
+                      Td.new(:text => '100.1, 200.2, 300.3'),
+                      Td.new(:text => '7.2 5.5'),
+                      Td.new(:text => '1.1 10.1 3.2 2.2 9.0 7.1')
+                    ])
+                  ]
+                )
+              )
+            )
+            
+            tr = table.data.format.trs.first
+            
+            # Retrieval...
+            assert_equal true, tr.tds[0].value
+            assert_equal [true, false, true, true, false, false], tr.tds[1].value
+            assert_equal 1, tr.tds[2].value
+            assert_equal [1, 1, 0, 1, 1], tr.tds[3].value
+            assert_equal 97, tr.tds[4].value
+            assert_equal [97, 98, 99, 100], tr.tds[5].value
+            assert_equal 34, tr.tds[6].value
+            assert_equal [34, 12, 4, 1], tr.tds[7].value
+            assert_equal 100, tr.tds[8].value
+            assert_equal [100, 101, 102], tr.tds[9].value
+            assert_equal 1000, tr.tds[10].value
+            assert_equal [1000, 1001, 1002], tr.tds[11].value
+            assert_equal 'a', tr.tds[12].value
+            assert_equal 'hello', tr.tds[13].value
+            assert_equal 'b', tr.tds[14].value
+            assert_equal 'world', tr.tds[15].value
+            assert_equal 12.1, tr.tds[16].value
+            assert_equal [1.1, 2.2, 3.3], tr.tds[17].value
+            assert_equal 1000, tr.tds[18].value
+            assert_equal [100.1, 200.2, 300.3], tr.tds[19].value
+            assert_equal Complex.new(7.2, 5.5), tr.tds[20].value
+            assert_equal [Complex.new(1.1, 10.1), Complex.new(3.2, 2.2), Complex.new(9.0, 7.1)], tr.tds[21].value
+            
+            # Setters
+            tr.tds[0].value = true
+            assert_equal true, tr.tds[0].value
+            tr.tds[2].value = 1
+            assert_equal 1, tr.tds[2].value
+            tr.tds[4].value = 'a'
+            assert_equal 97, tr.tds[4].value
+            tr.tds[6].value = 1000
+            assert_equal 1000, tr.tds[6].value
+            tr.tds[8].value = 10000
+            assert_equal 10000, tr.tds[8].value
+            tr.tds[10].value = 1000000
+            assert_equal 1000000, tr.tds[10].value
+            tr.tds[12].value = 'b'
+            assert_equal 'b', tr.tds[12].value
+            tr.tds[14].value = 'B'
+            assert_equal 'B', tr.tds[14].value
+            tr.tds[16].value = 1.1
+            assert_equal 1.1, tr.tds[16].value
+            tr.tds[18].value = 10001.1
+            assert_equal 10001.1, tr.tds[18].value
+            tr.tds[20].value = Complex.new(1.1, 2.2)
+            assert_equal Complex.new(1.1, 2.2), tr.tds[20].value
+            
+            # This should be an array...
+            assert_raise RuntimeError do
+              tr.tds[1].value = 1
+            end
+            
+            # And this should be a scalar...
+            assert_raise RuntimeError do
+              tr.tds[0].value = [1, 0, 1, 1]
+            end
+            
+          end
+          
+          def test_to_html
+            td = Td.new(:text => '1 1 0 1 1')
+            assert_equal("<td>1 1 0 1 1</td>", td.to_html.strip.gsub(/\n+\s*/, ''))
+          end
+        end
+        
+        class NSVOTableTest < ::Test::Unit::TestCase
+          def test_ns
+            votable = VOTable.new(File.open('test/voruby/votable/1.1/votable.ns.xml'))
+            table = votable.resources.first.tables.first
+            
+            assert_equal 'ra', table.fields[-3].name
+            assert_equal 'double', table.fields[-3].datatype
+            assert_equal 10, table.fields[-3].width
+            
+            assert_equal -14.0986, table.data.format.trs.first.tds[3].value
+            assert_equal 1.0456679, table.data.format.trs[1].tds[-2].value
+          end
+        end
+        
+      end
+    end
+  end
+end