vasputils 0.0.0

data/test/test_poscar.rb

@@ -0,0 +1,209 @@
+#! /usr/bin/ruby -W
+
+require "test/unit"
+require "stringio"
+require "vasputils/poscar.rb"
+
+require "rubygems"
+gem "mageo"
+require "mageo/vector3dinternal.rb"
+gem "crystalcell"
+require "crystalcell/cell.rb"
+
+class TC_Poscar < Test::Unit::TestCase
+	$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(Poscar::ElementMismatchError){
+			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
+		Poscar.dump(cell, [0,1], io)
+		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)
+
+		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
+		Poscar.dump(cell, [0,1], io)
+		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)
+	end
+
+	def test_parse
+		io = StringIO.new
+		assert_raises(Poscar::ParseError){ Poscar.parse(io) }
+
+		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 = 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])
+
+		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 = 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])
+	end
+
+	def test_load_file
+		cell = Poscar.load_file("test/poscar/POSCAR.00")
+		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])
+
+		#cell = Poscar.load_file("test/poscar/POSCAR.02")
+		#assert_equal("sample0", cell.comment)
+		#assert_in_delta( 7.1028554188641708, cell.axes[0][0], $tolerance)
+		#assert_in_delta(-0.0000000169534433, cell.axes[0][1], $tolerance)
+		#assert_in_delta(-0.0000000169534428, cell.axes[0][2], $tolerance)
+		#assert_in_delta( 0.0000001136137521, cell.axes[1][0], $tolerance) 
+		#assert_in_delta( 7.1028554188641725, cell.axes[1][1], $tolerance) 
+		#assert_in_delta(-0.0000000169534433, cell.axes[1][2], $tolerance) 
+		#assert_in_delta( 0.0000001136137521, cell.axes[2][0], $tolerance) 
+		#assert_in_delta( 0.0000001136137521, cell.axes[2][1], $tolerance) 
+		#assert_in_delta( 7.1028554188641725, cell.axes[2][2], $tolerance) 
+		#assert_equal(0, cell.atoms[0].element)
+		#assert_equal(0.0395891220708791, cell.atoms[0].position[0]) 
+		#assert_equal(0.0395891220708791, cell.atoms[0].position[1])
+		#assert_equal(0.0395891220708791, cell.atoms[0].position[2])
+
+	end
+
+	#def setup
+	#	#@pp02 = Poscar.new("test/poscar/POSCAR.shirai")
+	#end
+
+end

data/test/test_potcar.rb

@@ -0,0 +1,65 @@
+#! /usr/bin/ruby
+
+require "test/unit"
+require "vasputils/potcar.rb"
+
+class TC_Potcar < Test::Unit::TestCase
+
+	def setup
+		@p0 = Potcar.load_file("test/potcar/POTCAR"           )
+		@p1 = Potcar.load_file("test/potcar/POTCAR.dummy"     )
+		@p2 = 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_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_self_elements
+	#	assert_equal([ "Li", "Ge", "O" ], Potcar.elements( @p0 ))
+	#	assert_equal([ "Li", "Ge", "O" ], Potcar.elements( @p1 ))
+	#	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, Potcar.elements( @p2 ))
+	#end
+
+end
+

data/test/test_vaspdir.rb

