ritsu 0.7.0 → 0.7.1

data/test/ritsu/src_files/target_cmake_lists_test.rb

@@ -1,16 +1,16 @@
-require File.dirname(__FILE__) + "/../../test_helpers"
-
-class TargetCMakeListsTest < Test::Unit::TestCase
-  include Ritsu::SetupProjectAndClearEverythingElse
-  
-  must "src_path must be target_name/CMakeLists.txt" do
-    target = Ritsu::Targets::Executable.new("abc", :project=>@project)
-    assert_equal "abc/CMakeLists.txt", target.cmake_lists.src_path
-  end
-
-  must "src_path must be project_dir/target_name/CMakeLists.txt" do
-    target = Ritsu::Targets::Executable.new("abc", :project=>@project)
-    assert_equal "#{@project.project_dir}/src/abc/CMakeLists.txt", 
-      target.cmake_lists.abs_path
-  end
+require File.dirname(__FILE__) + "/../../test_helpers"
+
+class TargetCMakeListsTest < Test::Unit::TestCase
+  include Ritsu::SetupProjectAndClearEverythingElse
+  
+  must "src_path must be target_name/CMakeLists.txt" do
+    target = Ritsu::Targets::Executable.new("abc", :project=>@project)
+    assert_equal "abc/CMakeLists.txt", target.cmake_lists.src_path
+  end
+
+  must "src_path must be project_dir/target_name/CMakeLists.txt" do
+    target = Ritsu::Targets::Executable.new("abc", :project=>@project)
+    assert_equal "#{@project.project_dir}/src/abc/CMakeLists.txt", 
+      target.cmake_lists.abs_path
+  end
 end

data/test/ritsu/target_test.rb

