/test/unit/bio/db/pdb/test_pdb.rb

Large files files are truncated, but you can click here to view the full file

#
# = test/unit/bio/db/pdb/test_pdb.rb - Unit test for Bio::PDB classes
#
# Copyright:: Copyright (C) 2010 Kazuhiro Hayashi <k.hayashi.info@gmail.com>
# Copyright:: Copyright (C) 2006 Naohisa Goto <ng@bioruby.org>
#
# License:: The Ruby License
#
#  $Id:$
#

# loading helper routine for testing bioruby
require 'pathname'
require 'matrix'
load Pathname.new(File.join(File.dirname(__FILE__), ['..'] * 4,
                            'bioruby_test_helper.rb')).cleanpath.to_s

# libraries needed for the tests
require 'test/unit'
require 'bio'

module Bio

  #This class tests Bio::PDB class.
  #The sample record isn't sufficient because it cannot pass through all of the case statement...
  class TestPDB < Test::Unit::TestCase
    def setup
      str =<<EOF
HEADER    OXIDOREDUCTASE                          12-AUG-09   3INJ
TITLE     HUMAN MITOCHONDRIAL ALDEHYDE DEHYDROGENASE COMPLEXED WITH
DBREF  3INJ A    1   500  UNP    P05091   ALDH2_HUMAN     18    517
HELIX    1   1 ASP A   55  PHE A   70  1                                  16
KEYWDS    OXIDOREDUCTASE, ALDH, E487K, ROSSMANN FOLD, ALDA-1,
SEQRES   1 A  500  SER ALA ALA ALA THR GLN ALA VAL PRO ALA PRO ASN GLN
SHEET    1   A 2 ILE A  22  ILE A  24  0
SSBOND   1 CYS B  301    CYS B  303                          1555   1555  2.97
REVDAT   1   12-JAN-10 3INJ
MODEL        1
ATOM      1  N   ALA A   7      23.484 -35.866  44.510  1.00 28.52           N
ANISOU    1  N   ALA A   7     2406   1892   1614    198    519   -328       N
SIGUIJ    1  N   ALA A   7       10     10     10     10     10     10       N
SIGATM    1  N   ALA     7       0.040   0.030   0.030  0.00  0.00           N
ATOM      2  CA  ALA A   7      23.849 -34.509  44.904  1.00 27.89           C
ANISOU    2  CA  ALA A   7     2748   2004   1679    -21    155   -419       C
SIGUIJ    2  CA  ALA A   7       10     10     10     10     10     10       C
SIGATM    2  CA  ALA     7       0.040   0.030   0.030  0.00  0.00           C
ATOM      3  C   ALA A   7      23.102 -34.082  46.159  1.00 26.68           C
ANISOU    3  C   ALA A   7     2555   1955   1468     87    357   -109       C
SIGUIJ    3  C   ALA A   7       10     10     10     10     10     10       C
SIGATM    3  N   ALA     7       0.040   0.030   0.030  0.00  0.00           C
ATOM      4  O   ALA A   7      23.097 -32.903  46.524  1.00 30.02           O
ANISOU    4  O   ALA A   7     2555   1955   1468     87    357   -109       O
SIGUIJ    4  O   ALA A   7       10     10     10     10     10     10       O
SIGATM    4  O   ALA     7       0.040   0.030   0.030  0.00  0.00           O
ATOM      5  CB  ALA A   7      23.581 -33.526  43.770  1.00 31.41           C
ANISOU    5  CB  ALA A   7     2555   1955   1468     87    357   -109       C
SIGUIJ    5  CB  ALA A   7       10     10     10     10     10     10       C
SIGATM    1  CB  ALA     7       0.040   0.030   0.030  0.00  0.00           C
MODEL        2
ATOM      1  N   ALA A   7      23.484 -35.866  44.510  1.00 28.52           N
TER    3821      SER A 500
HETATM30582  C1  EDO A 701      -0.205 -27.262  49.961  1.00 34.45           C
HETATM30583  O1  EDO A 701      -1.516 -26.859  49.587  1.00 35.20           O
HETATM30584  C2  EDO A 701      -0.275 -28.124  51.219  1.00 34.49           C
HETATM30585  O2  EDO A 701      -1.442 -28.941  51.167  1.00 33.95           O
HETATM30586  C1  EDO A 702       2.792   7.449  67.655  1.00 17.09           C
HETATM30587  O1  EDO A 702       1.451   7.273  67.213  1.00 15.74           O
HETATM30588  C2  EDO A 702       3.678   7.589  66.425  1.00 15.31           C
HETATM30589  O2  EDO A 702       3.391   6.512  65.550  1.00 17.67           O
HETATM30857  O   HOH A 502      13.654 -16.451  49.711  1.00 12.79           O
EOF
      @pdb = Bio::PDB.new(str)
    end
    def test_accession
      assert_equal("3INJ", @pdb.accession)
    end
    def test_addModel
      assert_nothing_raised{@pdb.addModel(Bio::PDB::Model.new(1,nil))}
    end
    def test_authors
      assert_equal([],@pdb.authors)
    end
    def test_classification
      assert_equal("OXIDOREDUCTASE",@pdb.classification)
    end
    def test_dbref
      assert_instance_of(Bio::PDB::Record::DBREF,@pdb.dbref.first)
      assert_instance_of(Bio::PDB::Record::DBREF,@pdb.dbref("A").first)
    end
    def test_definition
      assert_equal("HUMAN MITOCHONDRIAL ALDEHYDE DEHYDROGENASE COMPLEXED WITH",@pdb.definition)
    end
    def test_each
      expected = [nil, 1, 2, 3]
      pdb = Bio::PDB.new(" ")
      pdb.addModel(Bio::PDB::Model.new(1,nil))
      pdb.addModel(Bio::PDB::Model.new(2,nil))
      pdb.addModel(Bio::PDB::Model.new(3,nil))
      actual = []
      pdb.each do |model|
        actual << model.serial
      end
      assert_equal(expected,actual)
    end
    def test_each_model
      expected = [nil, 1, 2, 3]
      pdb = Bio::PDB.new("")
      pdb.addModel(Bio::PDB::Model.new(1,nil))
      pdb.addModel(Bio::PDB::Model.new(2,nil))
      pdb.addModel(Bio::PDB::Model.new(3,nil))
      actual = []
      pdb.each_model do |model|
        actual << model.serial
      end
      assert_equal(expected,actual)
    end

    def test_entry_id
      assert_equal("3INJ", @pdb.entry_id)
    end
    def test_helix
      assert_instance_of(Array, @pdb.helix)
      assert_equal(nil,@pdb.helix(1))
    end
    def test_inspect
      assert_equal("#<Bio::PDB entry_id=\"3INJ\">",@pdb.inspect)
    end
    def test_jrnl
      assert_instance_of(Hash, @pdb.jrnl)
    end
    def test_keywords
      assert_equal(["OXIDOREDUCTASE", "ALDH", "E487K", "ROSSMANN FOLD", "ALDA-1"],@pdb.keywords)
    end
    def test_remark
      str =<<EOS
