vasputils 0.0.11 → 0.0.12

data/test/test_poscar.rb

@@ -1,283 +1,284 @@
 #! /usr/bin/ruby -W
 
+require "helper"
 require "test/unit"
 require "stringio"
-require "vasputils.rb"
-require "vasputils/poscar.rb"
 
 require "rubygems"
-gem "mageo"
-require "mageo/vector3dinternal.rb"
-gem "crystalcell"
-require "crystalcell/cell.rb"
+#gem "crystalcell"
+require "crystalcell"
 
 class TC_Poscar < Test::Unit::TestCase
-  $tolerance = 10 ** (-10)
+    $tolerance = 10 ** (-10)
 
-  def test_dump
-    # 例外ケース
-    axes = LatticeAxes.new( [
-      [1.0, 0.0, 0.0 ],
-      [0.0, 1.0, 0.0 ],
-      [0.0, 0.0, 1.0 ],
-      ])
-    atoms = [
-      Atom.new(0, [0.1, 0.2, 0.3]),
-      Atom.new(1, [0.2, 0.3, 0.4]),
-      Atom.new(0, [0.3, 0.4, 0.5]),
-    ]
-    cell = Cell.new(axes, atoms)
-    cell.comment = "test"
-    io = StringIO.new
-    assert_raises(VaspUtils::Poscar::ElementMismatchError){
-      VaspUtils::Poscar.dump(cell, [0,1,2], io)}
+    def test_dump
+        # 例外ケース
+        axes = CrystalCell::LatticeAxes.new( [
+            [1.0, 0.0, 0.0 ],
+            [0.0, 1.0, 0.0 ],
+            [0.0, 0.0, 1.0 ],
+            ])
+        atoms = [
+            CrystalCell::Atom.new(0, [0.1, 0.2, 0.3]),
+            CrystalCell::Atom.new(1, [0.2, 0.3, 0.4]),
+            CrystalCell::Atom.new(0, [0.3, 0.4, 0.5]),
+        ]
+        cell = CrystalCell::Cell.new(axes, atoms)
+        cell.comment = "test"
+        io = StringIO.new
+        assert_raises(VaspUtils::Poscar::ElementMismatchError){
+            VaspUtils::Poscar.dump(cell, [0,1,2], io)}
 
-    # 生成
-    axes = LatticeAxes.new( [
-      [1.0, 0.0, 0.0 ],
-      [0.0, 1.0, 0.0 ],
-      [0.0, 0.0, 1.0 ],
-      ])
-    atoms = [
-      Atom.new(0, [0.1, 0.2, 0.3]),
-      Atom.new(1, [0.2, 0.3, 0.4]),
-      Atom.new(0, [0.3, 0.4, 0.5]),
-    ]
-    cell = Cell.new(axes, atoms)
-    cell.comment = "test"
-    io = StringIO.new
-    VaspUtils::Poscar.dump(cell, [0,1], io, 4)
-    io.rewind
-    corrects = [
-      "test\n",
-      "1.0\n",
-      "   1.000000000000000   0.000000000000000   0.000000000000000\n",
-      "   0.000000000000000   1.000000000000000   0.000000000000000\n",
-      "   0.000000000000000   0.000000000000000   1.000000000000000\n",
-      "2 1\n",
-      "Direct\n",
-      "   0.100000000000000   0.200000000000000   0.300000000000000\n",
-      "   0.300000000000000   0.400000000000000   0.500000000000000\n",
-      "   0.200000000000000   0.300000000000000   0.400000000000000\n",
-    ]
-    lines = io.readlines
-    corrects.each_with_index do |cor, index|
-      assert_equal(cor, lines[index], "line: #{index}")
-    end
-    assert_equal(corrects.size, lines.size)
+        # 生成
+        axes = CrystalCell::LatticeAxes.new( [
+            [1.0, 0.0, 0.0 ],
+            [0.0, 1.0, 0.0 ],
+            [0.0, 0.0, 1.0 ],
+            ])
+        atoms = [
+            CrystalCell::Atom.new(0, [0.1, 0.2, 0.3]),
+            CrystalCell::Atom.new(1, [0.2, 0.3, 0.4]),
+            CrystalCell::Atom.new(0, [0.3, 0.4, 0.5]),
+        ]
+        cell = CrystalCell::Cell.new(axes, atoms)
+        cell.comment = "test"
+        io = StringIO.new
+        VaspUtils::Poscar.dump(cell, [0,1], io, 4)
+        io.rewind
+        corrects = [
+            "test\n",
+            "1.0\n",
+            "   1.000000000000000     0.000000000000000     0.000000000000000\n",
+            "   0.000000000000000     1.000000000000000     0.000000000000000\n",
+            "   0.000000000000000     0.000000000000000     1.000000000000000\n",
+            "2 1\n",
+            "Direct\n",
+            "     0.100000000000000     0.200000000000000     0.300000000000000\n",
+            "     0.300000000000000     0.400000000000000     0.500000000000000\n",
+            "     0.200000000000000     0.300000000000000     0.400000000000000\n",
+        ]
+        lines = io.readlines
+        corrects.each_with_index do |cor, index|
+            assert_equal(cor, lines[index], "line: #{index}")
+        end
+        assert_equal(corrects.size, lines.size)
 