@@ -1,106 +1,106 @@
-require File.dirname(__FILE__) + "/../test_helpers"
-
-class TargetTest < Test::Unit::TestCase
-  include Ritsu
-  include Ritsu::Targets
-  include Ritsu::SetupProjectAndClearEverythingElse
-  
-  must "contruct instances and keep track of them correctly" do
-    Executable.new("abc")
-    SharedLibrary.new("def")
-    StaticLibrary.new("ghi")
-    
-    assert_equal 3, Target.instances.length
-    
-    assert Target.instances.any? {|x| x.name =='abc'}
-    assert Target.instances.any? {|x| x.name == 'def'}
-    assert Target.instances.any? {|x| x.name == 'ghi'}
-    
-    assert Target.instances.any? {|x| x.kind_of?(Executable)}
-    assert Target.instances.any? {|x| x.kind_of?(SharedLibrary)}
-    assert Target.instances.any? {|x| x.kind_of?(StaticLibrary)}
-  end
-  
-  must "set the project to the default project if none is explicitly specified" do
-    abc = Executable.new('abc')
-    assert_equal @project, abc.project
-  end
-  
-  must "upon creation, add the target to the given project" do
-    abc = Executable.new('abc', :project => @project)
-    assert_equal 1, @project.targets.length
-    assert @project.targets.any? {|x| x.name == 'abc'}
-  end
-  
-  def setup_abcd_dependency_tree
-    @a = SharedLibrary.new('a')
-    @b = SharedLibrary.new('b')
-    @c = SharedLibrary.new('c')
-    @d = StaticLibrary.new('d')
-
-    @b.dependency_targets << @a
-    @c.dependency_targets << @b
-    @d.dependency_targets << @a
-    
-    @nodes = {:a => @a, :b => @b, :c => @c, :d => @d}
-  end
-  
-  must "be able to determine which target it depends directly on" do
-    setup_abcd_dependency_tree
-    
-    [[:b,:a], [:c,:b], [:d,:a]].each do |u,v|
-      assert @nodes[u].depends_directly_on_target?(@nodes[v]), 
-        "#{u} must depend directly on #{v}"
-    end
-    
-    [[:c,:a], [:a,:b], [:b,:b], [:b,:d]].each do |u,v|
-      assert !(@nodes[u].depends_directly_on_target?(@nodes[v])),
-        "#{u} must not depend directly on #{v}"
-    end    
-  end
-  
-  must "be able to determine which target it depends on, even not directly, on" do
-    setup_abcd_dependency_tree
-    
-    [[:b,:a], [:c,:b], [:c,:b], [:d,:a]].each do |u,v|
-      assert @nodes[u].depends_on_target?(@nodes[v]), 
-        "#{u} must depend on #{v}"
-    end
-    
-    [[:a,:a], [:a,:b], [:a,:c], [:a,:d], [:b,:d], [:b,:c], [:c,:d], [:d,:c]].each do |u,v|
-      assert !(@nodes[u].depends_on_target?(@nodes[v])), 
-        "#{u} must not depend on #{v}"
-    end
-  end
-  
-  must "compute topological orders correctly" do
-    setup_abcd_dependency_tree
-    
-    Target.compute_topological_orders
-    
-    [[:b,:a], [:c,:b], [:d,:a]].each do |u,v|
-      assert @nodes[u].topological_order > @nodes[v].topological_order,
-        "#{u} should come after #{v} in topological ordering"
-    end
-  end
-  
-  must "src_dir" do
-    abc = Executable.new('abc')
-    assert_equal "abc", abc.src_dir
-  end
-    
-  must "compute src_path correctly" do
-    abc = Executable.new('abc')
-    assert_equal "abc/temp.cpp", abc.compute_src_path("temp.cpp")
-  end
-  
-  must "compute src_path correctly relative to src" do
-    abc = Executable.new('abc')
-    assert_equal "xyz/temp.cpp", abc.compute_src_path("xyz/temp.cpp", :relative_to => :src)
-  end
-  
-  must "compute src_path correct when the input is absolute" do
-    abc = Executable.new('abc')
-    assert_equal "../temp.cpp", abc.compute_src_path(@project.project_dir + "/temp.cpp", :relative_to => :absolute)
-  end
+require File.dirname(__FILE__) + "/../test_helpers"
+
+class TargetTest < Test::Unit::TestCase
+  include Ritsu
+  include Ritsu::Targets
+  include Ritsu::SetupProjectAndClearEverythingElse
+  
+  must "contruct instances and keep track of them correctly" do
+    Executable.new("abc")
+    SharedLibrary.new("def")
+    StaticLibrary.new("ghi")
+    
+    assert_equal 3, Target.instances.length
+    
+    assert Target.instances.any? {|x| x.name =='abc'}
+    assert Target.instances.any? {|x| x.name == 'def'}
+    assert Target.instances.any? {|x| x.name == 'ghi'}
+    
+    assert Target.instances.any? {|x| x.kind_of?(Executable)}
+    assert Target.instances.any? {|x| x.kind_of?(SharedLibrary)}
+    assert Target.instances.any? {|x| x.kind_of?(StaticLibrary)}
+  end
+  
+  must "set the project to the default project if none is explicitly specified" do
+    abc = Executable.new('abc')
+    assert_equal @project, abc.project
+  end
+  
+  must "upon creation, add the target to the given project" do
+    abc = Executable.new('abc', :project => @project)
+    assert_equal 1, @project.targets.length
+    assert @project.targets.any? {|x| x.name == 'abc'}
+  end
+  
+  def setup_abcd_dependency_tree
+    @a = SharedLibrary.new('a')
+    @b = SharedLibrary.new('b')
+    @c = SharedLibrary.new('c')
+    @d = StaticLibrary.new('d')
+
+    @b.dependency_targets << @a
+    @c.dependency_targets << @b
+    @d.dependency_targets << @a
+    
+    @nodes = {:a => @a, :b => @b, :c => @c, :d => @d}
+  end
+  
+  must "be able to determine which target it depends directly on" do
+    setup_abcd_dependency_tree
+    
+    [[:b,:a], [:c,:b], [:d,:a]].each do |u,v|
+      assert @nodes[u].depends_directly_on_target?(@nodes[v]), 
+        "#{u} must depend directly on #{v}"
+    end
+    
+    [[:c,:a], [:a,:b], [:b,:b], [:b,:d]].each do |u,v|
+      assert !(@nodes[u].depends_directly_on_target?(@nodes[v])),
+        "#{u} must not depend directly on #{v}"
+    end    
+  end
+  
+  must "be able to determine which target it depends on, even not directly, on" do
+    setup_abcd_dependency_tree
+    
+    [[:b,:a], [:c,:b], [:c,:b], [:d,:a]].each do |u,v|
+      assert @nodes[u].depends_on_target?(@nodes[v]), 
+        "#{u} must depend on #{v}"
+    end
+    
+    [[:a,:a], [:a,:b], [:a,:c], [:a,:d], [:b,:d], [:b,:c], [:c,:d], [:d,:c]].each do |u,v|
+      assert !(@nodes[u].depends_on_target?(@nodes[v])), 
+        "#{u} must not depend on #{v}"
+    end
+  end
+  
+  must "compute topological orders correctly" do
+    setup_abcd_dependency_tree
+    
+    Target.compute_topological_orders
+    
+    [[:b,:a], [:c,:b], [:d,:a]].each do |u,v|
+      assert @nodes[u].topological_order > @nodes[v].topological_order,
+        "#{u} should come after #{v} in topological ordering"
+    end
+  end
+  
+  must "src_dir" do
+    abc = Executable.new('abc')
+    assert_equal "abc", abc.src_dir
+  end
+    
+  must "compute src_path correctly" do
+    abc = Executable.new('abc')
+    assert_equal "abc/temp.cpp", abc.compute_src_path("temp.cpp")
+  end
+  
+  must "compute src_path correctly relative to src" do
+    abc = Executable.new('abc')
+    assert_equal "xyz/temp.cpp", abc.compute_src_path("xyz/temp.cpp", :relative_to => :src)
+  end
+  
+  must "compute src_path correct when the input is absolute" do
+    abc = Executable.new('abc')
+    assert_equal "../temp.cpp", abc.compute_src_path(@project.project_dir + "/temp.cpp", :relative_to => :absolute)
+  end
 end

