From 6d96008b8bd52eb65ae87dff3ebcaaa1f0c0160a Mon Sep 17 00:00:00 2001
From: Robert Haines <rhaines@manchester.ac.uk>
Date: Thu, 18 Oct 2018 23:49:54 +0100
Subject: [PATCH 1/2] Switch from test/unit to minitest.

---
 Rakefile                                      |   2 +-
 test/{tc_create_dir.rb => create_dir_test.rb} |  15 +-
 ...{tc_create_file.rb => create_file_test.rb} | 103 +++---
 test/{tc_exceptions.rb => exceptions_test.rb} |  37 +-
 ...ged_entries.rb => managed_entries_test.rb} | 321 ++++++++----------
 test/{tc_read_dir.rb => read_dir_test.rb}     |  31 +-
 test/{tc_read_file.rb => read_file_test.rb}   |  73 ++--
 ...served_names.rb => reserved_names_test.rb} |  77 ++---
 test/{ts_container.rb => test_helper.rb}      |  37 +-
 test/{tc_util.rb => util_test.rb}             |   5 +-
 zip-container.gemspec                         |   2 +-
 11 files changed, 298 insertions(+), 405 deletions(-)
 rename test/{tc_create_dir.rb => create_dir_test.rb} (81%)
 rename test/{tc_create_file.rb => create_file_test.rb} (52%)
 rename test/{tc_exceptions.rb => exceptions_test.rb} (78%)
 rename test/{tc_managed_entries.rb => managed_entries_test.rb} (50%)
 rename test/{tc_read_dir.rb => read_dir_test.rb} (76%)
 rename test/{tc_read_file.rb => read_file_test.rb} (55%)
 rename test/{tc_reserved_names.rb => reserved_names_test.rb} (83%)
 rename test/{ts_container.rb => test_helper.rb} (71%)
 rename test/{tc_util.rb => util_test.rb} (96%)

diff --git a/Rakefile b/Rakefile
index 55e188b..a94e366 100644
--- a/Rakefile
+++ b/Rakefile
@@ -39,7 +39,7 @@ task default: :test
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
-  t.test_files = FileList['test/ts_container.rb']
+  t.test_files = FileList['test/**/*_test.rb']
   t.verbose = true
 end
 
diff --git a/test/tc_create_dir.rb b/test/create_dir_test.rb
similarity index 81%
rename from test/tc_create_dir.rb
rename to test/create_dir_test.rb
index 5c0bb6c..2717f5e 100644
--- a/test/tc_create_dir.rb
+++ b/test/create_dir_test.rb
@@ -30,25 +30,20 @@
 #
 # Author: Robert Haines
 
-require 'test/unit'
+require 'test_helper'
 require 'tmpdir'
-require 'zip-container'
 
-class TestCreateDir < Test::Unit::TestCase
+class TestCreateDir < MiniTest::Test
 
   def test_create_container
     Dir.mktmpdir do |dir|
       container = File.join(dir, 'empty.container')
 
-      assert_nothing_raised do
-        ZipContainer::Dir.create(container, $mimetype) do
-          assert File.exist?(File.join(container, 'mimetype'))
-        end
+      ZipContainer::Dir.create(container, TEST_MIMETYPE) do
+        assert File.exist?(File.join(container, 'mimetype'))
       end
 
-      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
-        ZipContainer::Dir.verify!(container)
-      end
+      ZipContainer::Dir.verify!(container)
     end
   end
 end
diff --git a/test/tc_create_file.rb b/test/create_file_test.rb
similarity index 52%
rename from test/tc_create_file.rb
rename to test/create_file_test.rb
index 5c1be06..4a5990a 100644
--- a/test/tc_create_file.rb
+++ b/test/create_file_test.rb
@@ -30,29 +30,24 @@
 #
 # Author: Robert Haines
 
-require 'test/unit'
+require 'test_helper'
 require 'tmpdir'
-require 'zip-container'
 
-class TestCreateFile < Test::Unit::TestCase
+class TestCreateFile < MiniTest::Test
 
   # Check creation of standard empty container files.
   def test_create_standard_file
     Dir.mktmpdir do |dir|
       filename = File.join(dir, 'test.container')
 
-      assert_nothing_raised do
-        ZipContainer::File.create(filename, $mimetype) do |c|
-          assert(c.on_disk?)
-          refute(c.in_memory?)
+      ZipContainer::File.create(filename, TEST_MIMETYPE) do |c|
+        assert(c.on_disk?)
+        refute(c.in_memory?)
 
-          assert(c.find_entry('mimetype').local_header_offset.zero?)
-        end
+        assert(c.find_entry('mimetype').local_header_offset.zero?)
       end
 
-      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
-        ZipContainer::File.verify!(filename)
-      end
+      ZipContainer::File.verify!(filename)
     end
   end
 
@@ -63,18 +58,14 @@ def test_create_mimetype_file
     Dir.mktmpdir do |dir|
       filename = File.join(dir, 'test.container')
 
-      assert_nothing_raised do
-        ZipContainer::File.create(filename, mimetype) do |c|
-          assert(c.on_disk?)
-          refute(c.in_memory?)
+      ZipContainer::File.create(filename, mimetype) do |c|
+        assert(c.on_disk?)
+        refute(c.in_memory?)
 
-          assert(c.find_entry('mimetype').local_header_offset.zero?)
-        end
+        assert(c.find_entry('mimetype').local_header_offset.zero?)
       end
 
-      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
-        ZipContainer::File.verify!(filename)
-      end
+      ZipContainer::File.verify!(filename)
     end
   end
 
@@ -84,55 +75,51 @@ def test_create_contents_file
     Dir.mktmpdir do |dir|
       filename = File.join(dir, 'test.container')
 
-      assert_nothing_raised do
-        ZipContainer::File.create(filename, $mimetype) do |c|
-          assert(c.on_disk?)
-          refute(c.in_memory?)
+      ZipContainer::File.create(filename, TEST_MIMETYPE) do |c|
+        assert(c.on_disk?)
+        refute(c.in_memory?)
 
-          c.file.open('test.txt', 'w') do |f|
-            f.print 'testing'
-          end
+        c.file.open('test.txt', 'w') do |f|
+          f.print 'testing'
+        end
 