REMARK   1 REFERENCE 1
REMARK   1  AUTH   C.H.CHEN,G.R.BUDAS,E.N.CHURCHILL,M.H.DISATNIK
REMARK   2 
REMARK   3
EOS

      expected =
     { 1 => {:remarkNum=>1,
                :sub_record=>"AUTH",
                :authorList=>["C.H.CHEN", "G.R.BUDAS", "E.N.CHURCHILL", "M.H.DISATNIK"]},
        2=>[],
        3=>[]}
      obj = Bio::PDB.new(str)
      actual = 
      { 1 => {:remarkNum=>obj.remark[1][0].remarkNum,
                :sub_record=>obj.remark[1][0].sub_record,
                :authorList=>obj.remark[1][0].authorList},
        2=>obj.remark[2],
        3=>obj.remark[3]}

      assert_equal(actual,expected)
    end
    def test_record
      assert_instance_of(Hash, @pdb.record)
    end
    def test_seqres
      assert_equal({"A"=>"SAAATQAVPAPNQ"},@pdb.seqres)
      assert_equal(nil,@pdb.seqres(7)) #I'm not sure why this returns nil
      str =<<EOS
SEQRES   1 X   39    U   C   C   C   C   C   G   U   G   C   C   C   A 
EOS
      obj = Bio::PDB.new(str)
      assert_equal({"X"=>"ucccccgugccca"},obj.seqres)
    end
    # too redundant?
    def test_sheet
      seq =<<EOS