-    # vasp 4
-    atoms = [
-      Atom.new(0, [0.1, 0.2, 0.3], "atom0", [false, true , true ]),
-      Atom.new(1, [0.2, 0.3, 0.4], "atom1", [false, false, true ]),
-      Atom.new(0, [0.3, 0.4, 0.5], "atom2", [false, false, false]),
-    ]
-    cell = Cell.new(axes, atoms)
-    cell.comment = "test"
-    io = StringIO.new
-    VaspUtils::Poscar.dump(cell, [0,1], io, 4)
-    io.rewind
-    corrects = [
-      "test\n",
-      "1.0\n",
-      "   1.000000000000000   0.000000000000000   0.000000000000000\n",
-      "   0.000000000000000   1.000000000000000   0.000000000000000\n",
-      "   0.000000000000000   0.000000000000000   1.000000000000000\n",
-      "2 1\n",
-      "Selective dynamics\n",
-      "Direct\n",
-      "   0.100000000000000   0.200000000000000   0.300000000000000 F T T\n",
-      "   0.300000000000000   0.400000000000000   0.500000000000000 F F F\n",
-      "   0.200000000000000   0.300000000000000   0.400000000000000 F F T\n",
-    ]
-    lines = io.readlines
-    corrects.each_with_index do |cor, index|
-      assert_equal(cor, lines[index], "line: #{index}")
-    end
-    assert_equal(corrects.size, lines.size)
+        # vasp 4
+        atoms = [
+            CrystalCell::Atom.new(0, [0.1, 0.2, 0.3], "atom0", [false, true , true ]),
+            CrystalCell::Atom.new(1, [0.2, 0.3, 0.4], "atom1", [false, false, true ]),
+            CrystalCell::Atom.new(0, [0.3, 0.4, 0.5], "atom2", [false, false, false]),
+        ]
+        cell = CrystalCell::Cell.new(axes, atoms)
+        cell.comment = "test"
+        io = StringIO.new
+        VaspUtils::Poscar.dump(cell, [0,1], io, 4)
+        io.rewind
+        corrects = [
+            "test\n",
+            "1.0\n",
+            "   1.000000000000000     0.000000000000000     0.000000000000000\n",
+            "   0.000000000000000     1.000000000000000     0.000000000000000\n",
+            "   0.000000000000000     0.000000000000000     1.000000000000000\n",
+            "2 1\n",
+            "Selective dynamics\n",
+            "Direct\n",
+            "     0.100000000000000     0.200000000000000     0.300000000000000 F T T\n",
+            "     0.300000000000000     0.400000000000000     0.500000000000000 F F F\n",
+            "     0.200000000000000     0.300000000000000     0.400000000000000 F F T\n",
+        ]
+        lines = io.readlines
+        corrects.each_with_index do |cor, index|
+            assert_equal(cor, lines[index], "line: #{index}")
+        end
+        assert_equal(corrects.size, lines.size)
+
+        atoms = [
+            CrystalCell::Atom.new(0, [0.1, 0.2, 0.3], "atom0", [false, true , true ]),
+            CrystalCell::Atom.new(1, [0.2, 0.3, 0.4], "atom1", [false, false, true ]),
+            CrystalCell::Atom.new(0, [0.3, 0.4, 0.5], "atom2", [false, false, false]),
+        ]
+        cell = CrystalCell::Cell.new(axes, atoms)
+        cell.comment = "test"
+        io = StringIO.new
+        VaspUtils::Poscar.dump(cell, [0,1], io, 4)
+        io.rewind
+        corrects = [
+            "test\n",
+            "1.0\n",
+            "   1.000000000000000     0.000000000000000     0.000000000000000\n",
+            "   0.000000000000000     1.000000000000000     0.000000000000000\n",
+            "   0.000000000000000     0.000000000000000     1.000000000000000\n",
+            "2 1\n",
+            "Selective dynamics\n",
+            "Direct\n",
+            "     0.100000000000000     0.200000000000000     0.300000000000000 F T T\n",
+            "     0.300000000000000     0.400000000000000     0.500000000000000 F F F\n",
+            "     0.200000000000000     0.300000000000000     0.400000000000000 F F T\n",
+        ]
+        lines = io.readlines
+        corrects.each_with_index do |cor, index|
+            assert_equal(cor, lines[index], "line: #{index}")
+        end
+        assert_equal(corrects.size, lines.size)
+        # vasp 5
+        atoms = [
+            CrystalCell::Atom.new("Li", [0.1, 0.2, 0.3], "atom0", [false, true , true ]),
+            CrystalCell::Atom.new("O" , [0.2, 0.3, 0.4], "atom1", [false, false, true ]),
+            CrystalCell::Atom.new("Li", [0.3, 0.4, 0.5], "atom2", [false, false, false]),
+        ]
+        cell = CrystalCell::Cell.new(axes, atoms)
+        cell.comment = "test"
+        io = StringIO.new
+        VaspUtils::Poscar.dump(cell, ["Li", "O"], io, 5)
+        io.rewind
+        corrects = [
+            "test\n",
+            "1.0\n",
+            "   1.000000000000000     0.000000000000000     0.000000000000000\n",
+            "   0.000000000000000     1.000000000000000     0.000000000000000\n",
+            "   0.000000000000000     0.000000000000000     1.000000000000000\n",
+            "Li O\n",
+            "2 1\n",
+            "Selective dynamics\n",
+            "Direct\n",
+            "     0.100000000000000     0.200000000000000     0.300000000000000 F T T\n",
+            "     0.300000000000000     0.400000000000000     0.500000000000000 F F F\n",
+            "     0.200000000000000     0.300000000000000     0.400000000000000 F F T\n",
+        ]
+        lines = io.readlines
+        corrects.each_with_index do |cor, index|
+            assert_equal(cor, lines[index], "line: #{index}")
+        end
+        assert_equal(corrects.size, lines.size)
 