-          assert(c.commit_required?)
-          assert(c.commit)
-          refute(c.commit_required?)
-          refute(c.commit)
+        assert(c.commit_required?)
+        assert(c.commit)
+        refute(c.commit_required?)
+        refute(c.commit)
 
-          c.dir.mkdir('dir1')
-          c.mkdir('dir2')
+        c.dir.mkdir('dir1')
+        c.mkdir('dir2')
 
-          assert(c.commit_required?)
-          assert(c.commit)
-          refute(c.commit_required?)
-          refute(c.commit)
+        assert(c.commit_required?)
+        assert(c.commit)
+        refute(c.commit_required?)
+        refute(c.commit)
 
-          c.comment = 'A comment!'
+        c.comment = 'A comment!'
 
-          assert(c.commit_required?)
-          assert(c.commit)
-          refute(c.commit_required?)
-          refute(c.commit)
-        end
+        assert(c.commit_required?)
+        assert(c.commit)
+        refute(c.commit_required?)
+        refute(c.commit)
       end
 
-      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
-        ZipContainer::File.open(filename) do |c|
-          assert(c.on_disk?)
-          refute(c.in_memory?)
+      ZipContainer::File.open(filename) do |c|
+        assert(c.on_disk?)
+        refute(c.in_memory?)
 
-          assert(c.file.exists?('test.txt'))
-          assert(c.file.exists?('dir1'))
-          assert(c.file.exists?('dir2'))
-          refute(c.file.exists?('dir3'))
+        assert(c.file.exists?('test.txt'))
+        assert(c.file.exists?('dir1'))
+        assert(c.file.exists?('dir2'))
+        refute(c.file.exists?('dir3'))
 
-          text = c.file.read('test.txt')
-          assert_equal('testing', text)
+        text = c.file.read('test.txt')
+        assert_equal('testing', text)
 
-          assert_equal('A comment!', c.comment)
+        assert_equal('A comment!', c.comment)
 
-          refute(c.commit_required?)
-          refute(c.commit)
-        end
+        refute(c.commit_required?)
+        refute(c.commit)
       end
     end
   end
diff --git a/test/tc_exceptions.rb b/test/exceptions_test.rb
similarity index 78%
rename from test/tc_exceptions.rb
rename to test/exceptions_test.rb
index 31e471f..0978c8e 100644
--- a/test/tc_exceptions.rb
+++ b/test/exceptions_test.rb
@@ -30,58 +30,45 @@
 #
 # Author: Robert Haines
 
-require 'test/unit'
-require 'zip-container'
+require 'test_helper'
 
-class TestExceptions < Test::Unit::TestCase
+class TestExceptions < MiniTest::Test
 
   def test_rescue_container_errors
-    assert_raise(ZipContainer::Error) do
+    assert_raises(ZipContainer::Error) do
       raise ZipContainer::ZipError
     end
 
-    assert_raise(ZipContainer::Error) do
+    assert_raises(ZipContainer::Error) do
       raise ZipContainer::MalformedContainerError
     end
 
-    assert_raise(ZipContainer::Error) do
+    assert_raises(ZipContainer::Error) do
       raise ZipContainer::ReservedNameClashError, 'test'
     end
 
-    assert_raise(ZipContainer::Error) do
+    assert_raises(ZipContainer::Error) do
       raise Zip::ZipError
     end
   end
 
   def test_malformed_container_error_nil
-    mce = nil
-
-    assert_nothing_raised do
-      mce = ZipContainer::MalformedContainerError.new(nil)
-    end
+    mce = ZipContainer::MalformedContainerError.new(nil)
 
     refute mce.message.empty?
     refute mce.message.include?(':')
   end
 
   def test_malformed_container_error_empty_string
-    mce = nil
-
-    assert_nothing_raised do
-      mce = ZipContainer::MalformedContainerError.new('')
-    end
+    mce = ZipContainer::MalformedContainerError.new('')
 
     refute mce.message.empty?
     refute mce.message.include?(':')
   end
 
   def test_malformed_container_error_string
-    mce = nil
     message = 'test'
-
-    assert_nothing_raised do
-      mce = ZipContainer::MalformedContainerError.new(message)
-    end
+    mce = ZipContainer::MalformedContainerError.new(message)
 
     refute mce.message.empty?
     assert mce.message.include?(':')
@@ -89,12 +76,8 @@ def test_malformed_container_error_string
   end
 
   def test_malformed_container_error_list
-    mce = nil
     message = %w[test1 test2]
-
-    assert_nothing_raised do
-      mce = ZipContainer::MalformedContainerError.new(message)
-    end
+    mce = ZipContainer::MalformedContainerError.new(message)
 
     refute mce.message.empty?
     assert mce.message.include?(':')
diff --git a/test/tc_managed_entries.rb b/test/managed_entries_test.rb
similarity index 50%
rename from test/tc_managed_entries.rb
rename to test/managed_entries_test.rb
index 57e456c..745e962 100644
--- a/test/tc_managed_entries.rb
+++ b/test/managed_entries_test.rb
@@ -30,9 +30,8 @@
 #
 # Author: Robert Haines
 
-require 'test/unit'
+require 'test_helper'
 require 'tmpdir'
-require 'zip-container'
 require 'helpers/entry_lists'
 
 # Classes to test managed entries.
@@ -119,36 +118,32 @@ def initialize(filename)
   end
 end
 
-class TestManagedEntries < Test::Unit::TestCase
+class TestManagedEntries < MiniTest::Test
 
   # Check that the example ZipContainer file does not validate as a
   # ManagedZipContainer.
   def test_fail_verification
-    refute(ManagedZipContainer.verify?($example))
+    refute(ManagedZipContainer.verify?(EXAMPLE))
 
     assert_raises(ZipContainer::MalformedContainerError) do
-      ManagedZipContainer.verify!($example)
+      ManagedZipContainer.verify!(EXAMPLE)
     end
   end
 
   # Check that the example ZipContainer file does validate as an
   # ExampleZipContainer.
   def test_pass_verification
-    assert(ExampleZipContainer.verify?($example))
+    assert(ExampleZipContainer.verify?(EXAMPLE))
 
-    assert_nothing_raised(ZipContainer::MalformedContainerError) do
-      ExampleZipContainer.verify!($example)
-    end
+    ExampleZipContainer.verify!(EXAMPLE)
   end
 
   # Check that the example ZipContainer file does validate as an
   # ExampleZipContainer2.
   def test_pass_verification_2