data/test/ritsu/targets/executable_test.rb

@@ -1,11 +1,11 @@
-require File.dirname(__FILE__) + "/../../test_helpers"
-
-class ExecutableTest < Test::Unit::TestCase
-  include Ritsu::Targets
-  include Ritsu::SetupProjectAndClearEverythingElse
-  
-  must "not be able to be depended on" do
-    exe = Executable.new('exe')
-    assert !exe.can_be_depended_on?
-  end
+require File.dirname(__FILE__) + "/../../test_helpers"
+
+class ExecutableTest < Test::Unit::TestCase
+  include Ritsu::Targets
+  include Ritsu::SetupProjectAndClearEverythingElse
+  
+  must "not be able to be depended on" do
+    exe = Executable.new('exe')
+    assert !exe.can_be_depended_on?
+  end
 end

data/test/ritsu/targets/shared_library_test.rb

@@ -1,11 +1,11 @@
-require File.dirname(__FILE__) + "/../../test_helpers"
-
-class SharedLibraryTest < Test::Unit::TestCase
-  include Ritsu::Targets
-  include Ritsu::SetupProjectAndClearEverythingElse
-  
-  must "be able to be depended on" do
-    so = SharedLibrary.new('so')
-    assert so.can_be_depended_on?
-  end
+require File.dirname(__FILE__) + "/../../test_helpers"
+
+class SharedLibraryTest < Test::Unit::TestCase
+  include Ritsu::Targets
+  include Ritsu::SetupProjectAndClearEverythingElse
+  
+  must "be able to be depended on" do
+    so = SharedLibrary.new('so')
+    assert so.can_be_depended_on?
+  end
 end

data/test/ritsu/targets/static_library_test.rb

@@ -1,11 +1,11 @@
-require File.dirname(__FILE__) + "/../../test_helpers"
-
-class StaticLibraryTest < Test::Unit::TestCase
-  include Ritsu::Targets
-  include Ritsu::SetupProjectAndClearEverythingElse
-  
-  must "be able to be depended on" do
-    a = StaticLibrary.new('a')
-    assert a.can_be_depended_on?
-  end
+require File.dirname(__FILE__) + "/../../test_helpers"
+
+class StaticLibraryTest < Test::Unit::TestCase
+  include Ritsu::Targets
+  include Ritsu::SetupProjectAndClearEverythingElse
+  
+  must "be able to be depended on" do
+    a = StaticLibrary.new('a')
+    assert a.can_be_depended_on?
+  end
 end