@@ -0,0 +1,253 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+$TEST = true
+
+class VaspDir
+	attr_reader :mode
+end
+
+require "test/unit"
+require "vasputils/vaspdir.rb"
+
+#	assert_equal( cor, data)
+#	assert_in_delta( cor, data, $tolerance )
+#	assert_raise( RuntimeError ){}
+
+
+class TC_VaspDir < Test::Unit::TestCase
+
+	GENERATED_FILES_VD00 = 
+	[
+		"test/vaspdir/not-yet-ISIF2/CHG",
+		"test/vaspdir/not-yet-ISIF2/CHGCAR",
+		"test/vaspdir/not-yet-ISIF2/CONTCAR",
+		"test/vaspdir/not-yet-ISIF2/DOSCAR",
+		"test/vaspdir/not-yet-ISIF2/EIGENVAL",
+		"test/vaspdir/not-yet-ISIF2/IBZKPT",
+		"test/vaspdir/not-yet-ISIF2/OSZICAR",
+		"test/vaspdir/not-yet-ISIF2/OUTCAR",
+		"test/vaspdir/not-yet-ISIF2/PCDAT",
+		"test/vaspdir/not-yet-ISIF2/WAVECAR",
+		"test/vaspdir/not-yet-ISIF2/XDATCAR",
+		"test/vaspdir/not-yet-ISIF2/machines",
+		"test/vaspdir/not-yet-ISIF2/vasprun.xml",
+		"test/vaspdir/not-yet-ISIF2/lock",
+	]
+
+	def setup
+		@vd00 = VaspDir.new("test/vaspdir/not-yet-ISIF2")
+		@vd01 = VaspDir.new("test/vaspdir/not-yet-ISIF3")
+		@vd02 = VaspDir.new("test/vaspdir/ISIF3-NSW100-OUTCAR-Iter1-INT")
+		@vd03 = VaspDir.new("test/vaspdir/ISIF2-NSW100-OUTCAR-Iter1")
+		@vd04 = VaspDir.new("test/vaspdir/ISIF3-NSW002-OUTCAR-Iter2")
+		@vd05 = VaspDir.new("test/vaspdir/ISIF3-NSW100-OUTCAR-Iter3")
+		@vd06 = VaspDir.new("test/vaspdir/PI")
+		@vd07 = VaspDir.new("test/vaspdir/lock")
+		@vd08 = VaspDir.new("test/vaspdir/lock-PI")
+		@vd09 = VaspDir.new("test/vaspdir/ISIF2-NSW100-OUTCAR-Iter3")
+		@vd10 = VaspDir.new("test/vaspdir/next-try00")
+		@vd11 = VaspDir.new("test/vaspdir/ISIF2-NSW000-OUTCAR-Iter1")
+		@vd12 = VaspDir.new("test/vaspdir/ISIF2-NSW001-OUTCAR-Iter1")
+		@vd13 = VaspDir.new("test/vaspdir/ISIF3-NSW000-OUTCAR-Iter1")
+		@vd14 = VaspDir.new("test/vaspdir/ISIF3-NSW001-OUTCAR-Iter1")
+		@vd15 = VaspDir.new("test/vaspdir/IBRION-1-NSW000-OUTCAR-Iter1")
+
+		GENERATED_FILES_VD00.each do |file|
+			FileUtils.rm file if File.exist? file
+		end
+	end
+
+	def teardown
+		["test/vaspdir/next-try01/POSCAR" ,
+			"test/vaspdir/next-try01/POTCAR" ,
+			"test/vaspdir/next-try01/INCAR"  ,
+			"test/vaspdir/next-try01/KPOINTS"].each do |filename|
+			FileUtils.rm(filename) if File.exist?(filename)
+		end
+		Dir.rmdir("test/vaspdir/next-try01") if File.exist?("test/vaspdir/next-try01")
+
+		GENERATED_FILES_VD00.each do |file|
+			FileUtils.rm file if File.exist? file
+		end
+	end
+
+	def test_initialize
+		assert_raise(VaspDir::InitializeError){VaspDir.new("test/vaspdir/lack-INCAR"  )}
+		assert_raise(VaspDir::InitializeError){VaspDir.new("test/vaspdir/lack-KPOINTS")}
+		assert_raise(VaspDir::InitializeError){VaspDir.new("test/vaspdir/lack-POSCAR" )}
+		assert_raise(VaspDir::InitializeError){VaspDir.new("test/vaspdir/lack-POTCAR" )}
+
+		assert_equal(:geom_opt_atoms,   @vd00.mode)
+		assert_equal(:geom_opt_lattice, @vd01.mode)
+		assert_equal(:geom_opt_lattice, @vd02.mode)
+		assert_equal(:geom_opt_atoms,   @vd03.mode)
+	end
+
+	def test_name
+		assert_equal("test/vaspdir/not-yet-ISIF2"                , @vd00.name)
+		assert_equal("test/vaspdir/not-yet-ISIF3"                , @vd01.name)
+		assert_equal("test/vaspdir/ISIF3-NSW100-OUTCAR-Iter1-INT", @vd02.name)
+		assert_equal("test/vaspdir/ISIF2-NSW100-OUTCAR-Iter1"    , @vd03.name)
+		assert_equal("test/vaspdir/ISIF3-NSW002-OUTCAR-Iter2"    , @vd04.name)
+		assert_equal("test/vaspdir/ISIF3-NSW100-OUTCAR-Iter3"    , @vd05.name)
+		assert_equal("test/vaspdir/PI"                           , @vd06.name)
+		assert_equal("test/vaspdir/lock"                         , @vd07.name)
+		assert_equal("test/vaspdir/lock-PI"                      , @vd08.name)
+		assert_equal("test/vaspdir/ISIF2-NSW100-OUTCAR-Iter3"    , @vd09.name)
+		assert_equal("test/vaspdir/next-try00"                   , @vd10.name)
+		assert_equal("test/vaspdir/ISIF2-NSW000-OUTCAR-Iter1"    , @vd11.name)
+		assert_equal("test/vaspdir/ISIF2-NSW001-OUTCAR-Iter1"    , @vd12.name)
+		assert_equal("test/vaspdir/ISIF3-NSW000-OUTCAR-Iter1"    , @vd13.name)
+		assert_equal("test/vaspdir/ISIF3-NSW001-OUTCAR-Iter1"    , @vd14.name)
+		assert_equal("test/vaspdir/IBRION-1-NSW000-OUTCAR-Iter1" , @vd15.name)
+	end
+
+	def test_started?
+		assert_equal(false, @vd00.started?)
+		assert_equal(false, @vd01.started?)
+		assert_equal(true , @vd02.started?)
+		assert_equal(true , @vd03.started?)
+		assert_equal(true , @vd04.started?)
+		assert_equal(true , @vd05.started?)
+		assert_equal(false, @vd06.started?)
+		assert_equal(true , @vd07.started?)
+		assert_equal(true , @vd08.started?)
+		assert_equal(true , @vd09.started?)
+		assert_equal(true , @vd10.started?)
+		assert_equal(true , @vd11.started?)
+		assert_equal(true , @vd12.started?)
+		assert_equal(true , @vd13.started?)
+		assert_equal(true , @vd14.started?)
+		assert_equal(true , @vd15.started?)
+	end
+
+	def test_normal_ended?
+		assert_equal(false, @vd00.normal_ended?)
+		assert_equal(false, @vd01.normal_ended?)
+		assert_equal(false, @vd02.normal_ended?)
+		assert_equal(true , @vd03.normal_ended?)
+		assert_equal(true , @vd04.normal_ended?)
+		assert_equal(true , @vd05.normal_ended?)
+		assert_equal(false, @vd06.normal_ended?)
+		assert_equal(false, @vd07.normal_ended?)
+		assert_equal(false, @vd08.normal_ended?)
+		assert_equal(true , @vd09.normal_ended?)
+	end
+
+	def test_to_be_continued?
+		assert_equal(false, @vd00.to_be_continued?)
+		assert_equal(false, @vd01.to_be_continued?)
+		assert_equal(false, @vd02.to_be_continued?)
+		assert_equal(false, @vd03.to_be_continued?)
+		assert_equal(true , @vd04.to_be_continued?)
+		assert_equal(true , @vd05.to_be_continued?)
+		assert_equal(false, @vd06.to_be_continued?)
+		assert_equal(false, @vd07.to_be_continued?)
+		assert_equal(false, @vd08.to_be_continued?)
+		assert_equal(false, @vd09.to_be_continued?)
+		assert_equal(true , @vd10.to_be_continued?)
+		assert_equal(false, @vd11.to_be_continued?)
+		assert_equal(false, @vd12.to_be_continued?)
+		assert_equal(false, @vd13.to_be_continued?)
+		assert_equal(false, @vd14.to_be_continued?)
+		assert_equal(false, @vd15.to_be_continued?)
+	end
+
+	def test_calculate
+		assert_raise(VaspDir::LockedError){@vd07.calculate}
+		assert_raise(VaspDir::LockedError){@vd08.calculate}
+
+		#
+		assert_nothing_raised{@vd00.calculate}
+		GENERATED_FILES_VD00.each do |file|
+			assert(FileTest.exist?(file), "#{file} not found.")
+		end
+		assert(FileTest.exist? "test/vaspdir/not-yet-ISIF2/INCAR")
+		assert(FileTest.exist? "test/vaspdir/not-yet-ISIF2/KPOINTS")
+		assert(FileTest.exist? "test/vaspdir/not-yet-ISIF2/POSCAR")
+		assert(FileTest.exist? "test/vaspdir/not-yet-ISIF2/POTCAR")
+		#
+		io = File.open("test/vaspdir/not-yet-ISIF2/lock", "r")
+		lines = io.readlines
+		assert_equal("HOST: #{ENV["HOST"]}\n", lines[0])
+		assert(/^START: / =~ lines[1])
+		assert_equal("STATUS: normal ended.\n", lines[2])
+
+		io.close
+		# あとかたづけは teardown にまかせる。
+	end
+
+	def test_next
+		assert_raise(VaspDir::NotEndedError){@vd00.next}
+		assert_raise(VaspDir::NotEndedError){@vd01.next}
+		assert_raise(VaspDir::NotEndedError){@vd02.next}
+		assert_raise(VaspDir::ConvergedError){@vd03.next}
+		assert_raise(VaspDir::NotEndedError){@vd06.next}
+		assert_raise(VaspDir::NotEndedError){@vd07.next}
+		assert_raise(VaspDir::NotEndedError){@vd08.next}
+		assert_raise(VaspDir::ConvergedError){@vd09.next}
+
+		assert_equal(true , FileTest.exist?("test/vaspdir/next-try00"))
+		assert_equal(false, FileTest.exist?("test/vaspdir/next-try01"))
+		@vd10.next
+		assert_equal("test/vaspdir/next-try01", @vd10.name)
+		assert_equal(true , FileTest.exist?("test/vaspdir/next-try00"))
+		assert_equal(true , FileTest.exist?("test/vaspdir/next-try01"))
+		assert_equal(true , FileTest.exist?("test/vaspdir/next-try01/POSCAR"))
+		assert_equal(true , FileTest.exist?("test/vaspdir/next-try01/POTCAR"))
+		assert_equal(true , FileTest.exist?("test/vaspdir/next-try01/INCAR"))
+		assert_equal(true , FileTest.exist?("test/vaspdir/next-try01/KPOINTS"))
+		assert_equal(4 , Dir.glob("test/vaspdir/next-try01/*").size)
+		#
+		poscar_00  = File.open("test/vaspdir/next-try00/POSCAR" ).readlines
+		contcar_00 = File.open("test/vaspdir/next-try00/CONTCAR").readlines
+		poscar_01  = File.open("test/vaspdir/next-try01/POSCAR" ).readlines
+		assert_equal(false, poscar_00  == contcar_00)
+		assert_equal(true,  contcar_00 == poscar_01)
+		assert_equal(false, poscar_01  == poscar_00)
+		# あとかたづけは teardown にまかせる。
+	end
+
+	def test_teardown
+		# NO TEST
+	end
+
+	def test_internal_steps
+		assert_equal(18, @vd10.internal_steps)
+	end
+
+	def test_external_steps
+		assert_equal(2, @vd10.external_steps)
+	end
+
+	def test_elapsed_time
+		assert_in_delta(126.383, @vd10.elapsed_time)
+	end
+
+	def test_outcar
+		assert_equal("test/vaspdir/next-try00/OUTCAR", @vd10.outcar[:name])
+	end
+
+	def test_contcar
+		t = @vd10.contcar
+		assert_equal(Cell, t.class)
+		assert_in_delta(3.8678456093562040, t.axes[2][2])
+		
+		assert_raise(Errno::ENOENT){@vd00.contcar}
+	end
+
+	def test_incar
+		t = @vd10.incar
+		assert_equal("400", t["ENCUT"])
+	end
+
+	def test_kpoints
+		t = @vd10.kpoints
+		assert_equal("Automatic mesh", t[:comment])
+	end
+
+	#undef test_next
+
+end
+