-    assert(ExampleZipContainer2.verify?($example))
+    assert(ExampleZipContainer2.verify?(EXAMPLE))
 
-    assert_nothing_raised(ZipContainer::MalformedContainerError) do
-      ExampleZipContainer2.verify!($example)
-    end
+    ExampleZipContainer2.verify!(EXAMPLE)
   end
 
   # Check that a standard Container can be created
@@ -156,29 +151,23 @@ def test_create_standard_container
     Dir.mktmpdir do |dir|
       filename = File.join(dir, 'test.container')
 
-      assert_nothing_raised do
-        ZipContainer::File.create(filename, $mimetype) do |c|
-          c.mkdir('META-INF')
-          assert(c.file.exists?('META-INF'))
+      ZipContainer::File.create(filename, TEST_MIMETYPE) do |c|
+        c.mkdir('META-INF')
+        assert(c.file.exists?('META-INF'))
 
-          c.file.open('META-INF/container.xml', 'w') do |f|
-            f.puts '<?xml version="1.0"?>'
-          end
-          assert(c.file.exists?('META-INF/container.xml'))
+        c.file.open('META-INF/container.xml', 'w') do |f|
+          f.puts '<?xml version="1.0"?>'
         end
+        assert(c.file.exists?('META-INF/container.xml'))
       end
 
-      assert_nothing_raised(ZipContainer::MalformedContainerError) do
-        ZipContainer::File.verify!(filename)
-      end
+      ZipContainer::File.verify!(filename)
     end
   end
 
   # Check that a subclassed container with managed files verifies correctly.
   def test_verify_subclassed_dir_container
-    assert_nothing_raised do
-      ExampleDirContainer.verify!($dir_managed)
-    end
+    ExampleDirContainer.verify!(DIR_MANAGED)
   end
 
   # Create a subclassed container. Check it doesn't verify at first; satisfy
@@ -187,21 +176,17 @@ def test_create_subclassed_dir_container
     Dir.mktmpdir do |dir|
       filename = File.join(dir, 'test.container')
 
-      assert_nothing_raised do
-        ExampleDirContainer.create(filename, $mimetype) do |c|
-          assert_raises(ZipContainer::MalformedContainerError) do
-            c.verify!
-          end
-
-          Dir.mkdir(File.join(filename, 'dir'))
-          File.open(File.join(filename, 'greeting.txt'), 'w') do |f|
-            f.puts 'Yo means hello.'
-          end
+      ExampleDirContainer.create(filename, TEST_MIMETYPE) do |c|
+        assert_raises(ZipContainer::MalformedContainerError) do
+          c.verify!
+        end
 
-          assert_nothing_raised(ZipContainer::MalformedContainerError) do
-            c.verify!
-          end
+        Dir.mkdir(File.join(filename, 'dir'))
+        File.open(File.join(filename, 'greeting.txt'), 'w') do |f|
+          f.puts 'Yo means hello.'
         end
+
+        c.verify
       end
     end
   end
@@ -212,11 +197,9 @@ def test_create_bad_subclassed_container
     Dir.mktmpdir do |dir|
       filename = File.join(dir, 'test.container')
 
-      assert_nothing_raised do
-        ManagedZipContainer.create(filename, $mimetype) do |c|
-          assert_raises(ZipContainer::MalformedContainerError) do
-            c.verify!
-          end
+      ManagedZipContainer.create(filename, TEST_MIMETYPE) do |c|
+        assert_raises(ZipContainer::MalformedContainerError) do
+          c.verify!
         end
       end
 
@@ -233,121 +216,107 @@ def test_create_subclassed_container
     Dir.mktmpdir do |dir|
       filename = File.join(dir, 'test.container')
 
-      assert_nothing_raised do
-        ManagedZipContainer.create(filename, $mimetype) do |c|
-          c.dir.mkdir('src')
-          c.file.open('index.html', 'w') do |f|
-            f.puts '<html />'
-          end
-
-          # Test hidden entries before and after creation.
-          assert_nil(c.find_entry('test', include_hidden: true))
-          assert_nil(c.find_entry('test/test.txt', include_hidden: true))
-          c.dir.mkdir('test')
-          c.file.open('test/test.txt', 'w') do |f|
-            f.puts 'A test!'
-          end
-          assert_not_nil(c.find_entry('test', include_hidden: true))
-          assert_not_nil(c.find_entry('test/test.txt', include_hidden: true))
-
-          # Test deep hidden entries before and after creation.
-          assert_nil(c.find_entry('test/deep', include_hidden: true))
-          assert_nil(c.find_entry('test/deep/deep.txt', include_hidden: true))
-          c.dir.mkdir('test/deep')
-          c.file.open('test/deep/deep.txt', 'w') do |f|
-            f.puts 'A deep test!'
-          end
-          assert_not_nil(c.find_entry('test/deep', include_hidden: true))
-          assert_not_nil(c.find_entry('test/deep/deep.txt', include_hidden: true))
+      ManagedZipContainer.create(filename, TEST_MIMETYPE) do |c|
+        c.dir.mkdir('src')
+        c.file.open('index.html', 'w') do |f|
+          f.puts '<html />'
+        end
+
+        # Test hidden entries before and after creation.
+        assert_nil(c.find_entry('test', include_hidden: true))
+        assert_nil(c.find_entry('test/test.txt', include_hidden: true))
+        c.dir.mkdir('test')
+        c.file.open('test/test.txt', 'w') do |f|
+          f.puts 'A test!'
+        end
+        refute_nil(c.find_entry('test', include_hidden: true))
+        refute_nil(c.find_entry('test/test.txt', include_hidden: true))
+
+        # Test deep hidden entries before and after creation.
+        assert_nil(c.find_entry('test/deep', include_hidden: true))
+        assert_nil(c.find_entry('test/deep/deep.txt', include_hidden: true))
+        c.dir.mkdir('test/deep')
+        c.file.open('test/deep/deep.txt', 'w') do |f|
+          f.puts 'A deep test!'
         end
+        refute_nil(c.find_entry('test/deep', include_hidden: true))
+        refute_nil(c.find_entry('test/deep/deep.txt', include_hidden: true))
       end
 
       assert(ManagedZipContainer.verify?(filename))