data/test/ritsu/utility/accessors_test.rb

@@ -1,15 +1,15 @@
-require File.dirname(__FILE__) + "/../../test_helpers"
-
-
-class AccessorsTest < Test::Unit::TestCase
-  class A
-    include Ritsu::Utility::Accessors
-    attr_method :x
-  end
-
-  must "attr_equal works correctly" do
-    a = A.new
-    a.x 10
-    assert_equal 10, a.x
-  end
+require File.dirname(__FILE__) + "/../../test_helpers"
+
+
+class AccessorsTest < Test::Unit::TestCase
+  class A
+    include Ritsu::Utility::Accessors
+    attr_method :x
+  end
+
+  must "attr_equal works correctly" do
+    a = A.new
+    a.x 10
+    assert_equal 10, a.x
+  end
 end

data/test/ritsu/utility/check_upon_add_set_test.rb

@@ -1,32 +1,32 @@
-require File.dirname(__FILE__) + "/../../test_helpers"
-
-class CheckUponAddSetTest < Test::Unit::TestCase
-  include Ritsu::Utility
-  
-  must "behave like normal set when given no block" do
-    s = CheckUponAddSet.new
-    s << 1 << 2 << "abc"
-    assert s.include?(1)
-    assert s.include?(2)
-    assert s.include?("abc")
-    s.delete(1)
-    assert !s.include?(1)
-  end
-  
-  must "preform check when block is given" do
-    s = CheckUponAddSet.new do |s,x|
-      if x > 10
-        raise ArgumentError.new("inserted value more than 10!")
-      end
-    end
-    assert_nothing_raised do
-      s << 1
-      s << 2
-      s << 10
-      s << -1
-    end
-    assert_raises ArgumentError do
-      s << 11
-    end
-  end
+require File.dirname(__FILE__) + "/../../test_helpers"
+
+class CheckUponAddSetTest < Test::Unit::TestCase
+  include Ritsu::Utility
+  
+  must "behave like normal set when given no block" do
+    s = CheckUponAddSet.new
+    s << 1 << 2 << "abc"
+    assert s.include?(1)
+    assert s.include?(2)
+    assert s.include?("abc")
+    s.delete(1)
+    assert !s.include?(1)
+  end
+  
+  must "preform check when block is given" do
+    s = CheckUponAddSet.new do |s,x|
+      if x > 10
+        raise ArgumentError.new("inserted value more than 10!")
+      end
+    end
+    assert_nothing_raised do
+      s << 1
+      s << 2
+      s << 10
+      s << -1
+    end
+    assert_raises ArgumentError do
+      s << 11
+    end
+  end
 end

data/test/ritsu/utility/file_robot_test.rb