SHEET    2 BS8 3 LYS   639  LYS   648 -1  N  PHE   643   O  HIS   662
SHEET    3 BS8 3 ASN   596  VAL   600 -1  N  TYR   598   O  ILE   646
EOS
      s = Bio::PDB.new(seq)
      actual = []
      s.sheet.each do |obj2|
        obj2.each do |obj|
      
      actual <<
  {:strand=>obj.strand,
   :sheetID=>obj.sheetID,
   :numStrands=>obj.numStrands,
   :initResName=>obj.initResName,
   :initChainID=>obj.initChainID,
   :initSeqNum=>obj.initSeqNum,
   :initICode=>obj.initICode,
   :endResName=>obj.endResName,
   :endChainID=>obj.endChainID,
   :endSeqNum=>obj.endSeqNum,
   :endICode=>obj.endICode,
   :sense=>obj.sense,
   :curAtom=>obj.curAtom,
   :curResName=>obj.curResName,
   :curChainId=>obj.curChainId,
   :curResSeq=>obj.curResSeq,
   :curICode=>obj.curICode,
   :prevAtom=>obj.prevAtom,
   :prevResName=>obj.prevResName,
   :prevChainId=>obj.prevChainId,
   :prevResSeq=>obj.prevResSeq,
   :prevICode=>obj.prevICode}
      end
      end
      expected =
  [
  {:strand=>2,
   :sheetID=>"BS8",
   :numStrands=>3,
   :initResName=>"LYS",
   :initChainID=>" ",
   :initSeqNum=>639,
   :initICode=>"",
   :endResName=>"LYS",
   :endChainID=>" ",
   :endSeqNum=>648,
   :endICode=>"",
   :sense=>-1,
   :curAtom=>" N",
   :curResName=>"PHE",
   :curChainId=>" ",
   :curResSeq=>643,
   :curICode=>"",
   :prevAtom=>" O",
   :prevResName=>"HIS",
   :prevChainId=>" ",
   :prevResSeq=>662,
   :prevICode=>""},

   {:strand=>3,
   :sheetID=>"BS8",
   :numStrands=>3,
   :initResName=>"ASN",
   :initChainID=>" ",
   :initSeqNum=>596,
   :initICode=>"",
   :endResName=>"VAL",
   :endChainID=>" ",
   :endSeqNum=>600,
   :endICode=>"",
   :sense=>-1,
   :curAtom=>" N",
   :curResName=>"TYR",
   :curChainId=>" ",
   :curResSeq=>598,
   :curICode=>"",
   :prevAtom=>" O",
   :prevResName=>"ILE",
   :prevChainId=>" ",
   :prevResSeq=>646,
   :prevICode=>""}]
      actual2 = []
      s.sheet("BS8").each do |obj2|
        obj2.each do |obj|

      actual2 <<
  {:strand=>obj.strand,
   :sheetID=>obj.sheetID,
   :numStrands=>obj.numStrands,
   :initResName=>obj.initResName,
   :initChainID=>obj.initChainID,
   :initSeqNum=>obj.initSeqNum,
   :initICode=>obj.initICode,
   :endResName=>obj.endResName,
   :endChainID=>obj.endChainID,
   :endSeqNum=>obj.endSeqNum,
   :endICode=>obj.endICode,
   :sense=>obj.sense,
   :curAtom=>obj.curAtom,
   :curResName=>obj.curResName,
   :curChainId=>obj.curChainId,
   :curResSeq=>obj.curResSeq,
   :curICode=>obj.curICode,
   :prevAtom=>obj.prevAtom,
   :prevResName=>obj.prevResName,
   :prevChainId=>obj.prevChainId,
   :prevResSeq=>obj.prevResSeq,
   :prevICode=>obj.prevICode}
      end
      end

      assert_equal(expected,actual)
      assert_equal(expected,actual2)
    end
    def test_ssbond
      assert_instance_of(Bio::PDB::Record::SSBOND,@pdb.ssbond.first)
    end
    
    #is this method correct?
    def test_to_s
      assert_equal("MODEL     1\nATOM      1  N   ALA A   7      23.484 -35.866  44.510  1.00 28.52           N  \nATOM      2  CA  ALA A   7      23.849 -34.509  44.904  1.00 27.89           C  \nATOM      3  C   ALA A   7      23.102 -34.082  46.159  1.00 26.68           C  \nATOM      4  O   ALA A   7      23.097 -32.903  46.524  1.00 30.02           O  \nATOM      5  CB  ALA A   7      23.581 -33.526  43.770  1.00 31.41           C  \nTER\nENDMDL\nMODEL     2\nATOM      1  N   ALA A   7      23.484 -35.866  44.510  1.00 28.52           N  \nTER\nHETATM30582  C1  EDO A 701      -0.205 -27.262  49.961  1.00 34.45           C  \nHETATM30583  O1  EDO A 701      -1.516 -26.859  49.587  1.00 35.20           O  \nHETATM30584  C2  EDO A 701      -0.275 -28.124  51.219  1.00 34.49           C  \nHETATM30585  O2  EDO A 701      -1.442 -28.941  51.167  1.00 33.95           O  \nHETATM30586  C1  EDO A 702       2.792   7.449  67.655  1.00 17.09           C  \nHETATM30587  O1  EDO A 702       1.451   7.273  67.213  1.00 15.74           O  \nHETATM30588  C2  EDO A 702       3.678   7.589  66.425  1.00 15.31           C  \nHETATM30589  O2  EDO A 702       3.391   6.512  65.550  1.00 17.67           O  \nHETATM30857  O   HOH A 502      13.654 -16.451  49.711  1.00 12.79           O  \nENDMDL\nEND\n",@pdb.to_s)
    end
    def test_turn
      assert_equal([],@pdb.turn)
      assert_equal(nil,@pdb.turn(1))

    end
    def test_version
      assert_equal(1,@pdb.version)
    end

    def test_bracket #test for []
      assert_equal(1,@pdb[1].serial)
    end


  end

  #TestPDBRecord::Test* are unit tests for pdb field classes.
  #each test class uses one line or several lines of PDB record.
  #they tests all the methods described or generated in Bio::PDB::Record.

  module TestPDBRecord

    # test of Bio::PDB::Record::ATOM
    class TestATOM < Test::Unit::TestCase
      def setup
        # the data is taken from
        # http://www.rcsb.org/pdb/file_formats/pdb/pdbguide2.2/part_62.html
        @str = 'ATOM    154  CG2BVAL A  25      29.909  16.996  55.922  0.72 13.25      A1   C  '
        @atom = Bio::PDB::Record::ATOM.new.initialize_from_string(@str)
      end

      def test_record_name
        assert_equal('ATOM', @atom.record_name)
      end

      def test_serial
        assert_equal(154, @atom.serial)
      end

      def test_name
        assert_equal('CG2', @atom.name)
      end

      def test_altLoc
        assert_equal('B', @atom.altLoc)
      end

      def test_resName
        assert_equal('VAL', @atom.resName)
      end

      def test_chainID
        assert_equal('A', @atom.chainID)
      end

      def test_resSeq
        assert_equal(25, @atom.resSeq)
      end

      def test_iCode
        assert_equal('', @atom.iCode)
      end

      def test_x
        assert_in_delta(29.909, @atom.x, 0.0001)
      end

      def test_y
        assert_in_delta(16.996, @atom.y, 0.0001)
      end

      def test_z
        assert_in_delta(55.922, @atom.z, 0.0001)
      end

      def test_occupancy
        assert_in_delta(0.72, @atom.occupancy, 0.001)
      end

      def test_tempFactor
        assert_in_delta(13.25, @atom.tempFactor, 0.001)
      end

      def test_segID
        assert_equal('A1', @atom.segID)
      end

      def test_element
        assert_equal('C', @atom.element)
      end

      def test_charge
        assert_equal('', @atom.charge)
      end

      def test_xyz
        assert_equal(Bio::PDB::Coordinate[
                       "29.909".to_f,
                       "16.996".to_f,
                       "55.922".to_f ], @atom.xyz)
      end

      def test_to_a
        assert_equal([ "29.909".to_f,
                       "16.996".to_f,
                       "55.922".to_f ], @atom.to_a)
      end

      def test_comparable
        a = Bio::PDB::Record::ATOM.new
        a.serial = 999
        assert_equal(-1, @atom <=> a)
        a.serial = 154
        assert_equal( 0, @atom <=> a)
        a.serial = 111
        assert_equal( 1, @atom <=> a)
      end

      def test_to_s
        assert_equal(@str + "\n", @atom.to_s) 
      end


      def test_original_data
        assert_equal([ @str ], @atom.original_data)
      end

      def test_do_parse
        assert_equal(@atom, @atom.do_parse)
      end

      def test_residue
        assert_equal(nil, @atom.residue)
      end

      def test_sigatm
        assert_equal(nil, @atom.sigatm)
      end

      def test_anisou
        assert_equal(nil, @atom.anisou)
      end

      def test_ter
        assert_equal(nil, @atom.ter)
      end


    end #class TestATOM

    # test of Bio::PDB::Record::ATOM
    class TestHETATM < Test::Unit::TestCase
      def setup
        # the data is taken from
        # http://www.rcsb.org/pdb/file_formats/pdb/pdbguide2.2/part_62.html
        @str = 'HETATM30581 NA    NA A 601       5.037 -39.853  62.809  1.00 17.37          NA  '
        @hetatm = Bio::PDB::Record::HETATM.new.initialize_from_string(@str)
      end

      def test_record_name
        assert_equal('HETATM', @hetatm.record_name)
      end

      def test_serial
        assert_equal(30581, @hetatm.serial)
      end

      def test_name
        assert_equal('NA', @hetatm.name)
      end

      def test_altLoc
        assert_equal(' ', @hetatm.altLoc)
      end

      def test_resName
        assert_equal('NA', @hetatm.resName)
      end

      def test_chainID
        assert_equal('A', @hetatm.chainID)
      end

      def test_resSeq
        assert_equal(601, @hetatm.resSeq)
      end

      def test_iCode
        assert_equal('', @hetatm.iCode)
      end

      def test_x
        assert_in_delta(5.037, @hetatm.x, 0.0001)
      end

      def test_y
        assert_in_delta(-39.853, @hetatm.y, 0.0001)
      end

      def test_z
        assert_in_delta(62.809, @hetatm.z, 0.0001)
      end

      def test_occupancy
        assert_in_delta(1.00, @hetatm.occupancy, 0.001)
      end

      def test_tempFactor
        assert_in_delta(17.37, @hetatm.tempFactor, 0.001)
      end

      def test_segID
        assert_equal('', @hetatm.segID)
      end

      def test_element
        assert_equal('NA', @hetatm.element)
      end

      def test_charge
        assert_equal('', @hetatm.charge)
      end

      def test_xyz
        assert_equal(Bio::PDB::Coordinate[
                       "5.037".to_f,
                       "-39.853".to_f,
                       "62.809".to_f ], @hetatm.xyz)
      end

      def test_to_a
        assert_equal([ "5.037".to_f,
                       "-39.853".to_f,
                       "62.809".to_f ], @hetatm.to_a)
      end

      def test_comparable
        a = Bio::PDB::Record::HETATM.new
        a.serial = 40000
        assert_equal(-1, @hetatm <=> a)
        a.serial = 30581
        assert_equal( 0, @hetatm <=> a)
        a.serial = 30000
        assert_equal( 1, @hetatm <=> a)
      end

      def test_to_s
        assert_equal(@str + "\n", @hetatm.to_s)
      end

      def test_original_data
        assert_equal([ @str ], @hetatm.original_data)
      end

      def test_do_parse
        assert_equal(@hetatm, @hetatm.do_parse)
      end

      def test_residue
        assert_equal(nil, @hetatm.residue)
      end

      def test_sigatm
        assert_equal(nil, @hetatm.sigatm)
      end

      def test_anisou
        assert_equal(nil, @hetatm.anisou)
      end

      def test_ter
        assert_equal(nil, @hetatm.ter)
      end
    end #class TestATOM

    class TestHEADER < Test::Unit::TestCase
      def setup
        @str = 'HEADER    OXIDOREDUCTASE                          12-AUG-09   3INJ              '
        @header = Bio::PDB::Record::HEADER.new.initialize_from_string(@str)
      end


      def test_classification
        assert_equal('OXIDOREDUCTASE', @header.classification)
      end


      def test_depDate
        assert_equal('12-AUG-09', @header.depDate)
      end


      def test_idCode
        assert_equal('3INJ', @header.idCode)
      end


    end

    class TestOBSLTE < Test::Unit::TestCase
      def setup
        @str = 'OBSLTE     31-JAN-94 1MBP      2MBP                                   '
        @obslte = Bio::PDB::Record::OBSLTE.new.initialize_from_string(@str)
      end


      def test_repDate
        assert_equal('31-JAN-94', @obslte.repDate)
      end


      def test_idCode
        assert_equal('1MBP', @obslte.idCode)
      end


      def test_rIdCode
        assert_equal(["2MBP"], @obslte.rIdCode)
      end

    end

    #Is this unit test correct?
    class TestTITLE < Test::Unit::TestCase
      def setup
        @str =