-      assert_nothing_raised(ZipContainer::MalformedContainerError) do
-        ManagedZipContainer.verify!(filename)
-      end
+      ManagedZipContainer.verify!(filename)
     end
   end
 
   def test_hidden_entries
-    assert_nothing_raised do
-      ManagedZipContainer.open($subclass) do |c|
-        refute(c.hidden_entry?('src'))
-        refute(c.hidden_file?('src'))
-        refute(c.hidden_directory?('src'))
-
-        assert(c.hidden_entry?('test'))
-        assert(c.hidden_directory?('test'))
-        assert(c.hidden_entry?('test/'))
-        assert(c.hidden_directory?('test/'))
-        refute(c.hidden_file?('test'))
-
-        assert(c.hidden_entry?('test/deep'))
-        assert(c.hidden_directory?('test/deep'))
-        assert(c.hidden_entry?('test/deep/deep.txt'))
-        assert(c.hidden_file?('test/deep/deep.txt'))
-      end
+    ManagedZipContainer.open(SUBCLASS) do |c|
+      refute(c.hidden_entry?('src'))
+      refute(c.hidden_file?('src'))
+      refute(c.hidden_directory?('src'))
+
+      assert(c.hidden_entry?('test'))
+      assert(c.hidden_directory?('test'))
+      assert(c.hidden_entry?('test/'))
+      assert(c.hidden_directory?('test/'))
+      refute(c.hidden_file?('test'))
+
+      assert(c.hidden_entry?('test/deep'))
+      assert(c.hidden_directory?('test/deep'))
+      assert(c.hidden_entry?('test/deep/deep.txt'))
+      assert(c.hidden_file?('test/deep/deep.txt'))
     end
   end
 
   def test_find_entry
-    assert_nothing_raised do
-      ManagedZipContainer.open($subclass) do |c|
-        assert_not_nil(c.find_entry('src'))
-        assert_not_nil(c.find_entry('src', include_hidden: true))
-
-        assert_nil(c.find_entry('test'))
-        assert_nil(c.find_entry('test/test.txt'))
-        assert_not_nil(c.find_entry('test', include_hidden: true))
-        assert_not_nil(c.find_entry('test/test.txt', include_hidden: true))
-
-        assert_nil(c.find_entry('test/deep'))
-        assert_nil(c.find_entry('test/deep/deep.txt'))
-        assert_not_nil(c.find_entry('test/deep', include_hidden: true))
-        assert_not_nil(c.find_entry('test/deep/deep.txt', include_hidden: true))
-      end
+    ManagedZipContainer.open(SUBCLASS) do |c|
+      refute_nil(c.find_entry('src'))
+      refute_nil(c.find_entry('src', include_hidden: true))
+
+      assert_nil(c.find_entry('test'))
+      assert_nil(c.find_entry('test/test.txt'))
+      refute_nil(c.find_entry('test', include_hidden: true))
+      refute_nil(c.find_entry('test/test.txt', include_hidden: true))
+
+      assert_nil(c.find_entry('test/deep'))
+      assert_nil(c.find_entry('test/deep/deep.txt'))
+      refute_nil(c.find_entry('test/deep', include_hidden: true))
+      refute_nil(c.find_entry('test/deep/deep.txt', include_hidden: true))
     end
   end
 
   def test_get_entry
-    ManagedZipContainer.open($subclass) do |c|
-      assert_nothing_raised(Errno::ENOENT) do
-        c.get_entry('src')
-      end
-      assert_nothing_raised(Errno::ENOENT) do
-        c.get_entry('src', include_hidden: true)
-      end
+    ManagedZipContainer.open(SUBCLASS) do |c|
+      c.get_entry('src')
+      c.get_entry('src', include_hidden: true)
 
-      assert_raise(Errno::ENOENT) do
+      assert_raises(Errno::ENOENT) do
         c.get_entry('test')
       end
-      assert_raise(Errno::ENOENT) do
+
+      assert_raises(Errno::ENOENT) do
         c.get_entry('test/test.txt')
       end
-      assert_nothing_raised(Errno::ENOENT) do
-        c.get_entry('test', include_hidden: true)
-      end
-      assert_nothing_raised(Errno::ENOENT) do
-        c.get_entry('test/test.txt', include_hidden: true)
-      end
 
-      assert_raise(Errno::ENOENT) do
+      c.get_entry('test', include_hidden: true)
+
+      c.get_entry('test/test.txt', include_hidden: true)
+
+      assert_raises(Errno::ENOENT) do
         c.get_entry('test/deep')
       end
-      assert_raise(Errno::ENOENT) do
+
+      assert_raises(Errno::ENOENT) do
         c.get_entry('test/deep/deep.txt')
       end
-      assert_nothing_raised(Errno::ENOENT) do
-        c.get_entry('test/deep', include_hidden: true)
-      end
-      assert_nothing_raised(Errno::ENOENT) do
-        c.get_entry('test/deep/deep.txt', include_hidden: true)
-      end
+
+      c.get_entry('test/deep', include_hidden: true)
+
+      c.get_entry('test/deep/deep.txt', include_hidden: true)
     end
   end
 
   def test_glob