-    atoms = [
-      Atom.new(0, [0.1, 0.2, 0.3], "atom0", [false, true , true ]),
-      Atom.new(1, [0.2, 0.3, 0.4], "atom1", [false, false, true ]),
-      Atom.new(0, [0.3, 0.4, 0.5], "atom2", [false, false, false]),
-    ]
-    cell = Cell.new(axes, atoms)
-    cell.comment = "test"
-    io = StringIO.new
-    VaspUtils::Poscar.dump(cell, [0,1], io, 4)
-    io.rewind
-    corrects = [
-      "test\n",
-      "1.0\n",
-      "   1.000000000000000   0.000000000000000   0.000000000000000\n",
-      "   0.000000000000000   1.000000000000000   0.000000000000000\n",
-      "   0.000000000000000   0.000000000000000   1.000000000000000\n",
-      "2 1\n",
-      "Selective dynamics\n",
-      "Direct\n",
-      "   0.100000000000000   0.200000000000000   0.300000000000000 F T T\n",
-      "   0.300000000000000   0.400000000000000   0.500000000000000 F F F\n",
-      "   0.200000000000000   0.300000000000000   0.400000000000000 F F T\n",
-    ]
-    lines = io.readlines
-    corrects.each_with_index do |cor, index|
-      assert_equal(cor, lines[index], "line: #{index}")
-    end
-    assert_equal(corrects.size, lines.size)
-    # vasp 5
-    atoms = [
-      Atom.new("Li", [0.1, 0.2, 0.3], "atom0", [false, true , true ]),
-      Atom.new("O" , [0.2, 0.3, 0.4], "atom1", [false, false, true ]),
-      Atom.new("Li", [0.3, 0.4, 0.5], "atom2", [false, false, false]),
-    ]
-    cell = Cell.new(axes, atoms)
-    cell.comment = "test"
-    io = StringIO.new
-    VaspUtils::Poscar.dump(cell, ["Li", "O"], io, 5)
-    io.rewind
-    corrects = [
-      "test\n",
-      "1.0\n",
-      "   1.000000000000000   0.000000000000000   0.000000000000000\n",
-      "   0.000000000000000   1.000000000000000   0.000000000000000\n",
-      "   0.000000000000000   0.000000000000000   1.000000000000000\n",
-      "Li O\n",
-      "2 1\n",
-      "Selective dynamics\n",
-      "Direct\n",
-      "   0.100000000000000   0.200000000000000   0.300000000000000 F T T\n",
-      "   0.300000000000000   0.400000000000000   0.500000000000000 F F F\n",
-      "   0.200000000000000   0.300000000000000   0.400000000000000 F F T\n",
-    ]
-    lines = io.readlines
-    corrects.each_with_index do |cor, index|
-      assert_equal(cor, lines[index], "line: #{index}")
     end