"TITLE     HUMAN MITOCHONDRIAL ALDEHYDE DEHYDROGENASE COMPLEXED WITH             \n
TITLE    2 AGONIST ALDA-1                                                       "
        @title = Bio::PDB::Record::TITLE.new.initialize_from_string(@str)
      end


      def test_title
        assert_equal('HUMAN MITOCHONDRIAL ALDEHYDE DEHYDROGENASE COMPLEXED WITH', @title.title)
      end


    end

    class TestCAVEAT < Test::Unit::TestCase
      def setup
        @str = 'CAVEAT     1ABC    INCORRECT'
        @caveat = Bio::PDB::Record::CAVEAT.new.initialize_from_string(@str)
      end


      def test_idcode
        assert_equal('1ABC', @caveat.idcode)
      end


      def test_comment
        assert_equal('INCORRECT', @caveat.comment)
      end


    end

    class TestCOMPND < Test::Unit::TestCase
      def setup
        @str =<<EOS
COMPND    MOL_ID: 1;                                                            
COMPND   2 MOLECULE: ALDEHYDE DEHYDROGENASE, MITOCHONDRIAL;                     
COMPND   3 CHAIN: A, B, C, D, E, F, G, H;                                       
COMPND   4 SYNONYM: ALDH CLASS 2, ALDHI, ALDH-E2;                               
COMPND   5 EC: 1.2.1.3;                                                         
COMPND   6 ENGINEERED: YES                                                      

EOS
        @compnd = Bio::PDB::Record::COMPND.new.initialize_from_string(@str)
      end


      def test_compound
        assert_equal([["MOL_ID", "1"]], @compnd.compound)
      end


    end

    class TestSOURCE < Test::Unit::TestCase
      def setup
        @str =<<EOS
SOURCE    MOL_ID: 1;
SOURCE   2 ORGANISM_SCIENTIFIC: HOMO SAPIENS;
SOURCE   3 ORGANISM_COMMON: HUMAN;
SOURCE   4 ORGANISM_TAXID: 9606;
SOURCE   5 GENE: ALDH2, ALDM;
SOURCE   6 EXPRESSION_SYSTEM: ESCHERICHIA COLI;
SOURCE   7 EXPRESSION_SYSTEM_TAXID: 562;
SOURCE   8 EXPRESSION_SYSTEM_STRAIN: BL21(DE3);
SOURCE   9 EXPRESSION_SYSTEM_VECTOR_TYPE: PLASMID;
SOURCE  10 EXPRESSION_SYSTEM_PLASMID: PT-7-7
EOS
        @source = Bio::PDB::Record::SOURCE.new.initialize_from_string(@str)
      end


      def test_srcName
        expected =
          [["MOL_ID", "1"], ["SOURCE   2 ORGANISM_SCIENTIFIC", "HOMO SAPIENS"], ["SOU"]]
        assert_equal(expected, @source.srcName)
      end
    end

    class TestKEYWDS < Test::Unit::TestCase
      def setup
        @str =<<EOF
KEYWDS    OXIDOREDUCTASE, ALDH, E487K, ROSSMANN FOLD, ALDA-1,
KEYWDS   2 ACTIVATOR, ACETYLATION, MITOCHONDRION, NAD, POLYMORPHISM,
KEYWDS   3 TRANSIT PEPTIDE
EOF
        @keywds = Bio::PDB::Record::KEYWDS.new.initialize_from_string(@str)
      end


      def test_keywds
        assert_equal(["OXIDOREDUCTASE", "ALDH", "E487K", "ROSSMANN FOLD", "ALDA-1", "KEYWDS"], @keywds.keywds)
      end

    end

    class TestEXPDTA < Test::Unit::TestCase
      def setup
        @str = <<EOF
EXPDTA    X-RAY DIFFRACTION
EOF
        @expdta = Bio::PDB::Record::EXPDTA.new.initialize_from_string(@str)
      end


      def test_technique
        assert_equal(["X-RAY DIFFRACTION"], @expdta.technique)
      end


    end

    class TestAUTHOR < Test::Unit::TestCase
      def setup
        @str = 'AUTHOR    S.PEREZ-MILLER,T.D.HURLEY'
        @author = Bio::PDB::Record::AUTHOR.new.initialize_from_string(@str)
      end


      def test_authorList
        assert_equal(["S.PEREZ-MILLER", "T.D.HURLEY"], @author.authorList)
      end


    end

    class TestREVDAT < Test::Unit::TestCase
      def setup
        @str = 'REVDAT   1   12-JAN-10 3INJ    0'
        @revdat = Bio::PDB::Record::REVDAT.new.initialize_from_string(@str)
      end


      def test_modNum
        assert_equal(1, @revdat.modNum )
      end


      def test_modDate
        assert_equal('12-JAN-10', @revdat.modDate)
      end


      def test_modId
        assert_equal('3INJ', @revdat.modId  )
      end


      def test_modType
        assert_equal(0, @revdat.modType)
      end


      def test_record
        assert_equal([], @revdat.record )
      end


    end

    class TestSPRSDE < Test::Unit::TestCase
      def setup
        @str = 'SPRSDE     17-JUL-84 4HHB      1HHB                             '
        @sprsde = Bio::PDB::Record::SPRSDE.new.initialize_from_string(@str)
      end


      def test_sprsdeDate
        assert_equal('17-JUL-84', @sprsde.sprsdeDate)
      end


      def test_idCode
        assert_equal('4HHB', @sprsde.idCode)
      end


      def test_sIdCode
        assert_equal(["1HHB"], @sprsde.sIdCode)
      end

    end

    class TestDBREF < Test::Unit::TestCase
      def setup
        @str =<<EOS