data/test/vaspdir/IBRION-1-NSW000-OUTCAR-Iter1/CONTCAR

@@ -0,0 +1,17 @@
+Untitled (VASP)                         
+   1.00000000000000     
+     3.6509999999999998    0.0000000000000000    0.0000000000000000
+    -1.8254999999999919    3.1618587492169889    0.0000000000000000
+     0.0000000000000000    0.0000000000000000    3.8879999999999999
+   3   1
+Selective dynamics
+Direct
+  0.0000000000000000  0.0000000000000000  0.5000000000000000   T   T   T
+  0.3333333333333357  0.6666666666666642  0.0000000000000000   T   T   T
+  0.6666666666666642  0.3333333333333357  0.0000000000000000   T   T   T
+  0.0000000000000000  0.0000000000000000  0.0000000000000000   F   F   F
+ 
+  0.00000000E+00  0.00000000E+00  0.00000000E+00
+  0.00000000E+00  0.00000000E+00  0.00000000E+00
+  0.00000000E+00  0.00000000E+00  0.00000000E+00
+  0.00000000E+00  0.00000000E+00  0.00000000E+00

data/test/vaspdir/IBRION-1-NSW000-OUTCAR-Iter1/INCAR

@@ -0,0 +1,27 @@
+# SCF input for VASP
+
+SYSTEM = Untitled (VASP)
+    PREC = High
+  IBRION = -1     #-1:atoms not moved, 1:quasi-Newton, 2:conjugate-gradient
+     NSW = 0      #maximum number of ionic steps
+   ENCUT = 400
+    NELM = 60       #maximum number of electronic steps
+  NELMIN = 2        #minimum number of electronic steps
+   EDIFF = 1.0e-05
+  EDIFFG = -0.02
+ VOSKOWN = 1
+  NBLOCK = 1
+   ISPIN = 1        #1:non spin polarized, 2:spin polarized
+  INIWAV = 1
+  ISTART = 1
+  ICHARG = 1
+   LWAVE = .TRUE.
+  LCHARG = .TRUE.
+  ISMEAR = 0
+   SIGMA = 0.1
+   IALGO = 38       #38:KosugiAlgorithm, 48:RMM-DIIS
+   #LREAL = .FALSE.
+   LREAL = Auto     #fast & not accurate
+     NGX = 36
+     NGY = 36
+     NGZ = 42

data/test/vaspdir/IBRION-1-NSW000-OUTCAR-Iter1/KPOINTS

@@ -0,0 +1,6 @@
+Automatic mesh
+0
+Monkhorst Pack
+  5  5  5
+  0.  0.  0.
+