-    assert_equal(corrects.size, lines.size)
 
-  end
+    def test_parse
+        io = StringIO.new
+        assert_raises(VaspUtils::Poscar::ParseError){ VaspUtils::Poscar.parse(io) }
 
-  def test_parse
-    io = StringIO.new
-    assert_raises(VaspUtils::Poscar::ParseError){ VaspUtils::Poscar.parse(io) }
+        # vasp 4 style
+        io = StringIO.new
+        io.puts "sample0"
+        io.puts "1.0"
+        io.puts "        1.0    0.0  0.0"
+        io.puts "        0.0    1.0  0.0"
+        io.puts "        0.0    0.0  1.0"
+        io.puts " 1 1 1"
+        io.puts "Direct"
+        io.puts "        0.0    0.0  0.0    #Li-001"
+        io.puts "        0.5    0.0  0.0    #Ge-002"
+        io.puts "        0.5    0.5  0.0    #O--003"
+        io.rewind
+        cell = VaspUtils::Poscar.parse(io)
+        assert_equal("sample0", cell.comment)
+        assert_equal(
+            CrystalCell::LatticeAxes.new( [
+                [1.0, 0.0, 0.0 ],
+                [0.0, 1.0, 0.0 ],
+                [0.0, 0.0, 1.0 ],
+            ]),
+            cell.axes
+        )
+        assert_equal(
+            CrystalCell::Atom.new(0, [0.0, 0.0, 0.0], "#Li-001"), cell.atoms[0])
+        assert_equal(
+            CrystalCell::Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002"), cell.atoms[1])
+        assert_equal(
+            CrystalCell::Atom.new(2, [0.5, 0.5, 0.0], "#O--003"), cell.atoms[2])
 
-    # vasp 4 style
-    io = StringIO.new
-    io.puts "sample0"
-    io.puts "1.0"
-    io.puts "    1.0  0.0  0.0"
-    io.puts "    0.0  1.0  0.0"
-    io.puts "    0.0  0.0  1.0"
-    io.puts " 1 1 1"
-    io.puts "Direct"
-    io.puts "    0.0  0.0  0.0  #Li-001"
-    io.puts "    0.5  0.0  0.0  #Ge-002"
-    io.puts "    0.5  0.5  0.0  #O--003"
-    io.rewind
-    cell = VaspUtils::Poscar.parse(io)
-    assert_equal("sample0", cell.comment)
-    assert_equal(
-      LatticeAxes.new( [
-        [1.0, 0.0, 0.0 ],
-        [0.0, 1.0, 0.0 ],
-        [0.0, 0.0, 1.0 ],
-      ]),
-      cell.axes
-    )
-    assert_equal(
-      Atom.new(0, [0.0, 0.0, 0.0], "#Li-001"), cell.atoms[0])
-    assert_equal(
-      Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002"), cell.atoms[1])
-    assert_equal(
-      Atom.new(2, [0.5, 0.5, 0.0], "#O--003"), cell.atoms[2])
+        # vasp 4 style and selective dynamics
+        io = StringIO.new
+        io.puts "sample1"
+        io.puts "2.0"
+        io.puts "        1.0    0.0  0.0"
+        io.puts "        0.0    1.0  0.0"
+        io.puts "        0.0    0.0  1.0"
+        io.puts " 1 1 2"
+        io.puts "Selective dynamics"
+        io.puts "Direct"
+        io.puts "        0.0    0.0  0.0    F F F #Li-001"
+        io.puts "        0.5    0.0  0.0    F T F #Ge-002"
+        io.puts "        0.5    0.5  0.0    T T T #O--003"
+        io.puts "        0.5    0.5  0.5    T T T #O--004"
+        io.rewind
+        cell = VaspUtils::Poscar.parse(io)
+        assert_equal("sample1", cell.comment)
+        assert_equal(
+            CrystalCell::LatticeAxes.new( [
+                [2.0, 0.0, 0.0 ],
+                [0.0, 2.0, 0.0 ],
+                [0.0, 0.0, 2.0 ],
+            ]),
+            cell.axes
+        )
+        assert_equal(
+            CrystalCell::Atom.new(0, [0.0, 0.0, 0.0], "#Li-001", [false, false, false]),
+            cell.atoms[0])
+        assert_equal(
+            CrystalCell::Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002", [false, true , false]),
+            cell.atoms[1])
+        assert_equal(
+            CrystalCell::Atom.new(2, [0.5, 0.5, 0.0], "#O--003", [true, true, true]),
+            cell.atoms[2])
+        assert_equal(
+            CrystalCell::Atom.new(2, [0.5, 0.5, 0.5], "#O--004", [true, true, true]),
+            cell.atoms[3])
 
-    # vasp 4 style and selective dynamics
-    io = StringIO.new
-    io.puts "sample1"
-    io.puts "2.0"
-    io.puts "    1.0  0.0  0.0"
-    io.puts "    0.0  1.0  0.0"
-    io.puts "    0.0  0.0  1.0"
-    io.puts " 1 1 2"
-    io.puts "Selective dynamics"
-    io.puts "Direct"
-    io.puts "    0.0  0.0  0.0  F F F #Li-001"
-    io.puts "    0.5  0.0  0.0  F T F #Ge-002"
-    io.puts "    0.5  0.5  0.0  T T T #O--003"
-    io.puts "    0.5  0.5  0.5  T T T #O--004"
-    io.rewind
-    cell = VaspUtils::Poscar.parse(io)
-    assert_equal("sample1", cell.comment)
-    assert_equal(
-      LatticeAxes.new( [
-        [2.0, 0.0, 0.0 ],
-        [0.0, 2.0, 0.0 ],
-        [0.0, 0.0, 2.0 ],
-      ]),
-      cell.axes
-    )
-    assert_equal(
-      Atom.new(0, [0.0, 0.0, 0.0], "#Li-001", [false, false, false]),
-      cell.atoms[0])
-    assert_equal(
-      Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002", [false, true , false]),
-      cell.atoms[1])
-    assert_equal(
-      Atom.new(2, [0.5, 0.5, 0.0], "#O--003", [true, true, true]),
-      cell.atoms[2])
-    assert_equal(
-      Atom.new(2, [0.5, 0.5, 0.5], "#O--004", [true, true, true]),
-      cell.atoms[3])
+        # vasp 5 style
+        io = StringIO.new
+        io.puts "sample0"
+        io.puts "1.0"
+        io.puts "        1.0    0.0  0.0"
+        io.puts "        0.0    1.0  0.0"
+        io.puts "        0.0    0.0  1.0"
+        io.puts " Li Ge O"
+        io.puts " 1  1  1"
+        io.puts "Direct"
+        io.puts "        0.0    0.0  0.0    #Li-001"
+        io.puts "        0.5    0.0  0.0    #Ge-002"
+        io.puts "        0.5    0.5  0.0    #O--003"
+        io.rewind
+        cell = VaspUtils::Poscar.parse(io)
+        assert_equal("sample0", cell.comment)
+        assert_equal(
+            CrystalCell::LatticeAxes.new( [
+                [1.0, 0.0, 0.0 ],
+                [0.0, 1.0, 0.0 ],
+                [0.0, 0.0, 1.0 ],
+            ]),
+            cell.axes
+        )
+        assert_equal(
+            CrystalCell::Atom.new("Li", [0.0, 0.0, 0.0], "#Li-001"), cell.atoms[0])
+        assert_equal(
+            CrystalCell::Atom.new("Ge", [0.5, 0.0, 0.0], "#Ge-002"), cell.atoms[1])
+        assert_equal(
+            CrystalCell::Atom.new("O", [0.5, 0.5, 0.0], "#O--003"), cell.atoms[2])
+    end
 
-    # vasp 5 style
-    io = StringIO.new
-    io.puts "sample0"
-    io.puts "1.0"
-    io.puts "    1.0  0.0  0.0"
-    io.puts "    0.0  1.0  0.0"
-    io.puts "    0.0  0.0  1.0"
-    io.puts " Li Ge O"
-    io.puts " 1  1  1"
-    io.puts "Direct"
-    io.puts "    0.0  0.0  0.0  #Li-001"
-    io.puts "    0.5  0.0  0.0  #Ge-002"
-    io.puts "    0.5  0.5  0.0  #O--003"
-    io.rewind
-    cell = VaspUtils::Poscar.parse(io)
-    assert_equal("sample0", cell.comment)
-    assert_equal(
-      LatticeAxes.new( [
-        [1.0, 0.0, 0.0 ],
-        [0.0, 1.0, 0.0 ],
-        [0.0, 0.0, 1.0 ],
-      ]),
-      cell.axes
-    )
-    assert_equal(
-      Atom.new("Li", [0.0, 0.0, 0.0], "#Li-001"), cell.atoms[0])
-    assert_equal(
-      Atom.new("Ge", [0.5, 0.0, 0.0], "#Ge-002"), cell.atoms[1])
-    assert_equal(
-      Atom.new("O", [0.5, 0.5, 0.0], "#O--003"), cell.atoms[2])
-  end
+    def test_load_file
+        cell = VaspUtils::Poscar.load_file("test/poscar/POSCAR.4-0")
+        assert_equal("sample0", cell.comment)
+        assert_equal(
+            CrystalCell::LatticeAxes.new( [
+                [1.0, 0.0, 0.0 ],
+                [0.0, 1.0, 0.0 ],
+                [0.0, 0.0, 1.0 ],
+            ]),
+            cell.axes
+        )
+        assert_equal(
+            CrystalCell::Atom.new(0, [0.0, 0.0, 0.0], "#Li-001"), cell.atoms[0])
+        assert_equal(
+            CrystalCell::Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002"), cell.atoms[1])
+        assert_equal(
+            CrystalCell::Atom.new(2, [0.5, 0.5, 0.0], "#O--003"), cell.atoms[2])
 
-  def test_load_file
-    cell = VaspUtils::Poscar.load_file("test/poscar/POSCAR.4-0")
-    assert_equal("sample0", cell.comment)
-    assert_equal(
-      LatticeAxes.new( [
-        [1.0, 0.0, 0.0 ],
-        [0.0, 1.0, 0.0 ],
-        [0.0, 0.0, 1.0 ],
-      ]),
-      cell.axes
-    )
-    assert_equal(
-      Atom.new(0, [0.0, 0.0, 0.0], "#Li-001"), cell.atoms[0])
-    assert_equal(
-      Atom.new(1, [0.5, 0.0, 0.0], "#Ge-002"), cell.atoms[1])
-    assert_equal(
-      Atom.new(2, [0.5, 0.5, 0.0], "#O--003"), cell.atoms[2])
 
-  end
+        assert_raise(VaspUtils::Poscar::ParseError) {
+            VaspUtils::Poscar.load_file("test/poscar/NOT_POSCAR")
+        }
+    end
 end

data/test/test_potcar.rb

@@ -7,39 +7,39 @@ require "vasputils/setting.rb"
 
 class TC_Potcar < Test::Unit::TestCase
 
-  def setup
-    @p0 = VaspUtils::Potcar.load_file("test/potcar/POTCAR"           )
-    @p1 = VaspUtils::Potcar.load_file("test/potcar/POTCAR.dummy"     )
-    @p2 = VaspUtils::Potcar.load_file("test/potcar/POTCAR.allElement")
-  end
+    def setup
+        @p0 = VaspUtils::Potcar.load_file("test/potcar/POTCAR"                   )
+        @p1 = VaspUtils::Potcar.load_file("test/potcar/POTCAR.dummy"         )
+        @p2 = VaspUtils::Potcar.load_file("test/potcar/POTCAR.allElement")
+    end
 
-  def test_get_filename
-    assert_equal("test/potcar/POTCAR"           , @p0[:name])
-    assert_equal("test/potcar/POTCAR.dummy"     , @p1[:name])
-    assert_equal("test/potcar/POTCAR.allElement", @p2[:name])
-  end
+    def test_get_filename
+        assert_equal("test/potcar/POTCAR"                       , @p0[:name])
+        assert_equal("test/potcar/POTCAR.dummy"         , @p1[:name])
+        assert_equal("test/potcar/POTCAR.allElement", @p2[:name])
+    end
 
-  def test_elements
-    assert_equal([ "Li", "Ge", "O" ], @p0[:elements])
-    assert_equal([ "Li", "Ge", "O" ], @p1[:elements])
-    correct = [
-      "Ac", "Ac", "Ag", "Al", "Al", "Ar", "As", "Au", "B", "B", "B", "Ba",
-      "Be", "Be", "Bi", "Bi", "Br", "C", "C", "C", "Ca", "Ca", "Cd", "Ce",
-      "Ce", "Cl", "Cl", "Co", "Cr", "Cr", "Cs", "Cu", "Cu", "Dy",
-      "Er", "Er", "Eu", "Eu", "F", "F", "F", "Fe", "Fe", "Ga", "Ga", "Ga",
-      "Gd", "Gd", "Ge", "Ge", "Ge", "H", "H", "H", "H", "H", "H", "He",
-      "Hf", "Hf", "Hg", "Ho", "I", "In", "In", "Ir", "K", "K", "Kr",
-      "La", "La", "Li", "Li", "Lu", "Lu", "Mg", "Mg", "Mn", "Mn",
-      "Mo", "Mo", "N", "N", "N", "Na", "Na", "Na", "Nb", "Nb", "Nd", "Nd",
-      "Ne", "Ni", "Ni", "Np", "Np", "O", "O", "O", "Os", "Os", "P", "P",
-      "Pa", "Pa", "Pb", "Pb", "Pd", "Pd", "Pm", "Pm", "Pr", "Pr", "Pt",
-      "Pu", "Pu", "Rb", "Rb", "Re", "Re", "Rh", "Rh", "Ru", "Ru", "S", "S",
-      "Sb", "Sc", "Se", "Si", "Si", "Sm", "Sm", "Sn", "Sn", "Sr",
-      "Ta", "Ta", "Tb", "Tc", "Tc", "Te", "Th", "Th", "Ti", "Ti", "Ti",
-      "Tl", "Tl", "Tm", "Tm", "U", "U", "V", "V", "V", "W", "W", "X", "Y",
-      "Yb", "Yb", "Zn", "Zr", "Zr"]
-    assert_equal( correct, @p2[:elements])
-  end
+    def test_elements
+        assert_equal([ "Li", "Ge", "O" ], @p0[:elements])
+        assert_equal([ "Li", "Ge", "O" ], @p1[:elements])
+        correct = [
+            "Ac", "Ac", "Ag", "Al", "Al", "Ar", "As", "Au", "B", "B", "B", "Ba",
+            "Be", "Be", "Bi", "Bi", "Br", "C", "C", "C", "Ca", "Ca", "Cd", "Ce",
+            "Ce", "Cl", "Cl", "Co", "Cr", "Cr", "Cs", "Cu", "Cu", "Dy",
+            "Er", "Er", "Eu", "Eu", "F", "F", "F", "Fe", "Fe", "Ga", "Ga", "Ga",
+            "Gd", "Gd", "Ge", "Ge", "Ge", "H", "H", "H", "H", "H", "H", "He",
+            "Hf", "Hf", "Hg", "Ho", "I", "In", "In", "Ir", "K", "K", "Kr",
+            "La", "La", "Li", "Li", "Lu", "Lu", "Mg", "Mg", "Mn", "Mn",
+            "Mo", "Mo", "N", "N", "N", "Na", "Na", "Na", "Nb", "Nb", "Nd", "Nd",
+            "Ne", "Ni", "Ni", "Np", "Np", "O", "O", "O", "Os", "Os", "P", "P",
+            "Pa", "Pa", "Pb", "Pb", "Pd", "Pd", "Pm", "Pm", "Pr", "Pr", "Pt",
+            "Pu", "Pu", "Rb", "Rb", "Re", "Re", "Rh", "Rh", "Ru", "Ru", "S", "S",
+            "Sb", "Sc", "Se", "Si", "Si", "Sm", "Sm", "Sn", "Sn", "Sr",
+            "Ta", "Ta", "Tb", "Tc", "Tc", "Te", "Th", "Th", "Ti", "Ti", "Ti",
+            "Tl", "Tl", "Tm", "Tm", "U", "U", "V", "V", "V", "W", "W", "X", "Y",
+            "Yb", "Yb", "Zn", "Zr", "Zr"]
+        assert_equal( correct, @p2[:elements])
+    end
 
 end