DBREF  3INJ A    1   500  UNP    P05091   ALDH2_HUMAN     18    517
DBREF  3INJ B    1   500  UNP    P05091   ALDH2_HUMAN     18    517
DBREF  3INJ C    1   500  UNP    P05091   ALDH2_HUMAN     18    517
DBREF  3INJ D    1   500  UNP    P05091   ALDH2_HUMAN     18    517
DBREF  3INJ E    1   500  UNP    P05091   ALDH2_HUMAN     18    517
DBREF  3INJ F    1   500  UNP    P05091   ALDH2_HUMAN     18    517
DBREF  3INJ G    1   500  UNP    P05091   ALDH2_HUMAN     18    517
DBREF  3INJ H    1   500  UNP    P05091   ALDH2_HUMAN     18    517
EOS
        @dbref = Bio::PDB::Record::DBREF.new.initialize_from_string(@str)
      end


      def test_idCode
        assert_equal('3INJ', @dbref.idCode     )
      end


      def test_chainID
        assert_equal('A', @dbref.chainID    )
      end


      def test_seqBegin
        assert_equal(1, @dbref.seqBegin   )
      end


      def test_insertBegin
        assert_equal('', @dbref.insertBegin)
      end


      def test_seqEnd
        assert_equal(500, @dbref.seqEnd     )
      end


      def test_insertEnd
        assert_equal('', @dbref.insertEnd  )
      end


      def test_database
        assert_equal('UNP', @dbref.database   )
      end


      def test_dbAccession
        assert_equal('P05091', @dbref.dbAccession)
      end


      def test_dbIdCode
        assert_equal('ALDH2_HUMAN', @dbref.dbIdCode   )
      end


      def test_dbseqBegin
        assert_equal(18, @dbref.dbseqBegin )
      end


      def test_idbnsBeg
        assert_equal('', @dbref.idbnsBeg   )
      end


      def test_dbseqEnd
        assert_equal(517, @dbref.dbseqEnd   )
      end
    end

    class TestSEQADV < Test::Unit::TestCase
      def setup
        @str = 'SEQADV 3ABC MET A   -1  UNP  P10725              EXPRESSION TAG'
        @seqadv = Bio::PDB::Record::SEQADV.new.initialize_from_string(@str)
      end


      def test_idCode
        assert_equal('3ABC', @seqadv.idCode  )
      end


      def test_resName
        assert_equal('MET', @seqadv.resName )
      end


      def test_chainID
        assert_equal('A', @seqadv.chainID )
      end


      def test_seqNum
        assert_equal(-1, @seqadv.seqNum  )
      end


      def test_iCode
        assert_equal('', @seqadv.iCode   )
      end


      def test_database
        assert_equal('UNP', @seqadv.database)
      end


      def test_dbIdCode
        assert_equal('P10725', @seqadv.dbIdCode)
      end


      def test_dbRes
        assert_equal('', @seqadv.dbRes   )
      end


      def test_dbSeq
        assert_equal(0, @seqadv.dbSeq   )
      end


      def test_conflict
        assert_equal('EXPRESSION TAG', @seqadv.conflict)
      end


    end

    class TestSEQRES < Test::Unit::TestCase
      def setup
        @str =<<EOS
SEQRES   1 A  500  SER ALA ALA ALA THR GLN ALA VAL PRO ALA PRO ASN GLN
SEQRES   2 A  500  GLN PRO GLU VAL PHE CYS ASN GLN ILE PHE ILE ASN ASN
SEQRES   3 A  500  GLU TRP HIS ASP ALA VAL SER ARG LYS THR PHE PRO THR
SEQRES   4 A  500  VAL ASN PRO SER THR GLY GLU VAL ILE CYS GLN VAL ALA
SEQRES   5 A  500  GLU GLY ASP LYS GLU ASP VAL ASP LYS ALA VAL LYS ALA
SEQRES   6 A  500  ALA ARG ALA ALA PHE GLN LEU GLY SER PRO TRP ARG ARG
SEQRES   7 A  500  MET ASP ALA SER HIS ARG GLY ARG LEU LEU ASN ARG LEU
SEQRES   8 A  500  ALA ASP LEU ILE GLU ARG ASP ARG THR TYR LEU ALA ALA
SEQRES   9 A  500  LEU GLU THR LEU ASP ASN GLY LYS PRO TYR VAL ILE SER          
EOS

        @seqres = Bio::PDB::Record::SEQRES.new.initialize_from_string(@str)
      end

      
      def test_chainID
        assert_equal('A', @seqres.chainID)
      end


      def test_numRes
        assert_equal(500, @seqres.numRes )
      end


      def test_resName
        expected =
          ["SER",
 "ALA",
 "ALA",
 "ALA",
 "THR",
 "GLN",
 "ALA",
 "VAL",
 "PRO",
 "ALA",
 "PRO",
 "ASN",
 "GLN"]
        assert_equal(expected, @seqres.resName)
      end

    end

    class TestMODRES < Test::Unit::TestCase
      def setup
        @str = 'MODRES 2R0L ASN A   74  ASN  GLYCOSYLATION SITE                     '
        @modres = Bio::PDB::Record::MODRES.new.initialize_from_string(@str)
      end


      def test_idCode
        assert_equal('2R0L', @modres.idCode)
      end


      def test_resName
        assert_equal('ASN', @modres.resName)
      end


      def test_chainID
        assert_equal('A', @modres.chainID)
      end


      def test_seqNum
        assert_equal(74, @modres.seqNum)
      end


      def test_iCode
        assert_equal('', @modres.iCode)
      end


      def test_stdRes
        assert_equal('ASN', @modres.stdRes)
      end


      def test_comment
        assert_equal('GLYCOSYLATION SITE', @modres.comment)
      end


    end

    class TestHET < Test::Unit::TestCase
      def setup
        @str = 'HET     NA  A 601       1                                                       '
        @het = Bio::PDB::Record::HET.new.initialize_from_string(@str)
      end


      def test_hetID
        assert_equal(' NA', @het.hetID)
      end


      def test_ChainID
        assert_equal('A', @het.ChainID)
      end


      def test_seqNum
        assert_equal(601, @het.seqNum)
      end


      def test_iCode
        assert_equal('', @het.iCode)
      end


      def test_numHetAtoms
        assert_equal(1, @het.numHetAtoms)
      end


      def test_text
        assert_equal('', @het.text)
      end


    end

    class TestSHEET < Test::Unit::TestCase
      def setup
        @str =<<EOS