@@ -1,176 +1,176 @@
-require File.dirname(__FILE__) + "/../../test_helpers"
-
-class FileRobotTest < Test::Unit::TestCase
-  include Ritsu::Utility
-  include Ritsu::TestCaseWithFileTestData
-  
-  def data_dir; File.dirname(__FILE__) + "/" + File.basename(__FILE__, ".rb") end
-  
-  def setup
-    init_data_dir
-    @input = StringIO.new
-    @output = StringIO.new
-    FileRobot.input = @input
-    FileRobot.output = @output
-  end
-  
-  def provide_input(string)
-    @input << string
-    @input.rewind
-  end
-    
-  def expect_output(string)
-    assert_equal string, @output.string
-  end
-    
-  must "force must be initially false" do
-    assert !FileRobot.force
-  end
-  
-  must "quiet must be initially false" do
-    assert !FileRobot.quiet
-  end
-  
-  file_test "create empty file" do
-    FileRobot.create_file(output_path("abc.txt"))
-    assert_output_file_exists "abc.txt"
-    assert_output_file_content "", "abc.txt"
-    expect_output("      create #{output_dir}/abc.txt\n")
-  end
-  
-  file_test "create file with content" do
-    FileRobot.create_file(output_path("abc.txt"), "def")
-    assert_output_file_content "def", "abc.txt"
-    expect_output("      create #{output_dir}/abc.txt\n")
-  end
-  
-  file_test "create parent directories when creating a file" do
-    FileRobot.create_file(output_path("a/b/c/def.txt"), "def")
-    assert_output_file_exists "a/b/c/def.txt"
-    expect_output(
-      "      create #{output_dir}/a/b/c\n" +
-      "      create #{output_dir}/a/b/c/def.txt\n"
-    )
-  end
-  
-  file_test "create directory" do
-    FileRobot.create_dir(output_path("abc/def/ghi"))
-    assert_file_exists(output_path("abc/def/ghi"))
-    expect_output("      create #{output_dir}/abc/def/ghi\n")
-  end
-  
-  file_test "display exist message when dir already exist" do
-    FileRobot.create_dir(output_path("abc"))
-    FileRobot.create_dir(output_path("abc"))
-    expect_output(
-      "      create #{output_dir}/abc\n" +
-      "       exist #{output_dir}/abc\n"
-    )
-  end
-  
-  ['no', 'n', 'N', 'NO'].each do |answer|
-    file_test "ask user when file exist and do nothing when user says #{answer}" do
-      provide_input(answer)
-      FileRobot.create_file(output_path("abc.txt"), "abc")
-      FileRobot.create_file(output_path("abc.txt"), "def")
-      expect_output(
-        "      create #{output_dir}/abc.txt\n" +
-           "overwrite #{output_dir}/abc.txt? (yes/no/all): " +
-        "       exist #{output_dir}/abc.txt\n"
-      )
-      assert_output_file_content "abc", "abc.txt"
-    end
-  end
-  
-  ['yes', 'y', 'YES', 'Yes', 'Y'].each do |answer|
-    file_test "ask user when file exist and overwrite when user says #{answer}" do
-      provide_input(answer)
-      FileRobot.create_file(output_path("abc.txt"), "abc")
-      FileRobot.create_file(output_path("abc.txt"), "def")
-      expect_output(
-        "      create #{output_dir}/abc.txt\n" +
-           "overwrite #{output_dir}/abc.txt? (yes/no/all): " +
-        "   overwrite #{output_dir}/abc.txt\n"
-      )
-      assert_output_file_content "def", "abc.txt"
-    end
-  end
-    
-  ['ye', 'non', 'Nevar', 'programming'].each do |answer|
-    file_test "ask user when file exist and ask again when user says #{answer}" do
-      provide_input(answer + "\nno")
-      FileRobot.create_file(output_path("abc.txt"), "abc")
-      FileRobot.create_file(output_path("abc.txt"), "def")
-      expect_output(
-        "      create #{output_dir}/abc.txt\n" +
-           "overwrite #{output_dir}/abc.txt? (yes/no/all): " +
-           "overwrite #{output_dir}/abc.txt? (yes/no/all): " +
-        "       exist #{output_dir}/abc.txt\n"
-      )
-      assert_output_file_content "abc", "abc.txt"
-    end
-  end
-  
-  file_test "remove file" do
-    FileRobot.create_file(output_path("abc.txt"), "abc")
-    assert_output_file_exists("abc.txt")
-    FileRobot.remove_file(output_path("abc.txt"))
-    assert_output_file_not_exist("abc.txt")
-  end
-  
-  file_test "write a message if file to remove does not exist" do
-    FileRobot.remove_file(output_path("abc.txt"))
-    expect_output(
-      "   not exist #{output_dir}/abc.txt\n"
-    )
-  end
-  
-  file_test "write a message if file to remove is not a file" do
-    FileRobot.create_dir(output_path("abc.txt"))
-    assert_output_file_exists("abc.txt")
-    FileRobot.remove_file(output_path("abc.txt"))
-    expect_output(
-      "      create #{output_dir}/abc.txt\n" +
-      "    not file #{output_dir}/abc.txt\n"
-    )
-    assert_output_file_exists("abc.txt")
-  end
-  
-  file_test "remove dir" do
-    FileRobot.create_dir(output_path("abc"))
-    assert_output_file_exists("abc")
-    FileRobot.remove_dir(output_path("abc"))
-    assert_output_file_not_exist("abc")
-  end
-  
-  file_test "write a message if dir to remove does not exist" do
-    FileRobot.remove_file(output_path("abc"))
-    expect_output(
-      "   not exist #{output_dir}/abc\n"
-    )
-  end
-  
-  file_test "write a message if dir to remove is not a dir" do
-    FileRobot.create_file(output_path("abc"), "")
-    assert_output_file_exists("abc")
-    FileRobot.remove_dir(output_path("abc"))
-    expect_output(
-      "      create #{output_dir}/abc\n" +
-      "     not dir #{output_dir}/abc\n"
-    )
-    assert_output_file_exists("abc")    
-  end
-  
-  file_test "write a message if dir to remove is not empty" do
-    FileRobot.create_dir(output_path("abc"))
-    FileRobot.create_file(output_path("abc/def.txt"), "")
-    assert_output_file_exists('abc/def.txt')
-    FileRobot.remove_dir(output_path("abc"))
-    expect_output(
-      "      create #{output_dir}/abc\n" +
-      "      create #{output_dir}/abc/def.txt\n" +
-      "   not empty #{output_dir}/abc\n"
-    )
-    assert_output_file_exists("abc/def.txt")
-  end
+require File.dirname(__FILE__) + "/../../test_helpers"
+
+class FileRobotTest < Test::Unit::TestCase
+  include Ritsu::Utility
+  include Ritsu::TestCaseWithFileTestData
+  
+  def data_dir; File.dirname(__FILE__) + "/" + File.basename(__FILE__, ".rb") end
+  
+  def setup
+    init_data_dir
+    @input = StringIO.new
+    @output = StringIO.new
+    FileRobot.input = @input
+    FileRobot.output = @output
+  end
+  
+  def provide_input(string)
+    @input << string
+    @input.rewind
+  end
+    
+  def expect_output(string)
+    assert_equal string, @output.string
+  end
+    
+  must "force must be initially false" do
+    assert !FileRobot.force
+  end
+  
+  must "quiet must be initially false" do
+    assert !FileRobot.quiet
+  end
+  
+  file_test "create empty file" do
+    FileRobot.create_file(output_path("abc.txt"))
+    assert_output_file_exists "abc.txt"
+    assert_output_file_content "", "abc.txt"
+    expect_output("      create #{output_dir}/abc.txt\n")
+  end
+  
+  file_test "create file with content" do
+    FileRobot.create_file(output_path("abc.txt"), "def")
+    assert_output_file_content "def", "abc.txt"
+    expect_output("      create #{output_dir}/abc.txt\n")
+  end
+  
+  file_test "create parent directories when creating a file" do
+    FileRobot.create_file(output_path("a/b/c/def.txt"), "def")
+    assert_output_file_exists "a/b/c/def.txt"
+    expect_output(
+      "      create #{output_dir}/a/b/c\n" +
+      "      create #{output_dir}/a/b/c/def.txt\n"
+    )
+  end
+  
+  file_test "create directory" do
+    FileRobot.create_dir(output_path("abc/def/ghi"))
+    assert_file_exists(output_path("abc/def/ghi"))
+    expect_output("      create #{output_dir}/abc/def/ghi\n")
+  end
+  
+  file_test "display exist message when dir already exist" do
+    FileRobot.create_dir(output_path("abc"))
+    FileRobot.create_dir(output_path("abc"))
+    expect_output(
+      "      create #{output_dir}/abc\n" +
+      "       exist #{output_dir}/abc\n"
+    )
+  end
+  
+  ['no', 'n', 'N', 'NO'].each do |answer|
+    file_test "ask user when file exist and do nothing when user says #{answer}" do
+      provide_input(answer)
+      FileRobot.create_file(output_path("abc.txt"), "abc")
+      FileRobot.create_file(output_path("abc.txt"), "def")
+      expect_output(
+        "      create #{output_dir}/abc.txt\n" +
+           "overwrite #{output_dir}/abc.txt? (yes/no/all): " +
+        "       exist #{output_dir}/abc.txt\n"
+      )
+      assert_output_file_content "abc", "abc.txt"
+    end
+  end
+  
+  ['yes', 'y', 'YES', 'Yes', 'Y'].each do |answer|
+    file_test "ask user when file exist and overwrite when user says #{answer}" do
+      provide_input(answer)
+      FileRobot.create_file(output_path("abc.txt"), "abc")
+      FileRobot.create_file(output_path("abc.txt"), "def")
+      expect_output(
+        "      create #{output_dir}/abc.txt\n" +
+           "overwrite #{output_dir}/abc.txt? (yes/no/all): " +
+        "   overwrite #{output_dir}/abc.txt\n"
+      )
+      assert_output_file_content "def", "abc.txt"
+    end
+  end
+    
+  ['ye', 'non', 'Nevar', 'programming'].each do |answer|
+    file_test "ask user when file exist and ask again when user says #{answer}" do
+      provide_input(answer + "\nno")
+      FileRobot.create_file(output_path("abc.txt"), "abc")
+      FileRobot.create_file(output_path("abc.txt"), "def")
+      expect_output(
+        "      create #{output_dir}/abc.txt\n" +
+           "overwrite #{output_dir}/abc.txt? (yes/no/all): " +
+           "overwrite #{output_dir}/abc.txt? (yes/no/all): " +
+        "       exist #{output_dir}/abc.txt\n"
+      )
+      assert_output_file_content "abc", "abc.txt"
+    end
+  end
+  
+  file_test "remove file" do
+    FileRobot.create_file(output_path("abc.txt"), "abc")
+    assert_output_file_exists("abc.txt")
+    FileRobot.remove_file(output_path("abc.txt"))
+    assert_output_file_not_exist("abc.txt")
+  end
+  
+  file_test "write a message if file to remove does not exist" do
+    FileRobot.remove_file(output_path("abc.txt"))
+    expect_output(
+      "   not exist #{output_dir}/abc.txt\n"
+    )
+  end
+  
+  file_test "write a message if file to remove is not a file" do
+    FileRobot.create_dir(output_path("abc.txt"))
+    assert_output_file_exists("abc.txt")
+    FileRobot.remove_file(output_path("abc.txt"))
+    expect_output(
+      "      create #{output_dir}/abc.txt\n" +
+      "    not file #{output_dir}/abc.txt\n"
+    )
+    assert_output_file_exists("abc.txt")
+  end
+  
+  file_test "remove dir" do
+    FileRobot.create_dir(output_path("abc"))
+    assert_output_file_exists("abc")
+    FileRobot.remove_dir(output_path("abc"))
+    assert_output_file_not_exist("abc")
+  end
+  
+  file_test "write a message if dir to remove does not exist" do
+    FileRobot.remove_file(output_path("abc"))
+    expect_output(
+      "   not exist #{output_dir}/abc\n"
+    )
+  end
+  
+  file_test "write a message if dir to remove is not a dir" do
+    FileRobot.create_file(output_path("abc"), "")
+    assert_output_file_exists("abc")
+    FileRobot.remove_dir(output_path("abc"))
+    expect_output(
+      "      create #{output_dir}/abc\n" +
+      "     not dir #{output_dir}/abc\n"
+    )
+    assert_output_file_exists("abc")    
+  end
+  
+  file_test "write a message if dir to remove is not empty" do
+    FileRobot.create_dir(output_path("abc"))
+    FileRobot.create_file(output_path("abc/def.txt"), "")
+    assert_output_file_exists('abc/def.txt')
+    FileRobot.remove_dir(output_path("abc"))
+    expect_output(
+      "      create #{output_dir}/abc\n" +
+      "      create #{output_dir}/abc/def.txt\n" +
+      "   not empty #{output_dir}/abc\n"
+    )
+    assert_output_file_exists("abc/def.txt")
+  end
 end