-    ManagedZipContainer.open($subclass) do |c|
+    ManagedZipContainer.open(SUBCLASS) do |c|
       assert_equal(['index.html'], entry_list_names(c.glob('in*')))
       assert_equal([], c.glob('test/**/*'))
       assert_equal(
@@ -366,11 +335,9 @@ def test_create_subclassed_mimetype
     Dir.mktmpdir do |dir|
       filename = File.join(dir, 'test.container')
 
-      assert_nothing_raised do
-        ExampleZipContainer2.create(filename) do |c|
-          assert(c.file.exists?('mimetype'))
-          assert_equal('application/example+zip', c.file.read('mimetype'))
-        end
+      ExampleZipContainer2.create(filename) do |c|
+        assert(c.file.exists?('mimetype'))
+        assert_equal('application/example+zip', c.file.read('mimetype'))
       end
     end
   end
@@ -381,34 +348,28 @@ def test_create_subclassed_container_with_content_verification
     Dir.mktmpdir do |dir|
       filename = File.join(dir, 'test.container')
 
-      assert_nothing_raised do
-        ExampleZipContainer2.create(filename) do |c|
-          assert_raises(ZipContainer::MalformedContainerError) do
-            c.verify!
-          end
-
-          c.file.open('greeting.txt', 'w') do |f|
-            f.puts 'Goodbye!'
-          end
+      ExampleZipContainer2.create(filename) do |c|
+        assert_raises(ZipContainer::MalformedContainerError) do
+          c.verify!
+        end
 
-          assert_raises(ZipContainer::MalformedContainerError) do
-            c.verify!
-          end
+        c.file.open('greeting.txt', 'w') do |f|
+          f.puts 'Goodbye!'
+        end
 
-          c.file.open('greeting.txt', 'w') do |f|
-            f.puts "Hello, Y'All!"
-          end
+        assert_raises(ZipContainer::MalformedContainerError) do
+          c.verify!
+        end
 
-          assert_nothing_raised(ZipContainer::MalformedContainerError) do
-            c.verify!
-          end
+        c.file.open('greeting.txt', 'w') do |f|
+          f.puts "Hello, Y'All!"
         end
+
+        c.verify!
       end
 
       assert(ExampleZipContainer2.verify?(filename))
-      assert_nothing_raised(ZipContainer::MalformedContainerError) do
-        ExampleZipContainer2.verify!(filename)
-      end
+      ExampleZipContainer2.verify!(filename)
     end
   end
 
@@ -418,43 +379,35 @@ def test_create_subclassed_container_with_deep_content_verification
     Dir.mktmpdir do |dir|
       filename = File.join(dir, 'test.container')
 
-      assert_nothing_raised do
-        ExampleZipContainer2.create(filename) do |c|
-          assert_raises(ZipContainer::MalformedContainerError) do
-            c.verify!
-          end
-
-          c.file.open('greeting.txt', 'w') do |f|
-            f.puts "Hello, Y'All!"
-          end
+      ExampleZipContainer2.create(filename) do |c|
+        assert_raises(ZipContainer::MalformedContainerError) do
+          c.verify!
+        end
 
-          assert_nothing_raised(ZipContainer::MalformedContainerError) do
-            c.verify!
-          end
+        c.file.open('greeting.txt', 'w') do |f|
+          f.puts "Hello, Y'All!"
+        end
 
-          c.mkdir('dir')
-          c.file.open('dir/greet.txt', 'w') do |f|
-            f.puts 'Goodbye!'
-          end
+        c.verify!
 
-          assert_raises(ZipContainer::MalformedContainerError) do
-            c.verify!
-          end
+        c.mkdir('dir')
+        c.file.open('dir/greet.txt', 'w') do |f|
+          f.puts 'Goodbye!'
+        end
 
-          c.file.open('dir/greet.txt', 'w') do |f|
-            f.puts 'hello everyone.'
-          end
+        assert_raises(ZipContainer::MalformedContainerError) do
+          c.verify!
+        end
 
-          assert_nothing_raised(ZipContainer::MalformedContainerError) do
-            c.verify!
-          end
+        c.file.open('dir/greet.txt', 'w') do |f|
+          f.puts 'hello everyone.'
         end
+
+        c.verify!
       end
 
       assert(ExampleZipContainer2.verify?(filename))
-      assert_nothing_raised(ZipContainer::MalformedContainerError) do
-        ExampleZipContainer2.verify!(filename)
-      end
+      ExampleZipContainer2.verify!(filename)
     end
   end
 end
diff --git a/test/tc_read_dir.rb b/test/read_dir_test.rb
similarity index 76%
rename from test/tc_read_dir.rb
rename to test/read_dir_test.rb
index c2391d6..e8a8d20 100644
--- a/test/tc_read_dir.rb
+++ b/test/read_dir_test.rb
@@ -30,40 +30,37 @@
 #
 # Author: Robert Haines
 
-require 'test/unit'
+require 'test_helper'
 require 'tmpdir'
-require 'zip-container'
 
-class TestReadDir < Test::Unit::TestCase
+class TestReadDir < MiniTest::Test
 
   # Check that the empty directory does not verify.
   def test_verify_empty_directory
-    assert_raise(ZipContainer::MalformedContainerError) do
-      ZipContainer::Dir.verify!($dir_null)
+    assert_raises(ZipContainer::MalformedContainerError) do
+      ZipContainer::Dir.verify!(DIR_NULL)
     end
 
-    refute(ZipContainer::Dir.verify($dir_null).empty?)
-    refute(ZipContainer::Dir.verify?($dir_null))
+    refute(ZipContainer::Dir.verify(DIR_NULL).empty?)
+    refute(ZipContainer::Dir.verify?(DIR_NULL))
   end
 
   # Check that the empty container directory does verify.
   def test_verify_empty_container
-    assert_nothing_raised(ZipContainer::MalformedContainerError) do
-      ZipContainer::Dir.verify!($dir_empty)
-    end
+    ZipContainer::Dir.verify!(DIR_EMPTY)
 
-    assert(ZipContainer::Dir.verify($dir_empty).empty?)
-    assert(ZipContainer::Dir.verify?($dir_empty))
+    assert(ZipContainer::Dir.verify(DIR_EMPTY).empty?)
+    assert(ZipContainer::Dir.verify?(DIR_EMPTY))
   end
 
   # Check that a mimetype entry that is a directory does not verify.
   def test_verify_mimetype_directory
-    assert_raise(ZipContainer::MalformedContainerError) do
-      ZipContainer::Dir.verify!($dir_dir_mimetype)
+    assert_raises(ZipContainer::MalformedContainerError) do
+      ZipContainer::Dir.verify!(DIR_DIR_MIMETYPE)
     end
 
-    refute(ZipContainer::Dir.verify($dir_dir_mimetype).empty?)
-    refute(ZipContainer::Dir.verify?($dir_dir_mimetype))
+    refute(ZipContainer::Dir.verify(DIR_DIR_MIMETYPE).empty?)
+    refute(ZipContainer::Dir.verify?(DIR_DIR_MIMETYPE))
   end
 
   # Check that a mimetype which is not readable does not verify. We have to
@@ -78,7 +75,7 @@ def test_verify_unreadable_mimetype
       File.chmod(0o0000, mime_path)
 
       refute File.readable?(mime_path)
-      assert_raise(ZipContainer::MalformedContainerError) do
+      assert_raises(ZipContainer::MalformedContainerError) do
         ZipContainer::Dir.verify!(container)
       end
 
diff --git a/test/tc_read_file.rb b/test/read_file_test.rb
similarity index 55%
rename from test/tc_read_file.rb
rename to test/read_file_test.rb
index 3a2c07f..325d3b6 100644
--- a/test/tc_read_file.rb
+++ b/test/read_file_test.rb
@@ -30,88 +30,83 @@
 #
 # Author: Robert Haines
 
-require 'test/unit'
-require 'zip-container'
+require 'test_helper'
 
-class TestReadFile < Test::Unit::TestCase
+class TestReadFile < MiniTest::Test
 
   # Check that the null file does not verify.
   def test_verify_null_file
-    assert_raise(ZipContainer::ZipError) do
-      ZipContainer::File.verify($file_null)
+    assert_raises(ZipContainer::ZipError) do
+      ZipContainer::File.verify(FILE_NULL)
     end
 
-    assert_raise(ZipContainer::ZipError) do
-      ZipContainer::File.verify!($file_null)
+    assert_raises(ZipContainer::ZipError) do
+      ZipContainer::File.verify!(FILE_NULL)
     end
 
-    assert_raise(ZipContainer::ZipError) do
-      ZipContainer::File.verify?($file_null)
+    assert_raises(ZipContainer::ZipError) do
+      ZipContainer::File.verify?(FILE_NULL)
     end
   end
 
   # Check that the empty container file does verify.
   def test_verify_empty_container
-    assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
-      ZipContainer::File.verify!($empty)
-    end
+    ZipContainer::File.verify!(EMPTY_CONT)
 
-    assert(ZipContainer::File.verify($empty).empty?)
-    assert(ZipContainer::File.verify?($empty))
+    assert(ZipContainer::File.verify(EMPTY_CONT).empty?)
+    assert(ZipContainer::File.verify?(EMPTY_CONT))
   end
 
   # Check that the empty zip file does not verify.
   def test_verify_empty_zip
-    assert_raise(ZipContainer::MalformedContainerError) do
-      ZipContainer::File.verify!($empty_zip)
+    assert_raises(ZipContainer::MalformedContainerError) do
+      ZipContainer::File.verify!(EMPTY_ZIP)
     end
 
-    refute(ZipContainer::File.verify($empty_zip).empty?)
-    refute(ZipContainer::File.verify?($empty_zip))
+    refute(ZipContainer::File.verify(EMPTY_ZIP).empty?)
+    refute(ZipContainer::File.verify?(EMPTY_ZIP))
   end
 
   # Check that a compressed mimetype file is detected.
   def test_verify_compressed_mimetype
-    assert_raise(ZipContainer::MalformedContainerError) do
-      ZipContainer::File.verify!($compressed_mimetype)
+    assert_raises(ZipContainer::MalformedContainerError) do
+      ZipContainer::File.verify!(COMPRESSED_MIMETYPE)
     end
 
-    refute(ZipContainer::File.verify($compressed_mimetype).empty?)
-    refute(ZipContainer::File.verify?($compressed_mimetype))
+    refute(ZipContainer::File.verify(COMPRESSED_MIMETYPE).empty?)
+    refute(ZipContainer::File.verify?(COMPRESSED_MIMETYPE))
   end
 
   # Check the raw mimetype bytes
   def test_raw_mimetypes
-    empty_container = File.read($empty)
+    empty_container = File.read(EMPTY_CONT)
     assert_equal('application/epub+zip', empty_container[38..57])
 
-    compressed_mimetype = File.read($compressed_mimetype)
-    assert_not_equal('application/epub+zip', compressed_mimetype[38..57])
+    compressed_mimetype = File.read(COMPRESSED_MIMETYPE)
+    refute_equal('application/epub+zip', compressed_mimetype[38..57])
   end
 
   # Check reading files out of a container file and make sure we don't change
   # it.
   def test_read_files_from_container
-    assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
-      ZipContainer::File.open($example) do |c|
-        assert(c.on_disk?)
-        refute(c.in_memory?)
+    ZipContainer::File.open(EXAMPLE) do |c|
+      assert(c.on_disk?)
+      refute(c.in_memory?)
 
-        assert(c.file.exists?('greeting.txt'))
+      assert(c.file.exists?('greeting.txt'))
 
-        greeting = c.file.read('greeting.txt')
-        assert_equal("Hello, World!\n", greeting)
+      greeting = c.file.read('greeting.txt')
+      assert_equal("Hello, World!\n", greeting)
 
-        assert(c.file.exists?('dir'))
-        assert(c.file.directory?('dir'))
+      assert(c.file.exists?('dir'))
+      assert(c.file.directory?('dir'))
 
-        assert(c.file.exists?('dir/code.rb'))
+      assert(c.file.exists?('dir/code.rb'))
 
-        assert_equal('This is an example Container file!', c.comment)
+      assert_equal('This is an example Container file!', c.comment)
 
-        refute(c.commit_required?)
-        refute(c.commit)
-      end
+      refute(c.commit_required?)
+      refute(c.commit)
     end
   end
 end
diff --git a/test/tc_reserved_names.rb b/test/reserved_names_test.rb
similarity index 83%
rename from test/tc_reserved_names.rb
rename to test/reserved_names_test.rb
index 3a231b4..0395c38 100644
--- a/test/tc_reserved_names.rb
+++ b/test/reserved_names_test.rb
@@ -30,8 +30,7 @@
 #
 # Author: Robert Haines
 
-require 'test/unit'
-require 'zip-container'
+require 'test_helper'
 
 # A class to test the overriding of reserved and managed names.
 class NewZipContainer < ZipContainer::File
@@ -51,21 +50,19 @@ def initialize(filename)
   end
 end
 
-class TestReservedNames < Test::Unit::TestCase
+class TestReservedNames < MiniTest::Test
 
   # Check that the reserved names verify correctly.
   def test_verify_reserved_name
-    assert(NewZipContainer.verify?($example))
+    assert(NewZipContainer.verify?(EXAMPLE))
 
-    assert_nothing_raised(ZipContainer::MalformedContainerError) do
-      NewZipContainer.verify!($example)
-    end
+    NewZipContainer.verify!(EXAMPLE)
   end
 
   # Check the reserved names stuff all works correctly, baring in mind that
   # such comparisons for ZipContainer file should be case sensitive.
   def test_reserved_names
-    ZipContainer::File.open($example) do |c|
+    ZipContainer::File.open(EXAMPLE) do |c|
       assert_equal(1, c.reserved_names.length)
       assert_equal(['mimetype'], c.reserved_names)
 
@@ -87,7 +84,7 @@ def test_reserved_names
 
   # Check that overriding the reserved names in a sub-class works correctly
   def test_subclass_reserved_names
-    NewZipContainer.open($example) do |c|
+    NewZipContainer.open(EXAMPLE) do |c|
       assert_equal(3, c.reserved_names.length)
       assert_equal(
         ['mimetype', 'META-INF', 'reserved_dir'], c.reserved_names
@@ -131,7 +128,7 @@ def test_subclass_reserved_names
 
   # Check that nothing happens when trying to delete the mimetype file.
   def test_delete_mimetype
-    ZipContainer::File.open($example) do |c|
+    ZipContainer::File.open(EXAMPLE) do |c|
       assert(c.file.exists?('mimetype'))
       assert_nil(c.remove('mimetype'))
       assert(c.file.exists?('mimetype'))
@@ -140,7 +137,7 @@ def test_delete_mimetype
 
   # Check that nothing happens when trying to rename the mimetype file.
   def test_rename_mimetype
-    ZipContainer::File.open($example) do |c|
+    ZipContainer::File.open(EXAMPLE) do |c|
       assert(c.file.exists?('mimetype'))
       assert_nil(c.rename('mimetype', 'something-else'))
       assert(c.file.exists?('mimetype'))
@@ -151,9 +148,9 @@ def test_rename_mimetype
   # Check that nothing happens when trying to replace the contents of the
   # mimetype file.
   def test_replace_mimetype
-    ZipContainer::File.open($example) do |c|
+    ZipContainer::File.open(EXAMPLE) do |c|
       assert(c.file.exists?('mimetype'))
-      assert_nil(c.replace('mimetype', $zip_empty))
+      assert_nil(c.replace('mimetype', EMPTY_ZIP))
       assert_equal('application/epub+zip', c.file.read('mimetype'))
     end
   end
@@ -161,9 +158,9 @@ def test_replace_mimetype
   # Check that an exception is raised when trying to add file with a reserved
   # name.
   def test_add_reserved
-    ZipContainer::File.open($empty) do |c|
+    ZipContainer::File.open(EMPTY_CONT) do |c|
       assert_raises(ZipContainer::ReservedNameClashError) do
-        c.add('mimetype', $zip_empty)
+        c.add('mimetype', EMPTY_ZIP)
       end
     end
   end
@@ -171,21 +168,21 @@ def test_add_reserved
   # Check that an exception is raised when trying to add file with a reserved
   # name to a subclassed container.
   def test_subclass_add_reserved
-    NewZipContainer.open($empty) do |c|
+    NewZipContainer.open(EMPTY_CONT) do |c|
       assert_raises(ZipContainer::ReservedNameClashError) do
-        c.add('mimetype', $zip_empty)
+        c.add('mimetype', EMPTY_ZIP)
       end
 
       assert_raises(ZipContainer::ReservedNameClashError) do
-        c.add('reserved_dir', $zip_empty)
+        c.add('reserved_dir', EMPTY_ZIP)
       end
 
       assert_raises(ZipContainer::ReservedNameClashError) do
-        c.add('MimeType', $zip_empty)
+        c.add('MimeType', EMPTY_ZIP)
       end
 
       assert_raises(ZipContainer::ReservedNameClashError) do
-        c.add('Reserved_Dir', $zip_empty)
+        c.add('Reserved_Dir', EMPTY_ZIP)
       end
     end
   end
@@ -193,7 +190,7 @@ def test_subclass_add_reserved
   # Check that the META-INF directory is detected as non-existent when trying
   # to delete it.
   def test_delete_metainf
-    ZipContainer::File.open($example) do |c|
+    ZipContainer::File.open(EXAMPLE) do |c|
       assert_raises(Errno::ENOENT) do
         c.remove('META-INF')
       end
@@ -203,7 +200,7 @@ def test_delete_metainf
   # Check that the META-INF directory is detected as non-existent when trying
   # to rename it.
   def test_rename_metainf
-    ZipContainer::File.open($example) do |c|
+    ZipContainer::File.open(EXAMPLE) do |c|
       assert_raises(Errno::ENOENT) do
         c.rename('META-INF', 'something-else')
       end
@@ -213,7 +210,7 @@ def test_rename_metainf
   # Check that an exception is raised when trying to create a directory with a
   # reserved name.
   def test_mkdir_reserved
-    ZipContainer::File.open($empty) do |c|
+    ZipContainer::File.open(EMPTY_CONT) do |c|
       assert_raises(ZipContainer::ReservedNameClashError) do
         c.mkdir('mimetype')
       end
@@ -223,7 +220,7 @@ def test_mkdir_reserved
   # Check that an exception is raised when trying to create a directory with a
   # reserved name in a subclassed container.
   def test_subclass_mkdir_reserved
-    NewZipContainer.open($empty) do |c|
+    NewZipContainer.open(EMPTY_CONT) do |c|
       assert_raises(ZipContainer::ReservedNameClashError) do
         c.mkdir('mimetype')
       end
@@ -248,7 +245,7 @@ def test_subclass_mkdir_reserved
 
   # Check that a file cannot be renamed to one of the reserved names.
   def test_rename_to_reserved
-    ZipContainer::File.open($example) do |c|
+    ZipContainer::File.open(EXAMPLE) do |c|
       assert_raises(ZipContainer::ReservedNameClashError) do
         c.rename('dir/code.rb', 'mimetype')
       end
@@ -258,7 +255,7 @@ def test_rename_to_reserved
   # Check that a file cannot be renamed to one of the reserved names in a
   # subclassed container.
   def test_subclass_rename_to_reserved
-    NewZipContainer.open($example) do |c|
+    NewZipContainer.open(EXAMPLE) do |c|
       assert_raises(ZipContainer::ReservedNameClashError) do
         c.rename('dir/code.rb', 'mimetype')
       end
@@ -272,30 +269,26 @@ def test_subclass_rename_to_reserved
   # Check that the ruby-like File and Dir classes respect reserved and managed
   # names.
   def test_file_dir_ops_reserved
-    ZipContainer::File.open($empty) do |c|
+    ZipContainer::File.open(EMPTY_CONT) do |c|
       assert_raises(ZipContainer::ReservedNameClashError) do
         c.file.open('mimetype', 'w') do |f|
           f.puts 'TESTING'
         end
       end
 
-      assert_nothing_raised(ZipContainer::ReservedNameClashError) do
-        c.file.open('mimetype') do |f|
-          assert_equal('application/epub+zip', f.read)
-        end
+      c.file.open('mimetype') do |f|
+        assert_equal('application/epub+zip', f.read)
       end
 
-      assert_nothing_raised(ZipContainer::ReservedNameClashError) do
-        c.file.delete('mimetype')
-        assert(c.file.exists?('mimetype'))
-      end
+      c.file.delete('mimetype')
+      assert(c.file.exists?('mimetype'))
     end
   end
 
   # Check that the ruby-like File and Dir classes respect reserved names in a
   # subclassed container.
   def test_subclass_file_dir_ops_reserved
-    NewZipContainer.open($empty) do |c|
+    NewZipContainer.open(EMPTY_CONT) do |c|
       assert_raises(ZipContainer::ReservedNameClashError) do
         c.file.open('META-INF', 'w') do |f|
           f.puts 'TESTING'
@@ -308,16 +301,12 @@ def test_subclass_file_dir_ops_reserved
         end
       end
 
-      assert_nothing_raised(ZipContainer::ReservedNameClashError) do
-        c.file.open('mimetype') do |f|
-          assert_equal('application/epub+zip', f.read)
-        end
+      c.file.open('mimetype') do |f|
+        assert_equal('application/epub+zip', f.read)
       end
 
-      assert_nothing_raised(ZipContainer::ReservedNameClashError) do
-        c.file.delete('mimetype')
-        assert(c.file.exists?('mimetype'))
-      end
+      c.file.delete('mimetype')
+      assert(c.file.exists?('mimetype'))
 
       assert_raises(ZipContainer::ReservedNameClashError) do
         c.dir.mkdir('index.html')
diff --git a/test/ts_container.rb b/test/test_helper.rb
similarity index 71%
rename from test/ts_container.rb
rename to test/test_helper.rb
index 1c4247f..333920e 100644
--- a/test/ts_container.rb
+++ b/test/test_helper.rb
@@ -33,27 +33,22 @@
 require 'coveralls'
 Coveralls.wear!
 
+$LOAD_PATH.unshift ::File.expand_path('../lib', __dir__)
+require 'zip-container'
+
+require 'minitest/autorun'
+
 # Example default mimetype
-$mimetype = 'application/epub+zip'
+TEST_MIMETYPE = 'application/epub+zip'.freeze
 
 # Example data files
-$dir_null = 'test/data/dirs/null'
-$dir_empty = 'test/data/dirs/empty'
-$dir_dir_mimetype = 'test/data/dirs/dir-mimetype'
-$dir_managed = 'test/data/dirs/managed'
-$file_null = 'test/data/null.file'
-$empty = 'test/data/empty.container'
-$empty_zip = 'test/data/empty.zip'
-$compressed_mimetype = 'test/data/compressed_mimetype.container'
-$example = 'test/data/example.container'
-$subclass = 'test/data/subclassed.container'
-
-# Run test cases.
-require 'tc_util'
-require 'tc_exceptions'
-require 'tc_create_dir'
-require 'tc_create_file'
-require 'tc_read_dir'
-require 'tc_read_file'
-require 'tc_reserved_names'
-require 'tc_managed_entries'
+DIR_NULL = 'test/data/dirs/null'.freeze
+DIR_EMPTY = 'test/data/dirs/empty'.freeze
+DIR_DIR_MIMETYPE = 'test/data/dirs/dir-mimetype'.freeze
+DIR_MANAGED = 'test/data/dirs/managed'.freeze
+FILE_NULL = 'test/data/null.file'.freeze
+EMPTY_CONT = 'test/data/empty.container'.freeze
+EMPTY_ZIP = 'test/data/empty.zip'.freeze
+COMPRESSED_MIMETYPE = 'test/data/compressed_mimetype.container'.freeze
+EXAMPLE = 'test/data/example.container'.freeze
+SUBCLASS = 'test/data/subclassed.container'.freeze
diff --git a/test/tc_util.rb b/test/util_test.rb
similarity index 96%
rename from test/tc_util.rb
rename to test/util_test.rb
index 865ec03..91dba26 100644
--- a/test/tc_util.rb
+++ b/test/util_test.rb
@@ -30,15 +30,14 @@
 #
 # Author: Robert Haines
 
-require 'test/unit'
-require 'zip-container'
+require 'test_helper'
 
 class Util
 
   include ZipContainer::Util
 end
 
-class TestUtil < Test::Unit::TestCase
+class TestUtil < MiniTest::Test
 
   def setup
     @util = Util.new
diff --git a/zip-container.gemspec b/zip-container.gemspec
index dfddebb..63baeba 100644
--- a/zip-container.gemspec
+++ b/zip-container.gemspec
@@ -60,8 +60,8 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'bundler', '~> 1.16'
   s.add_development_dependency 'coveralls', '~> 0.8'
+  s.add_development_dependency 'minitest', '~> 5.0'
   s.add_development_dependency 'rake', '~> 10.1'
   s.add_development_dependency 'rdoc', '~> 4.1'
   s.add_development_dependency 'rubocop', '~> 0.59'
-  s.add_development_dependency 'test-unit', '~> 3.0'
 end

From dc10dc6c5bf4a9000963f7869fdca669ee78da25 Mon Sep 17 00:00:00 2001
From: Robert Haines <rhaines@manchester.ac.uk>
Date: Fri, 19 Oct 2018 14:27:39 +0100
Subject: [PATCH 2/2] Add a missing test: ZipContainer::File#to_s.

---
 test/read_file_test.rb | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/read_file_test.rb b/test/read_file_test.rb
index 325d3b6..8cac0e0 100644
--- a/test/read_file_test.rb
+++ b/test/read_file_test.rb
@@ -86,6 +86,13 @@ def test_raw_mimetypes
     refute_equal('application/epub+zip', compressed_mimetype[38..57])
   end
 
+  # Check that summary information about a container is correct.
+  def test_to_s
+    ZipContainer::File.open(EXAMPLE) do |c|
+      assert_equal('test/data/example.container - application/epub+zip', c.to_s)
+    end
+  end
+
   # Check reading files out of a container file and make sure we don't change
   # it.
   def test_read_files_from_container