SHEET    1   A 2 ILE A  22  ILE A  24  0                             
SHEET    2   A 2 GLU A  27  HIS A  29 -1  O  HIS A  29   N  ILE A  22
SHEET    1   B 2 THR A  36  VAL A  40  0                             
EOS
        @sheet = Bio::PDB::Record::SHEET.new.initialize_from_string(@str)
      end


      def test_strand
        assert_equal(1, @sheet.strand)
      end


      def test_sheetID
        assert_equal('A', @sheet.sheetID)
      end


      def test_numStrands
        assert_equal(2, @sheet.numStrands)
      end


      def test_initResName
        assert_equal('ILE', @sheet.initResName)
      end


      def test_initChainID
        assert_equal('A', @sheet.initChainID)
      end


      def test_initSeqNum
        assert_equal(22, @sheet.initSeqNum)
      end


      def test_initICode
        assert_equal('', @sheet.initICode)
      end


      def test_endResName
        assert_equal('ILE', @sheet.endResName)
      end


      def test_endChainID
        assert_equal('A', @sheet.endChainID)
      end


      def test_endSeqNum
        assert_equal(24, @sheet.endSeqNum)
      end


      def test_endICode
        assert_equal('', @sheet.endICode)
      end


      def test_sense
        assert_equal(0, @sheet.sense)
      end


      def test_curAtom
        assert_equal('', @sheet.curAtom)
      end


      def test_curResName
        assert_equal('', @sheet.curResName)
      end


      def test_curChainId
        assert_equal(' ', @sheet.curChainId)
      end


      def test_curResSeq
        assert_equal(0, @sheet.curResSeq)
      end


      def test_curICode
        assert_equal('', @sheet.curICode)
      end


      def test_prevAtom
        assert_equal('', @sheet.prevAtom)
      end


      def test_prevResName
        assert_equal('', @sheet.prevResName)
      end


      def test_prevChainId
        assert_equal(' ', @sheet.prevChainId)
      end


      def test_prevResSeq
        assert_equal(0, @sheet.prevResSeq)
      end


      def test_prevICode
        assert_equal('', @sheet.prevICode)
      end


    end

    class TestLINK < Test::Unit::TestCase
      def setup
        @str = 'LINK         O   VAL A  40                NA    NA A 601     1555   1555  2.41  '
        @link = Bio::PDB::Record::LINK.new.initialize_from_string(@str)
      end


      def test_name1
        assert_equal(' O', @link.name1)
      end


      def test_altLoc1
        assert_equal(' ', @link.altLoc1)
      end


      def test_resName1
        assert_equal('VAL', @link.resName1)
      end


      def test_chainID1
        assert_equal('A', @link.chainID1)
      end


      def test_resSeq1
        assert_equal(40, @link.resSeq1)
      end


      def test_iCode1
        assert_equal('', @link.iCode1)
      end


      def test_name2
        assert_equal("NA", @link.name2)
      end


      def test_altLoc2
        assert_equal(' ', @link.altLoc2)
      end


      def test_resName2
        assert_equal(' NA', @link.resName2)
      end


      def test_chainID2
        assert_equal('A', @link.chainID2)
      end


      def test_resSeq2
        assert_equal(601, @link.resSeq2)
      end


      def test_iCode2
        assert_equal('', @link.iCode2)
      end


      def test_sym1
        assert_equal('  1555', @link.sym1)
      end


      def test_sym2
        assert_equal('  1555', @link.sym2)
      end


    end

    class TestHYDBND < Test::Unit::TestCase
      def setup
        @str = 'HYDBND       O   PHE A    2        A    4  1HN  AIB A    4                    '
        @hydbnd = Bio::PDB::Record::HYDBND.new.initialize_from_string(@str)
      end


      def test_name1
        assert_equal(' O', @hydbnd.name1)
      end


      def test_altLoc1
        assert_equal(' ', @hydbnd.altLoc1)
      end


      def test_resName1
        assert_equal('PHE', @hydbnd.resName1)
      end


      def test_Chain1
        assert_equal('A', @hydbnd.Chain1)
      end


      def test_resSeq1
        assert_equal(2, @hydbnd.resSeq1)
      end


      def test_ICode1
        assert_equal('', @hydbnd.ICode1)
      end


      def test_nameH
        assert_equal('', @hydbnd.nameH)
      end


      def test_altLocH
        assert_equal(' ', @hydbnd.altLocH)
      end


      def test_ChainH
        assert_equal('A', @hydbnd.ChainH)
      end


      def test_resSeqH
        assert_equal(4, @hydbnd.resSeqH)
      end


      def test_iCodeH
        assert_equal('', @hydbnd.iCodeH)
      end


      def test_name2
        assert_equal('1HN', @hydbnd.name2)
      end


      def test_altLoc2
        assert_equal(' ', @hydbnd.altLoc2)
      end


      def test_resName2
        assert_equal('AIB', @hydbnd.resName2)
      end


      def test_chainID2
        assert_equal('A', @hydbnd.chainID2)
      end


      def test_resSeq2
        assert_equal(4, @hydbnd.resSeq2)
      end


      def test_iCode2
        assert_equal('', @hydbnd.iCode2)
      end


      def test_sym1
        assert_equal('', @hydbnd.sym1)
      end


      def test_sym2
        assert_equal('', @hydbnd.sym2)
      end


    end

    #SLTBRG field is deprecated.
    class TestSLTBRG < Test::Unit::TestCase
      def setup
        @str = ''
        @sltbrg = Bio::PDB::Record::SLTBRG.new.initialize_from_string(@str)
      end


      def test_atom1
        assert_equal('', @sltbrg.atom1)
      end


      def test_altLoc1
        assert_equal("", @sltbrg.altLoc1)
      end


      def test_resName1
        assert_equal("", @sltbrg.resName1)
      end


      def test_chainID1
        assert_equal('', @sltbrg.chainID1)
      end


      def test_resSeq1
        assert_equal(0, @sltbrg.resSeq1)
      end


      def test_iCode1
        assert_equal('', @sltbrg.iCode1)
      end


      def test_atom2
        assert_equal('', @sltbrg.atom2)
      end


      def test_altLoc2
        assert_equal('', @sltbrg.altLoc2)
      end


      def test_resName2
        assert_equal('', @sltbrg.resName2)
      end


      def test_chainID2
        assert_equal('', @sltbrg.chainID2)
      end


      def test_resSeq2
        assert_equal(0, @sltbrg.resSeq2)
      end


      def test_iCode2
        assert_equal('', @sltbrg.iCode2)
      end


      def test_sym1
        assert_equal('', @sltbrg.sym1)
      end


      def test_sym2
        assert_equal('', @sltbrg.sym2)
      end


    end

    class TestCISPEP < Test::Unit::TestCase
      def setup
        @str = 'CISPEP   1 GLY A  116    GLY A  117          0        18.50         '
        @cispep = Bio::PDB::Record::CISPEP.new.initialize_from_string(@str)
      end


      def test_serNum
        assert_equal(1, @cispep.serNum)
      end


      def test_pep1
        assert_equal("GLY", @cispep.pep1)
      end


      def test_chainID1
        assert_equal('A', @cispep.chainID1)
      end


      def test_seqNum1
        assert_equal(116, @cispep.seqNum1)
      end


      def test_icode1
        assert_equal('', @cispep.icode1)
      end


      def test_pep2
        assert_equal('GLY', @cispep.pep2)
      end


      def test_chainID2
        assert_equal('A', @cispep.chainID2)
      end


      def test_seqNum2
        assert_equal(117, @cispep.seqNum2)
      end


      def test_icode2
        assert_equal('', @cispep.icode2)
      end


      def test_modNum
        assert_equal(0, @cispep.modNum)
      end


      def test_measure
        assert_equal(18.5, @cispep.measure)
      end


    end

    class TestSITE < Test::Unit::TestCase
      def setup
        @str =<<EOS
SITE     1 AC1  5 THR A  39  VAL A  40  ASP A 109  GLN A 196
SITE     2 AC1  5 HOH A4009                                                     
EOS
        @site = Bio::PDB::Record::SITE.new.initialize_from_string(@str)
      end


      def test_seqNum
        assert_equal(1, @site.seqNum   )
      end


      def test_siteID
        assert_equal('AC1', @site.siteID   )
      end


      def test_numRes
        assert_equal(5, @site.numRes   )
      end


      def test_resName1
        assert_equal('THR', @site.resName1 )
      end


      def test_chainID1
        assert_equal('A', @site.chainID1 )
      end


      def test_seq1
        assert_equal(39, @site.seq1     )
      end


      def test_iCode1
        assert_equal('', @site.iCode1   )
      end


      def test_resName2
        assert_equal('VAL', @site.resName2 )
      end


      def test_chainID2
        assert_equal('A', @site.chainID2 )
      end


      def test_seq2
        assert_equal(40, @site.seq2     )
      end


      def test_iCode2
        assert_equal('', @site.iCode2   )
      end


      def test_resName3
        assert_equal('ASP', @site.resName3 )
      end


      def test_chainID3
        assert_equal('A', @site.chainID3 )
      end


      def test_seq3
        assert_equal(109, @site.seq3     )
      end


      def test_iCode3
        assert_equal('', @site.iCode3   )
      end


      def test_resName4
        assert_equal('GLN', @site.resName4 )
      end


      def test_chainID4
        assert_equal('A', @site.chainID4 )
      end


      def test_seq4
        assert_equal(196, @site.seq4     )
      end


      def test_iCode4
        assert_equal('', @site.iCode4   )
      end


    end

    class TestCRYST1 < Test::Unit::TestCase
      def setup
        @str = 'CRYST1  117.000   15.000   39.000  90.00  90.00  90.00 P 21 21 21    8'
        @cryst1 = Bio::PDB::Record::CRYST1.new.initialize_from_string(@str)
      end


      def test_a
        assert_equal(117.0, @cryst1.a)
      end


      def test_b
        assert_equal(15.0, @cryst1.b)
      end


      def test_c
        assert_equal(39.0, @cryst1.c)
      end


      def test_alpha
        assert_equal(90.0, @cryst1.alpha)
      end


      def test_beta
        assert_equal(90.0, @cryst1.beta)
      end


      def test_gamma
        assert_equal(90.0, @cryst1.gamma)
      end


      def test_sGroup
        assert_equal("P 21 21 21 ", @cryst1.sGroup)
      end


      def test_z
        assert_equal(8, @cryst1.z)
      end


    end

    class TestORIGX1 < Test::Unit::TestCase
      def setup
        @str = 'ORIGX1      1.000000  0.000000  0.000000        0.00000                         '
        @origx1 = Bio::PDB::Record::ORIGX1.new.initialize_from_string(@str)
      end


      def test_On1
        assert_equal(1.0, @origx1.On1)
      end


      def test_On2
        assert_equal(0.0, @origx1.On2)
      end


      def test_On3
        assert_equal(0.0, @origx1.On3)
      end


      def test_Tn
        assert_equal(0.0, @origx1.Tn)
      end


    end

    class TestSCALE1 < Test::Unit::TestCase
      def setup
        @str = 'SCALE1      0.019231  0.000000  0.000000        0.00000               '
        @scale1 = Bio::PDB::Record::SCALE1.new.initialize_from_string(@str)
      end


      def test_Sn1
        assert_equal(0.019231, @scale1.Sn1)
      end


      def test_Sn2
        assert_equal(0.0, @scale1.Sn2)
      end


      def test_Sn3
        assert_equal(0.0, @scale1.Sn3)
      end


      def test_Un
        assert_equal(0.0, @scale1.Un)
      end


    end

    class TestSCALE2 < Test::Unit::TestCase
      def setup
        @str = 'SCALE2      0.000000  0.017065  0.000000        0.00000               '
        @scale2 = Bio::PDB::Record::SCALE2.new.initialize_from_string(@str)
      end


      def test_Sn1
        assert_equal(0.0, @scale2.Sn1)
      end


      def test_Sn2
        assert_equal(0.017065, @scale2.Sn2)
      end


      def test_Sn3
        assert_equal(0.0, @scale2.Sn3)
      end


      def test_Un
        assert_equal(0.0, @scale2.Un)
      end


    end

    class TestSCALE3 < Test::Unit::TestCase
      def setup
        @str = 'SCALE3      0.000000  0.000000  0.016155        0.00000               '
        @scale3 = Bio::PDB::Record::SCALE3.new.initialize_from_string(@str)
      end


      def test_Sn1
        assert_equal(0.0, @scale3.Sn1)
      end


      def test_Sn2
        assert_equal(0.0, @scale3.Sn2)
      end


      def test_Sn3
        assert_equal(0.016155, @scale3.Sn3)
      end


      def test_Un
        assert_equal(0.0, @scale3.Un)
      end


    end

    class TestMTRIX1 < Test::Unit::TestCase
      def setup
        @str = 'MTRIX1   1 -1.000000  0.000000 -0.000000        0.00001    1          '
        @mtrix1 = Bio::PDB::Record::MTRIX1.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal(1, @mtrix1.serial)
      end


      def test_Mn1
        assert_equal(-1.0, @mtrix1.Mn1)
      end


      def test_Mn2
        assert_equal(0.0, @mtrix1.Mn2)
      end


      def test_Mn3
        assert_equal(-0.0, @mtrix1.Mn3)
      end


      def test_Vn
        assert_equal(1.0e-05, @mtrix1.Vn)
      end


      def test_iGiven
        assert_equal(1, @mtrix1.iGiven)
      end


    end

    class TestMTRIX2 < Test::Unit::TestCase
      def setup
        @str = 'MTRIX2   1 -0.000000  1.000000  0.000000        0.00002    1          '
        @mtrix2 = Bio::PDB::Record::MTRIX2.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal(1, @mtrix2.serial)
      end


      def test_Mn1
        assert_equal(-0.0, @mtrix2.Mn1)
      end


      def test_Mn2
        assert_equal(1.0, @mtrix2.Mn2)
      end


      def test_Mn3
        assert_equal(0.0, @mtrix2.Mn3)
      end


      def test_Vn
        assert_equal(2.0e-05, @mtrix2.Vn)
      end


      def test_iGiven
        assert_equal(1, @mtrix2.iGiven)
      end


    end

    class TestMTRIX3 < Test::Unit::TestCase
      def setup
        @str = 'MTRIX3   1  0.000000 -0.000000 -1.000000        0.00002    1          '
        @mtrix3 = Bio::PDB::Record::MTRIX3.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal(1, @mtrix3.serial)
      end


      def test_Mn1
        assert_equal(0.0, @mtrix3.Mn1)
      end


      def test_Mn2
        assert_equal(-0.0, @mtrix3.Mn2)
      end


      def test_Mn3
        assert_equal(-1.0, @mtrix3.Mn3)
      end


      def test_Vn
        assert_equal(2.0e-05, @mtrix3.Vn)
      end


      def test_iGiven
        assert_equal(1, @mtrix3.iGiven)
      end


    end

    class TestTVECT < Test::Unit::TestCase
      def setup
        @str = 'TVECT    1   0.00000   0.00000  28.30000                              '
        @tvect = Bio::PDB::Record::TVECT.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal(1, @tvect.serial)
      end


      def test_t1
        assert_equal(0.0, @tvect.t1)
      end


      def test_t2
        assert_equal(0.0, @tvect.t2)
      end


      def test_t3
        assert_equal(28.3, @tvect.t3)
      end


      def test_text
        assert_equal('', @tvect.text)
      end


    end

    class TestMODEL < Test::Unit::TestCase
      def setup
        @str = 'MODEL        1'
        @model = Bio::PDB::Record::MODEL.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal(1, @model.serial)
      end


    end

    class TestSIGATM < Test::Unit::TestCase

      def setup
        @str = 'SIGATM  230  N   PRO    15       0.040   0.030   0.030  0.00  0.00           N'
        @sigatm = Bio::PDB::Record::SIGATM.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal(230, @sigatm.serial)
      end


      def test_name
        assert_equal(' N', @sigatm.name)
      end


      def test_altLoc
        assert_equal(' ', @sigatm.altLoc)
      end


      def test_resName
        assert_equal('PRO', @sigatm.resName)
      end


      def test_chainID
        assert_equal(' ', @sigatm.chainID)
      end


      def test_resSeq
        assert_equal(15, @sigatm.resSeq)
      end


      def test_iCode
        assert_equal('', @sigatm.iCode)
      end


      def test_sigX
        assert_equal(0.04, @sigatm.sigX)
      end


      def test_sigY
        assert_equal(0.03, @sigatm.sigY)
      end


      def test_sigZ
        assert_equal(0.03, @sigatm.sigZ)
      end


      def test_sigOcc
        assert_equal(0.0, @sigatm.sigOcc)
      end


      def test_sigTemp
        assert_equal(0.0, @sigatm.sigTemp)
      end


      def test_segID
        assert_equal('    ', @sigatm.segID)
      end


      def test_element
        assert_equal(' N', @sigatm.element)
      end


      def test_charge
        assert_equal('  ', @sigatm.charge)
      end


    end

    class TestANISOU < Test::Unit::TestCase
      def setup
        @str = 'ANISOU  107  N   GLY    13     2406   1892   1614    198    519   -328       N'
        @anisou = Bio::PDB::Record::ANISOU.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal(107, @anisou.serial)
      end


      def test_name
        assert_equal(' N', @anisou.name)
      end


      def test_altLoc
        assert_equal(' ', @anisou.altLoc)
      end


      def test_resName
        assert_equal('GLY', @anisou.resName)
      end


      def test_chainID
        assert_equal(' ', @anisou.chainID)
      end


      def test_resSeq
        assert_equal(13, @anisou.resSeq)
      end


      def test_iCode
        assert_equal('', @anisou.iCode)
      end


      def test_U11
        assert_equal(2406, @anisou.U11)
      end


      def test_U22
        assert_equal(1892, @anisou.U22)
      end


      def test_U33
        assert_equal(1614, @anisou.U33)
      end


      def test_U12
        assert_equal(198, @anisou.U12)
      end


      def test_U13
        assert_equal(519, @anisou.U13)
      end


      def test_U23
        assert_equal(-328, @anisou.U23)
      end


      def test_segID
        assert_equal('    ', @anisou.segID)
      end


      def test_element
        assert_equal(' N', @anisou.element)
      end


      def test_charge
        assert_equal('  ', @anisou.charge)
      end


    end

    class TestSIGUIJ < Test::Unit::TestCase
      def setup
        @str = 'SIGUIJ  107  N   GLY    13       10     10     10     10    10      10       N'
        @siguij = Bio::PDB::Record::SIGUIJ.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal(107, @siguij.serial)
      end


      def test_name
        assert_equal(' N', @siguij.name)
      end


      def test_altLoc
        assert_equal(' ', @siguij.altLoc)
      end


      def test_resName
        assert_equal("GLY", @siguij.resName)
      end


      def test_chainID
        assert_equal(" ", @siguij.chainID)
      end


      def test_resSeq
        assert_equal(13, @siguij.resSeq)
      end


      def test_iCode
        assert_equal('', @siguij.iCode)
      end


      def test_SigmaU11
        assert_equal(10, @siguij.SigmaU11)
      end


      def test_SigmaU22
        assert_equal(10, @siguij.SigmaU22)
      end


      def test_SigmaU33
        assert_equal(10, @siguij.SigmaU33)
      end


      def test_SigmaU12
        assert_equal(10, @siguij.SigmaU12)
      end


      def test_SigmaU13
        assert_equal(10, @siguij.SigmaU13)
      end


      def test_SigmaU23
        assert_equal(10, @siguij.SigmaU23)
      end


      def test_segID
        assert_equal('    ', @siguij.segID)
      end


      def test_element
        assert_equal(' N', @siguij.element)
      end


      def test_charge
        assert_equal('  ', @siguij.charge)
      end


    end

    class TestTER < Test::Unit::TestCase
      def setup
        @str = 'TER    3821      SER A 500                                                      '
        @ter = Bio::PDB::Record::TER.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal(3821, @ter.serial)
      end


      def test_resName
        assert_equal('SER', @ter.resName)
      end


      def test_chainID
        assert_equal('A', @ter.chainID)
      end


      def test_resSeq
        assert_equal(500, @ter.resSeq)
      end


      def test_iCode
        assert_equal('', @ter.iCode)
      end


    end

    class TestENDMDL < Test::Unit::TestCase
      def setup
        @str = 'ENDMDL'
        @endmdl = Bio::PDB::Record::ENDMDL.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal(0, @endmdl.serial)
      end


    end

    class TestCONECT < Test::Unit::TestCase
      def setup
        @str = 'CONECT  27230581                                                                '
        @conect = Bio::PDB::Record::CONECT.new.initialize_from_string(@str)
      end


      def test_serial
        assert_equal([272, 30581], @conect.serial)
      end


    end

    class TestMASTER < Test::Unit::TestCase
      def setup
        @str = 'MASTER      589    0   41  150  164    0   77    634857    8  322  312          '
        @master = Bio::PDB::Record::MASTER.new.initialize_from_string(@str)
      end


      def test_numRemark
        assert_equal(589, @master.numRemark)
      end


      def test_numHet
        assert_equal(41, @master.numHet)
      end


      def test_numHelix
        assert_equal(150, @master.numHelix)
      end


      def test_numSheet
        assert_equal(164, @master.numSheet)
      end


      def test_numTurn
        assert_equal(0, @master.numTurn)
      end


      def test_numSite
        assert_equal(77, @master.numSite)
      end


      def test_numXform
        assert_equal(6, @master.numXform)
      end


      def test_numCoord
        assert_equal(34857, @master.numCoord)
      end


      def test_numTer
        assert_equal(8, @master.numTer)
      end


      def test_numConect
        assert_equal(322, @master.numConect)
      end


      def test_numSeq
        assert_equal(312, @master.numSeq)
      end


    end

    class TestRemarkN < Test::Unit::TestCase
      def setup
        @str =<…